Require Import DataTypeOps.
Require Import LayerCONTRACT.

Require Import DeepSpec.lib.Monad.StateMonadOption.
Require Import DeepSpec.lib.Monad.RunStateTInv.
Require Import lib.ArithInv.
Import DeepSpec.lib.Monad.Monad.MonadNotation.

Require Import Lia.
Require Import List.
Require Import Bool.
Require Import ZArith.
Require Import cclib.Maps.
Require Import cclib.Integers.

Require Import DataTypes.
Require Import backend.MachineModel.

Require Import DataTypes.
Import ListNotations.

Require Import core.MemoryModel.
Require Import HyperTypeInst.

Require Import Maps.
Import Maps.Int256Tree_Properties.
Import Maps.Int256Tree.

Require Import ContractModel.
Import ContractModel.ContractModel.

Open Scope Z.

Delimit Scope int256_scope with int256.
Declaring a scope implicitly is deprecated; use in advance an
explicit "Declare Scope int256_scope.". [undeclared-scope,deprecated]
Infix "+" := Int256.add : int256_scope.
Infix "-" := Int256.sub : int256_scope.
Infix "=?" := Int256.eq (at level 70, no associativity) : int256_scope.

Ltac me_transfer_cases :=
  try match goal with
    H : (Int256.one =? Int256.one)%int256 = false |- _ =>
      rewrite Int256.eq_true in H; discriminate
      end;
  try match goal with
    H : runStateT mzero _ = ret _ |- _ =>
    simpl in H; discriminate
  end.

Ltac ds_inv :=
      repeat (
        try inv_runStateT_branching;
        let Case := fresh "NoOverflowOrUnderflowInTransferCase" in
        try match goal with
          | H : context[me_transfer _  _ _] |- _ =>
          unfold me_transfer, make_machine_env in H;
          destruct (noOverflowOrUnderflowInTransfer _ _ _ _
                    && (_ _ _ _ _)) eqn:Case
        end
      );
      me_transfer_cases.

Section GenericProofs.
Lemma fold_snd_map :
  forall  A B (m : list (A * B)) x f,

  (fold_left (fun (a : B) (p : A * B) => f a (snd p))
  m x) =
  (fold_left f
  (List.map snd m) x).
forall (A B : Type) (m : list (A * B)) (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
Proof.
forall (A B : Type) (m : list (A * B)) (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
    intro.
A: Type
forall (B : Type) (m : list (A * B)) (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
    induction m.
A, B: Type
forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) [] x =
fold_left f (List.map snd []) x
A, B: Type
a: (A * B)%type
m: list (A * B)
IHm: forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) (a :: m) x =
fold_left f (List.map snd (a :: m)) x
    -
A, B: Type
forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) [] x =
fold_left f (List.map snd []) x intros.
A, B: Type
x: B
f: B -> B -> B
fold_left (fun (a : B) (p : A * B) => f a (snd p)) [] x =
fold_left f (List.map snd []) x simpl.
A, B: Type
x: B
f: B -> B -> B
x = x reflexivity.
    -
A, B: Type
a: (A * B)%type
m: list (A * B)
IHm: forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) (a :: m) x =
fold_left f (List.map snd (a :: m)) x intros.
A, B: Type
a: (A * B)%type
m: list (A * B)
IHm: forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
x: B
f: B -> B -> B
fold_left (fun (a : B) (p : A * B) => f a (snd p)) (a :: m) x =
fold_left f (List.map snd (a :: m)) x simpl.
A, B: Type
a: (A * B)%type
m: list (A * B)
IHm: forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
x: B
f: B -> B -> B
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m (f x (snd a)) =
fold_left f (List.map snd m) (f x (snd a)) rewrite IHm.
A, B: Type
a: (A * B)%type
m: list (A * B)
IHm: forall (x : B) (f : B -> B -> B),
fold_left (fun (a : B) (p : A * B) => f a (snd p)) m x =
fold_left f (List.map snd m) x
x: B
f: B -> B -> B
fold_left f (List.map snd m) (f x (snd a)) =
fold_left f (List.map snd m) (f x (snd a)) reflexivity.
Qed.


Lemma sum_starting_from_init_equals_sum_plus_init :
forall (init : Z) (m : Int256Tree.t Z),
Int256Tree.fold1 Z.add m init = Z.add (Int256Tree.fold1 Z.add m 0) init.
forall (init : Z) (m : t Z),
fold1 Z.add m init = fold1 Z.add m 0 + init
Proof.
forall (init : Z) (m : t Z),
fold1 Z.add m init = fold1 Z.add m 0 + init
  intros.
init: Z
m: t Z
fold1 Z.add m init = fold1 Z.add m 0 + init
  repeat rewrite Int256Tree.fold1_spec.
init: Z
m: t Z
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) init =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0 +
init
  assert(
  forall x,
    (fold_left (fun (a : Z) (p : Int256Tree.elt * Z) => Z.add a (snd p))
    (Int256Tree.elements m) x) =
    (fold_left Z.add
    (List.map snd (Int256Tree.elements m)) x)).
init: Z
m: t Z
forall x : Z,
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
init: Z
m: t Z
H: forall x : Z,
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) init =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0 +
init
    {
init: Z
m: t Z
forall x : Z,
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
      intros.
init: Z
m: t Z
x: Z
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
      apply fold_snd_map.
    }
init: Z
m: t Z
H: forall x : Z,
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) init =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0 +
init
  repeat rewrite H.
init: Z
m: t Z
H: forall x : Z,
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) x =
fold_left Z.add (List.map snd (elements m)) x
fold_left Z.add (List.map snd (elements m)) init =
fold_left Z.add (List.map snd (elements m)) 0 + init clear H.
init: Z
m: t Z
fold_left Z.add (List.map snd (elements m)) init =
fold_left Z.add (List.map snd (elements m)) 0 + init
  rewrite <- fold_left_last.
init: Z
m: t Z
fold_left Z.add (List.map snd (elements m)) init =
fold_left Z.add (List.map snd (elements m) ++ [init]) 0
  repeat rewrite fold_symmetric; try (intros; lia).
init: Z
m: t Z
fold_right Z.add init (List.map snd (elements m)) =
fold_right Z.add 0 (List.map snd (elements m) ++ [init])
  remember (List.map snd (Int256Tree.elements m)) as l.
init: Z
m: t Z
l: list Z
Heql: l = List.map snd (elements m)
fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
  clear Heql.
init: Z
m: t Z
l: list Z
fold_right Z.add init l = fold_right Z.add 0 (l ++ [init]) clear m.
init: Z
l: list Z
fold_right Z.add init l = fold_right Z.add 0 (l ++ [init]) generalize dependent l.
init: Z
forall l : list Z,
fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
  induction l.
init: Z
fold_right Z.add init [] = fold_right Z.add 0 ([] ++ [init])
init, a: Z
l: list Z
IHl: fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
fold_right Z.add init (a :: l) =
fold_right Z.add 0 ((a :: l) ++ [init])
    -
init: Z
fold_right Z.add init [] = fold_right Z.add 0 ([] ++ [init]) simpl.
init: Z
init = init + 0 lia.
    -
init, a: Z
l: list Z
IHl: fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
fold_right Z.add init (a :: l) =
fold_right Z.add 0 ((a :: l) ++ [init]) simpl.
init, a: Z
l: list Z
IHl: fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
a + fold_right Z.add init l = a + fold_right Z.add 0 (l ++ [init])
    rewrite IHl.
init, a: Z
l: list Z
IHl: fold_right Z.add init l = fold_right Z.add 0 (l ++ [init])
a + fold_right Z.add 0 (l ++ [init]) =
a + fold_right Z.add 0 (l ++ [init])
    reflexivity.
Qed.


Lemma Int256Tree_sum_set_value_initially_zero :
  forall (m: Int256Tree.t Z32)  k v, Int256Tree.get_default 0 k m = 0
                -> Int256Tree_Properties.sum (Int256Tree.set k v m) =
                  Int256Tree_Properties.sum m + v.
forall (m : t Z32) (k : elt) (v : Z32),
get_default 0 k m = 0 -> sum (set k v m) = sum m + v
Proof.
forall (m : t Z32) (k : elt) (v : Z32),
get_default 0 k m = 0 -> sum (set k v m) = sum m + v
  unfold Z32.
forall (m : t Z) (k : elt) (v : Z),
get_default 0 k m = 0 -> sum (set k v m) = sum m + v
  intros.
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
sum (set k v m) = sum m + v
  pose (@Int256Tree_Properties.sum_get_default 0 k v (Int256Tree.set k v m)) as Lemma1.
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) (0 + v)
sum (set k v m) = sum m + v
  simpl in Lemma1.
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
sum (set k v m) = sum m + v
  unfold Int256Tree_Properties.sum.
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (set k v m) 0 = fold1 Z.add m 0 + v
  rewrite Lemma1; [|  unfold Int256Tree.get_default;
                      rewrite Int256Tree.gss;
                      reflexivity].
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k (set k v m)) v = fold1 Z.add m 0 + v
  rewrite Int256Tree_Properties.fold1_remove_set; [|intros; lia].
m: t Z
k: elt
v: Z
H: get_default 0 k m = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  unfold Int256Tree.get_default in H.
m: t Z
k: elt
v: Z
H: match get k m with
| Some v => v
| None => 0
end = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v

  destruct (Int256Tree.get k m) eqn:Case.
m: t Z
k: elt
v, z: Z
Case: get k m = Some z
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  -
m: t Z
k: elt
v, z: Z
Case: get k m = Some z
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v rewrite H in Case.
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
    assert(Zswap : forall x y a : Z, a + x + y = a + y + x) by (intros; lia).
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
Zswap: forall x y a : Z, a + x + y = a + y + x
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
    epose (Int256Tree_Properties.fold1_get Z.add Zswap v Case) as H0.
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
Zswap: forall x y a : Z, a + x + y = a + y + x
H0:= fold1_get Z.add Zswap v Case: fold1 Z.add m v = fold1 Z.add (remove k m) (v + 0)
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
    rewrite Z.add_0_r in H0.
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
Zswap: forall x y a : Z, a + x + y = a + y + x
H0: fold1 Z.add m v = fold1 Z.add (remove k m) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
    rewrite <- H0.
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
Zswap: forall x y a : Z, a + x + y = a + y + x
H0: fold1 Z.add m v = fold1 Z.add (remove k m) v
fold1 Z.add m v = fold1 Z.add m 0 + v
    pose Int256Tree_Properties.sum_extensional.
m: t Z
k: elt
v, z: Z
Case: get k m = Some 0
H: z = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
Zswap: forall x y a : Z, a + x + y = a + y + x
H0: fold1 Z.add m v = fold1 Z.add (remove k m) v
e:= sum_extensional: forall (m n : t Z) (init : Z),
(forall i : elt, get_default 0 i m = get_default 0 i n) ->
fold1 Z.add m init = fold1 Z.add n init
fold1 Z.add m v = fold1 Z.add m 0 + v
    apply sum_starting_from_init_equals_sum_plus_init.
  -
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  assert(Int256Tree.get_default 0 k m = 0).
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
get_default 0 k m = 0
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  unfold Int256Tree.get_default.
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
match get k m with
| Some v => v
| None => 0
end = 0
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  rewrite Case.
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
0 = 0
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v reflexivity.
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  pose (@Int256Tree_Properties.sum_get_default v k 0 m H0).
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
e:= sum_get_default v k m H0: fold1 Z.add m v = fold1 Z.add (remove k m) (v + 0)
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  rewrite Z.add_0_r in e.
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
e: fold1 Z.add m v = fold1 Z.add (remove k m) v
fold1 Z.add (remove k m) v = fold1 Z.add m 0 + v
  rewrite <- e.
m: t Z
k: elt
v: Z
Case: get k m = None
H: 0 = 0
Lemma1:= sum_get_default 0 k (set k v m): get_default 0 k (set k v m) = v ->
fold1 Z.add (set k v m) 0 =
fold1 Z.add (remove k (set k v m)) v
H0: get_default 0 k m = 0
e: fold1 Z.add m v = fold1 Z.add (remove k m) v
fold1 Z.add m v = fold1 Z.add m 0 + v
  apply sum_starting_from_init_equals_sum_plus_init.
Qed.

Lemma sum_set_0_remove :
  forall k m,
  Int256Tree.fold1 Z.add (Int256Tree.set k 0 m) 0 =
  Int256Tree.fold1 Z.add (Int256Tree.remove k m) 0.
forall (k : elt) (m : t Z),
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
Proof.
forall (k : elt) (m : t Z),
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
  intros.
k: elt
m: t Z
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
  pose (Int256Tree.grs k m).
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
  pose (Int256Tree_Properties.set_permutation 0 e).
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p:= set_permutation 0 e: Permutation.Permutation (elements (set k 0 (remove k m)))
  ((k, 0) :: elements (remove k m))
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
  rewrite <- Int256Tree_Properties.elements_set_decompose in p.
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
  repeat rewrite Int256Tree.fold1_spec.
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (set k 0 m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (remove k m)) 0
  assert(Hf_comm : forall (b1 b2 : Int256Tree.elt * Z) (a : Z),
  a + snd b1 + snd b2 = a + snd b2 + snd b1) by (intros; lia).
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
Hf_comm: forall (b1 b2 : elt * Z) (a : Z),
a + snd b1 + snd b2 = a + snd b2 + snd b1
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (set k 0 m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (remove k m)) 0
  epose (@Int256Tree_Properties.fold1_permutation
            _ _ (fun (a:Z) (p0 : Int256Tree.elt * Z) => a + snd p0)
            Hf_comm
            (Int256Tree.elements (Int256Tree.set k 0 m))
            ((k, 0) :: Int256Tree.elements (Int256Tree.remove k m))
            p).
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
Hf_comm: forall (b1 b2 : elt * Z) (a : Z),
a + snd b1 + snd b2 = a + snd b2 + snd b1
e0:= fold1_permutation (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  Hf_comm p: forall init : Z,
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  (elements (set k 0 m)) init =
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  ((k, 0) :: elements (remove k m)) init
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (set k 0 m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (remove k m)) 0
  rewrite e0.
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
Hf_comm: forall (b1 b2 : elt * Z) (a : Z),
a + snd b1 + snd b2 = a + snd b2 + snd b1
e0:= fold1_permutation (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  Hf_comm p: forall init : Z,
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  (elements (set k 0 m)) init =
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  ((k, 0) :: elements (remove k m)) init
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  ((k, 0) :: elements (remove k m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (remove k m)) 0
  simpl.
k: elt
m: t Z
e:= grs k m: get k (remove k m) = None
p: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements (remove k m))
Hf_comm: forall (b1 b2 : elt * Z) (a : Z),
a + snd b1 + snd b2 = a + snd b2 + snd b1
e0:= fold1_permutation (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  Hf_comm p: forall init : Z,
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  (elements (set k 0 m)) init =
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  ((k, 0) :: elements (remove k m)) init
fold_left (fun (a : Z) (p0 : elt * Z) => a + snd p0)
  (elements (remove k m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (remove k m)) 0
  reflexivity.
Qed.


Lemma sum_set_0_minus : forall k m v, Int256Tree.get_default 0 k m = v ->
Int256Tree_Properties.sum (Int256Tree.set k 0 m) = Int256Tree_Properties.sum m - v.
forall (k : elt) (m : t Z) (v : Z),
get_default 0 k m = v -> sum (set k 0 m) = sum m - v
Proof.
forall (k : elt) (m : t Z) (v : Z),
get_default 0 k m = v -> sum (set k 0 m) = sum m - v
  intros.
k: elt
m: t Z
v: Z
H: get_default 0 k m = v
sum (set k 0 m) = sum m - v
  unfold Int256Tree_Properties.sum.
k: elt
m: t Z
v: Z
H: get_default 0 k m = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
  unfold Int256Tree.get_default in H.
k: elt
m: t Z
v: Z
H: match get k m with
| Some v => v
| None => 0
end = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
  destruct (Int256Tree.get k m) eqn:Case.
k: elt
m: t Z
v, z: Z
Case: get k m = Some z
H: z = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
k: elt
m: t Z
v: Z
Case: get k m = None
H: 0 = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
    -
k: elt
m: t Z
v, z: Z
Case: get k m = Some z
H: z = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v subst.
k: elt
m: t Z
v: Z
Case: get k m = Some v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
      assert((forall x y a : Z, a + x + y = a + y + x)) by (intros; lia).
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
      epose (Int256Tree_Properties.fold1_get Z.add H 0 Case).
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v
      rewrite e.
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) (0 + v) - v
      simpl.
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) v - v
      rewrite (sum_starting_from_init_equals_sum_plus_init v).
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0 + v - v
      (* Set Printing All. *)
      assert((Z.sub
      (Z.add (@Int256Tree.fold1 Z Z Z.add (@Int256Tree.remove Z k m) Z0) v) v) =
      (@Int256Tree.fold1 Z Z Z.add (@Int256Tree.remove Z k m) Z0)).
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
fold1 Z.add (remove k m) 0 + v - v = fold1 Z.add (remove k m) 0
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
H0: fold1 Z.add (remove k m) 0 + v - v = fold1 Z.add (remove k m) 0
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0 + v - v
      lia.
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
H0: fold1 Z.add (remove k m) 0 + v - v = fold1 Z.add (remove k m) 0
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0 + v - v
      rewrite H0.
k: elt
m: t Z
v: Z
Case: get k m = Some v
H: forall x y a : Z, a + x + y = a + y + x
e:= fold1_get Z.add H 0 Case: fold1 Z.add m 0 = fold1 Z.add (remove k m) (0 + v)
H0: fold1 Z.add (remove k m) 0 + v - v = fold1 Z.add (remove k m) 0
fold1 Z.add (set k 0 m) 0 = fold1 Z.add (remove k m) 0
      apply sum_set_0_remove.
  -
k: elt
m: t Z
v: Z
Case: get k m = None
H: 0 = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v unfold HyperType.ht_default in H.
k: elt
m: t Z
v: Z
Case: get k m = None
H: 0 = v
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - v subst.
k: elt
m: t Z
Case: get k m = None
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0 - 0
    rewrite Z.sub_0_r.
k: elt
m: t Z
Case: get k m = None
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0
    pose (Int256Tree_Properties.set_permutation 0 Case).
k: elt
m: t Z
Case: get k m = None
p:= set_permutation 0 Case: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements m)
fold1 Z.add (set k 0 m) 0 = fold1 Z.add m 0
    repeat rewrite Int256Tree.fold1_spec.
k: elt
m: t Z
Case: get k m = None
p:= set_permutation 0 Case: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements m)
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  (elements (set k 0 m)) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0
    rewrite Int256Tree_Properties.fold1_permutation
      with (l':=((k, 0) :: Int256Tree.elements m)); [|intros; lia|assumption].
k: elt
m: t Z
Case: get k m = None
p:= set_permutation 0 Case: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements m)
fold_left (fun (a : Z) (p : elt * Z) => a + snd p)
  ((k, 0) :: elements m) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0
    simpl.
k: elt
m: t Z
Case: get k m = None
p:= set_permutation 0 Case: Permutation.Permutation (elements (set k 0 m))
  ((k, 0) :: elements m)
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0 =
fold_left (fun (a : Z) (p : elt * Z) => a + snd p) (elements m) 0 reflexivity.
Qed.


Lemma Int256Tree_sum_minus :
  forall m k x,
    Int256Tree_Properties.sum m <= x
    ->
    Int256Tree_Properties.sum (Int256Tree.set k 0 m) <=
    x - (Int256Tree.get_default 0 k m).
forall (m : t Z) (k : elt) (x : Z),
sum m <= x -> sum (set k 0 m) <= x - get_default 0 k m
    intros.
m: t Z
k: elt
x: Z
H: sum m <= x
sum (set k 0 m) <= x - get_default 0 k m
    rewrite sum_set_0_minus with (v:= Int256Tree.get_default 0 k m) by reflexivity.
m: t Z
k: elt
x: Z
H: sum m <= x
sum m - get_default 0 k m <= x - get_default 0 k m
    lia.
Qed.

End GenericProofs.

Module FunctionalCorrectness.

(*
The goal here is to, in a sense, quantify over an arbitrary snapshot
 of the Blockchain and then model all possible interactions after that
 point. In particular, modelling most precisely the smart contract.
*)

Section Blockchain_Model.

Open Scope int256.

Context
  (snapshot_timestamp : int256)
  (snapshot_number : int256)
  (snapshot_blockhash : int256 -> int256)
  (snapshot_balances : addr -> wei).

Context
  (snapshot_balances_valid_prf :
    forall a, 0 <= (snapshot_balances a) < Int256.modulus).

Context
  (contract_address : addr).

Definition ContractState := global_abstract_data_type.

Context
  (address_accepts_funds : option ContractState -> addr -> addr -> wei -> bool).
(* The following is a helpful alternative to suppose instead
 of using `address_accepts_funds` alone. But it must be assumed explicitly. *)
Definition address_accepts_funds_assumed_for_from_contract
  d sender recipient amount :=
  if sender =? contract_address then true else
  address_accepts_funds d sender recipient amount.
Close Scope int256.
(* Definition address_accepts_funds_assumption :=
   address_accepts_funds_assumed_for_from_contract. *)
Definition address_accepts_funds_assumption
  (_ : option ContractState) (_ _ : addr) (_ : wei) := true.
(* The current model also has the implicit assumption
that the transfers to a smart contract during a function
call via callvalue are always accepted by the contract.
  This could be changed by editing callvalue_prf in the
   definition of Action, similarly to how it is done for
   `externalBalanceTransfer` *)

Definition constructor_call_context :=
  {| origin := Int256.zero;
    caller := Int256.zero;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero |}.

Definition constructor_blockchain_state :=
  {| timestamp := snapshot_timestamp;
    block_number := snapshot_number;
    balance := snapshot_balances;
    blockhash := snapshot_blockhash;
    contract_state := init_global_abstract_data |}.

Program Definition constructor_machine_env :=
make_machine_env contract_address constructor_blockchain_state
  constructor_call_context address_accepts_funds_assumption _ _ _.
Next Obligation.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
0 <= 0 < Int256.modulus
unfold Int256.modulus, two_power_nat.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
0 <= 0 < Z.pos (shift_nat Int256.wordsize 1) lia.
Defined.
Next Obligation.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
noOverflowOrUnderflowInTransfer Int256.zero contract_address 0
  snapshot_balances = true
unfold noOverflowOrUnderflowInTransfer.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero - 0 >=? 0) &&
(snapshot_balances contract_address + 0 <? Int256.modulus) = true
rewrite Z.add_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero - 0 >=? 0) &&
(snapshot_balances contract_address <? Int256.modulus) = true rewrite Z.sub_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero >=? 0) &&
(snapshot_balances contract_address <? Int256.modulus) = true
Search "&&" true.
andb_true_l: forall b : bool, true && b = b
andb_true_r: forall b : bool, b && true = b
BoolTheory:
  ring_theory false true xorb andb xorb (fun b : bool => b) eq
andb_true_intro:
  forall [b1 b2 : bool], b1 = true /\ b2 = true -> b1 && b2 = true
andb_prop: forall a b : bool, a && b = true -> a = true /\ b = true
andb_true_eq:
  forall a b : bool, true = a && b -> true = a /\ true = b
andb_true_iff:
  forall b1 b2 : bool, b1 && b2 = true <-> b1 = true /\ b2 = true
Runtime.zle_and_zlt_between:
  forall a b c : Z,
  a <= b < c ->
  Coqlib.proj_sumbool (Coqlib.zle a b) &&
  Coqlib.proj_sumbool (Coqlib.zlt b c) = true
bool_ring_ring_lemma2:
  forall (n : nat)
    (lH : list (Ring_polynom.PExpr bool * Ring_polynom.PExpr bool))
    (l : list bool),
  Ring_polynom.interp_PElist false true xorb andb xorb
    (fun b : bool => b) eq (IDphi (R:=bool)) id_phi_N
    (pow_N true andb) l lH ->
  forall lmp : list (bool * Ring_polynom.Mon * Ring_polynom.Pol bool),
  Ring_polynom.mk_monpol_list false true xorb andb xorb
    (fun b : bool => b) bool_eq (triv_div false true bool_eq) lH =
  lmp ->
  forall (pe : Ring_polynom.PExpr bool) (npe : Ring_polynom.Pol bool),
  Ring_polynom.norm_subst false true xorb andb xorb
    (fun b : bool => b) bool_eq (triv_div false true bool_eq) n lmp
    pe = npe ->
  Ring_polynom.PEeval false true xorb andb xorb (fun b : bool => b)
    (IDphi (R:=bool)) id_phi_N (pow_N true andb) l pe =
  Ring_polynom.Pphi_dev false true xorb andb xorb 
    (fun b : bool => b) false true bool_eq (IDphi (R:=bool))
    (get_sign_None (C:=bool)) l npe
bool_ring_ring_lemma1:
  forall (n : nat) (l : list bool)
    (lpe : list (Ring_polynom.PExpr bool * Ring_polynom.PExpr bool))
    (pe1 pe2 : Ring_polynom.PExpr bool),
  Ring_polynom.interp_PElist false true xorb andb xorb
    (fun b : bool => b) eq (IDphi (R:=bool)) id_phi_N
    (pow_N true andb) l lpe ->
  (let lmp :=
     Ring_polynom.mk_monpol_list false true xorb andb xorb
       (fun b : bool => b) bool_eq (triv_div false true bool_eq) lpe
     in
   Ring_polynom.Peq bool_eq
     (Ring_polynom.norm_subst false true xorb andb xorb
        (fun b : bool => b) bool_eq (triv_div false true bool_eq) n
        lmp pe1)
     (Ring_polynom.norm_subst false true xorb andb xorb
        (fun b : bool => b) bool_eq (triv_div false true bool_eq) n
        lmp pe2)) = true ->
  Ring_polynom.PEeval false true xorb andb xorb (fun b : bool => b)
    (IDphi (R:=bool)) id_phi_N (pow_N true andb) l pe1 =
  Ring_polynom.PEeval false true xorb andb xorb (fun b : bool => b)
    (IDphi (R:=bool)) id_phi_N (pow_N true andb) l pe2
Syntax.cmd_constr_prf_sind:
  forall {LayerSpec : LayerSpecClass}
    {OverlaySpec : OverlaySpecClass}
    {UnderlaySpec : UnderlaySpecClass} {HM : HyperMem}
    (is_realizing : bool)
    (P : forall ret : HyperType.hyper_type_pair,
         HyperType.HyperType (HyperType.tp_type_pair ret) ->
         Syntax.cmd_constr ret -> SProp),
  P void_unit_pair void_unit Syntax.CCskip ->
  (forall (r : HyperType.hyper_type_pair) (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (id : AST.ident)
     (c1 : Syntax.cmd_constr
             {|
               HyperType._tp_type_pair := tp;
               HyperType.tp_hyper_type_impl := hti
             |}) (c2 : Syntax.cmd_constr r),
   Syntax.function_return_dec
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} = true ->
   Syntax.cmd_constr_prf is_realizing
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c1 ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c1 ->
   Syntax.cmd_constr_prf is_realizing r htr c2 ->
   P r htr c2 -> P r htr (Syntax.CClet id c1 c2)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   HyperType.HyperByValueType tp ->
   forall e : Syntax.lexpr_constr tp,
   Syntax.lexpr_constr_prf e ->
   is_realizing && Syntax.lexpr_is_ghost e = false ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCload e)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   HyperType.HyperByValueType tp ->
   forall (el : Syntax.lexpr_constr tp) (er : Syntax.expr_constr tp),
   Syntax.lexpr_constr_prf el ->
   Syntax.expr_constr_prf er ->
   is_realizing || Syntax.lexpr_is_ghost el = true ->
   P void_unit_pair void_unit (Syntax.CCstore el er)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (c1 : Syntax.cmd_constr void_unit_pair)
     (c2 : Syntax.cmd_constr r),
   Syntax.cmd_constr_prf is_realizing void_unit_pair void_unit c1 ->
   P void_unit_pair void_unit c1 ->
   Syntax.cmd_constr_prf is_realizing r htr c2 ->
   P r htr c2 -> P r htr (Syntax.CCsequence c1 c2)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (e : Syntax.expr_constr tint_bool)
     (c_true c_false : Syntax.cmd_constr r),
   Syntax.expr_constr_prf e ->
   Syntax.cmd_constr_prf is_realizing r htr c_true ->
   P r htr c_true ->
   Syntax.cmd_constr_prf is_realizing r htr c_false ->
   P r htr c_false -> P r htr (Syntax.CCifthenelse e c_true c_false)) ->
  (forall (id_it id_end : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (c : Syntax.cmd_constr void_unit_pair),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.cmd_constr_prf is_realizing void_unit_pair void_unit c ->
   P void_unit_pair void_unit c ->
   P void_unit_pair void_unit (Syntax.CCfor id_it id_end e1 e2 c)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (id_it id_end id_dest : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (c3 : Syntax.cmd_constr int_bool_pair)
     (c4 c5 : Syntax.cmd_constr r),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c3 ->
   P int_bool_pair int_bool c3 ->
   Syntax.cmd_constr_prf is_realizing r htr c4 ->
   P r htr c4 ->
   Syntax.cmd_constr_prf is_realizing r htr c5 ->
   P r htr c5 ->
   P r htr (Syntax.CCfirst id_it id_end id_dest e1 e2 c3 c4 c5)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (id_it id_end id_recur id_dest : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (e3 : Syntax.expr_constr tp)
     (c : Syntax.cmd_constr
            {|
              HyperType._tp_type_pair := tp;
              HyperType.tp_hyper_type_impl := hti
            |}),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.expr_constr_prf e3 ->
   Syntax.function_return_dec
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} = true ->
   Syntax.cmd_constr_prf is_realizing
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCfold id_it id_end id_recur id_dest e1 e2 e3 c)) ->
  (forall (argt : list HyperType.hyper_type_pair)
     (ret : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair ret))
     (prim : Syntax.primitive argt ret)
     (arg : Syntax.expr_constr_list argt),
   Syntax.primitive_prf prim ->
   Syntax.primitive_exec_prf prim ->
   Syntax.primitive_passthrough_prf prim ->
   Syntax.expr_constr_prf_conj arg ->
   is_realizing || Syntax.PRIMpure prim = true ->
   P ret htr (Syntax.CCcall prim arg)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (e : Syntax.expr_constr tp),
   Syntax.expr_constr_prf e ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCyield e)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (fld_ids : list AST.ident)
     (fld_tps : list HyperType.hyper_type_pair)
     (el : Syntax.lexpr_constr tp)
     (flds : Syntax.expr_constr_list fld_tps)
     (constr : HyperType.list_curried_type fld_tps
                 (HyperType.unpair_ft tp)),
   HyperType.HyperConstructor tp fld_ids fld_tps constr ->
   Syntax.lexpr_constr_prf el ->
   Syntax.expr_constr_prf_conj flds ->
   HyperType.HList
     (fun htp : HyperType.hyper_type_pair =>
      HyperType.HyperByValueType (HyperType.tp_type_pair htp))
     fld_tps ->
   is_realizing || Syntax.lexpr_is_ghost el = true ->
   (length fld_ids <= Z.to_nat Int256.modulus)%nat ->
   P void_unit_pair void_unit
     (Syntax.CCconstr fld_ids fld_tps el flds constr)) ->
  (forall (e1 : Syntax.expr_constr tint_U)
     (e2 : Syntax.expr_constr tint_Z32),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   P void_unit_pair void_unit (Syntax.CCtransfer e1 e2)) ->
  (forall c : Syntax.cmd_constr int_bool_pair,
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c ->
   P int_bool_pair int_bool c ->
   P void_unit_pair void_unit (Syntax.CCassert c)) ->
  (forall c : Syntax.cmd_constr int_bool_pair,
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c ->
   P int_bool_pair int_bool c ->
   P void_unit_pair void_unit (Syntax.CCdeny c)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCpanic tp)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (tmp' : SimpleMaps.AList.t SEnv.TypePairProjection.A)
     (c : Syntax.cmd_constr r)
     (spec : SEnv.spec_env_t tmp' -> Syntax.DS (HyperType.tp_ft r)),
   Syntax.cmd_constr_prf is_realizing r htr c ->
   P r htr c -> P r htr (Syntax.CCrespec tmp' c spec)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (tmp' : SimpleMaps.AList.t SEnv.TypePairProjection.A)
     (c : Syntax.cmd_constr r)
     (spec : machine_env GetHighData ->
             SEnv.spec_env_t tmp' -> Syntax.DS ...),
   is_realizing = true ->
   Syntax.cmd_constr_prf is_realizing r htr c ->
   P r htr c -> P r htr (...)) ->
  forall (ret : HyperType.hyper_type_pair)
    (htr : HyperType.HyperType (HyperType.tp_type_pair ret))
    (c : Syntax.cmd_constr ret),
  Syntax.cmd_constr_prf is_realizing ret htr c -> P ret htr c
Syntax.cmd_constr_prf_ind:
  forall {LayerSpec : LayerSpecClass}
    {OverlaySpec : OverlaySpecClass}
    {UnderlaySpec : UnderlaySpecClass} {HM : HyperMem}
    (is_realizing : bool)
    (P : forall ret : HyperType.hyper_type_pair,
         HyperType.HyperType (HyperType.tp_type_pair ret) ->
         Syntax.cmd_constr ret -> Prop),
  P void_unit_pair void_unit Syntax.CCskip ->
  (forall (r : HyperType.hyper_type_pair) (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (id : AST.ident)
     (c1 : Syntax.cmd_constr
             {|
               HyperType._tp_type_pair := tp;
               HyperType.tp_hyper_type_impl := hti
             |}) (c2 : Syntax.cmd_constr r),
   Syntax.function_return_dec
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} = true ->
   Syntax.cmd_constr_prf is_realizing
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c1 ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c1 ->
   Syntax.cmd_constr_prf is_realizing r htr c2 ->
   P r htr c2 -> P r htr (Syntax.CClet id c1 c2)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   HyperType.HyperByValueType tp ->
   forall e : Syntax.lexpr_constr tp,
   Syntax.lexpr_constr_prf e ->
   is_realizing && Syntax.lexpr_is_ghost e = false ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCload e)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   HyperType.HyperByValueType tp ->
   forall (el : Syntax.lexpr_constr tp) (er : Syntax.expr_constr tp),
   Syntax.lexpr_constr_prf el ->
   Syntax.expr_constr_prf er ->
   is_realizing || Syntax.lexpr_is_ghost el = true ->
   P void_unit_pair void_unit (Syntax.CCstore el er)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (c1 : Syntax.cmd_constr void_unit_pair)
     (c2 : Syntax.cmd_constr r),
   Syntax.cmd_constr_prf is_realizing void_unit_pair void_unit c1 ->
   P void_unit_pair void_unit c1 ->
   Syntax.cmd_constr_prf is_realizing r htr c2 ->
   P r htr c2 -> P r htr (Syntax.CCsequence c1 c2)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (e : Syntax.expr_constr tint_bool)
     (c_true c_false : Syntax.cmd_constr r),
   Syntax.expr_constr_prf e ->
   Syntax.cmd_constr_prf is_realizing r htr c_true ->
   P r htr c_true ->
   Syntax.cmd_constr_prf is_realizing r htr c_false ->
   P r htr c_false -> P r htr (Syntax.CCifthenelse e c_true c_false)) ->
  (forall (id_it id_end : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (c : Syntax.cmd_constr void_unit_pair),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.cmd_constr_prf is_realizing void_unit_pair void_unit c ->
   P void_unit_pair void_unit c ->
   P void_unit_pair void_unit (Syntax.CCfor id_it id_end e1 e2 c)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (id_it id_end id_dest : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (c3 : Syntax.cmd_constr int_bool_pair)
     (c4 c5 : Syntax.cmd_constr r),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c3 ->
   P int_bool_pair int_bool c3 ->
   Syntax.cmd_constr_prf is_realizing r htr c4 ->
   P r htr c4 ->
   Syntax.cmd_constr_prf is_realizing r htr c5 ->
   P r htr c5 ->
   P r htr (Syntax.CCfirst id_it id_end id_dest e1 e2 c3 c4 c5)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (id_it id_end id_recur id_dest : AST.ident)
     (e1 e2 : Syntax.expr_constr tint_Z32)
     (e3 : Syntax.expr_constr tp)
     (c : Syntax.cmd_constr
            {|
              HyperType._tp_type_pair := tp;
              HyperType.tp_hyper_type_impl := hti
            |}),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   Syntax.expr_constr_prf e3 ->
   Syntax.function_return_dec
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} = true ->
   Syntax.cmd_constr_prf is_realizing
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht c ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCfold id_it id_end id_recur id_dest e1 e2 e3 c)) ->
  (forall (argt : list HyperType.hyper_type_pair)
     (ret : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair ret))
     (prim : Syntax.primitive argt ret)
     (arg : Syntax.expr_constr_list argt),
   Syntax.primitive_prf prim ->
   Syntax.primitive_exec_prf prim ->
   Syntax.primitive_passthrough_prf prim ->
   Syntax.expr_constr_prf_conj arg ->
   is_realizing || Syntax.PRIMpure prim = true ->
   P ret htr (Syntax.CCcall prim arg)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (e : Syntax.expr_constr tp),
   Syntax.expr_constr_prf e ->
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCyield e)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp)
     (fld_ids : list AST.ident)
     (fld_tps : list HyperType.hyper_type_pair)
     (el : Syntax.lexpr_constr tp)
     (flds : Syntax.expr_constr_list fld_tps)
     (constr : HyperType.list_curried_type fld_tps
                 (HyperType.unpair_ft tp)),
   HyperType.HyperConstructor tp fld_ids fld_tps constr ->
   Syntax.lexpr_constr_prf el ->
   Syntax.expr_constr_prf_conj flds ->
   HyperType.HList
     (fun htp : HyperType.hyper_type_pair =>
      HyperType.HyperByValueType (HyperType.tp_type_pair htp))
     fld_tps ->
   is_realizing || Syntax.lexpr_is_ghost el = true ->
   (length fld_ids <= Z.to_nat Int256.modulus)%nat ->
   P void_unit_pair void_unit
     (Syntax.CCconstr fld_ids fld_tps el flds constr)) ->
  (forall (e1 : Syntax.expr_constr tint_U)
     (e2 : Syntax.expr_constr tint_Z32),
   Syntax.expr_constr_prf e1 ->
   Syntax.expr_constr_prf e2 ->
   P void_unit_pair void_unit (Syntax.CCtransfer e1 e2)) ->
  (forall c : Syntax.cmd_constr int_bool_pair,
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c ->
   P int_bool_pair int_bool c ->
   P void_unit_pair void_unit (Syntax.CCassert c)) ->
  (forall c : Syntax.cmd_constr int_bool_pair,
   Syntax.cmd_constr_prf is_realizing int_bool_pair int_bool c ->
   P int_bool_pair int_bool c ->
   P void_unit_pair void_unit (Syntax.CCdeny c)) ->
  (forall (tp : HyperType.type_pair)
     (hti : HyperType.HyperTypeImpl tp) (ht : HyperType.HyperType tp),
   P
     {|
       HyperType._tp_type_pair := tp;
       HyperType.tp_hyper_type_impl := hti
     |} ht (Syntax.CCpanic tp)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (tmp' : SimpleMaps.AList.t SEnv.TypePairProjection.A)
     (c : Syntax.cmd_constr r)
     (spec : SEnv.spec_env_t tmp' -> Syntax.DS (HyperType.tp_ft r)),
   Syntax.cmd_constr_prf is_realizing r htr c ->
   P r htr c -> P r htr (Syntax.CCrespec tmp' c spec)) ->
  (forall (r : HyperType.hyper_type_pair)
     (htr : HyperType.HyperType (HyperType.tp_type_pair r))
     (tmp' : SimpleMaps.AList.t SEnv.TypePairProjection.A)
     (c : Syntax.cmd_constr r)
     (spec : machine_env GetHighData ->
             SEnv.spec_env_t tmp' -> Syntax.DS ...),
   is_realizing = true ->
   Syntax.cmd_constr_prf is_realizing r htr c ->
   P r htr c -> P r htr (...)) ->
  forall (ret : HyperType.hyper_type_pair)
    (htr : HyperType.HyperType (HyperType.tp_type_pair ret))
    (c : Syntax.cmd_constr ret),
  Syntax.cmd_constr_prf is_realizing ret htr c -> P ret htr c
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero >=? 0) &&
(snapshot_balances contract_address <? Int256.modulus) = true
rewrite andb_true_iff.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero >=? 0) = true /\
(snapshot_balances contract_address <? Int256.modulus) = true
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(snapshot_balances contract_address <? Int256.modulus) = true
pose proof (snapshot_balances_valid_prf Int256.zero).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
H: 0 <= snapshot_balances Int256.zero < Int256.modulus
(0 <=? 0) && (0 <? Int256.modulus) &&
(snapshot_balances Int256.zero >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(snapshot_balances contract_address <? Int256.modulus) = true lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
(snapshot_balances contract_address <? Int256.modulus) = true
pose proof (snapshot_balances_valid_prf contract_address).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
H: 0 <= snapshot_balances contract_address < Int256.modulus
(snapshot_balances contract_address <? Int256.modulus) = true lia.
Defined.

Context {HmemOps: MemoryModelOps mem}.
Context {memModelOps : MemoryModelOps mem}.

Definition init_state :=
  match runStateT (Crowdfunding_constructor_opt constructor_machine_env)
  init_global_abstract_data
  with
  | Some (_, d) => Some d
  | None => None
  end.

Eval vm_compute in init_state.
= Some
    {|
      Outgoing_transfer_recipient_and_amount := None;
      Crowdfunding_owner :=
        {|
          Int256.intval :=
            890025619261977197475349953386626580431692757011;
          Int256.intrange :=
            Int256.Z_mod_modulus_range'
              890025619261977197475349953386626580431692757011
        |};
      Crowdfunding_max_block :=
        {|
          Int256.intval := 140;
          Int256.intrange := Int256.Z_mod_modulus_range' 140
        |};
      Crowdfunding_goal := 50;
      Crowdfunding_backers :=
        exist
          (fun tr : PTree.t Z32 =>
           forall x : positive,
           tr ! x <> None ->
           Int256Indexed.index (Int256Indexed.index_inv x) = x)
          PTree.Leaf
          (fun (x : positive) (x0 : PTree.Leaf ! x <> None) =>
           Maps.Int256Tree.empty_obligation_1 x x0);
      Crowdfunding_funded := false;
      Crowdfunding_deadlinePassed_msg := 0;
      Crowdfunding_successfullyDonated_msg := 1;
      Crowdfunding_alreadyDonated_msg := 2;
      Crowdfunding_funded_msg := 3;
      Crowdfunding_failed_msg := 4;
      Crowdfunding_too_early_to_claim_funds_msg := 5;
      Crowdfunding_too_early_to_reclaim_msg := 6;
      Crowdfunding_cannot_refund_msg := 7;
      Crowdfunding_here_is_your_money_msg := 8
    |}
: option GetHighData

(* The following lemma is true for the current setup right now,
 but would not be true in general, e.g. if the constructor allowed
  arbitrary setting of a storage variable. *)
Lemma same_init : init_state = Some init_global_abstract_data.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
init_state = Some init_global_abstract_data
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
init_state = Some init_global_abstract_data
  unfold init_state.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
match
  runStateT (Crowdfunding_constructor_opt constructor_machine_env)
    init_global_abstract_data
with
| Some (_, d) => Some d
| None => None
end = Some init_global_abstract_data
  vm_compute.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Some
  {|
    Outgoing_transfer_recipient_and_amount := None;
    Crowdfunding_owner :=
      {|
        Int256.intval :=
          890025619261977197475349953386626580431692757011;
        Int256.intrange :=
          Int256.Z_mod_modulus_range'
            890025619261977197475349953386626580431692757011
      |};
    Crowdfunding_max_block :=
      {|
        Int256.intval := 140;
        Int256.intrange := Int256.Z_mod_modulus_range' 140
      |};
    Crowdfunding_goal := 50;
    Crowdfunding_backers :=
      exist
        (fun tr : PTree.t Z32 =>
         forall x : positive,
         tr ! x <> None ->
         Int256Indexed.index (Int256Indexed.index_inv x) = x)
        PTree.Leaf
        (fun (x : positive) (x0 : PTree.Leaf ! x <> None) =>
         Maps.Int256Tree.empty_obligation_1 x x0);
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg := 0;
    Crowdfunding_successfullyDonated_msg := 1;
    Crowdfunding_alreadyDonated_msg := 2;
    Crowdfunding_funded_msg := 3;
    Crowdfunding_failed_msg := 4;
    Crowdfunding_too_early_to_claim_funds_msg := 5;
    Crowdfunding_too_early_to_reclaim_msg := 6;
    Crowdfunding_cannot_refund_msg := 7;
    Crowdfunding_here_is_your_money_msg := 8
  |} =
Some
  {|
    Outgoing_transfer_recipient_and_amount := None;
    Crowdfunding_owner :=
      {|
        Int256.intval :=
          890025619261977197475349953386626580431692757011;
        Int256.intrange :=
          Int256.Z_mod_modulus_range'
            890025619261977197475349953386626580431692757011
      |};
    Crowdfunding_max_block :=
      {|
        Int256.intval := 140;
        Int256.intrange := Int256.Z_mod_modulus_range' 140
      |};
    Crowdfunding_goal := 50;
    Crowdfunding_backers :=
      exist
        (fun tr : PTree.t Z32 =>
         forall x : positive,
         tr ! x <> None ->
         Int256Indexed.index (Int256Indexed.index_inv x) = x)
        PTree.Leaf
        (fun (x : positive) (x0 : PTree.Leaf ! x <> None) =>
         Maps.Int256Tree.empty_obligation_1 x x0);
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg := 0;
    Crowdfunding_successfullyDonated_msg := 1;
    Crowdfunding_alreadyDonated_msg := 2;
    Crowdfunding_funded_msg := 3;
    Crowdfunding_failed_msg := 4;
    Crowdfunding_too_early_to_claim_funds_msg := 5;
    Crowdfunding_too_early_to_reclaim_msg := 6;
    Crowdfunding_cannot_refund_msg := 7;
    Crowdfunding_here_is_your_money_msg := 8
  |}
  unfold init_global_abstract_data.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Some
  {|
    Outgoing_transfer_recipient_and_amount := None;
    Crowdfunding_owner :=
      {|
        Int256.intval :=
          890025619261977197475349953386626580431692757011;
        Int256.intrange :=
          Int256.Z_mod_modulus_range'
            890025619261977197475349953386626580431692757011
      |};
    Crowdfunding_max_block :=
      {|
        Int256.intval := 140;
        Int256.intrange := Int256.Z_mod_modulus_range' 140
      |};
    Crowdfunding_goal := 50;
    Crowdfunding_backers :=
      exist
        (fun tr : PTree.t Z32 =>
         forall x : positive,
         tr ! x <> None ->
         Int256Indexed.index (Int256Indexed.index_inv x) = x)
        PTree.Leaf
        (fun (x : positive) (x0 : PTree.Leaf ! x <> None) =>
         Maps.Int256Tree.empty_obligation_1 x x0);
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg := 0;
    Crowdfunding_successfullyDonated_msg := 1;
    Crowdfunding_alreadyDonated_msg := 2;
    Crowdfunding_funded_msg := 3;
    Crowdfunding_failed_msg := 4;
    Crowdfunding_too_early_to_claim_funds_msg := 5;
    Crowdfunding_too_early_to_reclaim_msg := 6;
    Crowdfunding_cannot_refund_msg := 7;
    Crowdfunding_here_is_your_money_msg := 8
  |} =
Some
  {|
    Outgoing_transfer_recipient_and_amount := None;
    Crowdfunding_owner :=
      {|
        Int256.intval :=
          890025619261977197475349953386626580431692757011;
        Int256.intrange :=
          Int256.Z_mod_modulus_range'
            890025619261977197475349953386626580431692757011
      |};
    Crowdfunding_max_block :=
      {|
        Int256.intval := 140;
        Int256.intrange := Int256.Z_mod_modulus_range' 140
      |};
    Crowdfunding_goal := 50;
    Crowdfunding_backers :=
      exist
        (fun tr : PTree.t Z32 =>
         forall x : positive,
         tr ! x <> None ->
         Int256Indexed.index (Int256Indexed.index_inv x) = x)
        PTree.Leaf
        (fun (x : positive) (x0 : PTree.Leaf ! x <> None) =>
         Maps.Int256Tree.empty_obligation_1 x x0);
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg := 0;
    Crowdfunding_successfullyDonated_msg := 1;
    Crowdfunding_alreadyDonated_msg := 2;
    Crowdfunding_funded_msg := 3;
    Crowdfunding_failed_msg := 4;
    Crowdfunding_too_early_to_claim_funds_msg := 5;
    Crowdfunding_too_early_to_reclaim_msg := 6;
    Crowdfunding_cannot_refund_msg := 7;
    Crowdfunding_here_is_your_money_msg := 8
  |}
  reflexivity.
Qed.

Definition initial_state :=
  mkBlockchainState
    snapshot_timestamp
    snapshot_number
    snapshot_balances
    snapshot_blockhash
    init_global_abstract_data
.

Definition updateTimeAndBlock before block_count time_passing
  : BlockchainState :=
mkBlockchainState
  (time_passing + (timestamp before))%int256
  (block_count + (block_number before))%int256
  (balance before)
  (blockhash before)
  (contract_state before)
.

Definition validTimeChange block_count time_passing
  current_block_number current_timestamp : bool :=
  ((Int256.intval block_count) + (Int256.intval current_block_number) <=? Int256.max_unsigned)%Z
  && ((Int256.intval time_passing) + (Int256.intval current_timestamp) <=? Int256.max_unsigned)%Z.

Definition update_balances sender recipient amount balances
  : (addr -> wei) :=
  (* Here the balances are updated without checking for overflows.
     Overflow checks must be done elsewhere. *)
  fun a =>
  if (sender =? recipient)%int256 then balances a else
    if (a =? sender)%int256 then (balances sender) - amount else
    if (a =? recipient)%int256 then (balances recipient) + amount
      else balances a.

Definition update_balance before latest_balances : BlockchainState :=
  mkBlockchainState
  (timestamp before)
  (block_number before)
  latest_balances
  (blockhash before)
  (contract_state before)
.


Definition current_balances
  (successful_transfer : option (addr * Z))
  (initial_balances : addr -> wei)
  : (addr -> wei) :=
    match successful_transfer with
      | None => initial_balances
      | Some (recipient, amount) =>
          update_balances contract_address recipient amount initial_balances
    end.

Definition new_balance_after_contract_call (before : BlockchainState) (context : CallContext) (d : ContractState) : (addr -> wei) :=
    (current_balances
      (Outgoing_transfer_recipient_and_amount d)
      (update_balances (caller context) contract_address (callvalue context) (balance before))).

Definition resetTransfers (d : ContractState) : ContractState :=
  {|
  Crowdfunding_owner := Crowdfunding_owner d;
  Crowdfunding_max_block := Crowdfunding_max_block d;
  Crowdfunding_goal := Crowdfunding_goal d;
  Crowdfunding_backers := Crowdfunding_backers d;
  Crowdfunding_funded := Crowdfunding_funded d;
  Crowdfunding_deadlinePassed_msg := Crowdfunding_deadlinePassed_msg d;
  Crowdfunding_successfullyDonated_msg := Crowdfunding_successfullyDonated_msg d;
  Crowdfunding_alreadyDonated_msg := Crowdfunding_alreadyDonated_msg d;
  Crowdfunding_funded_msg := Crowdfunding_funded_msg d;
  Crowdfunding_failed_msg := Crowdfunding_failed_msg d;
  Crowdfunding_too_early_to_claim_funds_msg := Crowdfunding_too_early_to_claim_funds_msg d;
  Crowdfunding_too_early_to_reclaim_msg := Crowdfunding_too_early_to_reclaim_msg d;
  Crowdfunding_cannot_refund_msg := Crowdfunding_cannot_refund_msg d;
  Crowdfunding_here_is_your_money_msg := Crowdfunding_here_is_your_money_msg d;
  Outgoing_transfer_recipient_and_amount := None
|}.

Definition next_blockchain_state (before : BlockchainState)
  (context : CallContext) (d : ContractState) : BlockchainState :=
  mkBlockchainState
    (timestamp before)
    (block_number before)
    (new_balance_after_contract_call before context d)
    (blockhash before)
    (resetTransfers d).

Definition next_blockchain_state_keep_transfer (before : BlockchainState)
   (context : CallContext) (d : ContractState) : BlockchainState :=
  mkBlockchainState
    (timestamp before)
    (block_number before)
    (new_balance_after_contract_call before context d)
    (blockhash before)
    d.

(* This approach to defining Action requires all calls to a contract
  function to succeed, i.e. return (Some _ _), failure cases are
  amalgamated into the revert case. This means only needing to prove
  the (typically) trivial revert case once, without losing generality. *)
Inductive Action (before : BlockchainState) :=
  | call_Crowdfunding_donate (context : CallContext)
      (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
      (balances_bounded_prf : forall a, 0 <= (balance before) a < Int256.modulus)
      (callvalue_prf : noOverflowOrUnderflowInTransfer (caller context)
         contract_address (callvalue context) (balance before) = true)
      r
      contract_state_after
      (case_donate_prf :
          runStateT (Crowdfunding_donate_opt
            (make_machine_env contract_address before context
            address_accepts_funds_assumption callvalue_bounded_prf
            balances_bounded_prf callvalue_prf)) (contract_state before)
          = Some (r, contract_state_after))
  | call_Crowdfunding_getFunds (context : CallContext)
      (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
      (balances_bounded_prf : forall a, 0 <= (balance before) a < Int256.modulus)
      (callvalue_prf : noOverflowOrUnderflowInTransfer
        (caller context) contract_address (callvalue context) (balance before) = true)
      r
      contract_state_after
      (case_getFunds_prf :
          runStateT (Crowdfunding_getFunds_opt
          (make_machine_env contract_address before context
           address_accepts_funds_assumption callvalue_bounded_prf
           balances_bounded_prf callvalue_prf)) (contract_state before)
          = Some (r, contract_state_after))
  | call_Crowdfunding_claim (context : CallContext)
      (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
      (balances_bounded_prf : forall a, 0 <= (balance before) a < Int256.modulus)
      (callvalue_prf : noOverflowOrUnderflowInTransfer (caller context)
       contract_address (callvalue context) (balance before) = true)
      r
      contract_state_after
      (case_claim_prf :
          runStateT (Crowdfunding_claim_opt (make_machine_env
           contract_address before context address_accepts_funds_assumption
            callvalue_bounded_prf balances_bounded_prf callvalue_prf))
             (contract_state before)
          = Some (r, contract_state_after))
  | externalBalanceTransfer (sender recipient : addr) (amount : wei)
      (prf : sender <> contract_address /\ amount >= 0 /\
        ((noOverflowOrUnderflowInTransfer sender recipient amount (balance before))
        && (address_accepts_funds_assumption None sender recipient amount) = true))
  | timePassing (block_count time_passing : int256)
                (prf : validTimeChange block_count time_passing
                 (block_number before) (timestamp before) = true)
  | revert.

Fixpoint step
  (before : BlockchainState) (action : Action before) : BlockchainState :=
match action with
| call_Crowdfunding_donate context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_donate_prf =>
      next_blockchain_state before context d_after
| call_Crowdfunding_claim context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_claim_prf =>
      next_blockchain_state before context d_after
| call_Crowdfunding_getFunds context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_getFunds_prf =>
      next_blockchain_state before context d_after
| timePassing block_count time_passing prf =>
    updateTimeAndBlock before block_count time_passing
| externalBalanceTransfer sender recipient amount prf =>
    update_balance before (update_balances sender recipient amount (balance before))
| revert => before
end.
Not a truly recursive fixpoint. [non-recursive,fixpoints]

Fixpoint step_keep_transfer
  (before : BlockchainState) (action : Action before) : BlockchainState :=
match action with
| call_Crowdfunding_donate context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_donate_prf =>
      next_blockchain_state_keep_transfer before context d_after
| call_Crowdfunding_claim context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_claim_prf =>
      next_blockchain_state_keep_transfer before context d_after
| call_Crowdfunding_getFunds context
    callvalue_bounded_prf balances_bounded_prf callvalue_prf
    r d_after case_getFunds_prf =>
      next_blockchain_state_keep_transfer before context d_after
| timePassing block_count time_passing prf =>
    updateTimeAndBlock before block_count time_passing
| externalBalanceTransfer sender recipient amount prf =>
    update_balance before (update_balances sender recipient amount (balance before))
| revert => before
end.
Not a truly recursive fixpoint. [non-recursive,fixpoints]

Record Step := mkStep
  {
    Step_state : BlockchainState;
    Step_action : Action Step_state
  }.

Record StepSpace := mkStepSpace
  {
    StepSpace_state : BlockchainState;
    StepSpace_actions : Type
  }.

Class Next (b : BlockchainState) : Type :=
{
    next : Action b -> BlockchainState
}.

Instance : Next initial_state :=
{
  next := step initial_state
}.


Definition InSecond (st : BlockchainState) :=
  exists (a : Action initial_state), st = step initial_state a.

Definition InThird (st : BlockchainState) :=
    exists (two : BlockchainState) (a : Action two) ,
      InSecond two /\ st = step two a.

Definition InFourth (st : BlockchainState) :=
  exists (three : BlockchainState) (a : Action three) ,
    InThird three /\ st = step three a.

Open Scope nat.
Inductive InPossible (st : BlockchainState) (n:nat) :=
  | inzero (H : exists (a : Action initial_state), st = step initial_state a)
      (Hn : n = 0) : InPossible st n
  | inSn (current : BlockchainState) (Hs : InPossible current (n - 1))

  (
    H : exists (a : Action current),
    st = step current a
  )
  : InPossible st n

  .
Close Scope nat.

Definition stepOnce prev := (step (Step_state prev) (Step_action prev)).
Definition stepOnceAndWrap prev next_action := (mkStep (stepOnce prev) next_action).
Hint Unfold stepOnce stepOnceAndWrap.
Adding and removing hints in the core database implicitly is
deprecated. Please specify a hint database.
[implicit-core-hint-db,deprecated]

Inductive ReachableFromBy from : BlockchainState -> Step -> list Step -> Prop :=
| initial_case (Hno_leftover_outgoings :
    Outgoing_transfer_recipient_and_amount (contract_state from) = None)
      (next_action : Action from)
    : ReachableFromBy from from (mkStep from next_action) [mkStep from next_action]
| step_case (prevSt : BlockchainState) (prev : Step) (prevList : list Step)
            (Hprev : ReachableFromBy from prevSt prev prevList)
    (next_action : Action (stepOnce prev))
    : ReachableFromBy from  (stepOnce prev)
    (stepOnceAndWrap prev next_action)
    (stepOnceAndWrap prev next_action :: prevList)  .
(* begin snippet ReachableFromByLinkStateToStep *)
Lemma ReachableFromByLinkStateToStep : forall st st' s l,
  ReachableFromBy st st' s l -> st' = Step_state s.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l -> st' = Step_state s
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l -> st' = Step_state s
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, st': BlockchainState
s: Step
l: list Step
H: ReachableFromBy st st' s l
st' = Step_state s
  destruct H; reflexivity.
Qed.
(* end snippet ReachableFromByLinkStateToStep *)

Lemma ReachableFromByLinkStepToList : forall st st' s l,
  ReachableFromBy st st' s l -> exists tl, s :: tl = l.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l -> exists tl : list Step, s :: tl = l
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l -> exists tl : list Step, s :: tl = l
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, st': BlockchainState
s: Step
l: list Step
H: ReachableFromBy st st' s l
exists tl : list Step, s :: tl = l
  destruct H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st: BlockchainState
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state st) = None
next_action: Action st
exists tl : list Step,
  {| Step_state := st; Step_action := next_action |} :: tl =
  [{| Step_state := st; Step_action := next_action |}]
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
exists tl : list Step,
  stepOnceAndWrap prev next_action :: tl =
  stepOnceAndWrap prev next_action :: prevList
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st: BlockchainState
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state st) = None
next_action: Action st
exists tl : list Step,
  {| Step_state := st; Step_action := next_action |} :: tl =
  [{| Step_state := st; Step_action := next_action |}] exists [].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st: BlockchainState
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state st) = None
next_action: Action st
[{| Step_state := st; Step_action := next_action |}] =
[{| Step_state := st; Step_action := next_action |}] reflexivity.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
exists tl : list Step,
  stepOnceAndWrap prev next_action :: tl =
  stepOnceAndWrap prev next_action :: prevList exists prevList.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
stepOnceAndWrap prev next_action :: prevList =
stepOnceAndWrap prev next_action :: prevList reflexivity.
Qed.

Ltac reachableFromByLinks :=
  match goal with
  | H : ReachableFromBy _ _ _ _ |- _ =>
    let StateToStepName := fresh "HReachableFromByLinkStateToStep" in
    let StepToListName := fresh "HReachableFromByLinkStepToList" in
    epose proof (ReachableFromByLinkStateToStep _ _ _ _ H) as StateToStepName;
    epose proof (ReachableFromByLinkStepToList _ _ _ _ H) as StepToListName
  end.

Lemma NoLeftoverOutgoings : forall {st st' s l},
  ReachableFromBy st st' s l ->
    Outgoing_transfer_recipient_and_amount (contract_state st') = None.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l ->
Outgoing_transfer_recipient_and_amount (contract_state st') = None
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (st st' : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy st st' s l ->
Outgoing_transfer_recipient_and_amount (contract_state st') = None
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, st': BlockchainState
s: Step
l: list Step
H: ReachableFromBy st st' s l
Outgoing_transfer_recipient_and_amount (contract_state st') = None
  induction H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st: BlockchainState
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state st) = None
next_action: Action st
Outgoing_transfer_recipient_and_amount (contract_state st) = None
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
Outgoing_transfer_recipient_and_amount
  (contract_state (stepOnce prev)) = None
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st: BlockchainState
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state st) = None
next_action: Action st
Outgoing_transfer_recipient_and_amount (contract_state st) = None assumption.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
Outgoing_transfer_recipient_and_amount
  (contract_state (stepOnce prev)) = None unfold stepOnce.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
Outgoing_transfer_recipient_and_amount
  (contract_state (step (Step_state prev) (Step_action prev))) = None
    unfold step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
Outgoing_transfer_recipient_and_amount
  (contract_state
     ((fix step
         (before : BlockchainState) (action : Action before) {struct
          action} : BlockchainState :=
         match action with
         | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
           @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
           @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
             next_blockchain_state before context d_after
         | @externalBalanceTransfer _ sender recipient amount _ =>
             update_balance before
               (update_balances sender recipient amount
                  (balance before))
         | @timePassing _ block_count time_passing _ =>
             updateTimeAndBlock before block_count time_passing
         | @revert _ => before
         end) (Step_state prev) (Step_action prev))) = None
    destruct (Step_action prev) eqn:Case; simpl; try reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Outgoing_transfer_recipient_and_amount
  (contract_state prevSt) = None
Case: Step_action prev = revert (Step_state prev)
Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
    all: reachableFromByLinks; subst; assumption.
Qed.

Definition since_as_long (P : BlockchainState -> Prop) (Q : BlockchainState -> Prop)
(R : Step -> Prop) :=
  forall schedule st st' step',
    ReachableFromBy st st' step' schedule ->
    P st ->
    (forall sa, List.In sa schedule -> R sa) ->
    Q st'.

Notation "Q `since` P `as-long-as` R" := (since_as_long P Q R) (at level 1).

Definition donation_recorded (a : addr) (amount : Z) (s : BlockchainState) :=
  Int256Tree.get_default 0 a (Crowdfunding_backers (contract_state s))
   = amount /\ amount > 0.

Definition no_claims_from (a : addr) (s : Step) :=
  match Step_action s with
  | (call_Crowdfunding_claim _ a _ _ _ _ _) => False
  | _ => True
  end.

Ltac destruct_if_H :=
  let caseName := fresh "IfCase" in
  match goal with
    | [ _ : context[if ?X then _ else _] |- _ ] => destruct X eqn:caseName
  end.

Ltac destruct_beq256_H :=
  let caseName := fresh "IfCaseBeq" in
    match goal with
      | [ _ : context[(?X =? ?Y)%int256] |- _ ] => destruct (X =? Y)%int256 eqn:caseName
    end.

Ltac destruct_geq256_H :=
  let caseName := fresh "IfCaseGeq" in
    match goal with
      | [ _ : context[(?X >=? ?Y)%int256] |- _ ] => destruct (X >=? Y)%int256 eqn:caseName
    end.

Hint Unfold Z_bounded. (*Causes annoying issues, use autounfold in *. *)
Adding and removing hints in the core database implicitly is
deprecated. Please specify a hint database.
[implicit-core-hint-db,deprecated]


Ltac destruct_and :=
  match goal with
    | [ H : (_ /\ _) |- _ ] => destruct H
  end.

(* The expanded version more closely mirrors the proof as it was first
    proven, before being written concisely. *)
Lemma donation_preserved_expanded_version (a : addr) (amount : Z):
              (donation_recorded a amount)
  `since`      (donation_recorded a amount)
  `as-long-as` (no_claims_from a).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
(donation_recorded a amount) `since` donation_recorded a amount
`as-long-as` (no_claims_from a)
    Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
(donation_recorded a amount) `since` donation_recorded a amount
`as-long-as` (no_claims_from a)
      unfold since_as_long.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
forall (schedule : list Step) (st st' : BlockchainState)
  (step' : Step),
ReachableFromBy st st' step' schedule ->
donation_recorded a amount st ->
(forall sa : Step, In sa schedule -> no_claims_from a sa) ->
donation_recorded a amount st'
      intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
schedule: list Step
st, st': BlockchainState
step': Step
H: ReachableFromBy st st' step' schedule
H0: donation_recorded a amount st
H1: forall sa : Step, In sa schedule -> no_claims_from a sa
donation_recorded a amount st'

      induction H; [assumption|].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)

      assert(donation_recorded a amount prevSt).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
donation_recorded a amount prevSt
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      apply IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
forall sa : Step, In sa prevList -> no_claims_from a sa
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
sa: Step
H2: In sa prevList
no_claims_from a sa
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      apply H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
sa: Step
H2: In sa prevList
In sa (stepOnceAndWrap prev next_action :: prevList)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      apply in_cons; assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a amount st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)

      clear H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a amount prevSt
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      clear IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H2: donation_recorded a amount prevSt
donation_recorded a amount (stepOnce prev)
      unfold donation_recorded in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H2: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount /\ amount > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount /\
amount > 0
      destruct_and.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount /\
amount > 0
      split; [|assumption].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount

      reachableFromByLinks.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount

      assert (no_claims_from a prev).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
no_claims_from a prev
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount
      apply H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
In prev (stepOnceAndWrap prev next_action :: prevList)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount
      destruct HReachableFromByLinkStepToList.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
x: list Step
H3: prev :: x = prevList
In prev (stepOnceAndWrap prev next_action :: prevList)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount
      subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st: BlockchainState
prev: Step
x: list Step
H: ReachableFromBy st (Step_state prev) prev (prev :: x)
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prev :: x) ->
no_claims_from a sa
H2: get_default 0 a
  (Crowdfunding_backers (contract_state (Step_state prev))) > 0
In prev (stepOnceAndWrap prev next_action :: prev :: x)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount
      right.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st: BlockchainState
prev: Step
x: list Step
H: ReachableFromBy st (Step_state prev) prev (prev :: x)
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prev :: x) ->
no_claims_from a sa
H2: get_default 0 a
  (Crowdfunding_backers (contract_state (Step_state prev))) > 0
In prev (prev :: x)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount left.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st: BlockchainState
prev: Step
x: list Step
H: ReachableFromBy st (Step_state prev) prev (prev :: x)
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prev :: x) ->
no_claims_from a sa
H2: get_default 0 a
  (Crowdfunding_backers (contract_state (Step_state prev))) > 0
prev = prev
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = amount

      destruct prev; simpl in *; unfold stepOnceAndWrap, step in *; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H: ReachableFromBy st prevSt
  {| Step_state := Step_state0; Step_action := Step_action0 |}
  prevList
next_action: Action
  (stepOnce
     {|
       Step_state := Step_state0;
       Step_action := Step_action0
     |})
H1: forall sa : Step,
{|
  Step_state :=
    stepOnce
      {|
        Step_state := Step_state0; Step_action := Step_action0
      |};
  Step_action := next_action
|} = sa \/ In sa prevList -> 
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
HReachableFromByLinkStepToList: exists tl : list Step,
  {|
    Step_state := Step_state0;
    Step_action := Step_action0
  |} :: tl = prevList
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      clear H1. (* no_claims_one, not needed this time? *)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H: ReachableFromBy st prevSt
  {| Step_state := Step_state0; Step_action := Step_action0 |}
  prevList
next_action: Action
  (stepOnce
     {|
       Step_state := Step_state0;
       Step_action := Step_action0
     |})
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
HReachableFromByLinkStepToList: exists tl : list Step,
  {|
    Step_state := Step_state0;
    Step_action := Step_action0
  |} :: tl = prevList
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      clear next_action.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H: ReachableFromBy st prevSt
  {| Step_state := Step_state0; Step_action := Step_action0 |}
  prevList
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
HReachableFromByLinkStepToList: exists tl : list Step,
  {|
    Step_state := Step_state0;
    Step_action := Step_action0
  |} :: tl = prevList
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      clear H. (* ReachableFromBy, no longer needed? *)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
HReachableFromByLinkStepToList: exists tl : list Step,
  {|
    Step_state := Step_state0;
    Step_action := Step_action0
  |} :: tl = prevList
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      clear HReachableFromByLinkStepToList.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      unfold no_claims_from in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (stepOnce
           {|
             Step_state := Step_state0; Step_action := Step_action0
           |}))) = amount
      unfold stepOnce.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        (step
           (Step_state
              {|
                Step_state := Step_state0;
                Step_action := Step_action0
              |})
           (Step_action
              {|
                Step_state := Step_state0;
                Step_action := Step_action0
              |})))) = amount simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state (step Step_state0 Step_action0))) = amount
      unfold donation_recorded in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state (step Step_state0 Step_action0))) = amount
      destruct Step_action0; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf)) 
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: False
get_default 0 a (Crowdfunding_backers contract_state_after) = amount
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
sender, recipient: addr
amount0: wei
prf: sender <> contract_address /\
amount0 >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount0
  (balance Step_state0) &&
address_accepts_funds_assumption None sender recipient amount0 =
true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number Step_state0) 
  (timestamp Step_state0) = true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount Transparent Crowdfunding_donate_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount unfold Crowdfunding_donate_opt in case_donate_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            Step_state0 context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           Step_state0 context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                Step_state0 context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address Step_state0
                    context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address Step_state0
                    context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount
          ds_inv; subst; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
H20: false = true
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
get_default 0 a
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
false
H22: false = true
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
          +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
H20: false = true
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) match goal with H : false = true |- _ => inversion H end.
          +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) destruct (a =? (caller context))%int256 eqn:Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: (a =? caller context)%int256 = true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: (a =? caller context)%int256 = false
get_default 0 a
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
            *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: (a =? caller context)%int256 = true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) apply Int256eq_true in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: a = caller context
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) rewrite <- Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: a = caller context
get_default 0 a
  (set a (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
              rewrite get_default_ss.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: a = caller context
callvalue context =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
              exfalso.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: a = caller context
False
              subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
False
              unfold make_machine_env in Heqb0; simpl in Heqb0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
False
              apply Z.eqb_eq in Heqb0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) = 0
False
              rewrite Heqb0 in H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: 0 > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) = 0
False
              lia.
            *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: (a =? caller context)%int256 = false
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) apply Int256eq_false in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
true
Case: a <> caller context
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
              apply get_default_so; assumption.
          +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0) =
false
H22: false = true
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) match goal with H : false = true |- _ => inversion H end.
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount Transparent Crowdfunding_getFunds_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount unfold Crowdfunding_getFunds_opt in case_getFunds_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            Step_state0 context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           Step_state0 context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             Step_state0 context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             Step_state0 context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                Step_state0 context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt)) (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = amount
          ds_inv; subst; simpl; try reflexivity.
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf)) 
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: False
get_default 0 a (Crowdfunding_backers contract_state_after) = amount contradiction.
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
sender, recipient: addr
amount0: wei
prf: sender <> contract_address /\
amount0 >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount0
  (balance Step_state0) &&
address_accepts_funds_assumption None sender recipient amount0 =
true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount rewrite <- HReachableFromByLinkStateToStep.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
sender, recipient: addr
amount0: wei
prf: sender <> contract_address /\
amount0 >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount0
  (balance Step_state0) &&
address_accepts_funds_assumption None sender recipient amount0 =
true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount assumption.
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number Step_state0) 
  (timestamp Step_state0) = true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount rewrite <- HReachableFromByLinkStateToStep.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number Step_state0) 
  (timestamp Step_state0) = true
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount assumption.
        -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) =
amount rewrite <- HReachableFromByLinkStateToStep.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
amount: Z
st, prevSt, Step_state0: BlockchainState
prevList: list Step
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount
H2: amount > 0
HReachableFromByLinkStateToStep: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
amount assumption.
Qed.
Opaque Crowdfunding_donate_opt Crowdfunding_getFunds_opt Crowdfunding_claim_opt.

Ltac Hlinks :=
  match goal with
  | H : ReachableFromBy _ _ _ _ |- _ =>
    let StateToStepName := fresh "HS" in
    let StepToListName := fresh "HL" in
    epose proof (ReachableFromByLinkStateToStep _ _ _ _ H) as StateToStepName;
    epose proof (ReachableFromByLinkStepToList _ _ _ _ H) as StepToListName
  end.

Ltac inv_FT :=
  try match goal with H : false = true |- _ => inversion H end.

Hint Unfold stepOnceAndWrap step stepOnce make_machine_env.
Adding and removing hints in the core database implicitly is
deprecated. Please specify a hint database.
[implicit-core-hint-db,deprecated]

Definition donate_fun := Crowdfunding_donate_opt.

Open Scope int256.

Lemma donation_preserved :
  forall (a : addr) (d : Z),
                (donation_recorded a d)
    `since`      (donation_recorded a d)
    `as-long-as` (no_claims_from a).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (a : addr) (d : Z),
(donation_recorded a d) `since` donation_recorded a d
`as-long-as` (no_claims_from a)
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (a : addr) (d : Z),
(donation_recorded a d) `since` donation_recorded a d
`as-long-as` (no_claims_from a)
(* Proof of a temporal property. *)
unfold since_as_long.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (a : addr) (d : Z) (schedule : list Step)
  (st st' : BlockchainState) (step' : Step),
ReachableFromBy st st' step' schedule ->
donation_recorded a d st ->
(forall sa : Step, In sa schedule -> no_claims_from a sa) ->
donation_recorded a d st' intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
schedule: list Step
st, st': BlockchainState
step': Step
H: ReachableFromBy st st' step' schedule
H0: donation_recorded a d st
H1: forall sa : Step, In sa schedule -> no_claims_from a sa
donation_recorded a d st' induction H; [assumption|].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a d st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a d prevSt
donation_recorded a d (stepOnce prev)
assert(donation_recorded a d prevSt) by (apply IHReachableFromBy;
intros; apply H1; apply in_cons; assumption).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H0: donation_recorded a d st
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
IHReachableFromBy: (forall sa : Step,
 In sa prevList -> no_claims_from a sa) ->
donation_recorded a d prevSt
H2: donation_recorded a d prevSt
donation_recorded a d (stepOnce prev)
clear H0 IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H2: donation_recorded a d prevSt
donation_recorded a d (stepOnce prev) unfold donation_recorded in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H2: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d /\ d > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = d /\
d > 0 destruct_and.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = d /\
d > 0
split; [|assumption].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = d Hlinks.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state prev
HL: exists tl : list Step, prev :: tl = prevList
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = d assert (no_claims_from a prev) by
(apply H1; destruct HL; subst; right; left; auto).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy st prevSt prev prevList
next_action: Action (stepOnce prev)
H1: forall sa : Step,
In sa (stepOnceAndWrap prev next_action :: prevList) ->
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state prev
HL: exists tl : list Step, prev :: tl = prevList
H3: no_claims_from a prev
get_default 0 a
  (Crowdfunding_backers (contract_state (stepOnce prev))) = d
destruct prev; autounfold in *; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
H: ReachableFromBy st prevSt
  {| Step_state := Step_state0; Step_action := Step_action0 |}
  prevList
next_action: Action
  ((fix step
      (before : BlockchainState)
      (action : Action before) {struct action} :
        BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _
        d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient
        amount _ =>
          update_balance before
            (update_balances sender recipient amount
               (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count
            time_passing
      | @revert _ => before
      end) Step_state0 Step_action0)
H1: forall sa : Step,
{|
  Step_state :=
    (fix step
       (before : BlockchainState) 
       (action : Action before) {struct action} :
         BlockchainState :=
       match action with
       | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
         @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
         @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
           next_blockchain_state before context d_after
       | @externalBalanceTransfer _ sender recipient amount _ =>
           update_balance before
             (update_balances sender recipient amount
                (balance before))
       | @timePassing _ block_count time_passing _ =>
           updateTimeAndBlock before block_count time_passing
       | @revert _ => before
       end) Step_state0 Step_action0;
  Step_action := next_action
|} = sa \/ In sa prevList -> 
no_claims_from a sa
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
HL: exists tl : list Step,
  {| Step_state := Step_state0; Step_action := Step_action0 |}
  :: tl = prevList
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        ((fix step
            (before : BlockchainState) (action : Action before)
            {struct action} : BlockchainState :=
            match action with
            | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
                next_blockchain_state before context d_after
            | @externalBalanceTransfer _ sender recipient amount _ =>
                update_balance before
                  (update_balances sender recipient amount
                     (balance before))
            | @timePassing _ block_count time_passing _ =>
                updateTimeAndBlock before block_count time_passing
            | @revert _ => before
            end) Step_state0 Step_action0))) = d
clear H1 H HL.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
next_action: Action
  ((fix step
      (before : BlockchainState)
      (action : Action before) {struct action} :
        BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _
        d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient
        amount _ =>
          update_balance before
            (update_balances sender recipient amount
               (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count
            time_passing
      | @revert _ => before
      end) Step_state0 Step_action0)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: no_claims_from a
  {| Step_state := Step_state0; Step_action := Step_action0 |}
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        ((fix step
            (before : BlockchainState) (action : Action before)
            {struct action} : BlockchainState :=
            match action with
            | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
                next_blockchain_state before context d_after
            | @externalBalanceTransfer _ sender recipient amount _ =>
                update_balance before
                  (update_balances sender recipient amount
                     (balance before))
            | @timePassing _ block_count time_passing _ =>
                updateTimeAndBlock before block_count time_passing
            | @revert _ => before
            end) Step_state0 Step_action0))) = d unfold no_claims_from in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
next_action: Action
  ((fix step
      (before : BlockchainState)
      (action : Action before) {struct action} :
        BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _
        d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient
        amount _ =>
          update_balance before
            (update_balances sender recipient amount
               (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count
            time_passing
      | @revert _ => before
      end) Step_state0 Step_action0)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        ((fix step
            (before : BlockchainState) (action : Action before)
            {struct action} : BlockchainState :=
            match action with
            | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
                next_blockchain_state before context d_after
            | @externalBalanceTransfer _ sender recipient amount _ =>
                update_balance before
                  (update_balances sender recipient amount
                     (balance before))
            | @timePassing _ block_count time_passing _ =>
                updateTimeAndBlock before block_count time_passing
            | @revert _ => before
            end) Step_state0 Step_action0))) = d
unfold donation_recorded in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
Step_action0: Action Step_state0
prevList: list Step
next_action: Action
  ((fix step
      (before : BlockchainState)
      (action : Action before) {struct action} :
        BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _
        d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _
        d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient
        amount _ =>
          update_balance before
            (update_balances sender recipient amount
               (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count
            time_passing
      | @revert _ => before
      end) Step_state0 Step_action0)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: match
  Step_action
    {| Step_state := Step_state0; Step_action := Step_action0 |}
with
| @call_Crowdfunding_claim _ _ _ _ _ _ _ _ => False
| _ => True
end
get_default 0 a
  (Crowdfunding_backers
     (contract_state
        ((fix step
            (before : BlockchainState) (action : Action before)
            {struct action} : BlockchainState :=
            match action with
            | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
              @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
                next_blockchain_state before context d_after
            | @externalBalanceTransfer _ sender recipient amount _ =>
                update_balance before
                  (update_balances sender recipient amount
                     (balance before))
            | @timePassing _ block_count time_passing _ =>
                updateTimeAndBlock before block_count time_passing
            | @revert _ => before
            end) Step_state0 Step_action0))) = d destruct Step_action0; simpl in *;
rewrite <- HS in *; try assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf)) 
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: False
get_default 0 a (Crowdfunding_backers contract_state_after) = d
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d Transparent Crowdfunding_donate_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d
  unfold Crowdfunding_donate_opt in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)));;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            Step_state0 context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           Step_state0 context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                Step_state0 context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if (spec4 =? 0)%Z
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address Step_state0
                    context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address Step_state0
                    context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d ds_inv; subst; simpl; inv_FT.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
  destruct (a =? (caller context)) eqn:Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: (a =? caller context) = true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: (a =? caller context) = false
get_default 0 a
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
  +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: (a =? caller context) = true
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) apply Int256eq_true in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: a = caller context
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) rewrite <- Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: a = caller context
get_default 0 a
  (set a (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0))
    rewrite get_default_ss.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: a = caller context
callvalue context =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) exfalso.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: a = caller context
False subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
False simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set (caller context) 
           (callvalue context)
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb (caller context =? contract_address) = true
a2: unit
H8: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (block_number Step_state0) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
False
    apply Z.eqb_eq in Heqb0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set (caller context) 
           (callvalue context)
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb (caller context =? contract_address) = true
a2: unit
H8: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (block_number Step_state0) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) = 0
False rewrite Heqb0 in H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: 0 > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set (caller context) 
           (callvalue context)
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb (caller context =? contract_address) = true
a2: unit
H8: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (block_number Step_state0) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state Step_state0)) = 0
False lia.
  +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: (a =? caller context) = false
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) apply Int256eq_false in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
st, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
prevList: list Step
H2: get_default 0 a
  (Crowdfunding_backers (contract_state Step_state0)) > 0
next_action: Action
  (next_blockchain_state Step_state0 context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address
                 Step_state0 context
                 address_accepts_funds_assumption
                 callvalue_bounded_prf
                 balances_bounded_prf callvalue_prf))
           (Crowdfunding_backers
              (contract_state Step_state0)))
        (contract_state Step_state0)))
H3: True
a0: unit
H4: negb
  (me_caller
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
a2: unit
H8: (me_callvalue
   (make_machine_env contract_address Step_state0 context
      address_accepts_funds_assumption callvalue_bounded_prf
      balances_bounded_prf callvalue_prf) >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state Step_state0))
  (me_number
     (make_machine_env contract_address Step_state0 context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address Step_state0 context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state Step_state0)) =? 0)%Z =
true
Case: a <> caller context
get_default 0 a
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state Step_state0))) =
get_default 0 a (Crowdfunding_backers (contract_state Step_state0)) apply get_default_so; assumption.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d Transparent Crowdfunding_getFunds_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        Step_state0 context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d
  unfold Crowdfunding_getFunds_opt in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               Step_state0 context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)));;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            Step_state0 context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0)%Z;; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     me_caller
       (make_machine_env contract_address
          Step_state0 context
          address_accepts_funds_assumption
          callvalue_bounded_prf
          balances_bounded_prf callvalue_prf) =?
     spec1
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             Step_state0 context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             Step_state0 context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                Step_state0 context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if success =? Int256.one
          then put d'
          else mzero)
        else ret tt)
      else ret tt)
    else ret tt)) (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: True
get_default 0 a (Crowdfunding_backers contract_state_after) = d
  ds_inv; subst; reflexivity.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
a: addr
d: Z
st, prevSt, Step_state0: BlockchainState
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance Step_state0 a < Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance Step_state0) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address Step_state0
        context address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf)) 
  (contract_state Step_state0) =
Some (r, contract_state_after)
prevList: list Step
next_action: Action
  (next_blockchain_state prevSt context
     contract_state_after)
H0: get_default 0 a (Crowdfunding_backers (contract_state prevSt)) =
d
H2: d > 0
HS: prevSt = Step_state0
H3: False
get_default 0 a (Crowdfunding_backers contract_state_after) = d contradiction.
Qed.

Opaque Crowdfunding_donate_opt Crowdfunding_getFunds_opt Crowdfunding_claim_opt.
Close Scope int256.

(* Safety property predicate *)
Definition Safe P :=
  forall state s l, ReachableFromBy initial_state state s l -> P state.


Definition balance_backed state :=
  (Crowdfunding_funded (contract_state state)) = false
  ->
  sum (Crowdfunding_backers (contract_state state))
    <= (balance state (contract_address)) /\
    (forall key value,
      get key (Crowdfunding_backers (contract_state state)) = Some value ->
        ((value >= 0) /\ (value < Int256.modulus))).

Lemma addZeroBalance : forall sender recipient balances a,
  update_balances sender recipient 0 balances a = balances a.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (sender recipient : int256) (balances : addr -> wei)
  (a : addr),
update_balances sender recipient 0 balances a = balances a
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (sender recipient : int256) (balances : addr -> wei)
  (a : addr),
update_balances sender recipient 0 balances a = balances a
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
update_balances sender recipient 0 balances a = balances a
  unfold update_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
(if (sender =? recipient)%int256
 then balances a
 else
  if (a =? sender)%int256
  then balances sender - 0
  else
   if (a =? recipient)%int256
   then balances recipient + 0
   else balances a) = balances a
  destruct (Int256.eq sender recipient).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
balances a = balances a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
(if (a =? sender)%int256
 then balances sender - 0
 else
  if (a =? recipient)%int256
  then balances recipient + 0
  else balances a) = 
balances a
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
balances a = balances a reflexivity.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
(if (a =? sender)%int256
 then balances sender - 0
 else
  if (a =? recipient)%int256
  then balances recipient + 0
  else balances a) = balances a destruct (Int256.eq a sender) eqn:Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = true
balances sender - 0 = balances a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
(if (a =? recipient)%int256
 then balances recipient + 0
 else balances a) = balances a
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = true
balances sender - 0 = balances a rewrite Z.sub_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = true
balances sender = balances a
    apply Int256eq_true in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: a = sender
balances sender = balances a subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
balances sender = balances sender
    reflexivity.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
(if (a =? recipient)%int256
 then balances recipient + 0
 else balances a) = balances a destruct (Int256.eq a recipient) eqn:SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: (a =? recipient)%int256 = true
balances recipient + 0 = balances a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: (a =? recipient)%int256 = false
balances a = balances a
      *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: (a =? recipient)%int256 = true
balances recipient + 0 = balances a rewrite Z.add_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: (a =? recipient)%int256 = true
balances recipient = balances a
        apply Int256eq_true in SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: a = recipient
balances recipient = balances a subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
Case: (recipient =? sender)%int256 = false
balances recipient = balances recipient
        reflexivity.
      *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
sender, recipient: int256
balances: addr -> wei
a: addr
Case: (a =? sender)%int256 = false
SCase: (a =? recipient)%int256 = false
balances a = balances a reflexivity.
Qed.

Lemma balance_backed_in_next_state :
  forall prev context,
    balance_backed (Step_state prev)
    (* -> contract_state_after =   *)
    -> Outgoing_transfer_recipient_and_amount (contract_state (Step_state prev)) = None
    -> (callvalue context =? 0) = true
    (* -> negb (Int256.eq (caller context) contract_address) = true  *)

    -> balance_backed
    (next_blockchain_state (Step_state prev) context
    (contract_state (Step_state prev))).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (prev : Step) (context : CallContext),
balance_backed (Step_state prev) ->
Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None ->
(callvalue context =? 0) = true ->
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
    (* balance_backed (next_blockchain_state {|
      timestamp := timestamp (Step_state prev);
      block_number := block_number (Step_state prev);
      balance := balance (Step_state prev);
      blockhash := blockhash (Step_state prev);
      contract_state := (resetTransfers (contract_state (Step_state prev)))
    |}
    context
    (resetTransfers (contract_state (Step_state prev)))
    ). *)
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (prev : Step) (context : CallContext),
balance_backed (Step_state prev) ->
Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None ->
(callvalue context =? 0) = true ->
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: balance_backed (Step_state prev)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: (callvalue context =? 0) = true
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
unfold step; unfold balance_backed; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: balance_backed (Step_state prev)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: (callvalue context =? 0) = true
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
unfold balance_backed in H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: (callvalue context =? 0) = true
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
apply Z.eqb_eq in H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) unfold current_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
match
  Outgoing_transfer_recipient_and_amount
    (contract_state (Step_state prev))
with
| Some (recipient, amount) =>
    update_balances contract_address recipient amount
      (update_balances (caller context) contract_address
         (callvalue context) (balance (Step_state prev)))
| None =>
    update_balances (caller context) contract_address
      (callvalue context) (balance (Step_state prev))
end contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
match
  Outgoing_transfer_recipient_and_amount
    (contract_state (Step_state prev))
with
| Some (recipient, amount) =>
    update_balances contract_address recipient amount
      (update_balances (caller context) contract_address
         (callvalue context) (balance (Step_state prev)))
| None =>
    update_balances (caller context) contract_address
      (callvalue context) (balance (Step_state prev))
end contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
rewrite H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
match
  Outgoing_transfer_recipient_and_amount
    (contract_state (Step_state prev))
with
| Some (recipient, amount) =>
    update_balances contract_address recipient amount
      (update_balances (caller context) contract_address 0
         (balance (Step_state prev)))
| None =>
    update_balances (caller context) contract_address 0
      (balance (Step_state prev))
end contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
rewrite H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 0
  (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
(* subst. *)
(* unfold resetTransfers. simpl. *)
rewrite addZeroBalance.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
H2: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
subst.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prev: Step
context: CallContext
H: Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
H1: callvalue context = 0
H2: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
split;
  apply H in H2; destruct H2; assumption.
Qed.

(* One of three properties describing a correct crowdfunding contract *)
Lemma sufficient_funds_safe : Safe balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Safe balance_backed
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Safe balance_backed
  unfold Safe.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (state : BlockchainState) (s : Step) (l : list Step),
ReachableFromBy initial_state state s l -> balance_backed state
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
H: ReachableFromBy initial_state state s l
balance_backed state
  induction H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
balance_backed initial_state
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed prevSt
balance_backed (stepOnce prev)
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
balance_backed initial_state unfold initial_state, balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
Crowdfunding_funded
  (contract_state
     {|
       timestamp := snapshot_timestamp;
       block_number := snapshot_number;
       balance := snapshot_balances;
       blockhash := snapshot_blockhash;
       contract_state := init_global_abstract_data
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := snapshot_timestamp;
          block_number := snapshot_number;
          balance := snapshot_balances;
          blockhash := snapshot_blockhash;
          contract_state := init_global_abstract_data
        |})) <=
balance
  {|
    timestamp := snapshot_timestamp;
    block_number := snapshot_number;
    balance := snapshot_balances;
    blockhash := snapshot_blockhash;
    contract_state := init_global_abstract_data
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := snapshot_timestamp;
           block_number := snapshot_number;
           balance := snapshot_balances;
           blockhash := snapshot_blockhash;
           contract_state := init_global_abstract_data
         |})) = Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
false = false ->
sum (empty Z32) <= snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key (empty Z32) = Some value ->
 value >= 0 /\ value < Int256.modulus)
    intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
sum (empty Z32) <= snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key (empty Z32) = Some value ->
 value >= 0 /\ value < Int256.modulus)
    unfold Int256Tree_Properties.sum.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
fold1 Z.add (empty Z32) 0 <= snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key (empty Z32) = Some value ->
 value >= 0 /\ value < Int256.modulus) unfold Int256Tree.empty.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
fold1 Z.add
  (exist
     (fun tr : PTree.t Z32 =>
      forall x : positive,
      tr ! x <> None ->
      Int256Indexed.index (Int256Indexed.index_inv x) = x)
     (PTree.empty Z32)
     (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
      Maps.Int256Tree.empty_obligation_1 x H)) 0 <=
snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (exist
      (fun tr : PTree.t Z32 =>
       forall x : positive,
       tr ! x <> None ->
       Int256Indexed.index (Int256Indexed.index_inv x) = x)
      (PTree.empty Z32)
      (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
       Maps.Int256Tree.empty_obligation_1 x H)) = 
 Some value -> value >= 0 /\ value < Int256.modulus)
    unfold Int256Tree.fold1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
PTree.fold1 Z.add
  (proj1_sig
     (exist
        (fun tr : PTree.t Z32 =>
         forall x : positive,
         tr ! x <> None ->
         Int256Indexed.index (Int256Indexed.index_inv x) = x)
        (PTree.empty Z32)
        (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
         Maps.Int256Tree.empty_obligation_1 x H))) 0 <=
snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (exist
      (fun tr : PTree.t Z32 =>
       forall x : positive,
       tr ! x <> None ->
       Int256Indexed.index (Int256Indexed.index_inv x) = x)
      (PTree.empty Z32)
      (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
       Maps.Int256Tree.empty_obligation_1 x H)) = 
 Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
0 <= snapshot_balances contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (exist
      (fun tr : PTree.t Z32 =>
       forall x : positive,
       tr ! x <> None ->
       Int256Indexed.index (Int256Indexed.index_inv x) = x)
      (PTree.empty Z32)
      (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
       Maps.Int256Tree.empty_obligation_1 x H)) = 
 Some value -> value >= 0 /\ value < Int256.modulus)
    split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
0 <= snapshot_balances contract_address
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
forall (key : elt) (value : Z32),
get key
  (exist
     (fun tr : PTree.t Z32 =>
      forall x : positive,
      tr ! x <> None ->
      Int256Indexed.index (Int256Indexed.index_inv x) = x)
     (PTree.empty Z32)
     (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
      Maps.Int256Tree.empty_obligation_1 x H)) = 
Some value -> value >= 0 /\ value < Int256.modulus
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
0 <= snapshot_balances contract_address apply snapshot_balances_valid_prf.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
forall (key : elt) (value : Z32),
get key
  (exist
     (fun tr : PTree.t Z32 =>
      forall x : positive,
      tr ! x <> None ->
      Int256Indexed.index (Int256Indexed.index_inv x) = x)
     (PTree.empty Z32)
     (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
      Maps.Int256Tree.empty_obligation_1 x H)) = Some value ->
value >= 0 /\ value < Int256.modulus unfold Int256Tree.get_default, Int256Tree.get.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
forall (key : elt) (value : Z32),
(proj1_sig
   (exist
      (fun tr : PTree.t Z32 =>
       forall x : positive,
       tr ! x <> None ->
       Int256Indexed.index (Int256Indexed.index_inv x) = x)
      (PTree.empty Z32)
      (fun (x : positive) (H : (PTree.empty Z32) ! x <> None) =>
       Maps.Int256Tree.empty_obligation_1 x H)))
! (Int256Indexed.index key) = Some value ->
value >= 0 /\ value < Int256.modulus simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
forall (key : elt) (value : Z32),
(PTree.empty Z32) ! (Int256Indexed.index key) = Some value ->
value >= 0 /\ value < Int256.modulus
      unfold PTree.empty, Int256Indexed.index.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
forall (key : elt) (value : Z32),
PTree.Leaf
! (let (intval, _) := key in
   match intval with
   | 0%Z => 1
   | Z.pos p => p~0
   | Z.neg p => p~1
   end) = Some value -> value >= 0 /\ value < Int256.modulus intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
key: elt
value: Z32
H0: PTree.Leaf
! (let (intval, _) := key in
   match intval with
   | 0%Z => 1
   | Z.pos p => p~0
   | Z.neg p => p~1
   end) = Some value
value >= 0 /\ value < Int256.modulus destruct key.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
intval: Z
intrange: -1 < intval < Int256.modulus
value: Z32
H0: PTree.Leaf
! match intval with
  | 0%Z => 1
  | Z.pos p => p~0
  | Z.neg p => p~1
  end = Some value
value >= 0 /\ value < Int256.modulus
    unfold "!".
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
Hno_leftover_outgoings: Outgoing_transfer_recipient_and_amount
  (contract_state initial_state) = None
next_action: Action initial_state
H: false = false
intval: Z
intrange: -1 < intval < Int256.modulus
value: Z32
H0: PTree.Leaf
! match intval with
  | 0%Z => 1
  | Z.pos p => p~0
  | Z.neg p => p~1
  end = Some value
value >= 0 /\ value < Int256.modulus destruct intval; intros; discriminate.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed prevSt
balance_backed (stepOnce prev) reachableFromByLinks.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state prevSt prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed prevSt
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
balance_backed (stepOnce prev) repeat rewrite HReachableFromByLinkStateToStep in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
HReachableFromByLinkStateToStep: prevSt = Step_state prev
HReachableFromByLinkStepToList: exists tl : list Step,
  prev :: tl = prevList
balance_backed (stepOnce prev)
    clear HReachableFromByLinkStateToStep HReachableFromByLinkStepToList.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
balance_backed (stepOnce prev)
    (* unfold stepOnce in next_action. *)
    destruct (Step_action prev) eqn:Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
balance_backed (stepOnce prev)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
balance_backed (stepOnce prev)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
balance_backed (stepOnce prev)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
balance_backed (stepOnce prev)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
Case: Step_action prev = revert (Step_state prev)
balance_backed (stepOnce prev)
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev) Transparent Crowdfunding_donate_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
      simpl in next_action.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
      unfold next_blockchain_state in next_action.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
      simpl in next_action.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  (Crowdfunding_donate_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
      (* destruct next_action. *)
      unfold Crowdfunding_donate_opt in case_donate_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
balance_backed (stepOnce prev)
      pose proof case_donate_prf as case_donate_prf'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_donate_prf
case_donate_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (stepOnce prev)
      (* A way around the error: case_donate_prf is used in hypothesis Case.
      If using eqn:Case in the destruct
      *)

      inv_runStateT_branching; subst; try discriminate.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some
  (tt,
  update_Crowdfunding_backers
    (set
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (me_callvalue
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (me_callvalue
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context address_accepts_funds_assumption
      callvalue_bounded_prf balances_bounded_prf callvalue_prf) >=?
 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed (stepOnce prev)
      *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some
  (tt,
  update_Crowdfunding_backers
    (set
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (me_callvalue
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (me_callvalue
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context address_accepts_funds_assumption
      callvalue_bounded_prf balances_bounded_prf callvalue_prf) >=?
 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed (stepOnce prev)
        unfold stepOnce.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some
  (tt,
  update_Crowdfunding_backers
    (set
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (me_callvalue
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (me_callvalue
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context address_accepts_funds_assumption
      callvalue_bounded_prf balances_bounded_prf callvalue_prf) >=?
 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed (step (Step_state prev) (Step_action prev)) unfold step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some
  (tt,
  update_Crowdfunding_backers
    (set
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (me_callvalue
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (me_callvalue
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context address_accepts_funds_assumption
      callvalue_bounded_prf balances_bounded_prf callvalue_prf) >=?
 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite -> Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) >=?
       0);; guard v);;
   gets Crowdfunding_backers;;
   spec2 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec3 <- gets Crowdfunding_max_block;;
   (if Int256.ltu spec3 spec2
    then ret tt;; v <- ret false;; guard v
    else
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     (if spec4 =? 0
      then
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set
               (me_caller
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (me_callvalue
                  (make_machine_env
                    contract_address
                    (Step_state prev) context
                    address_accepts_funds_assumption
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf))
               (Crowdfunding_backers s)) s)
      else ret tt;; v <- ret false;; guard v)))
  (contract_state (Step_state prev)) =
Some
  (tt,
  update_Crowdfunding_backers
    (set
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (me_callvalue
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (me_callvalue
           (make_machine_env contract_address
              (Step_state prev) context
              address_accepts_funds_assumption
              callvalue_bounded_prf balances_bounded_prf
              callvalue_prf))
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context address_accepts_funds_assumption
      callvalue_bounded_prf balances_bounded_prf callvalue_prf) >=?
 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        address_accepts_funds_assumption callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         address_accepts_funds_assumption
         callvalue_bounded_prf balances_bounded_prf
         callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  (next_blockchain_state (Step_state prev) context
     (update_Crowdfunding_backers
        (set
           (me_caller
              (make_machine_env contract_address (Step_state prev)
                 context address_accepts_funds_assumption
                 callvalue_bounded_prf balances_bounded_prf
                 callvalue_prf))
           (me_callvalue
              (make_machine_env contract_address (Step_state prev)
                 context address_accepts_funds_assumption
                 callvalue_bounded_prf balances_bounded_prf
                 callvalue_prf))
           (Crowdfunding_backers (contract_state (Step_state prev))))
        (contract_state (Step_state prev))))
        simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  (next_blockchain_state (Step_state prev) context
     (update_Crowdfunding_backers
        (set (caller context) (callvalue context)
           (Crowdfunding_backers (contract_state (Step_state prev))))
        (contract_state (Step_state prev))))
        unfold next_blockchain_state.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (update_Crowdfunding_backers
           (set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        (update_Crowdfunding_backers
           (set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))
  |}
        unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      current_balances
        (Outgoing_transfer_recipient_and_amount
           (update_Crowdfunding_backers
              (set (caller context) (callvalue context)
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev))))
        (update_balances (caller context) contract_address
           (callvalue context) (balance (Step_state prev)));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        (update_Crowdfunding_backers
           (set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))
  |}
        unfold current_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      match
        Outgoing_transfer_recipient_and_amount
          (update_Crowdfunding_backers
             (set (caller context) (callvalue context)
                (Crowdfunding_backers
                   (contract_state (Step_state prev))))
             (contract_state (Step_state prev)))
      with
      | Some (recipient, amount) =>
          update_balances contract_address recipient amount
            (update_balances (caller context) contract_address
               (callvalue context) (balance (Step_state prev)))
      | None =>
          update_balances (caller context) contract_address
            (callvalue context) (balance (Step_state prev))
      end;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        (update_Crowdfunding_backers
           (set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))
  |}
        unfold update_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      match
        Outgoing_transfer_recipient_and_amount
          (update_Crowdfunding_backers
             (set (caller context) (callvalue context)
                (Crowdfunding_backers
                   (contract_state (Step_state prev))))
             (contract_state (Step_state prev)))
      with
      | Some (recipient, amount) =>
          fun a : addr =>
          if (contract_address =? recipient)%int256
          then
           if (caller context =? contract_address)%int256
           then balance (Step_state prev) a
           else
            if (a =? caller context)%int256
            then
             balance (Step_state prev) (caller context) -
             callvalue context
            else
             if (a =? contract_address)%int256
             then
              balance (Step_state prev) contract_address +
              callvalue context
             else balance (Step_state prev) a
          else
           if (a =? contract_address)%int256
           then
            (if (caller context =? contract_address)%int256
             then balance (Step_state prev) contract_address
             else
              if (contract_address =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (contract_address =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) contract_address) -
            amount
           else
            if (a =? recipient)%int256
            then
             (if (caller context =? contract_address)%int256
              then balance (Step_state prev) recipient
              else
               if (recipient =? caller context)%int256
               then
                balance (Step_state prev) (caller context) -
                callvalue context
               else
                if (recipient =? contract_address)%int256
                then
                 balance (Step_state prev) contract_address +
                 callvalue context
                else balance (Step_state prev) recipient) + amount
            else
             if (caller context =? contract_address)%int256
             then balance (Step_state prev) a
             else
              if (a =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (a =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) a
      | None =>
          fun a : addr =>
          if (caller context =? contract_address)%int256
          then balance (Step_state prev) a
          else
           if (a =? caller context)%int256
           then
            balance (Step_state prev) (caller context) -
            callvalue context
           else
            if (a =? contract_address)%int256
            then
             balance (Step_state prev) contract_address +
             callvalue context
            else balance (Step_state prev) a
      end;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        (update_Crowdfunding_backers
           (set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))
  |}
        unfold update_Crowdfunding_backers.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      match
        Outgoing_transfer_recipient_and_amount
          {|
            Outgoing_transfer_recipient_and_amount :=
              Outgoing_transfer_recipient_and_amount
                (contract_state (Step_state prev));
            Crowdfunding_owner :=
              Crowdfunding_owner (contract_state (Step_state prev));
            Crowdfunding_max_block :=
              Crowdfunding_max_block
                (contract_state (Step_state prev));
            Crowdfunding_goal :=
              Crowdfunding_goal (contract_state (Step_state prev));
            Crowdfunding_backers :=
              set (caller context) (callvalue context)
                (Crowdfunding_backers
                   (contract_state (Step_state prev)));
            Crowdfunding_funded :=
              Crowdfunding_funded (contract_state (Step_state prev));
            Crowdfunding_deadlinePassed_msg :=
              Crowdfunding_deadlinePassed_msg
                (contract_state (Step_state prev));
            Crowdfunding_successfullyDonated_msg :=
              Crowdfunding_successfullyDonated_msg
                (contract_state (Step_state prev));
            Crowdfunding_alreadyDonated_msg :=
              Crowdfunding_alreadyDonated_msg
                (contract_state (Step_state prev));
            Crowdfunding_funded_msg :=
              Crowdfunding_funded_msg
                (contract_state (Step_state prev));
            Crowdfunding_failed_msg :=
              Crowdfunding_failed_msg
                (contract_state (Step_state prev));
            Crowdfunding_too_early_to_claim_funds_msg :=
              Crowdfunding_too_early_to_claim_funds_msg
                (contract_state (Step_state prev));
            Crowdfunding_too_early_to_reclaim_msg :=
              Crowdfunding_too_early_to_reclaim_msg
                (contract_state (Step_state prev));
            Crowdfunding_cannot_refund_msg :=
              Crowdfunding_cannot_refund_msg
                (contract_state (Step_state prev));
            Crowdfunding_here_is_your_money_msg :=
              Crowdfunding_here_is_your_money_msg
                (contract_state (Step_state prev))
          |}
      with
      | Some (recipient, amount) =>
          fun a : addr =>
          if (contract_address =? recipient)%int256
          then
           if (caller context =? contract_address)%int256
           then balance (Step_state prev) a
           else
            if (a =? caller context)%int256
            then
             balance (Step_state prev) (caller context) -
             callvalue context
            else
             if (a =? contract_address)%int256
             then
              balance (Step_state prev) contract_address +
              callvalue context
             else balance (Step_state prev) a
          else
           if (a =? contract_address)%int256
           then
            (if (caller context =? contract_address)%int256
             then balance (Step_state prev) contract_address
             else
              if (contract_address =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (contract_address =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) contract_address) -
            amount
           else
            if (a =? recipient)%int256
            then
             (if (caller context =? contract_address)%int256
              then balance (Step_state prev) recipient
              else
               if (recipient =? caller context)%int256
               then
                balance (Step_state prev) (caller context) -
                callvalue context
               else
                if (recipient =? contract_address)%int256
                then
                 balance (Step_state prev) contract_address +
                 callvalue context
                else balance (Step_state prev) recipient) + amount
            else
             if (caller context =? contract_address)%int256
             then balance (Step_state prev) a
             else
              if (a =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (a =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) a
      | None =>
          fun a : addr =>
          if (caller context =? contract_address)%int256
          then balance (Step_state prev) a
          else
           if (a =? caller context)%int256
           then
            balance (Step_state prev) (caller context) -
            callvalue context
           else
            if (a =? contract_address)%int256
            then
             balance (Step_state prev) contract_address +
             callvalue context
            else balance (Step_state prev) a
      end;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        {|
          Outgoing_transfer_recipient_and_amount :=
            Outgoing_transfer_recipient_and_amount
              (contract_state (Step_state prev));
          Crowdfunding_owner :=
            Crowdfunding_owner (contract_state (Step_state prev));
          Crowdfunding_max_block :=
            Crowdfunding_max_block (contract_state (Step_state prev));
          Crowdfunding_goal :=
            Crowdfunding_goal (contract_state (Step_state prev));
          Crowdfunding_backers :=
            set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev)));
          Crowdfunding_funded :=
            Crowdfunding_funded (contract_state (Step_state prev));
          Crowdfunding_deadlinePassed_msg :=
            Crowdfunding_deadlinePassed_msg
              (contract_state (Step_state prev));
          Crowdfunding_successfullyDonated_msg :=
            Crowdfunding_successfullyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_alreadyDonated_msg :=
            Crowdfunding_alreadyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_funded_msg :=
            Crowdfunding_funded_msg
              (contract_state (Step_state prev));
          Crowdfunding_failed_msg :=
            Crowdfunding_failed_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_claim_funds_msg :=
            Crowdfunding_too_early_to_claim_funds_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_reclaim_msg :=
            Crowdfunding_too_early_to_reclaim_msg
              (contract_state (Step_state prev));
          Crowdfunding_cannot_refund_msg :=
            Crowdfunding_cannot_refund_msg
              (contract_state (Step_state prev));
          Crowdfunding_here_is_your_money_msg :=
            Crowdfunding_here_is_your_money_msg
              (contract_state (Step_state prev))
        |}
  |} simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      match
        Outgoing_transfer_recipient_and_amount
          (contract_state (Step_state prev))
      with
      | Some (recipient, amount) =>
          fun a : addr =>
          if (contract_address =? recipient)%int256
          then
           if (caller context =? contract_address)%int256
           then balance (Step_state prev) a
           else
            if (a =? caller context)%int256
            then
             balance (Step_state prev) (caller context) -
             callvalue context
            else
             if (a =? contract_address)%int256
             then
              balance (Step_state prev) contract_address +
              callvalue context
             else balance (Step_state prev) a
          else
           if (a =? contract_address)%int256
           then
            (if (caller context =? contract_address)%int256
             then balance (Step_state prev) contract_address
             else
              if (contract_address =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (contract_address =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) contract_address) -
            amount
           else
            if (a =? recipient)%int256
            then
             (if (caller context =? contract_address)%int256
              then balance (Step_state prev) recipient
              else
               if (recipient =? caller context)%int256
               then
                balance (Step_state prev) (caller context) -
                callvalue context
               else
                if (recipient =? contract_address)%int256
                then
                 balance (Step_state prev) contract_address +
                 callvalue context
                else balance (Step_state prev) recipient) + amount
            else
             if (caller context =? contract_address)%int256
             then balance (Step_state prev) a
             else
              if (a =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (a =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) a
      | None =>
          fun a : addr =>
          if (caller context =? contract_address)%int256
          then balance (Step_state prev) a
          else
           if (a =? caller context)%int256
           then
            balance (Step_state prev) (caller context) -
            callvalue context
           else
            if (a =? contract_address)%int256
            then
             balance (Step_state prev) contract_address +
             callvalue context
            else balance (Step_state prev) a
      end;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        {|
          Outgoing_transfer_recipient_and_amount :=
            Outgoing_transfer_recipient_and_amount
              (contract_state (Step_state prev));
          Crowdfunding_owner :=
            Crowdfunding_owner (contract_state (Step_state prev));
          Crowdfunding_max_block :=
            Crowdfunding_max_block (contract_state (Step_state prev));
          Crowdfunding_goal :=
            Crowdfunding_goal (contract_state (Step_state prev));
          Crowdfunding_backers :=
            set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev)));
          Crowdfunding_funded :=
            Crowdfunding_funded (contract_state (Step_state prev));
          Crowdfunding_deadlinePassed_msg :=
            Crowdfunding_deadlinePassed_msg
              (contract_state (Step_state prev));
          Crowdfunding_successfullyDonated_msg :=
            Crowdfunding_successfullyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_alreadyDonated_msg :=
            Crowdfunding_alreadyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_funded_msg :=
            Crowdfunding_funded_msg
              (contract_state (Step_state prev));
          Crowdfunding_failed_msg :=
            Crowdfunding_failed_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_claim_funds_msg :=
            Crowdfunding_too_early_to_claim_funds_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_reclaim_msg :=
            Crowdfunding_too_early_to_reclaim_msg
              (contract_state (Step_state prev));
          Crowdfunding_cannot_refund_msg :=
            Crowdfunding_cannot_refund_msg
              (contract_state (Step_state prev));
          Crowdfunding_here_is_your_money_msg :=
            Crowdfunding_here_is_your_money_msg
              (contract_state (Step_state prev))
        |}
  |}
        rewrite (NoLeftoverOutgoings H).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      fun a : addr =>
      if (caller context =? contract_address)%int256
      then balance (Step_state prev) a
      else
       if (a =? caller context)%int256
       then
        balance (Step_state prev) (caller context) -
        callvalue context
       else
        if (a =? contract_address)%int256
        then
         balance (Step_state prev) contract_address +
         callvalue context
        else balance (Step_state prev) a;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        {|
          Outgoing_transfer_recipient_and_amount := None;
          Crowdfunding_owner :=
            Crowdfunding_owner (contract_state (Step_state prev));
          Crowdfunding_max_block :=
            Crowdfunding_max_block (contract_state (Step_state prev));
          Crowdfunding_goal :=
            Crowdfunding_goal (contract_state (Step_state prev));
          Crowdfunding_backers :=
            set (caller context) (callvalue context)
              (Crowdfunding_backers
                 (contract_state (Step_state prev)));
          Crowdfunding_funded :=
            Crowdfunding_funded (contract_state (Step_state prev));
          Crowdfunding_deadlinePassed_msg :=
            Crowdfunding_deadlinePassed_msg
              (contract_state (Step_state prev));
          Crowdfunding_successfullyDonated_msg :=
            Crowdfunding_successfullyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_alreadyDonated_msg :=
            Crowdfunding_alreadyDonated_msg
              (contract_state (Step_state prev));
          Crowdfunding_funded_msg :=
            Crowdfunding_funded_msg
              (contract_state (Step_state prev));
          Crowdfunding_failed_msg :=
            Crowdfunding_failed_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_claim_funds_msg :=
            Crowdfunding_too_early_to_claim_funds_msg
              (contract_state (Step_state prev));
          Crowdfunding_too_early_to_reclaim_msg :=
            Crowdfunding_too_early_to_reclaim_msg
              (contract_state (Step_state prev));
          Crowdfunding_cannot_refund_msg :=
            Crowdfunding_cannot_refund_msg
              (contract_state (Step_state prev));
          Crowdfunding_here_is_your_money_msg :=
            Crowdfunding_here_is_your_money_msg
              (contract_state (Step_state prev))
        |}
  |}
        unfold resetTransfers.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      fun a : addr =>
      if (caller context =? contract_address)%int256
      then balance (Step_state prev) a
      else
       if (a =? caller context)%int256
       then
        balance (Step_state prev) (caller context) -
        callvalue context
       else
        if (a =? contract_address)%int256
        then
         balance (Step_state prev) contract_address +
         callvalue context
        else balance (Step_state prev) a;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      {|
        Outgoing_transfer_recipient_and_amount := None;
        Crowdfunding_owner :=
          Crowdfunding_owner
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_max_block :=
          Crowdfunding_max_block
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_goal :=
          Crowdfunding_goal
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_backers :=
          Crowdfunding_backers
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_funded :=
          Crowdfunding_funded
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_deadlinePassed_msg :=
          Crowdfunding_deadlinePassed_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_successfullyDonated_msg :=
          Crowdfunding_successfullyDonated_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_alreadyDonated_msg :=
          Crowdfunding_alreadyDonated_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_funded_msg :=
          Crowdfunding_funded_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_failed_msg :=
          Crowdfunding_failed_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_too_early_to_claim_funds_msg :=
          Crowdfunding_too_early_to_claim_funds_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_too_early_to_reclaim_msg :=
          Crowdfunding_too_early_to_reclaim_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_cannot_refund_msg :=
          Crowdfunding_cannot_refund_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |};
        Crowdfunding_here_is_your_money_msg :=
          Crowdfunding_here_is_your_money_msg
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |}
      |}
  |}
        simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      fun a : addr =>
      if (caller context =? contract_address)%int256
      then balance (Step_state prev) a
      else
       if (a =? caller context)%int256
       then
        balance (Step_state prev) (caller context) -
        callvalue context
       else
        if (a =? contract_address)%int256
        then
         balance (Step_state prev) contract_address +
         callvalue context
        else balance (Step_state prev) a;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      {|
        Outgoing_transfer_recipient_and_amount := None;
        Crowdfunding_owner :=
          Crowdfunding_owner (contract_state (Step_state prev));
        Crowdfunding_max_block :=
          Crowdfunding_max_block (contract_state (Step_state prev));
        Crowdfunding_goal :=
          Crowdfunding_goal (contract_state (Step_state prev));
        Crowdfunding_backers :=
          set (caller context) (callvalue context)
            (Crowdfunding_backers (contract_state (Step_state prev)));
        Crowdfunding_funded :=
          Crowdfunding_funded (contract_state (Step_state prev));
        Crowdfunding_deadlinePassed_msg :=
          Crowdfunding_deadlinePassed_msg
            (contract_state (Step_state prev));
        Crowdfunding_successfullyDonated_msg :=
          Crowdfunding_successfullyDonated_msg
            (contract_state (Step_state prev));
        Crowdfunding_alreadyDonated_msg :=
          Crowdfunding_alreadyDonated_msg
            (contract_state (Step_state prev));
        Crowdfunding_funded_msg :=
          Crowdfunding_funded_msg (contract_state (Step_state prev));
        Crowdfunding_failed_msg :=
          Crowdfunding_failed_msg (contract_state (Step_state prev));
        Crowdfunding_too_early_to_claim_funds_msg :=
          Crowdfunding_too_early_to_claim_funds_msg
            (contract_state (Step_state prev));
        Crowdfunding_too_early_to_reclaim_msg :=
          Crowdfunding_too_early_to_reclaim_msg
            (contract_state (Step_state prev));
        Crowdfunding_cannot_refund_msg :=
          Crowdfunding_cannot_refund_msg
            (contract_state (Step_state prev));
        Crowdfunding_here_is_your_money_msg :=
          Crowdfunding_here_is_your_money_msg
            (contract_state (Step_state prev))
      |}
  |}
        unfold balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
Crowdfunding_funded
  (contract_state
     {|
       timestamp := timestamp (Step_state prev);
       block_number := block_number (Step_state prev);
       balance :=
         fun a : addr =>
         if (caller context =? contract_address)%int256
         then balance (Step_state prev) a
         else
          if (a =? caller context)%int256
          then
           balance (Step_state prev) (caller context) -
           callvalue context
          else
           if (a =? contract_address)%int256
           then
            balance (Step_state prev) contract_address +
            callvalue context
           else balance (Step_state prev) a;
       blockhash := blockhash (Step_state prev);
       contract_state :=
         {|
           Outgoing_transfer_recipient_and_amount := None;
           Crowdfunding_owner :=
             Crowdfunding_owner (contract_state (Step_state prev));
           Crowdfunding_max_block :=
             Crowdfunding_max_block
               (contract_state (Step_state prev));
           Crowdfunding_goal :=
             Crowdfunding_goal (contract_state (Step_state prev));
           Crowdfunding_backers :=
             set (caller context) (callvalue context)
               (Crowdfunding_backers
                  (contract_state (Step_state prev)));
           Crowdfunding_funded :=
             Crowdfunding_funded (contract_state (Step_state prev));
           Crowdfunding_deadlinePassed_msg :=
             Crowdfunding_deadlinePassed_msg
               (contract_state (Step_state prev));
           Crowdfunding_successfullyDonated_msg :=
             Crowdfunding_successfullyDonated_msg
               (contract_state (Step_state prev));
           Crowdfunding_alreadyDonated_msg :=
             Crowdfunding_alreadyDonated_msg
               (contract_state (Step_state prev));
           Crowdfunding_funded_msg :=
             Crowdfunding_funded_msg
               (contract_state (Step_state prev));
           Crowdfunding_failed_msg :=
             Crowdfunding_failed_msg
               (contract_state (Step_state prev));
           Crowdfunding_too_early_to_claim_funds_msg :=
             Crowdfunding_too_early_to_claim_funds_msg
               (contract_state (Step_state prev));
           Crowdfunding_too_early_to_reclaim_msg :=
             Crowdfunding_too_early_to_reclaim_msg
               (contract_state (Step_state prev));
           Crowdfunding_cannot_refund_msg :=
             Crowdfunding_cannot_refund_msg
               (contract_state (Step_state prev));
           Crowdfunding_here_is_your_money_msg :=
             Crowdfunding_here_is_your_money_msg
               (contract_state (Step_state prev))
         |}
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := timestamp (Step_state prev);
          block_number := block_number (Step_state prev);
          balance :=
            fun a : addr =>
            if (caller context =? contract_address)%int256
            then balance (Step_state prev) a
            else
             if (a =? caller context)%int256
             then
              balance (Step_state prev) (caller context) -
              callvalue context
             else
              if (a =? contract_address)%int256
              then
               balance (Step_state prev) contract_address +
               callvalue context
              else balance (Step_state prev) a;
          blockhash := blockhash (Step_state prev);
          contract_state :=
            {|
              Outgoing_transfer_recipient_and_amount := None;
              Crowdfunding_owner :=
                Crowdfunding_owner (contract_state (Step_state prev));
              Crowdfunding_max_block :=
                Crowdfunding_max_block
                  (contract_state (Step_state prev));
              Crowdfunding_goal :=
                Crowdfunding_goal (contract_state (Step_state prev));
              Crowdfunding_backers :=
                set (caller context) (callvalue context)
                  (Crowdfunding_backers
                     (contract_state (Step_state prev)));
              Crowdfunding_funded :=
                Crowdfunding_funded
                  (contract_state (Step_state prev));
              Crowdfunding_deadlinePassed_msg :=
                Crowdfunding_deadlinePassed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_successfullyDonated_msg :=
                Crowdfunding_successfullyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_alreadyDonated_msg :=
                Crowdfunding_alreadyDonated_msg
                  (contract_state (Step_state prev));
              Crowdfunding_funded_msg :=
                Crowdfunding_funded_msg
                  (contract_state (Step_state prev));
              Crowdfunding_failed_msg :=
                Crowdfunding_failed_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_claim_funds_msg :=
                Crowdfunding_too_early_to_claim_funds_msg
                  (contract_state (Step_state prev));
              Crowdfunding_too_early_to_reclaim_msg :=
                Crowdfunding_too_early_to_reclaim_msg
                  (contract_state (Step_state prev));
              Crowdfunding_cannot_refund_msg :=
                Crowdfunding_cannot_refund_msg
                  (contract_state (Step_state prev));
              Crowdfunding_here_is_your_money_msg :=
                Crowdfunding_here_is_your_money_msg
                  (contract_state (Step_state prev))
            |}
        |})) <=
balance
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      fun a : addr =>
      if (caller context =? contract_address)%int256
      then balance (Step_state prev) a
      else
       if (a =? caller context)%int256
       then
        balance (Step_state prev) (caller context) -
        callvalue context
       else
        if (a =? contract_address)%int256
        then
         balance (Step_state prev) contract_address +
         callvalue context
        else balance (Step_state prev) a;
    blockhash := blockhash (Step_state prev);
    contract_state :=
      {|
        Outgoing_transfer_recipient_and_amount := None;
        Crowdfunding_owner :=
          Crowdfunding_owner (contract_state (Step_state prev));
        Crowdfunding_max_block :=
          Crowdfunding_max_block (contract_state (Step_state prev));
        Crowdfunding_goal :=
          Crowdfunding_goal (contract_state (Step_state prev));
        Crowdfunding_backers :=
          set (caller context) (callvalue context)
            (Crowdfunding_backers (contract_state (Step_state prev)));
        Crowdfunding_funded :=
          Crowdfunding_funded (contract_state (Step_state prev));
        Crowdfunding_deadlinePassed_msg :=
          Crowdfunding_deadlinePassed_msg
            (contract_state (Step_state prev));
        Crowdfunding_successfullyDonated_msg :=
          Crowdfunding_successfullyDonated_msg
            (contract_state (Step_state prev));
        Crowdfunding_alreadyDonated_msg :=
          Crowdfunding_alreadyDonated_msg
            (contract_state (Step_state prev));
        Crowdfunding_funded_msg :=
          Crowdfunding_funded_msg (contract_state (Step_state prev));
        Crowdfunding_failed_msg :=
          Crowdfunding_failed_msg (contract_state (Step_state prev));
        Crowdfunding_too_early_to_claim_funds_msg :=
          Crowdfunding_too_early_to_claim_funds_msg
            (contract_state (Step_state prev));
        Crowdfunding_too_early_to_reclaim_msg :=
          Crowdfunding_too_early_to_reclaim_msg
            (contract_state (Step_state prev));
        Crowdfunding_cannot_refund_msg :=
          Crowdfunding_cannot_refund_msg
            (contract_state (Step_state prev));
        Crowdfunding_here_is_your_money_msg :=
          Crowdfunding_here_is_your_money_msg
            (contract_state (Step_state prev))
      |}
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := timestamp (Step_state prev);
           block_number := block_number (Step_state prev);
           balance :=
             fun a : addr =>
             if (caller context =? contract_address)%int256
             then balance (Step_state prev) a
             else
              if (a =? caller context)%int256
              then
               balance (Step_state prev) (caller context) -
               callvalue context
              else
               if (a =? contract_address)%int256
               then
                balance (Step_state prev) contract_address +
                callvalue context
               else balance (Step_state prev) a;
           blockhash := blockhash (Step_state prev);
           contract_state :=
             {|
               Outgoing_transfer_recipient_and_amount := None;
               Crowdfunding_owner :=
                 Crowdfunding_owner
                   (contract_state (Step_state prev));
               Crowdfunding_max_block :=
                 Crowdfunding_max_block
                   (contract_state (Step_state prev));
               Crowdfunding_goal :=
                 Crowdfunding_goal (contract_state (Step_state prev));
               Crowdfunding_backers :=
                 set (caller context) (callvalue context)
                   (Crowdfunding_backers
                      (contract_state (Step_state prev)));
               Crowdfunding_funded :=
                 Crowdfunding_funded
                   (contract_state (Step_state prev));
               Crowdfunding_deadlinePassed_msg :=
                 Crowdfunding_deadlinePassed_msg
                   (contract_state (Step_state prev));
               Crowdfunding_successfullyDonated_msg :=
                 Crowdfunding_successfullyDonated_msg
                   (contract_state (Step_state prev));
               Crowdfunding_alreadyDonated_msg :=
                 Crowdfunding_alreadyDonated_msg
                   (contract_state (Step_state prev));
               Crowdfunding_funded_msg :=
                 Crowdfunding_funded_msg
                   (contract_state (Step_state prev));
               Crowdfunding_failed_msg :=
                 Crowdfunding_failed_msg
                   (contract_state (Step_state prev));
               Crowdfunding_too_early_to_claim_funds_msg :=
                 Crowdfunding_too_early_to_claim_funds_msg
                   (contract_state (Step_state prev));
               Crowdfunding_too_early_to_reclaim_msg :=
                 Crowdfunding_too_early_to_reclaim_msg
                   (contract_state (Step_state prev));
               Crowdfunding_cannot_refund_msg :=
                 Crowdfunding_cannot_refund_msg
                   (contract_state (Step_state prev));
               Crowdfunding_here_is_your_money_msg :=
                 Crowdfunding_here_is_your_money_msg
                   (contract_state (Step_state prev))
             |}
         |})) = Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
Case: Step_action prev =
call_Crowdfunding_donate 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf tt
  (update_Crowdfunding_backers
     (set (caller context) 
        (callvalue context)
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) case_donate_prf
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        clear Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_donate_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context >=? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            Int256.ltu 
              (Crowdfunding_max_block s0)
              (block_number (Step_state prev))
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type
                => None
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    Some
                    (tt,
                    update_Crowdfunding_backers
                    (set (...) (...) (...)) s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    _ : global_abstract_data_type
                    => None
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end =
Some
  (tt,
  update_Crowdfunding_backers
    (set (caller context) 
       (callvalue context)
       (Crowdfunding_backers
          (contract_state (Step_state prev))))
    (contract_state (Step_state prev)))
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus) clear case_donate_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        unfold balance_backed in IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) (callvalue context)
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        apply Z.eqb_eq in Heqb0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus

        (* Search  "=?" true.
        Search int256 false. *)
        rewrite negb_true_iff in H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        rewrite H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then balance (Step_state prev) (caller context) - callvalue context
 else
  if (contract_address =? contract_address)%int256
  then balance (Step_state prev) contract_address + callvalue context
  else balance (Step_state prev) contract_address)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        rewrite Int256.eq_true.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then balance (Step_state prev) (caller context) - callvalue context
 else balance (Step_state prev) contract_address + callvalue context)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        (* Search ( _ =? _)%int256. *)
        rewrite Int256.eq_sym.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (caller context =? contract_address)%int256
 then balance (Step_state prev) (caller context) - callvalue context
 else balance (Step_state prev) contract_address + callvalue context)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        rewrite H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + callvalue context
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        (* apply Int256eq_false in H2. *)

        rewrite Int256Tree_sum_set_value_initially_zero; [|assumption].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) +
callvalue context <=
balance (Step_state prev) contract_address + callvalue context
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        (* Search Int256.unsigned. *)


        unfold noOverflowOrUnderflowInTransfer in callvalue_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: (0 <=? callvalue context) &&
(callvalue context <? Int256.modulus) &&
(balance (Step_state prev) (caller context) -
 callvalue context >=? 0) &&
(balance (Step_state prev) contract_address +
 callvalue context <? Int256.modulus) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) +
callvalue context <=
balance (Step_state prev) contract_address + callvalue context
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus

        destruct H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: (0 <=? callvalue context) &&
(callvalue context <? Int256.modulus) &&
(balance (Step_state prev) (caller context) -
 callvalue context >=? 0) &&
(balance (Step_state prev) contract_address +
 callvalue context <? Int256.modulus) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
sum (Crowdfunding_backers (contract_state (Step_state prev))) +
callvalue context <=
balance (Step_state prev) contract_address + callvalue context
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: (0 <=? callvalue context) &&
(callvalue context <? Int256.modulus) &&
(balance (Step_state prev) (caller context) -
 callvalue context >=? 0) &&
(balance (Step_state prev) contract_address +
 callvalue context <? Int256.modulus) = true
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) =
0
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
sum (Crowdfunding_backers (contract_state (Step_state prev))) +
callvalue context <=
balance (Step_state prev) contract_address + callvalue context
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        destruct H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
forall (key : elt) (value : Z32),
get key
  (set (caller context) (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
value >= 0 /\ value < Int256.modulus
        destruct (Int256.eq key (caller context)) eqn:SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = true
value >= 0 /\ value < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        apply Int256eq_true in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key = caller context
value >= 0 /\ value < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus rewrite SSCase in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get (caller context)
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key = caller context
value >= 0 /\ value < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        rewrite Int256Tree.gss in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: Some (callvalue context) = Some value
SSCase: key = caller context
value >= 0 /\ value < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        inversion H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: Some (callvalue context) = Some value
SSCase: key = caller context
H5: callvalue context = value
callvalue context >= 0 /\ callvalue context < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        clear -callvalue_bounded_prf.
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
callvalue context >= 0 /\ callvalue context < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) (balance (Step_state prev)) =
true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
        apply Int256eq_false in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (set (caller context) 
     (callvalue context)
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key <> caller context
value >= 0 /\ value < Int256.modulus
        rewrite Int256Tree.gso in H3 by assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value
SSCase: key <> caller context
value >= 0 /\ value < Int256.modulus
        apply H1 in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context >=? 0) = true
Heqb: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0) = true
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H1: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H3: value >= 0 /\ value < Int256.modulus
SSCase: key <> caller context
value >= 0 /\ value < Int256.modulus
        assumption.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
balance_backed (stepOnce prev) Transparent Crowdfunding_getFunds_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
balance_backed (stepOnce prev)
      pose proof case_getFunds_prf as case_getFunds_prf'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (stepOnce prev)
      unfold Crowdfunding_getFunds_opt in case_getFunds_prf'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (stepOnce prev)
      unfold stepOnce.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (step (Step_state prev) (Step_action prev)) unfold step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: runStateT
  (Crowdfunding_getFunds_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf
        balances_bounded_prf callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      simpl in case_getFunds_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_getFunds 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_getFunds_prf
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) clear Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      unfold  address_accepts_funds_assumption in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
case_getFunds_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               (fun (_ : option ContractState)
                  (_ _ : addr) 
                  (_ : wei) => true)
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               (fun (_ : option ContractState)
                  (_ _ : addr) 
                  (_ : wei) => true)
               callvalue_bounded_prf
               balances_bounded_prf
               callvalue_prf))%int256);; 
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            (fun (_ : option ContractState)
               (_ _ : addr) 
               (_ : wei) => true)
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <- gets Crowdfunding_owner;;
   (if
     (me_caller
        (make_machine_env contract_address
           (Step_state prev) context
           (fun (_ : option ContractState)
              (_ _ : addr) 
              (_ : wei) => true)
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf) =?
      spec1)%int256
    then
     spec2 <-
     ret
       (me_number
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf));;
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)));;
     spec4 <- gets Crowdfunding_max_block;;
     (if Int256.ltu spec4 spec2
      then
       spec5 <- gets Crowdfunding_goal;;
       (if spec5 <=? spec3
        then
         MonadState.modify
           (update_Crowdfunding_funded true);;
         ret tt;;
         d <- MonadState.get;;
         (let (success, d') :=
            me_transfer (...) spec1 spec3 d in
          if (...)%int256 then put d' else mzero)
        else ret tt)
      else ret tt)
    else ret tt))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      ds_inv; subst; try discriminate.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     me_transfer
       (make_machine_env contract_address
          (Step_state prev) context
          (fun (_ : option ContractState)
             (_ _ : addr) 
             (_ : wei) => true)
          callvalue_bounded_prf
          balances_bounded_prf callvalue_prf)
       (Crowdfunding_owner
          (contract_state (Step_state prev)))
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)))
       (update_Crowdfunding_funded true
          (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then put d'
   else mzero)
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
ret (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) unfold me_transfer in case_getFunds_prf'2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     (let
        (_, _, _, me_callvalue, _, _, _, _,
         me_balance, _, me_transfer, _, _,
         _) :=
        make_machine_env contract_address
          (Step_state prev) context
          (fun (_ : option ContractState)
             (_ _ : addr) 
             (_ : wei) => true)
          callvalue_bounded_prf
          balances_bounded_prf callvalue_prf in
      me_transfer)
       (Crowdfunding_owner
          (contract_state (Step_state prev)))
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf
                callvalue_prf)))
       (update_Crowdfunding_funded true
          (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then put d'
   else mzero)
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
ret (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
      unfold make_machine_env in case_getFunds_prf'2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if
      noOverflowOrUnderflowInTransfer
        contract_address
        (Crowdfunding_owner
           (contract_state (Step_state prev)))
        (me_balance
           {|
             me_address := contract_address;
             me_origin := origin context;
             me_caller := caller context;
             me_callvalue := callvalue context;
             me_coinbase := coinbase context;
             me_timestamp :=
               timestamp (Step_state prev);
             me_number :=
               block_number (Step_state prev);
             me_chainid := chainid context;
             me_balance :=
               ContractModel.update_balances
                 (caller context)
                 contract_address
                 (callvalue context)
                 (balance (Step_state prev));
             me_blockhash :=
               blockhash (Step_state prev);
             me_transfer :=
               fun (recipient : int256)
                 (amount : Z)
                 (d : global_abstract_data_type)
               =>
               if
                noOverflowOrUnderflowInTransfer
                  contract_address recipient
                  amount
                  (ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))) &&
                true
               then
                (Int256.one,
                update_Outgoing_transfer_recipient_and_amount
                  (Some (recipient, amount)) d)
               else (Int256.zero, d);
             me_callmethod :=
               fun (_ : HighValues.val)
                 (_ : int) 
                 (_ : HighValues.val)
                 (_ : list HighValues.val)
                 (_ : global_abstract_data_type)
                 (_ : ExtEnv.ext_env)
                 (_ : global_abstract_data_type)
                 (_ : ExtEnv.ext_env)
                 (_ : int256)
                 (_ : list HighValues.val) =>
               False;
             me_log :=
               fun (_ _ : list HighValues.val)
                 (d : global_abstract_data_type)
               => d;
             me_valid :=
               ContractModel.ContractModel.make_machine_env_obligation_1
                 contract_address
                 (Step_state prev) context
                 callvalue_bounded_prf
                 balances_bounded_prf
                 callvalue_prf
           |}
           (me_address
              {|
                me_address := contract_address;
                me_origin := origin context;
                me_caller := caller context;
                me_callvalue :=
                  callvalue context;
                me_coinbase := coinbase context;
                me_timestamp :=
                  timestamp (Step_state prev);
                me_number :=
                  block_number
                    (Step_state prev);
                me_chainid := chainid context;
                me_balance :=
                  ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev));
                me_blockhash :=
                  blockhash (Step_state prev);
                me_transfer :=
                  fun 
                    (recipient : int256)
                    (amount : Z)
                    (d : global_abstract_data_type)
                  =>
                  if
                   noOverflowOrUnderflowInTransfer
                    contract_address recipient
                    amount
                    (ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))) &&
                   true
                  then
                   (Int256.one,
                   update_Outgoing_transfer_recipient_and_amount
                    (Some (recipient, amount))
                    d)
                  else (Int256.zero, d);
                me_callmethod :=
                  fun 
                    (_ : HighValues.val)
                    (_ : int)
                    (_ : HighValues.val)
                    (_ : list HighValues.val)
                    (_ : global_abstract_data_type)
                    (_ : ExtEnv.ext_env)
                    (_ : global_abstract_data_type)
                    (_ : ExtEnv.ext_env)
                    (_ : int256)
                    (_ : list HighValues.val)
                  => False;
                me_log :=
                  fun
                    (_ _ : list HighValues.val)
                    (d : global_abstract_data_type)
                  => d;
                me_valid :=
                  ContractModel.ContractModel.make_machine_env_obligation_1
                    contract_address
                    (Step_state prev) context
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf
              |}))
        (ContractModel.update_balances
           (caller context) contract_address
           (callvalue context)
           (balance (Step_state prev))) && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           me_balance
             {|
               me_address := contract_address;
               me_origin := origin context;
               me_caller := caller context;
               me_callvalue :=
                 callvalue context;
               me_coinbase := coinbase context;
               me_timestamp :=
                 timestamp (Step_state prev);
               me_number :=
                 block_number (Step_state prev);
               me_chainid := chainid context;
               me_balance :=
                 ContractModel.update_balances
                   (caller context)
                   contract_address
                   (callvalue context)
                   (balance (Step_state prev));
               me_blockhash :=
                 blockhash (Step_state prev);
               me_transfer :=
                 fun 
                   (recipient : int256)
                   (amount : Z)
                   (d : global_abstract_data_type)
                 =>
                 if
                  noOverflowOrUnderflowInTransfer
                    contract_address recipient
                    amount
                    (ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))) &&
                  true
                 then
                  (Int256.one,
                  update_Outgoing_transfer_recipient_and_amount
                    (Some (recipient, amount))
                    d)
                 else (Int256.zero, d);
               me_callmethod :=
                 fun 
                   (_ : HighValues.val)
                   (_ : int)
                   (_ : HighValues.val)
                   (_ : list HighValues.val)
                   (_ : global_abstract_data_type)
                   (_ : ExtEnv.ext_env)
                   (_ : global_abstract_data_type)
                   (_ : ExtEnv.ext_env)
                   (_ : int256)
                   (_ : list HighValues.val) =>
                 False;
               me_log :=
                 fun
                   (_ _ : list HighValues.val)
                   (d : global_abstract_data_type)
                 => d;
               me_valid :=
                 ContractModel.ContractModel.make_machine_env_obligation_1
                   contract_address
                   (Step_state prev) context
                   callvalue_bounded_prf
                   balances_bounded_prf
                   callvalue_prf
             |}
             (me_address
                {|
                  me_address :=
                    contract_address;
                  me_origin := origin context;
                  me_caller := caller context;
                  me_callvalue :=
                    callvalue context;
                  me_coinbase :=
                    coinbase context;
                  me_timestamp :=
                    timestamp (Step_state prev);
                  me_number :=
                    block_number
                    (Step_state prev);
                  me_chainid := chainid context;
                  me_balance :=
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev));
                  me_blockhash :=
                    blockhash (Step_state prev);
                  me_transfer :=
                    fun 
                    (recipient : int256)
                    (amount : Z)
                    (d : global_abstract_data_type)
                    =>
                    if
                    noOverflowOrUnderflowInTransfer
                    contract_address recipient
                    amount
                    (ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance ...)) && true
                    then
                    (Int256.one,
                    update_Outgoing_transfer_recipient_and_amount
                    (Some (recipient, amount))
                    d)
                    else (Int256.zero, d);
                  me_callmethod :=
                    fun 
                    (_ : HighValues.val)
                    (_ : int)
                    (_ : HighValues.val)
                    (_ : list HighValues.val)
                    (_ : global_abstract_data_type)
                    (_ : ExtEnv.ext_env)
                    (_ : global_abstract_data_type)
                    (_ : ExtEnv.ext_env)
                    (_ : int256)
                    (_ : list HighValues.val)
                    => False;
                  me_log :=
                    fun
                    (_ _ : list HighValues.val)
                    (d : global_abstract_data_type)
                    => d;
                  me_valid :=
                    ContractModel.ContractModel.make_machine_env_obligation_1
                    contract_address
                    (Step_state prev) context
                    callvalue_bounded_prf
                    balances_bounded_prf
                    callvalue_prf
                |})))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then put d'
   else mzero)
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
ret (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if
      noOverflowOrUnderflowInTransfer
        contract_address
        (Crowdfunding_owner
           (contract_state (Step_state prev)))
        (ContractModel.update_balances
           (caller context) contract_address
           (callvalue context)
           (balance (Step_state prev))
           contract_address)
        (ContractModel.update_balances
           (caller context) contract_address
           (callvalue context)
           (balance (Step_state prev))) && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
      destruct (noOverflowOrUnderflowInTransfer
      contract_address
      (Crowdfunding_owner
        (contract_state (Step_state prev)))
      (ContractModel.update_balances
        (caller context) contract_address
        (callvalue context)
        (balance (Step_state prev))
        contract_address)
      (ContractModel.update_balances
        (caller context) contract_address
        (callvalue context)
        (balance (Step_state prev)))).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if true && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))


            simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (Crowdfunding_owner
          (contract_state (Step_state prev)),
       ContractModel.update_balances
         (caller context) contract_address
         (callvalue context)
         (balance (Step_state prev))
         contract_address))
    (update_Crowdfunding_funded true
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            inversion case_getFunds_prf'2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (Crowdfunding_owner
          (contract_state (Step_state prev)),
       ContractModel.update_balances
         (caller context) contract_address
         (callvalue context)
         (balance (Step_state prev))
         contract_address))
    (update_Crowdfunding_funded true
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (Crowdfunding_owner (contract_state (Step_state prev)),
     ContractModel.update_balances 
       (caller context) contract_address 
       (callvalue context) 
       (balance (Step_state prev)) contract_address))
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) = contract_state_after
balance_backed
  (next_blockchain_state (Step_state prev) context
     (update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner (contract_state (Step_state prev)),
           ContractModel.update_balances (caller context)
             contract_address (callvalue context)
             (balance (Step_state prev)) contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev)))))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold next_blockchain_state; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (Crowdfunding_owner
          (contract_state (Step_state prev)),
       ContractModel.update_balances
         (caller context) contract_address
         (callvalue context)
         (balance (Step_state prev))
         contract_address))
    (update_Crowdfunding_funded true
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (Crowdfunding_owner (contract_state (Step_state prev)),
     ContractModel.update_balances 
       (caller context) contract_address 
       (callvalue context) 
       (balance (Step_state prev)) contract_address))
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) = contract_state_after
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (update_Outgoing_transfer_recipient_and_amount
           (Some
              (Crowdfunding_owner (contract_state (Step_state prev)),
              ContractModel.update_balances (caller context)
                contract_address (callvalue context)
                (balance (Step_state prev)) contract_address))
           (update_Crowdfunding_funded true
              (contract_state (Step_state prev))));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers
        (update_Outgoing_transfer_recipient_and_amount
           (Some
              (Crowdfunding_owner (contract_state (Step_state prev)),
              ContractModel.update_balances (caller context)
                contract_address (callvalue context)
                (balance (Step_state prev)) contract_address))
           (update_Crowdfunding_funded true
              (contract_state (Step_state prev))))
  |}
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold balance_backed; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (Crowdfunding_owner
          (contract_state (Step_state prev)),
       ContractModel.update_balances
         (caller context) contract_address
         (callvalue context)
         (balance (Step_state prev))
         contract_address))
    (update_Crowdfunding_funded true
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (Crowdfunding_owner (contract_state (Step_state prev)),
     ContractModel.update_balances 
       (caller context) contract_address 
       (callvalue context) 
       (balance (Step_state prev)) contract_address))
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) = contract_state_after
true = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (update_Outgoing_transfer_recipient_and_amount
     (Some
        (Crowdfunding_owner (contract_state (Step_state prev)),
        ContractModel.update_balances (caller context)
          contract_address (callvalue context)
          (balance (Step_state prev)) contract_address))
     (update_Crowdfunding_funded true
        (contract_state (Step_state prev)))) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            intros; discriminate.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold balance_backed; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = true
case_getFunds_prf'2: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (Crowdfunding_owner
              (contract_state (Step_state prev)),
           ContractModel.update_balances
             (caller context) contract_address
             (callvalue context)
             (balance (Step_state prev))
             contract_address))
        (update_Crowdfunding_funded true
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_funded true
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        None
    |})
  (update_Crowdfunding_funded true
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
Crowdfunding_funded contract_state_after = false ->
sum (Crowdfunding_backers contract_state_after) <=
new_balance_after_contract_call (Step_state prev) context
  contract_state_after contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers contract_state_after) = Some value ->
 value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            intros; discriminate.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            clear case_getFunds_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            unfold balance_backed in IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold next_blockchain_state.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |}
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) unfold balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
Crowdfunding_funded
  (contract_state
     {|
       timestamp := timestamp (Step_state prev);
       block_number := block_number (Step_state prev);
       balance :=
         new_balance_after_contract_call (Step_state prev) context
           (contract_state (Step_state prev));
       blockhash := blockhash (Step_state prev);
       contract_state :=
         resetTransfers (contract_state (Step_state prev))
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := timestamp (Step_state prev);
          block_number := block_number (Step_state prev);
          balance :=
            new_balance_after_contract_call (Step_state prev) context
              (contract_state (Step_state prev));
          blockhash := blockhash (Step_state prev);
          contract_state :=
            resetTransfers (contract_state (Step_state prev))
        |})) <=
balance
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := timestamp (Step_state prev);
           block_number := block_number (Step_state prev);
           balance :=
             new_balance_after_contract_call (Step_state prev)
               context (contract_state (Step_state prev));
           blockhash := blockhash (Step_state prev);
           contract_state :=
             resetTransfers (contract_state (Step_state prev))
         |})) = Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            pose proof (NoLeftoverOutgoings H).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            rewrite H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances None
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 me_balance
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf)
   (me_address
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            (* intros. *)
            unfold step; unfold balance_backed; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            apply Z.eqb_eq in H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            rewrite H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 0
  (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            (* rewrite H0. *)
            (* subst. *)
            (* unfold resetTransfers. simpl. *)
            rewrite addZeroBalance.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = true
Heqb1: (Crowdfunding_goal (contract_state (Step_state prev)) <=?
 ContractModel.update_balances 
   (caller context) contract_address 
   (callvalue context) 
   (balance (Step_state prev)) contract_address) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            (* ---- *)

            clear case_getFunds_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            unfold balance_backed in IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold next_blockchain_state.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |}
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) unfold balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Crowdfunding_funded
  (contract_state
     {|
       timestamp := timestamp (Step_state prev);
       block_number := block_number (Step_state prev);
       balance :=
         new_balance_after_contract_call (Step_state prev) context
           (contract_state (Step_state prev));
       blockhash := blockhash (Step_state prev);
       contract_state :=
         resetTransfers (contract_state (Step_state prev))
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := timestamp (Step_state prev);
          block_number := block_number (Step_state prev);
          balance :=
            new_balance_after_contract_call (Step_state prev) context
              (contract_state (Step_state prev));
          blockhash := blockhash (Step_state prev);
          contract_state :=
            resetTransfers (contract_state (Step_state prev))
        |})) <=
balance
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := timestamp (Step_state prev);
           block_number := block_number (Step_state prev);
           balance :=
             new_balance_after_contract_call (Step_state prev)
               context (contract_state (Step_state prev));
           blockhash := blockhash (Step_state prev);
           contract_state :=
             resetTransfers (contract_state (Step_state prev))
         |})) = Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev))) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            pose proof (NoLeftoverOutgoings H).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            rewrite H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances None
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (me_number
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) 
           (_ _ : addr) 
           (_ : wei) => true) callvalue_bounded_prf
        balances_bounded_prf callvalue_prf)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            (* intros. *)
            unfold step; unfold balance_backed; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            apply Z.eqb_eq in H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))

            rewrite H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 0
  (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            (* rewrite H0. *)
            (* subst. *)
            (* unfold resetTransfers. simpl. *)
            rewrite addZeroBalance.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
true
Heqb0: Int256.ltu
  (Crowdfunding_max_block (contract_state (Step_state prev)))
  (block_number (Step_state prev)) = false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
            assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_getFunds_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0))
        s
    with
    | Some (_, s0) =>
        runStateT
          (if
            (caller context =?
             Crowdfunding_owner s0)%int256
           then
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    Int256.ltu
                    (Crowdfunding_max_block s1)
                    (block_number
                    (Step_state prev))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (if
                    Crowdfunding_goal s2 <=?
                    ContractModel.update_balances
                    ... contract_address ... ...
                    contract_address
                    then {| ... |}
                    else {| ... |}) s2
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}) s1
            |}
           else
            {|
              runStateT :=
                fun
                  s1 : global_abstract_data_type
                => Some (tt, s1)
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))

            (* ---- *)

            clear case_getFunds_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))

            unfold balance_backed in IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
            unfold next_blockchain_state.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
balance_backed
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |} unfold balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
Crowdfunding_funded
  (contract_state
     {|
       timestamp := timestamp (Step_state prev);
       block_number := block_number (Step_state prev);
       balance :=
         new_balance_after_contract_call (Step_state prev) context
           (contract_state (Step_state prev));
       blockhash := blockhash (Step_state prev);
       contract_state :=
         resetTransfers (contract_state (Step_state prev))
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := timestamp (Step_state prev);
          block_number := block_number (Step_state prev);
          balance :=
            new_balance_after_contract_call (Step_state prev) context
              (contract_state (Step_state prev));
          blockhash := blockhash (Step_state prev);
          contract_state :=
            resetTransfers (contract_state (Step_state prev))
        |})) <=
balance
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      new_balance_after_contract_call (Step_state prev) context
        (contract_state (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state :=
      resetTransfers (contract_state (Step_state prev))
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := timestamp (Step_state prev);
           block_number := block_number (Step_state prev);
           balance :=
             new_balance_after_contract_call (Step_state prev)
               context (contract_state (Step_state prev));
           blockhash := blockhash (Step_state prev);
           contract_state :=
             resetTransfers (contract_state (Step_state prev))
         |})) = Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
new_balance_after_contract_call (Step_state prev) context
  (contract_state (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            pose proof (NoLeftoverOutgoings H).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (contract_state (Step_state prev)))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            rewrite H1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
current_balances None
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: (me_caller
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
       => true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)

            (* intros. *)
            unfold step; unfold balance_backed; simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)

            apply Z.eqb_eq in H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 
  (callvalue context) (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)

            rewrite H6.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances (caller context) contract_address 0
  (balance (Step_state prev)) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            (* rewrite H0. *)
            (* subst. *)
            (* unfold resetTransfers. simpl. *)
            rewrite addZeroBalance.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: callvalue context = 0
Heqb: (caller context =?
 Crowdfunding_owner (contract_state (Step_state prev)))%int256 =
false
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H1: Outgoing_transfer_recipient_and_amount
  (contract_state (Step_state prev)) = None
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
            assumption.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
balance_backed (stepOnce prev) Transparent Crowdfunding_claim_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
balance_backed (stepOnce prev)
      pose proof case_claim_prf as case_claim_prf'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (stepOnce prev)
      unfold Crowdfunding_claim_opt in case_claim_prf'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (stepOnce prev)
      unfold stepOnce.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed (step (Step_state prev) (Step_action prev)) unfold step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address
        (Step_state prev) context
        address_accepts_funds_assumption
        callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      simpl in case_claim_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
Case: Step_action prev =
call_Crowdfunding_claim 
  (Step_state prev) context callvalue_bounded_prf
  balances_bounded_prf callvalue_prf r contract_state_after
  case_claim_prf
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) clear Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            address_accepts_funds_assumption
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           address_accepts_funds_assumption
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             address_accepts_funds_assumption
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                address_accepts_funds_assumption
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context
               address_accepts_funds_assumption
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      unfold  address_accepts_funds_assumption in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
case_claim_prf': runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address
               (Step_state prev) context
               (fun (_ : option ContractState)
                  (_ _ : addr) 
                  (_ : wei) => true)
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf) =?
          me_address
            (make_machine_env contract_address
               (Step_state prev) context
               (fun (_ : option ContractState)
                  (_ _ : addr) 
                  (_ : wei) => true)
               callvalue_bounded_prf
               balances_bounded_prf callvalue_prf))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address
            (Step_state prev) context
            (fun (_ : option ContractState)
               (_ _ : addr) 
               (_ : wei) => true)
            callvalue_bounded_prf
            balances_bounded_prf callvalue_prf) =?
       0);; guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address
           (Step_state prev) context
           (fun (_ : option ContractState)
              (_ _ : addr) 
              (_ : wei) => true)
           callvalue_bounded_prf
           balances_bounded_prf callvalue_prf));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if
       (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0
               (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address
               (...) context 
               (...) callvalue_bounded_prf
               balances_bounded_prf callvalue_prf)
            (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256
        then put d'
        else mzero))))
  (contract_state (Step_state prev)) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      ds_inv; subst; try discriminate.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (me_number
        (make_machine_env contract_address 
           (Step_state prev) context
           (fun (_ : option ContractState) 
              (_ _ : addr) 
              (_ : wei) => true) callvalue_bounded_prf
           balances_bounded_prf callvalue_prf))) = true
balance_backed
  (next_blockchain_state (Step_state prev) context
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (tt, contract_state (Step_state prev))
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (me_number
        (make_machine_env contract_address 
           (Step_state prev) context
           (fun (_ : option ContractState) 
              (_ _ : addr) 
              (_ : wei) => true) callvalue_bounded_prf
           balances_bounded_prf callvalue_prf))) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState) 
                (_ _ : addr) 
                (_ : wei) => true) callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState) 
                   (_ _ : addr) 
                   (_ : wei) => true) callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)))) = true
balance_backed
  (next_blockchain_state 
     (Step_state prev) context 
     (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (me_number
        (make_machine_env contract_address 
           (Step_state prev) context
           (fun (_ : option ContractState) 
              (_ _ : addr) 
              (_ : wei) => true) callvalue_bounded_prf
           balances_bounded_prf callvalue_prf))) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState) 
                (_ _ : addr) 
                (_ : wei) => true) callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState) 
                   (_ _ : addr) 
                   (_ : wei) => true) callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)))) =
false
case_claim_prf'1: runStateT
  (let (success, d') :=
     me_transfer
       (make_machine_env contract_address
          (Step_state prev) context
          (fun (_ : option ContractState)
             (_ _ : addr) 
             (_ : wei) => true)
          callvalue_bounded_prf
          balances_bounded_prf callvalue_prf)
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (update_Crowdfunding_backers
          (set
             (me_caller
                (make_machine_env contract_address
                   (Step_state prev) context
                   (fun 
                    (_ : option ContractState)
                    (_ _ : addr) 
                    (_ : wei) => true)
                   callvalue_bounded_prf
                   balances_bounded_prf
                   callvalue_prf)) 0
             (Crowdfunding_backers
                (contract_state (Step_state prev))))
          (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then put d'
   else mzero)
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              (fun (_ : option ContractState)
                 (_ _ : addr) 
                 (_ : wei) => true)
              callvalue_bounded_prf
              balances_bounded_prf callvalue_prf))
        0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
ret (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
      1,2: simpl in H6; pose proof (NoLeftoverOutgoings H); apply balance_backed_in_next_state; try assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: GetHighData
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb
  (me_caller
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf) =?
   me_address
     (make_machine_env contract_address 
        (Step_state prev) context
        (fun (_ : option ContractState) (_ _ : addr) (_ : wei)
         => true) callvalue_bounded_prf balances_bounded_prf
        callvalue_prf))%int256 = true
a1: unit
H6: (me_callvalue
   (make_machine_env contract_address 
      (Step_state prev) context
      (fun (_ : option ContractState) (_ _ : addr) (_ : wei) =>
       true) callvalue_bounded_prf balances_bounded_prf
      callvalue_prf) =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (me_number
        (make_machine_env contract_address 
           (Step_state prev) context
           (fun (_ : option ContractState) 
              (_ _ : addr) 
              (_ : wei) => true) callvalue_bounded_prf
           balances_bounded_prf callvalue_prf))) = false
Heqb0: (get_default 0
   (me_caller
      (make_machine_env contract_address 
         (Step_state prev) context
         (fun (_ : option ContractState) 
            (_ _ : addr) 
            (_ : wei) => true) callvalue_bounded_prf
         balances_bounded_prf callvalue_prf))
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        me_balance
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState) 
                (_ _ : addr) 
                (_ : wei) => true) callvalue_bounded_prf
             balances_bounded_prf callvalue_prf)
          (me_address
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState) 
                   (_ _ : addr) 
                   (_ : wei) => true) callvalue_bounded_prf
                balances_bounded_prf callvalue_prf)))) =
false
case_claim_prf'1: runStateT
  (let (success, d') :=
     me_transfer
       (make_machine_env contract_address
          (Step_state prev) context
          (fun (_ : option ContractState)
             (_ _ : addr) 
             (_ : wei) => true)
          callvalue_bounded_prf
          balances_bounded_prf callvalue_prf)
       (me_caller
          (make_machine_env contract_address
             (Step_state prev) context
             (fun (_ : option ContractState)
                (_ _ : addr) 
                (_ : wei) => true)
             callvalue_bounded_prf
             balances_bounded_prf callvalue_prf))
       (get_default 0
          (me_caller
             (make_machine_env contract_address
                (Step_state prev) context
                (fun 
                   (_ : option ContractState)
                   (_ _ : addr) 
                   (_ : wei) => true)
                callvalue_bounded_prf
                balances_bounded_prf callvalue_prf))
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (update_Crowdfunding_backers
          (set
             (me_caller
                (make_machine_env contract_address
                   (Step_state prev) context
                   (fun 
                    (_ : option ContractState)
                    (_ _ : addr) 
                    (_ : wei) => true)
                   callvalue_bounded_prf
                   balances_bounded_prf
                   callvalue_prf)) 0
             (Crowdfunding_backers
                (contract_state (Step_state prev))))
          (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then put d'
   else mzero)
  (update_Crowdfunding_backers
     (set
        (me_caller
           (make_machine_env contract_address
              (Step_state prev) context
              (fun (_ : option ContractState)
                 (_ _ : addr) 
                 (_ : wei) => true)
              callvalue_bounded_prf
              balances_bounded_prf callvalue_prf))
        0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
ret (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
case_claim_prf'1: runStateT
  (let (success, d') :=
     if
      noOverflowOrUnderflowInTransfer
        contract_address 
        (caller context)
        (get_default 0 
           (caller context)
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (ContractModel.update_balances
           (caller context) contract_address
           (callvalue context)
           (balance (Step_state prev))) && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 
             (caller context)
             (Crowdfunding_backers
                (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type => None
    |})
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
      destruct (noOverflowOrUnderflowInTransfer
      contract_address (caller context)
      (get_default 0 (caller context)
        (Crowdfunding_backers
            (contract_state (Step_state prev))))
      (ContractModel.update_balances
        (caller context) contract_address
        (callvalue context)
        (balance (Step_state prev)))) eqn:SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: runStateT
  (let (success, d') :=
     if true && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 
             (caller context)
             (Crowdfunding_backers
                (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type => None
    |})
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = false
case_claim_prf'1: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 
             (caller context)
             (Crowdfunding_backers
                (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type => None
    |})
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state 
     (Step_state prev) context contract_state_after)
      *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: runStateT
  (let (success, d') :=
     if true && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 
             (caller context)
             (Crowdfunding_backers
                (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type => None
    |})
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) inversion case_claim_prf'1.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
balance_backed
  (next_blockchain_state (Step_state prev) context
     (update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 (caller context)
             (Crowdfunding_backers (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))))
        unfold balance_backed; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
new_balance_after_contract_call (Step_state prev) context
  (update_Outgoing_transfer_recipient_and_amount
     (Some
        (caller context,
        get_default 0 (caller context)
          (Crowdfunding_backers (contract_state (Step_state prev)))))
     (update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers (contract_state (Step_state prev))))
        (contract_state (Step_state prev)))) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
new_balance_after_contract_call (Step_state prev) context
  (update_Outgoing_transfer_recipient_and_amount
     (Some
        (caller context,
        get_default 0 (caller context)
          (Crowdfunding_backers (contract_state (Step_state prev)))))
     (update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers (contract_state (Step_state prev))))
        (contract_state (Step_state prev)))) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus) apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
new_balance_after_contract_call (Step_state prev) context
  (update_Outgoing_transfer_recipient_and_amount
     (Some
        (caller context,
        get_default 0 (caller context)
          (Crowdfunding_backers (contract_state (Step_state prev)))))
     (update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers (contract_state (Step_state prev))))
        (contract_state (Step_state prev)))) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)

        unfold new_balance_after_contract_call.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     (update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 (caller context)
             (Crowdfunding_backers (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev)))))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        unfold update_Outgoing_transfer_recipient_and_amount.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
current_balances
  (Outgoing_transfer_recipient_and_amount
     {|
       Outgoing_transfer_recipient_and_amount :=
         Some
           (caller context,
           get_default 0 (caller context)
             (Crowdfunding_backers (contract_state (Step_state prev))));
       Crowdfunding_owner :=
         Crowdfunding_owner
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_max_block :=
         Crowdfunding_max_block
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_goal :=
         Crowdfunding_goal
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_backers :=
         Crowdfunding_backers
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_funded :=
         Crowdfunding_funded
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_deadlinePassed_msg :=
         Crowdfunding_deadlinePassed_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_successfullyDonated_msg :=
         Crowdfunding_successfullyDonated_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_alreadyDonated_msg :=
         Crowdfunding_alreadyDonated_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_funded_msg :=
         Crowdfunding_funded_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_failed_msg :=
         Crowdfunding_failed_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_too_early_to_claim_funds_msg :=
         Crowdfunding_too_early_to_claim_funds_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_too_early_to_reclaim_msg :=
         Crowdfunding_too_early_to_reclaim_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_cannot_refund_msg :=
         Crowdfunding_cannot_refund_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)));
       Crowdfunding_here_is_your_money_msg :=
         Crowdfunding_here_is_your_money_msg
           (update_Crowdfunding_backers
              (set (caller context) 0
                 (Crowdfunding_backers
                    (contract_state (Step_state prev))))
              (contract_state (Step_state prev)))
     |})
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
update_balances contract_address (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (update_balances (caller context) contract_address
     (callvalue context) (balance (Step_state prev)))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        unfold update_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (caller context =? contract_address)%int256
  then balance (Step_state prev) contract_address
  else
   if (contract_address =? caller context)%int256
   then
    balance (Step_state prev) (caller context) - callvalue context
   else
    if (contract_address =? contract_address)%int256
    then
     balance (Step_state prev) contract_address + callvalue context
    else balance (Step_state prev) contract_address
 else
  if (contract_address =? contract_address)%int256
  then
   (if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) -
   get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev)))
  else
   if (contract_address =? caller context)%int256
   then
    (if (caller context =? contract_address)%int256
     then balance (Step_state prev) (caller context)
     else
      if (caller context =? caller context)%int256
      then
       balance (Step_state prev) (caller context) - callvalue context
      else
       if (caller context =? contract_address)%int256
       then
        balance (Step_state prev) contract_address +
        callvalue context
       else balance (Step_state prev) (caller context)) +
    get_default 0 (caller context)
      (Crowdfunding_backers (contract_state (Step_state prev)))
   else
    if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (caller context =? contract_address)%int256
  then balance (Step_state prev) contract_address
  else
   if (contract_address =? caller context)%int256
   then
    balance (Step_state prev) (caller context) - callvalue context
   else
    if (contract_address =? contract_address)%int256
    then
     balance (Step_state prev) contract_address + callvalue context
    else balance (Step_state prev) contract_address
 else
  if (contract_address =? contract_address)%int256
  then
   (if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) -
   get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev)))
  else
   if (contract_address =? caller context)%int256
   then
    (if (caller context =? contract_address)%int256
     then balance (Step_state prev) (caller context)
     else
      if (caller context =? caller context)%int256
      then
       balance (Step_state prev) (caller context) - callvalue context
      else
       if (caller context =? contract_address)%int256
       then
        balance (Step_state prev) contract_address +
        callvalue context
       else balance (Step_state prev) (caller context)) +
    get_default 0 (caller context)
      (Crowdfunding_backers (contract_state (Step_state prev)))
   else
    if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        (* Open Scope int256.
        Search "=?" false. *)
        (* Search negb false true. *)
        rewrite negb_true_iff in H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (caller context =? contract_address)%int256
  then balance (Step_state prev) contract_address
  else
   if (contract_address =? caller context)%int256
   then
    balance (Step_state prev) (caller context) - callvalue context
   else
    if (contract_address =? contract_address)%int256
    then
     balance (Step_state prev) contract_address + callvalue context
    else balance (Step_state prev) contract_address
 else
  if (contract_address =? contract_address)%int256
  then
   (if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) -
   get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev)))
  else
   if (contract_address =? caller context)%int256
   then
    (if (caller context =? contract_address)%int256
     then balance (Step_state prev) (caller context)
     else
      if (caller context =? caller context)%int256
      then
       balance (Step_state prev) (caller context) - callvalue context
      else
       if (caller context =? contract_address)%int256
       then
        balance (Step_state prev) contract_address +
        callvalue context
       else balance (Step_state prev) (caller context)) +
    get_default 0 (caller context)
      (Crowdfunding_backers (contract_state (Step_state prev)))
   else
    if (caller context =? contract_address)%int256
    then balance (Step_state prev) contract_address
    else
     if (contract_address =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else
      if (contract_address =? contract_address)%int256
      then
       balance (Step_state prev) contract_address + callvalue context
      else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        (* apply Int256eq_false in H2. *)
        rewrite H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else
   if (contract_address =? contract_address)%int256
   then
    balance (Step_state prev) contract_address + callvalue context
   else balance (Step_state prev) contract_address
 else
  if (contract_address =? contract_address)%int256
  then
   (if (contract_address =? caller context)%int256
    then
     balance (Step_state prev) (caller context) - callvalue context
    else
     if (contract_address =? contract_address)%int256
     then
      balance (Step_state prev) contract_address + callvalue context
     else balance (Step_state prev) contract_address) -
   get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev)))
  else
   if (contract_address =? caller context)%int256
   then
    (if (caller context =? caller context)%int256
     then
      balance (Step_state prev) (caller context) - callvalue context
     else balance (Step_state prev) (caller context)) +
    get_default 0 (caller context)
      (Crowdfunding_backers (contract_state (Step_state prev)))
   else
    if (contract_address =? caller context)%int256
    then
     balance (Step_state prev) (caller context) - callvalue context
    else
     if (contract_address =? contract_address)%int256
     then
      balance (Step_state prev) contract_address + callvalue context
     else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        rewrite Int256.eq_true.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (caller context =? contract_address)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else balance (Step_state prev) contract_address + callvalue context
 else
  (if (contract_address =? caller context)%int256
   then
    balance (Step_state prev) (caller context) - callvalue context
   else
    balance (Step_state prev) contract_address + callvalue context) -
  get_default 0 (caller context)
    (Crowdfunding_backers (contract_state (Step_state prev)))) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        rewrite Int256.eq_sym in H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
(if (contract_address =? caller context)%int256
 then
  if (contract_address =? caller context)%int256
  then balance (Step_state prev) (caller context) - callvalue context
  else balance (Step_state prev) contract_address + callvalue context
 else
  (if (contract_address =? caller context)%int256
   then
    balance (Step_state prev) (caller context) - callvalue context
   else
    balance (Step_state prev) contract_address + callvalue context) -
  get_default 0 (caller context)
    (Crowdfunding_backers (contract_state (Step_state prev)))) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        rewrite H2.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + callvalue context -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev))) /\
(forall (key : elt) (value : Z32),
 get key
   (set (caller context) 0
      (Crowdfunding_backers (contract_state (Step_state prev)))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + callvalue context -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
        --
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + callvalue context -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
          match goal with H : (callvalue context =? 0) = true |- _ => apply Z.eqb_eq in H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: callvalue context = 0
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + callvalue context -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
          match goal with H : (callvalue context = 0) |- _ => rewrite H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: callvalue context = 0
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address + 0 -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
          repeat rewrite Z.add_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: callvalue context = 0
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
          match goal with H : _ /\ _ |- _ => destruct H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: callvalue context = 0
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
sum
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) <=
balance (Step_state prev) contract_address -
get_default 0 (caller context)
  (Crowdfunding_backers (contract_state (Step_state prev)))
          apply Int256Tree_sum_minus.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: callvalue context = 0
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
          assumption.
        --
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
forall (key : elt) (value : Z32),
get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus match goal with H : _ /\ _ |- _ => destruct H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
forall (key : elt) (value : Z32),
get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value -> value >= 0 /\ value < Int256.modulus
          intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
value >= 0 /\ value < Int256.modulus destruct (Int256.eq key (caller context)) eqn:SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = true
value >= 0 /\ value < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus
          ++
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = true
value >= 0 /\ value < Int256.modulus apply Int256eq_true in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key = caller context
value >= 0 /\ value < Int256.modulus
              match goal with H : context[get key] |- _ => rewrite SSCase in H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get (caller context)
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key = caller context
value >= 0 /\ value < Int256.modulus
              (* rewrite Int256Tree.gss in H5. *)
              match goal with H :  get _ (set _ _ _) = _ |- _ => rewrite Int256Tree.gss in H; inversion H end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: Some 0 = Some value
SSCase: key = caller context
H8: 0 = value
0 >= 0 /\ 0 < Int256.modulus
              lia.
          ++
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: (key =? caller context)%int256 = false
value >= 0 /\ value < Int256.modulus apply Int256eq_false in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (set (caller context) 0
     (Crowdfunding_backers (contract_state (Step_state prev)))) =
Some value
SSCase: key <> caller context
value >= 0 /\ value < Int256.modulus

              match goal with H : context[get key] |- _ => rewrite Int256Tree.gso in H by assumption end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: (contract_address =? caller context)%int256 = false
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = true
case_claim_prf'1: Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (caller context,
       get_default 0 
         (caller context)
         (Crowdfunding_backers
            (contract_state (Step_state prev)))))
    (update_Crowdfunding_backers
       (set (caller context) 0
          (Crowdfunding_backers
             (contract_state (Step_state prev))))
       (contract_state (Step_state prev)))) =
Some (r, contract_state_after)
H1: tt = r
H3: update_Outgoing_transfer_recipient_and_amount
  (Some
     (caller context,
     get_default 0 (caller context)
       (Crowdfunding_backers (contract_state (Step_state prev)))))
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) = contract_state_after
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address
H4: forall (key : elt) (value : Z32),
get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value -> value >= 0 /\ value < Int256.modulus
key: elt
value: Z32
H5: get key
  (Crowdfunding_backers (contract_state (Step_state prev))) =
Some value
SSCase: key <> caller context
value >= 0 /\ value < Int256.modulus
              (* apply H4 in H5. *)
              match goal with H1 : (forall k v, get k _ = Some v -> v >= 0 /\ v < Int256.modulus),
                              H2 : (get key _ = _) |- _ =>
              apply H1 in H2; assumption
              end.
          *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = false
case_claim_prf'1: runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (caller context,
           get_default 0 
             (caller context)
             (Crowdfunding_backers
                (contract_state (Step_state prev)))))
        (update_Crowdfunding_backers
           (set (caller context) 0
              (Crowdfunding_backers
                 (contract_state (Step_state prev))))
           (contract_state (Step_state prev))))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set (caller context) 0
           (Crowdfunding_backers
              (contract_state (Step_state prev))))
        (contract_state (Step_state prev))) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT :=
        fun _ : global_abstract_data_type =>
        Some (tt, d')
    |}
   else
    {|
      runStateT :=
        fun _ : global_abstract_data_type => None
    |})
  (update_Crowdfunding_backers
     (set (caller context) 0
        (Crowdfunding_backers
           (contract_state (Step_state prev))))
     (contract_state (Step_state prev))) =
Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
context: CallContext
callvalue_bounded_prf: 0 <= callvalue context < Int256.modulus
balances_bounded_prf: forall a : addr,
0 <= balance (Step_state prev) a <
Int256.modulus
callvalue_prf: noOverflowOrUnderflowInTransfer 
  (caller context) contract_address
  (callvalue context) 
  (balance (Step_state prev)) = true
r: unit
contract_state_after: global_abstract_data_type
case_claim_prf: match
  runStateT
    (guard
       (negb
          (caller context =? contract_address)%int256))
    (contract_state (Step_state prev))
with
| Some (_, s) =>
    match
      runStateT (guard (callvalue context =? 0)) s
    with
    | Some (_, s0) =>
        runStateT
          (if
            negb
              (Int256.ltu
                 (Crowdfunding_max_block s0)
                 (block_number (Step_state prev)))
           then
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                => Some (tt, s1)
            |}
           else
            {|
              runStateT :=
                fun s1 : global_abstract_data_type
                =>
                runStateT
                  (if
                    (get_default 0 
                    (caller context)
                    (Crowdfunding_backers s1) =? 0)
                    || 
                    (Crowdfunding_funded s1
                    || 
                    (Crowdfunding_goal s1 <=?
                    ContractModel.update_balances
                    (caller context)
                    contract_address
                    (callvalue context)
                    (balance (Step_state prev))
                    contract_address))
                   then
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    => 
                    Some (tt, s2)
                    |}
                   else
                    {|
                    runStateT :=
                    fun
                    s2 : global_abstract_data_type
                    =>
                    runStateT
                    (let 
                    (success, d') :=
                    if ... then ... else ... in
                    if (...)%int256
                    then {| ... |}
                    else {| ... |})
                    (update_Crowdfunding_backers
                    (set (...) 0 (...)) s2)
                    |}) s1
            |}) s0
    | None => None
    end
| None => None
end = Some (r, contract_state_after)
a: unit
H2: negb (caller context =? contract_address)%int256 = true
a1: unit
H6: (callvalue context =? 0) = true
Heqb: negb
  (Int256.ltu
     (Crowdfunding_max_block
        (contract_state (Step_state prev)))
     (block_number (Step_state prev))) = false
Heqb0: (get_default 0 (caller context)
   (Crowdfunding_backers (contract_state (Step_state prev))) =?
 0)
|| (Crowdfunding_funded (contract_state (Step_state prev))
    || (Crowdfunding_goal (contract_state (Step_state prev)) <=?
        ContractModel.update_balances 
          (caller context) contract_address
          (callvalue context) 
          (balance (Step_state prev)) contract_address)) =
false
SCase: noOverflowOrUnderflowInTransfer contract_address
  (caller context)
  (get_default 0 (caller context)
     (Crowdfunding_backers (contract_state (Step_state prev))))
  (ContractModel.update_balances 
     (caller context) contract_address 
     (callvalue context) 
     (balance (Step_state prev))) = false
case_claim_prf'1: None = Some (r, contract_state_after)
balance_backed
  (next_blockchain_state (Step_state prev) context
     contract_state_after) discriminate.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
balance_backed (stepOnce prev) unfold stepOnce, step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
balance_backed
  (update_balance (Step_state prev)
     (update_balances sender recipient amount
        (balance (Step_state prev))))
      unfold balance_backed.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
Crowdfunding_funded
  (contract_state
     (update_balance (Step_state prev)
        (update_balances sender recipient amount
           (balance (Step_state prev))))) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        (update_balance (Step_state prev)
           (update_balances sender recipient amount
              (balance (Step_state prev)))))) <=
balance
  (update_balance (Step_state prev)
     (update_balances sender recipient amount
        (balance (Step_state prev)))) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         (update_balance (Step_state prev)
            (update_balances sender recipient amount
               (balance (Step_state prev)))))) = Some value ->
 value >= 0 /\ value < Int256.modulus)
      unfold update_balance.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
Crowdfunding_funded
  (contract_state
     {|
       timestamp := timestamp (Step_state prev);
       block_number := block_number (Step_state prev);
       balance :=
         update_balances sender recipient amount
           (balance (Step_state prev));
       blockhash := blockhash (Step_state prev);
       contract_state := contract_state (Step_state prev)
     |}) = false ->
sum
  (Crowdfunding_backers
     (contract_state
        {|
          timestamp := timestamp (Step_state prev);
          block_number := block_number (Step_state prev);
          balance :=
            update_balances sender recipient amount
              (balance (Step_state prev));
          blockhash := blockhash (Step_state prev);
          contract_state := contract_state (Step_state prev)
        |})) <=
balance
  {|
    timestamp := timestamp (Step_state prev);
    block_number := block_number (Step_state prev);
    balance :=
      update_balances sender recipient amount
        (balance (Step_state prev));
    blockhash := blockhash (Step_state prev);
    contract_state := contract_state (Step_state prev)
  |} contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state
         {|
           timestamp := timestamp (Step_state prev);
           block_number := block_number (Step_state prev);
           balance :=
             update_balances sender recipient amount
               (balance (Step_state prev));
           blockhash := blockhash (Step_state prev);
           contract_state := contract_state (Step_state prev)
         |})) = Some value -> value >= 0 /\ value < Int256.modulus)
      simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
prf: sender <> contract_address /\
amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount prf
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances sender recipient amount (balance (Step_state prev))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      destruct prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
a: amount >= 0 /\
noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount 
  (conj n a)
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances sender recipient amount (balance (Step_state prev))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) destruct a.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances sender recipient amount (balance (Step_state prev))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: Crowdfunding_funded (contract_state (Step_state prev)) = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances sender recipient amount (balance (Step_state prev))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      apply IHReachableFromBy in H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
update_balances sender recipient amount (balance (Step_state prev))
  contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      unfold update_balances.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
(if (sender =? recipient)%int256
 then balance (Step_state prev) contract_address
 else
  if (contract_address =? sender)%int256
  then balance (Step_state prev) sender - amount
  else
   if (contract_address =? recipient)%int256
   then balance (Step_state prev) recipient + amount
   else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      destruct (Int256.eq sender recipient); try assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
(if (contract_address =? sender)%int256
 then balance (Step_state prev) sender - amount
 else
  if (contract_address =? recipient)%int256
  then balance (Step_state prev) recipient + amount
  else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      destruct (Int256.eq contract_address sender) eqn:SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = true
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) sender - amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
(if (contract_address =? recipient)%int256
 then balance (Step_state prev) recipient + amount
 else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
        *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = true
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) sender - amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) apply Int256eq_true in SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: contract_address = sender
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) sender - amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) symmetry in SCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: sender = contract_address
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) sender - amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) contradiction.
        *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
(if (contract_address =? recipient)%int256
 then balance (Step_state prev) recipient + amount
 else balance (Step_state prev) contract_address) /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) destruct(Int256.eq contract_address recipient) eqn:SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: (contract_address =? recipient)%int256 = true
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) recipient + amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: (contract_address =? recipient)%int256 = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
          --
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: (contract_address =? recipient)%int256 = true
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) recipient + amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) apply Int256eq_true in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: contract_address = recipient
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) recipient + amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) rewrite <- SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: contract_address = recipient
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address + amount /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) split; [|apply H0].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: contract_address = recipient
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address + amount lia.
          --
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
sender, recipient: addr
amount: wei
n: sender <> contract_address
g: amount >= 0
e: noOverflowOrUnderflowInTransfer sender recipient amount
  (balance (Step_state prev)) &&
address_accepts_funds_assumption None sender recipient amount =
true
Case: Step_action prev =
externalBalanceTransfer 
  (Step_state prev) sender recipient amount
  (conj n (conj g e))
H0: sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
SCase: (contract_address =? sender)%int256 = false
SSCase: (contract_address =? recipient)%int256 = false
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus) split; apply H0.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
balance_backed (stepOnce prev) unfold stepOnce, step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
balance_backed
  (updateTimeAndBlock (Step_state prev) block_count time_passing)
      unfold balance_backed; simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      unfold balance_backed in IHReachableFromBy.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      simpl in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: Crowdfunding_funded
  (contract_state (Step_state prev)) = false ->
sum
  (Crowdfunding_backers
     (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key
   (Crowdfunding_backers
      (contract_state (Step_state prev))) =
 Some value ->
 value >= 0 /\ value < Int256.modulus)
block_count, time_passing: int256
prf: validTimeChange block_count time_passing
  (block_number (Step_state prev))
  (timestamp (Step_state prev)) = true
Case: Step_action prev =
timePassing (Step_state prev) block_count time_passing prf
Crowdfunding_funded (contract_state (Step_state prev)) = false ->
sum (Crowdfunding_backers (contract_state (Step_state prev))) <=
balance (Step_state prev) contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state (Step_state prev))) =
 Some value -> value >= 0 /\ value < Int256.modulus)
      assumption.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
Case: Step_action prev = revert (Step_state prev)
balance_backed (stepOnce prev) unfold stepOnce, step.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
Case: Step_action prev = revert (Step_state prev)
balance_backed
  ((fix step
      (before : BlockchainState) (action : Action before) {struct
       action} : BlockchainState :=
      match action with
      | @call_Crowdfunding_donate _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_getFunds _ context _ _ _ _ d_after _ |
        @call_Crowdfunding_claim _ context _ _ _ _ d_after _ =>
          next_blockchain_state before context d_after
      | @externalBalanceTransfer _ sender recipient amount _ =>
          update_balance before
            (update_balances sender recipient amount (balance before))
      | @timePassing _ block_count time_passing _ =>
          updateTimeAndBlock before block_count time_passing
      | @revert _ => before
      end) (Step_state prev) (Step_action prev)) rewrite Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
prevSt: BlockchainState
prev: Step
prevList: list Step
H: ReachableFromBy initial_state (Step_state prev) prev prevList
next_action: Action (stepOnce prev)
IHReachableFromBy: balance_backed (Step_state prev)
Case: Step_action prev = revert (Step_state prev)
balance_backed (Step_state prev)
      assumption.
Qed.

Opaque Crowdfunding_donate_opt Crowdfunding_getFunds_opt Crowdfunding_claim_opt.

Lemma can_claim_back :
forall state s l
backer_addr backed_amount,
ReachableFromBy initial_state state s l ->
  backed_amount = Int256Tree.get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) ->
  (* Backer is not the contract itself *)
  contract_address <> backer_addr ->
  (* Backed nonzero *)
  backed_amount > 0 ->
  (* Backer is not so rich that receiving their refund would cause their balance to overflow. *)
  (balance state backer_addr + backed_amount <? Int256.modulus) = true ->
  (* Not funded *)
  Crowdfunding_funded (contract_state state) = false ->
  (* Balance is small: not reached the goal *)
  balance state contract_address < (Crowdfunding_goal (contract_state state)) ->
  (* Balances start in a legitimate range*)
  (forall a : addr, 0 <= balance state a < Int256.modulus)
  ->
  (* Block number exceeds the set number *)
  Int256.ltu (Crowdfunding_max_block (contract_state state)) (block_number state) = true ->
  (* Can emit message from b *)
  exists (action : Action state),
          Outgoing_transfer_recipient_and_amount (contract_state (step_keep_transfer state action)) = Some (backer_addr, backed_amount)
          /\
          (* The following represents the idea that the action must not merely be some action by anyone, but it must be one do-able by the caller. And that the caller can get their funds back without giving away more funds, hence the callvalue must be zero. *)
          match action with
          | call_Crowdfunding_donate context _ _ _ _ _ _ => callvalue context = 0 /\ caller context = backer_addr
          | call_Crowdfunding_getFunds context _ _ _ _ _ _ => callvalue context = 0 /\ caller context = backer_addr
          | call_Crowdfunding_claim context _ _ _ _ _ _ => callvalue context = 0 /\ caller context = backer_addr
          | _ => False
          end.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (state : BlockchainState) (s : Step) (l : list Step)
  (backer_addr : elt) (backed_amount : Z),
ReachableFromBy initial_state state s l ->
backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) ->
contract_address <> backer_addr ->
backed_amount > 0 ->
(balance state backer_addr + backed_amount <? Int256.modulus) = true ->
Crowdfunding_funded (contract_state state) = false ->
balance state contract_address <
Crowdfunding_goal (contract_state state) ->
(forall a : addr, 0 <= balance state a < Int256.modulus) ->
Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true ->
exists action : Action state,
  Outgoing_transfer_recipient_and_amount
    (contract_state (step_keep_transfer state action)) =
  Some (backer_addr, backed_amount) /\
  match action with
  | @call_Crowdfunding_donate _ context _ _ _ _ _ _ |
    @call_Crowdfunding_getFunds _ context _ _ _ _ _ _ |
    @call_Crowdfunding_claim _ context _ _ _ _ _ _ =>
      callvalue context = 0 /\ caller context = backer_addr
  | _ => False
  end
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (state : BlockchainState) (s : Step) (l : list Step)
  (backer_addr : elt) (backed_amount : Z),
ReachableFromBy initial_state state s l ->
backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) ->
contract_address <> backer_addr ->
backed_amount > 0 ->
(balance state backer_addr + backed_amount <? Int256.modulus) = true ->
Crowdfunding_funded (contract_state state) = false ->
balance state contract_address <
Crowdfunding_goal (contract_state state) ->
(forall a : addr, 0 <= balance state a < Int256.modulus) ->
Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true ->
exists action : Action state,
  Outgoing_transfer_recipient_and_amount
    (contract_state (step_keep_transfer state action)) =
  Some (backer_addr, backed_amount) /\
  match action with
  | @call_Crowdfunding_donate _ context _ _ _ _ _ _ |
    @call_Crowdfunding_getFunds _ context _ _ _ _ _ _ |
    @call_Crowdfunding_claim _ context _ _ _ _ _ _ =>
      callvalue context = 0 /\ caller context = backer_addr
  | _ => False
  end
intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
exists action : Action state,
  Outgoing_transfer_recipient_and_amount
    (contract_state (step_keep_transfer state action)) =
  Some (backer_addr, backed_amount) /\
  match action with
  | @call_Crowdfunding_donate _ context _ _ _ _ _ _ |
    @call_Crowdfunding_getFunds _ context _ _ _ _ _ _ |
    @call_Crowdfunding_claim _ context _ _ _ _ _ _ =>
      callvalue context = 0 /\ caller context = backer_addr
  | _ => False
  end
eexists (call_Crowdfunding_claim state _ _ _ _ _ _ _).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  (contract_state
     (step_keep_transfer state
        (call_Crowdfunding_claim state ?context
           ?callvalue_bounded_prf ?balances_bounded_prf
           ?callvalue_prf ?r ?contract_state_after 
           ?case_claim_prf))) = Some (backer_addr, backed_amount) /\
callvalue ?context = 0 /\ caller ?context = backer_addr
unfold step_keep_transfer, next_blockchain_state_keep_transfer.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  (contract_state
     {|
       timestamp := timestamp state;
       block_number := block_number state;
       balance :=
         new_balance_after_contract_call state ?context
           ?contract_state_after;
       blockhash := blockhash state;
       contract_state := ?contract_state_after
     |}) = Some (backer_addr, backed_amount) /\
callvalue ?context = 0 /\ caller ?context = backer_addr
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  (contract_state
     {|
       timestamp := timestamp state;
       block_number := block_number state;
       balance :=
         new_balance_after_contract_call state ?context
           ?contract_state_after;
       blockhash := blockhash state;
       contract_state := ?contract_state_after
     |}) = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue ?context = 0 /\ caller ?context = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue ?context = 0 /\ caller ?context = backer_addr
shelve.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue ?context = 0 /\ caller ?context = backer_addr
shelve.
Unshelve.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
CallContext
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <= callvalue ?context < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer 
  (caller ?context) contract_address 
  (callvalue ?context) 
  (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state 
        ?context address_accepts_funds_assumption
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue ?context = 0 /\ caller ?context = backer_addr
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
addr
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
addr
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
wei
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := ?Goal1;
    caller := ?Goal2;
    callvalue := ?Goal3;
    coinbase := ?Goal4;
    chainid := ?Goal5
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := ?Goal1;
       caller := ?Goal2;
       callvalue := ?Goal3;
       coinbase := ?Goal4;
       chainid := ?Goal5
     |}) contract_address
  (callvalue
     {|
       origin := ?Goal1;
       caller := ?Goal2;
       callvalue := ?Goal3;
       coinbase := ?Goal4;
       chainid := ?Goal5
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := ?Goal1;
          caller := ?Goal2;
          callvalue := ?Goal3;
          coinbase := ?Goal4;
          chainid := ?Goal5
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := ?Goal1;
    caller := ?Goal2;
    callvalue := ?Goal3;
    coinbase := ?Goal4;
    chainid := ?Goal5
  |} = 0 /\
caller
  {|
    origin := ?Goal1;
    caller := ?Goal2;
    callvalue := ?Goal3;
    coinbase := ?Goal4;
    chainid := ?Goal5
  |} = backer_addr
exact backer_addr.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
addr
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
wei
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := backer_addr;
    caller := ?Goal1;
    callvalue := ?Goal2;
    coinbase := ?Goal3;
    chainid := ?Goal4
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := ?Goal1;
       callvalue := ?Goal2;
       coinbase := ?Goal3;
       chainid := ?Goal4
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := ?Goal1;
       callvalue := ?Goal2;
       coinbase := ?Goal3;
       chainid := ?Goal4
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := ?Goal1;
          callvalue := ?Goal2;
          coinbase := ?Goal3;
          chainid := ?Goal4
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := ?Goal1;
    callvalue := ?Goal2;
    coinbase := ?Goal3;
    chainid := ?Goal4
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := ?Goal1;
    callvalue := ?Goal2;
    coinbase := ?Goal3;
    chainid := ?Goal4
  |} = backer_addr
exact backer_addr.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
wei
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := ?Goal1;
    coinbase := ?Goal2;
    chainid := ?Goal3
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := ?Goal1;
       coinbase := ?Goal2;
       chainid := ?Goal3
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := ?Goal1;
       coinbase := ?Goal2;
       chainid := ?Goal3
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := ?Goal1;
          coinbase := ?Goal2;
          chainid := ?Goal3
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := ?Goal1;
    coinbase := ?Goal2;
    chainid := ?Goal3
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := ?Goal1;
    coinbase := ?Goal2;
    chainid := ?Goal3
  |} = backer_addr
exact 0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := ?Goal1;
    chainid := ?Goal2
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := ?Goal1;
       chainid := ?Goal2
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := ?Goal1;
       chainid := ?Goal2
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := ?Goal1;
          chainid := ?Goal2
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := ?Goal1;
    chainid := ?Goal2
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := ?Goal1;
    chainid := ?Goal2
  |} = backer_addr
exact Int256.zero.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
int256
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := ?Goal1
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := ?Goal1
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := ?Goal1
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := ?Goal1
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := ?Goal1
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := ?Goal1
  |} = backer_addr
exact Int256.zero.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <=
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption 
        ?callvalue_bounded_prf 
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <= 0 < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption 
        ?Goal1 ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr unfold Int256.modulus, two_power_nat.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <= 0 < Z.pos (shift_nat Int256.wordsize 1)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption 
        ?Goal1 ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
forall a : addr, 0 <= balance state a < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr)
        ?balances_bounded_prf 
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer
  (caller
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) contract_address
  (callvalue
     {|
       origin := backer_addr;
       caller := backer_addr;
       callvalue := 0;
       coinbase := Int256.zero;
       chainid := Int256.zero
     |}) (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        ?callvalue_prf)) 
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
noOverflowOrUnderflowInTransfer backer_addr contract_address 0
  (balance state) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        ?Goal1)) (contract_state state) =
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
unfold noOverflowOrUnderflowInTransfer.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr - 0 >=? 0) &&
(balance state contract_address + 0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        ?Goal1)) (contract_state state) =
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr rewrite Z.sub_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr >=? 0) &&
(balance state contract_address + 0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true) ?Goal1 
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr rewrite Z.add_0_r.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr >=? 0) &&
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true) 
              ?Goal1 
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr Search "&&" "/\".
andb_prop_elim:
  forall a b : bool, Is_true (a && b) -> Is_true a /\ Is_true b
andb_prop_intro:
  forall b1 b2 : bool, Is_true b1 /\ Is_true b2 -> Is_true (b1 && b2)
andb_prop: forall a b : bool, a && b = true -> a = true /\ b = true
andb_true_intro:
  forall [b1 b2 : bool], b1 = true /\ b2 = true -> b1 && b2 = true
andb_true_eq:
  forall a b : bool, true = a && b -> true = a /\ true = b
andb_true_iff:
  forall b1 b2 : bool, b1 && b2 = true <-> b1 = true /\ b2 = true
Byte.bits_and:
  forall (x y : byte) (i : Z),
  0 <= i < Byte.zwordsize ->
  Byte.testbit (Byte.and x y) i =
  Byte.testbit x i && Byte.testbit y i
Int.bits_and:
  forall (x y : int) (i : Z),
  0 <= i < Int.zwordsize ->
  Int.testbit (Int.and x y) i = Int.testbit x i && Int.testbit y i
Int64.bits_and:
  forall (x y : int64) (i : Z),
  0 <= i < Int64.zwordsize ->
  Int64.testbit (Int64.and x y) i =
  Int64.testbit x i && Int64.testbit y i
Int256.bits_and:
  forall (x y : int256) (i : Z),
  0 <= i < Int256.zwordsize ->
  Int256.testbit (Int256.and x y) i =
  Int256.testbit x i && Int256.testbit y i
Runtime.zle_and_zlt_between:
  forall a b c : Z,
  a <= b < c ->
  Coqlib.proj_sumbool (Coqlib.zle a b) &&
  Coqlib.proj_sumbool (Coqlib.zlt b c) = true
Int256.Z_add_is_or:
  forall i : Z,
  0 <= i ->
  forall x y : Z,
  (forall j : Z,
   0 <= j <= i -> Z.testbit x j && Z.testbit y j = false) ->
  Z.testbit (x + y) i = Z.testbit x i || Z.testbit y i
Int64.Z_add_is_or:
  forall i : Z,
  0 <= i ->
  forall x y : Z,
  (forall j : Z,
   0 <= j <= i -> Z.testbit x j && Z.testbit y j = false) ->
  Z.testbit (x + y) i = Z.testbit x i || Z.testbit y i
Byte.Z_add_is_or:
  forall i : Z,
  0 <= i ->
  forall x y : Z,
  (forall j : Z,
   0 <= j <= i -> Z.testbit x j && Z.testbit y j = false) ->
  Z.testbit (x + y) i = Z.testbit x i || Z.testbit y i
Int.Z_add_is_or:
  forall i : Z,
  0 <= i ->
  forall x y : Z,
  (forall j : Z,
   0 <= j <= i -> Z.testbit x j && Z.testbit y j = false) ->
  Z.testbit (x + y) i = Z.testbit x i || Z.testbit y i
externalBalanceTransfer:
  forall (before : BlockchainState) (sender recipient : addr)
    (amount : wei),
  sender <> contract_address /\
  amount >= 0 /\
  noOverflowOrUnderflowInTransfer sender recipient amount
    (balance before) &&
  address_accepts_funds_assumption None sender recipient amount =
  true -> Action before
Action_ind:
  forall (before : BlockchainState) (P : Action before -> Prop),
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_donate_prf : runStateT
                          (Crowdfunding_donate_opt
                             (make_machine_env contract_address
                                before context
                                address_accepts_funds_assumption
                                callvalue_bounded_prf
                                balances_bounded_prf callvalue_prf))
                          (contract_state before) =
                        Some (r, contract_state_after)),
   P
     (call_Crowdfunding_donate before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_donate_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_getFunds_prf : runStateT
                            (Crowdfunding_getFunds_opt
                               (make_machine_env contract_address
                                  before context
                                  address_accepts_funds_assumption
                                  callvalue_bounded_prf
                                  balances_bounded_prf callvalue_prf))
                            (contract_state before) =
                          Some (r, contract_state_after)),
   P
     (call_Crowdfunding_getFunds before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_getFunds_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_claim_prf : runStateT
                         (Crowdfunding_claim_opt
                            (make_machine_env contract_address before
                               context
                               address_accepts_funds_assumption
                               callvalue_bounded_prf
                               balances_bounded_prf callvalue_prf))
                         (contract_state before) =
                       Some (r, contract_state_after)),
   P
     (call_Crowdfunding_claim before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_claim_prf)) ->
  (forall (sender recipient : addr) (amount : wei)
     (prf : sender <> contract_address /\
            amount >= 0 /\
            noOverflowOrUnderflowInTransfer sender recipient amount
              (balance before) &&
            address_accepts_funds_assumption None sender recipient
              amount = true),
   P (externalBalanceTransfer before sender recipient amount prf)) ->
  (forall (block_count time_passing : int256)
     (prf : validTimeChange block_count time_passing
              (block_number before) (timestamp before) = true),
   P (timePassing before block_count time_passing prf)) ->
  P (revert before) -> forall a : Action before, P a
Action_rec:
  forall (before : BlockchainState) (P : Action before -> Set),
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_donate_prf : runStateT
                          (Crowdfunding_donate_opt
                             (make_machine_env contract_address
                                before context
                                address_accepts_funds_assumption
                                callvalue_bounded_prf
                                balances_bounded_prf callvalue_prf))
                          (contract_state before) =
                        Some (r, contract_state_after)),
   P
     (call_Crowdfunding_donate before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_donate_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_getFunds_prf : runStateT
                            (Crowdfunding_getFunds_opt
                               (make_machine_env contract_address
                                  before context
                                  address_accepts_funds_assumption
                                  callvalue_bounded_prf
                                  balances_bounded_prf callvalue_prf))
                            (contract_state before) =
                          Some (r, contract_state_after)),
   P
     (call_Crowdfunding_getFunds before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_getFunds_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_claim_prf : runStateT
                         (Crowdfunding_claim_opt
                            (make_machine_env contract_address before
                               context
                               address_accepts_funds_assumption
                               callvalue_bounded_prf
                               balances_bounded_prf callvalue_prf))
                         (contract_state before) =
                       Some (r, contract_state_after)),
   P
     (call_Crowdfunding_claim before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_claim_prf)) ->
  (forall (sender recipient : addr) (amount : wei)
     (prf : sender <> contract_address /\
            amount >= 0 /\
            noOverflowOrUnderflowInTransfer sender recipient amount
              (balance before) &&
            address_accepts_funds_assumption None sender recipient
              amount = true),
   P (externalBalanceTransfer before sender recipient amount prf)) ->
  (forall (block_count time_passing : int256)
     (prf : validTimeChange block_count time_passing
              (block_number before) (timestamp before) = true),
   P (timePassing before block_count time_passing prf)) ->
  P (revert before) -> forall a : Action before, P a
Action_rect:
  forall (before : BlockchainState) (P : Action before -> Type),
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_donate_prf : runStateT
                          (Crowdfunding_donate_opt
                             (make_machine_env contract_address
                                before context
                                address_accepts_funds_assumption
                                callvalue_bounded_prf
                                balances_bounded_prf callvalue_prf))
                          (contract_state before) =
                        Some (r, contract_state_after)),
   P
     (call_Crowdfunding_donate before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_donate_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_getFunds_prf : runStateT
                            (Crowdfunding_getFunds_opt
                               (make_machine_env contract_address
                                  before context
                                  address_accepts_funds_assumption
                                  callvalue_bounded_prf
                                  balances_bounded_prf callvalue_prf))
                            (contract_state before) =
                          Some (r, contract_state_after)),
   P
     (call_Crowdfunding_getFunds before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_getFunds_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_claim_prf : runStateT
                         (Crowdfunding_claim_opt
                            (make_machine_env contract_address before
                               context
                               address_accepts_funds_assumption
                               callvalue_bounded_prf
                               balances_bounded_prf callvalue_prf))
                         (contract_state before) =
                       Some (r, contract_state_after)),
   P
     (call_Crowdfunding_claim before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_claim_prf)) ->
  (forall (sender recipient : addr) (amount : wei)
     (prf : sender <> contract_address /\
            amount >= 0 /\
            noOverflowOrUnderflowInTransfer sender recipient amount
              (balance before) &&
            address_accepts_funds_assumption None sender recipient
              amount = true),
   P (externalBalanceTransfer before sender recipient amount prf)) ->
  (forall (block_count time_passing : int256)
     (prf : validTimeChange block_count time_passing
              (block_number before) (timestamp before) = true),
   P (timePassing before block_count time_passing prf)) ->
  P (revert before) -> forall a : Action before, P a
Action_sind:
  forall (before : BlockchainState) (P : Action before -> SProp),
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_donate_prf : runStateT
                          (Crowdfunding_donate_opt
                             (make_machine_env contract_address
                                before context
                                address_accepts_funds_assumption
                                callvalue_bounded_prf
                                balances_bounded_prf callvalue_prf))
                          (contract_state before) =
                        Some (r, contract_state_after)),
   P
     (call_Crowdfunding_donate before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_donate_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_getFunds_prf : runStateT
                            (Crowdfunding_getFunds_opt
                               (make_machine_env contract_address
                                  before context
                                  address_accepts_funds_assumption
                                  callvalue_bounded_prf
                                  balances_bounded_prf callvalue_prf))
                            (contract_state before) =
                          Some (r, contract_state_after)),
   P
     (call_Crowdfunding_getFunds before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_getFunds_prf)) ->
  (forall (context : CallContext)
     (callvalue_bounded_prf : 0 <= callvalue context < Int256.modulus)
     (balances_bounded_prf : forall a : addr,
                             0 <= balance before a < Int256.modulus)
     (callvalue_prf : noOverflowOrUnderflowInTransfer
                        (caller context) contract_address
                        (callvalue context) (balance before) = true)
     (r : unit) (contract_state_after : GetHighData)
     (case_claim_prf : runStateT
                         (Crowdfunding_claim_opt
                            (make_machine_env contract_address before
                               context
                               address_accepts_funds_assumption
                               callvalue_bounded_prf
                               balances_bounded_prf callvalue_prf))
                         (contract_state before) =
                       Some (r, contract_state_after)),
   P
     (call_Crowdfunding_claim before context callvalue_bounded_prf
        balances_bounded_prf callvalue_prf r contract_state_after
        case_claim_prf)) ->
  (forall (sender recipient : addr) (amount : wei)
     (prf : sender <> contract_address /\
            amount >= 0 /\
            noOverflowOrUnderflowInTransfer sender recipient amount
              (balance before) &&
            address_accepts_funds_assumption None sender recipient
              amount = true),
   P (externalBalanceTransfer before sender recipient amount prf)) ->
  (forall (block_count time_passing : int256)
     (prf : validTimeChange block_count time_passing
              (block_number before) (timestamp before) = true),
   P (timePassing before block_count time_passing prf)) ->
  P (revert before) -> forall a : Action before, P a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr >=? 0) &&
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true) 
              ?Goal1 
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
apply andb_true_intro.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr >=? 0) = true /\
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true) 
              (andb_true_intro ?Goal1)
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) &&
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro (conj ?Goal1 ?Goal2))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
apply andb_true_intro.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) = true /\
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro (conj (andb_true_intro ?Goal2) ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) && (0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj (andb_true_intro (conj ?Goal2 ?Goal3)) ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
apply andb_true_intro.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) = true /\ (0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj (andb_true_intro ?Goal3) ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
split.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj 
                    (andb_true_intro (conj ?Goal3 ?Goal4)) 
                    ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith) 
                    ?Goal3)) 
                    ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
unfold Int256.modulus, two_power_nat.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <? Z.pos (shift_nat Int256.wordsize 1)) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith) 
                    ?Goal3)) 
                    ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(0 <?
 115792089237316195423570985008687907853269984665640564039457584007913129639936) =
true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith) 
                    ?Goal3)) 
                    ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state backer_addr >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith))) 
                    ?Goal2)) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
rewrite Z.geb_le.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 <= balance state backer_addr
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0) 
                    ?Goal2))) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr pose proof (H6 backer_addr).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H8: 0 <= balance state backer_addr < Int256.modulus
0 <= balance state backer_addr
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    ?Goal2)))) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
(balance state contract_address <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    let __arith :
                    forall (__p1 : Prop) (__x1 : Z),
                    ... /\ __p1 -> 0 <= __x1 :=
                    fun (__p1 : Prop) (__x1 : Z) =>
                    let __wit := [] in ... ... in
                    __arith
                    (balance state backer_addr < Int256.modulus)
                    (balance state backer_addr) H8)))) 
                    ?Goal1))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
rewrite Z.ltb_lt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
balance state contract_address < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    let __arith :
                    forall (__p1 : Prop) (__x1 : Z),
                    ... /\ __p1 -> 0 <= __x1 :=
                    fun (__p1 : Prop) (__x1 : Z) =>
                    let __wit := [] in ... ... in
                    __arith
                    (balance state backer_addr < Int256.modulus)
                    (balance state backer_addr) H8))))
                    ((fun
                    lemma : 
                    (balance state contract_address <? Int256.modulus) =
                    true <->
                    balance state contract_address < Int256.modulus
                    =>
                    Morphisms.iff_flip_impl_subrelation
                    ((balance state contract_address <?
                    Int256.modulus) = true)
                    (balance state contract_address < Int256.modulus)
                    lemma)
                    (Z.ltb_lt 
                    (balance state contract_address) Int256.modulus)
                    ?Goal1)))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr pose proof (H6 contract_address).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H8: 0 <= balance state contract_address < Int256.modulus
balance state contract_address < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    let __arith :
                    forall (__p1 : Prop) (__x1 : Z),
                    ... /\ __p1 -> 0 <= __x1 :=
                    fun (__p1 : Prop) (__x1 : Z) =>
                    let __wit := [] in ... ... in
                    __arith
                    (balance state backer_addr < Int256.modulus)
                    (balance state backer_addr) H8))))
                    ((fun
                    lemma : 
                    (balance state contract_address <? Int256.modulus) =
                    true <->
                    balance state contract_address < Int256.modulus
                    =>
                    Morphisms.iff_flip_impl_subrelation
                    ((balance state contract_address <?
                    Int256.modulus) = true)
                    (balance state contract_address < Int256.modulus)
                    lemma)
                    (Z.ltb_lt 
                    (balance state contract_address) Int256.modulus)
                    (let H8 :
                    0 <= 
                    balance state contract_address < Int256.modulus :=
                    H6 contract_address in
                    ?Goal1))))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
unit
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    let __arith :
                    forall (__p1 : Prop) (__x1 : Z),
                    ... /\ __p1 -> 0 <= __x1 :=
                    fun (__p1 : Prop) (__x1 : Z) =>
                    let __wit := [] in ... ... in
                    __arith
                    (balance state backer_addr < Int256.modulus)
                    (balance state backer_addr) H8))))
                    ((fun
                    lemma : 
                    (balance state contract_address <? Int256.modulus) =
                    true <->
                    balance state contract_address < Int256.modulus
                    =>
                    Morphisms.iff_flip_impl_subrelation
                    ((balance state contract_address <?
                    Int256.modulus) = true)
                    (balance state contract_address < Int256.modulus)
                    lemma)
                    (Z.ltb_lt 
                    (balance state contract_address) Int256.modulus)
                    (let H8 :
                    0 <= 
                    balance state contract_address < Int256.modulus :=
                    H6 contract_address in
                    let __arith :
                    forall (__p1 : Prop) (__x2 __x1 : Z),
                    __p1 /\ __x1 < __x2 -> __x1 < __x2 :=
                    fun (__p1 : Prop) (__x2 __x1 : Z) =>
                    let __wit := [] in
                    let __varmap :=
                    VarMap.Branch (VarMap.Elt __x2) __x1 VarMap.Empty
                    in
                    let __ff := Tauto.IMPL (...) None (...) in
                    ZMicromega.ZTautoChecker_sound __ff __wit
                    (eq_refl <: ...) 
                    (VarMap.find 0 __varmap) in
                    __arith 
                    (0 <= balance state contract_address)
                    Int256.modulus 
                    (balance state contract_address) H8))))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (?r, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
exact tt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
GetHighData
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : 
           forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLe;
                    RingMicromega.Frhs := EnvRing.PEc 0
                    |} tt)
                  (Tauto.A Tauto.isProp
                    {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                    (conj
                    (andb_true_intro
                    (conj
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)
                    (let __arith : 
                    (...) = true := 
                    let __wit := [] in ... ... in
                    __arith)))
                    ((fun
                    lemma : 
                    (...) = true <-> 
                    0 <= balance state backer_addr =>
                    Morphisms.iff_flip_impl_subrelation
                    ((... >=? 0) = true)
                    (0 <= balance state backer_addr) lemma)
                    (Z.geb_le (balance state backer_addr) 0)
                    (let H8 :
                    0 <= balance state backer_addr < Int256.modulus :=
                    H6 backer_addr in
                    let __arith :
                    forall (__p1 : Prop) (__x1 : Z),
                    ... /\ __p1 -> 0 <= __x1 :=
                    fun (__p1 : Prop) (__x1 : Z) =>
                    let __wit := [] in ... ... in
                    __arith
                    (balance state backer_addr < Int256.modulus)
                    (balance state backer_addr) H8))))
                    ((fun
                    lemma : 
                    (balance state contract_address <? Int256.modulus) =
                    true <->
                    balance state contract_address < Int256.modulus
                    =>
                    Morphisms.iff_flip_impl_subrelation
                    ((balance state contract_address <?
                    Int256.modulus) = true)
                    (balance state contract_address < Int256.modulus)
                    lemma)
                    (Z.ltb_lt 
                    (balance state contract_address) Int256.modulus)
                    (let H8 :
                    0 <= 
                    balance state contract_address < Int256.modulus :=
                    H6 contract_address in
                    let __arith :
                    forall (__p1 : Prop) (__x2 __x1 : Z),
                    __p1 /\ __x1 < __x2 -> __x1 < __x2 :=
                    fun (__p1 : Prop) (__x2 __x1 : Z) =>
                    let __wit := [] in
                    let __varmap :=
                    VarMap.Branch (VarMap.Elt __x2) __x1 VarMap.Empty
                    in
                    let __ff := Tauto.IMPL (...) None (...) in
                    ZMicromega.ZTautoChecker_sound __ff __wit
                    (eq_refl <: ...) 
                    (VarMap.find 0 __varmap) in
                    __arith 
                    (0 <= balance state contract_address)
                    Int256.modulus 
                    (balance state contract_address) H8))))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) = 
Some (tt, ?contract_state_after)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount ?contract_state_after =
Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
exact(
  {| Outgoing_transfer_recipient_and_amount := (Some (backer_addr, backed_amount));
  Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block := Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers := set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg := Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg := Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg := Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg := Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg := Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg := Crowdfunding_too_early_to_claim_funds_msg (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg := Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg := Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg := Crowdfunding_here_is_your_money_msg (contract_state state) |}
).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                     {|
                       RingMicromega.Flhs := EnvRing.PEc 0;
                       RingMicromega.Fop := RingMicromega.OpLe;
                       RingMicromega.Frhs := EnvRing.PEc 0
                     |} tt)
                  (Tauto.A Tauto.isProp
                     {|
                       RingMicromega.Flhs := EnvRing.PEc 0;
                       RingMicromega.Fop := RingMicromega.OpLt;
                       RingMicromega.Frhs := EnvRing.PEX 1
                     |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                       (conj
                          (andb_true_intro
                             (conj
                                (let __arith : (...) = true :=
                                   let __wit := [] in ... ... in
                                 __arith)
                                (let __arith : (...) = true :=
                                   let __wit := [] in ... ... in
                                 __arith)))
                          ((fun
                              lemma : (...) = true <->
                                      0 <= balance state backer_addr
                            =>
                            Morphisms.iff_flip_impl_subrelation
                              ((... >=? 0) = true)
                              (0 <= balance state backer_addr) lemma)
                             (Z.geb_le (balance state backer_addr) 0)
                             (let H8 :
                                0 <= balance state backer_addr <
                                Int256.modulus := 
                                H6 backer_addr in
                              let __arith :
                                forall (__p1 : Prop) (__x1 : Z),
                                ... /\ __p1 -> 0 <= __x1 :=
                                fun (__p1 : Prop) (__x1 : Z) =>
                                let __wit := [] in ... ... in
                              __arith
                                (balance state backer_addr <
                                 Int256.modulus)
                                (balance state backer_addr) H8))))
                    ((fun
                        lemma : (balance state contract_address <?
                                 Int256.modulus) = true <->
                                balance state contract_address <
                                Int256.modulus =>
                      Morphisms.iff_flip_impl_subrelation
                        ((balance state contract_address <?
                          Int256.modulus) = true)
                        (balance state contract_address <
                         Int256.modulus) lemma)
                       (Z.ltb_lt (balance state contract_address)
                          Int256.modulus)
                       (let H8 :
                          0 <= balance state contract_address <
                          Int256.modulus := H6 contract_address in
                        let __arith :
                          forall (__p1 : Prop) (__x2 __x1 : Z),
                          __p1 /\ __x1 < __x2 -> __x1 < __x2 :=
                          fun (__p1 : Prop) (__x2 __x1 : Z) =>
                          let __wit := [] in
                          let __varmap :=
                            VarMap.Branch (VarMap.Elt __x2) __x1
                              VarMap.Empty in
                          let __ff := Tauto.IMPL (...) None (...) in
                          ZMicromega.ZTautoChecker_sound __ff __wit
                            (eq_refl <: ...) (VarMap.find 0 __varmap)
                          in
                        __arith (0 <= balance state contract_address)
                          Int256.modulus
                          (balance state contract_address) H8))))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
Transparent Crowdfunding_claim_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  (Crowdfunding_claim_opt
     (make_machine_env contract_address state
        {|
          origin := backer_addr;
          caller := backer_addr;
          callvalue := 0;
          coinbase := Int256.zero;
          chainid := Int256.zero
        |} address_accepts_funds_assumption
        (let cstr : 0 < Z.pos (shift_nat Int256.wordsize 1) :=
           Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1) in
         let __arith : forall __x1 : Z, 0 < __x1 -> 0 <= 0 < __x1 :=
           fun __x1 : Z =>
           let __wit := [] in
           let __varmap := VarMap.Elt __x1 in
           let __ff :=
             Tauto.IMPL
               (Tauto.A Tauto.isProp
                  {|
                    RingMicromega.Flhs := EnvRing.PEc 0;
                    RingMicromega.Fop := RingMicromega.OpLt;
                    RingMicromega.Frhs := EnvRing.PEX 1
                  |} tt) None
               (Tauto.AND
                  (Tauto.A Tauto.isProp
                     {|
                       RingMicromega.Flhs := EnvRing.PEc 0;
                       RingMicromega.Fop := RingMicromega.OpLe;
                       RingMicromega.Frhs := EnvRing.PEc 0
                     |} tt)
                  (Tauto.A Tauto.isProp
                     {|
                       RingMicromega.Flhs := EnvRing.PEc 0;
                       RingMicromega.Fop := RingMicromega.OpLt;
                       RingMicromega.Frhs := EnvRing.PEX 1
                     |} tt)) in
           ZMicromega.ZTautoChecker_sound __ff __wit
             (eq_refl <: ZMicromega.ZTautoChecker __ff __wit = true)
             (VarMap.find 0 __varmap) in
         __arith (Z.pos (shift_nat Int256.wordsize 1)) cstr) H6
        (eq_ind_r
           (fun z : Z =>
            (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
            (balance state contract_address + 0 <? Int256.modulus) =
            true)
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) &&
               (balance state backer_addr >=? 0) &&
               (z <? Int256.modulus) = true)
              (andb_true_intro
                 (conj
                    (andb_true_intro
                       (conj
                          (andb_true_intro
                             (conj
                                (let __arith : (...) = true :=
                                   let __wit := [] in ... ... in
                                 __arith)
                                (let __arith : (...) = true :=
                                   let __wit := [] in ... ... in
                                 __arith)))
                          ((fun
                              lemma : (...) = true <->
                                      0 <= balance state backer_addr
                            =>
                            Morphisms.iff_flip_impl_subrelation
                              ((... >=? 0) = true)
                              (0 <= balance state backer_addr) lemma)
                             (Z.geb_le (balance state backer_addr) 0)
                             (let H8 :
                                0 <= balance state backer_addr <
                                Int256.modulus := 
                                H6 backer_addr in
                              let __arith :
                                forall (__p1 : Prop) (__x1 : Z),
                                ... /\ __p1 -> 0 <= __x1 :=
                                fun (__p1 : Prop) (__x1 : Z) =>
                                let __wit := [] in ... ... in
                              __arith
                                (balance state backer_addr <
                                 Int256.modulus)
                                (balance state backer_addr) H8))))
                    ((fun
                        lemma : (balance state contract_address <?
                                 Int256.modulus) = true <->
                                balance state contract_address <
                                Int256.modulus =>
                      Morphisms.iff_flip_impl_subrelation
                        ((balance state contract_address <?
                          Int256.modulus) = true)
                        (balance state contract_address <
                         Int256.modulus) lemma)
                       (Z.ltb_lt (balance state contract_address)
                          Int256.modulus)
                       (let H8 :
                          0 <= balance state contract_address <
                          Int256.modulus := H6 contract_address in
                        let __arith :
                          forall (__p1 : Prop) (__x2 __x1 : Z),
                          __p1 /\ __x1 < __x2 -> __x1 < __x2 :=
                          fun (__p1 : Prop) (__x2 __x1 : Z) =>
                          let __wit := [] in
                          let __varmap :=
                            VarMap.Branch (VarMap.Elt __x2) __x1
                              VarMap.Empty in
                          let __ff := Tauto.IMPL (...) None (...) in
                          ZMicromega.ZTautoChecker_sound __ff __wit
                            (eq_refl <: ...) (VarMap.find 0 __varmap)
                          in
                        __arith (0 <= balance state contract_address)
                          Int256.modulus
                          (balance state contract_address) H8))))
              (Z.add_0_r (balance state contract_address)))
           (Z.sub_0_r (balance state backer_addr)))))
  (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
unfold Crowdfunding_claim_opt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
runStateT
  ((v <-
    ret
      (negb
         (me_caller
            (make_machine_env contract_address state
               {|
                 origin := backer_addr;
                 caller := backer_addr;
                 callvalue := 0;
                 coinbase := Int256.zero;
                 chainid := Int256.zero
               |} address_accepts_funds_assumption
               (ZMicromega.ZTautoChecker_sound
                  (Tauto.IMPL
                     (Tauto.A Tauto.isProp
                        {|
                          RingMicromega.Flhs := EnvRing.PEc 0;
                          RingMicromega.Fop := RingMicromega.OpLt;
                          RingMicromega.Frhs := EnvRing.PEX 1
                        |} tt) None
                     (Tauto.AND
                        (Tauto.A Tauto.isProp
                           {|
                             RingMicromega.Flhs := EnvRing.PEc 0;
                             RingMicromega.Fop := RingMicromega.OpLe;
                             RingMicromega.Frhs := EnvRing.PEc 0
                           |} tt)
                        (Tauto.A Tauto.isProp
                           {|
                             RingMicromega.Flhs := EnvRing.PEc 0;
                             RingMicromega.Fop := RingMicromega.OpLt;
                             RingMicromega.Frhs := EnvRing.PEX 1
                           |} tt))) [] eq_refl
                  (VarMap.find 0
                     (VarMap.Elt
                        (Z.pos (shift_nat Int256.wordsize 1))))
                  (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1)))
               H6
               (eq_ind_r
                  (fun z : Z =>
                   (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
                   (balance state contract_address + 0 <?
                    Int256.modulus) = true)
                  (eq_ind_r
                     (fun z : Z =>
                      (0 <=? 0) && (0 <? Int256.modulus) &&
                      (balance state backer_addr >=? 0) &&
                      (z <? Int256.modulus) = true)
                     (andb_true_intro
                        (conj (andb_true_intro (conj (...) (...)))
                           (Morphisms.iff_flip_impl_subrelation
                              ((...) = true)
                              (balance state contract_address <
                               Int256.modulus)
                              (Z.ltb_lt (...) Int256.modulus)
                              (ZMicromega.ZTautoChecker_sound 
                                 (...) [] eq_refl 
                                 (...) (...)))))
                     (Z.add_0_r (balance state contract_address)))
                  (Z.sub_0_r (balance state backer_addr)))) =?
          me_address
            (make_machine_env contract_address state
               {|
                 origin := backer_addr;
                 caller := backer_addr;
                 callvalue := 0;
                 coinbase := Int256.zero;
                 chainid := Int256.zero
               |} address_accepts_funds_assumption
               (ZMicromega.ZTautoChecker_sound
                  (Tauto.IMPL
                     (Tauto.A Tauto.isProp
                        {|
                          RingMicromega.Flhs := EnvRing.PEc 0;
                          RingMicromega.Fop := RingMicromega.OpLt;
                          RingMicromega.Frhs := EnvRing.PEX 1
                        |} tt) None
                     (Tauto.AND
                        (Tauto.A Tauto.isProp
                           {|
                             RingMicromega.Flhs := EnvRing.PEc 0;
                             RingMicromega.Fop := RingMicromega.OpLe;
                             RingMicromega.Frhs := EnvRing.PEc 0
                           |} tt)
                        (Tauto.A Tauto.isProp
                           {|
                             RingMicromega.Flhs := EnvRing.PEc 0;
                             RingMicromega.Fop := RingMicromega.OpLt;
                             RingMicromega.Frhs := EnvRing.PEX 1
                           |} tt))) [] eq_refl
                  (VarMap.find 0
                     (VarMap.Elt
                        (Z.pos (shift_nat Int256.wordsize 1))))
                  (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1)))
               H6
               (eq_ind_r
                  (fun z : Z =>
                   (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
                   (balance state contract_address + 0 <?
                    Int256.modulus) = true)
                  (eq_ind_r
                     (fun z : Z =>
                      (0 <=? 0) && (0 <? Int256.modulus) &&
                      (balance state backer_addr >=? 0) &&
                      (z <? Int256.modulus) = true)
                     (andb_true_intro
                        (conj (andb_true_intro (conj (...) (...)))
                           (Morphisms.iff_flip_impl_subrelation
                              ((...) = true)
                              (balance state contract_address <
                               Int256.modulus)
                              (Z.ltb_lt (...) Int256.modulus)
                              (ZMicromega.ZTautoChecker_sound 
                                 (...) [] eq_refl 
                                 (...) (...)))))
                     (Z.add_0_r (balance state contract_address)))
                  (Z.sub_0_r (balance state backer_addr)))))%int256);;
    guard v);;
   (v <-
    ret
      (me_callvalue
         (make_machine_env contract_address state
            {|
              origin := backer_addr;
              caller := backer_addr;
              callvalue := 0;
              coinbase := Int256.zero;
              chainid := Int256.zero
            |} address_accepts_funds_assumption
            (ZMicromega.ZTautoChecker_sound
               (Tauto.IMPL
                  (Tauto.A Tauto.isProp
                     {|
                       RingMicromega.Flhs := EnvRing.PEc 0;
                       RingMicromega.Fop := RingMicromega.OpLt;
                       RingMicromega.Frhs := EnvRing.PEX 1
                     |} tt) None
                  (Tauto.AND
                     (Tauto.A Tauto.isProp
                        {|
                          RingMicromega.Flhs := EnvRing.PEc 0;
                          RingMicromega.Fop := RingMicromega.OpLe;
                          RingMicromega.Frhs := EnvRing.PEc 0
                        |} tt)
                     (Tauto.A Tauto.isProp
                        {|
                          RingMicromega.Flhs := EnvRing.PEc 0;
                          RingMicromega.Fop := RingMicromega.OpLt;
                          RingMicromega.Frhs := EnvRing.PEX 1
                        |} tt))) [] eq_refl
               (VarMap.find 0
                  (VarMap.Elt (Z.pos (shift_nat Int256.wordsize 1))))
               (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1))) H6
            (eq_ind_r
               (fun z : Z =>
                (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
                (balance state contract_address + 0 <? Int256.modulus) =
                true)
               (eq_ind_r
                  (fun z : Z =>
                   (0 <=? 0) && (0 <? Int256.modulus) &&
                   (balance state backer_addr >=? 0) &&
                   (z <? Int256.modulus) = true)
                  (andb_true_intro
                     (conj
                        (andb_true_intro
                           (conj (andb_true_intro ...)
                              (Morphisms.iff_flip_impl_subrelation
                                 ... ... ... ...)))
                        (Morphisms.iff_flip_impl_subrelation
                           ((... <? Int256.modulus) = true)
                           (balance state contract_address <
                            Int256.modulus)
                           (Z.ltb_lt (balance state contract_address)
                              Int256.modulus)
                           (ZMicromega.ZTautoChecker_sound
                              (Tauto.IMPL ... None ...) [] eq_refl
                              (VarMap.find 0 ...)
                              (H6 contract_address)))))
                  (Z.add_0_r (balance state contract_address)))
               (Z.sub_0_r (balance state backer_addr)))) =? 0);;
    guard v);;
   spec1 <-
   ret
     (me_number
        (make_machine_env contract_address state
           {|
             origin := backer_addr;
             caller := backer_addr;
             callvalue := 0;
             coinbase := Int256.zero;
             chainid := Int256.zero
           |} address_accepts_funds_assumption
           (ZMicromega.ZTautoChecker_sound
              (Tauto.IMPL
                 (Tauto.A Tauto.isProp
                    {|
                      RingMicromega.Flhs := EnvRing.PEc 0;
                      RingMicromega.Fop := RingMicromega.OpLt;
                      RingMicromega.Frhs := EnvRing.PEX 1
                    |} tt) None
                 (Tauto.AND
                    (Tauto.A Tauto.isProp
                       {|
                         RingMicromega.Flhs := EnvRing.PEc 0;
                         RingMicromega.Fop := RingMicromega.OpLe;
                         RingMicromega.Frhs := EnvRing.PEc 0
                       |} tt)
                    (Tauto.A Tauto.isProp
                       {|
                         RingMicromega.Flhs := EnvRing.PEc 0;
                         RingMicromega.Fop := RingMicromega.OpLt;
                         RingMicromega.Frhs := EnvRing.PEX 1
                       |} tt))) [] eq_refl
              (VarMap.find 0
                 (VarMap.Elt (Z.pos (shift_nat Int256.wordsize 1))))
              (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1))) H6
           (eq_ind_r
              (fun z : Z =>
               (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
               (balance state contract_address + 0 <? Int256.modulus) =
               true)
              (eq_ind_r
                 (fun z : Z =>
                  (0 <=? 0) && (0 <? Int256.modulus) &&
                  (balance state backer_addr >=? 0) &&
                  (z <? Int256.modulus) = true)
                 (andb_true_intro
                    (conj
                       (andb_true_intro
                          (conj (andb_true_intro (conj ... ...))
                             (Morphisms.iff_flip_impl_subrelation
                                (... = true) (0 <= ...)
                                (Z.geb_le ... 0)
                                (ZMicromega.ZTautoChecker_sound ...
                                   [] eq_refl ... ...))))
                       (Morphisms.iff_flip_impl_subrelation
                          ((balance state contract_address <?
                            Int256.modulus) = true)
                          (balance state contract_address <
                           Int256.modulus)
                          (Z.ltb_lt (balance state contract_address)
                             Int256.modulus)
                          (ZMicromega.ZTautoChecker_sound
                             (Tauto.IMPL (Tauto.AND ... ...) None
                                (Tauto.A Tauto.isProp ... tt)) []
                             eq_refl
                             (VarMap.find 0
                                (VarMap.Branch ... ... VarMap.Empty))
                             (H6 contract_address)))))
                 (Z.add_0_r (balance state contract_address)))
              (Z.sub_0_r (balance state backer_addr)))));;
   spec2 <- gets Crowdfunding_max_block;;
   (if negb (Int256.ltu spec2 spec1)
    then ret tt
    else
     spec3 <-
     ret
       (me_balance
          (make_machine_env contract_address state
             {|
               origin := backer_addr;
               caller := backer_addr;
               callvalue := 0;
               coinbase := Int256.zero;
               chainid := Int256.zero
             |} address_accepts_funds_assumption
             (ZMicromega.ZTautoChecker_sound
                (Tauto.IMPL
                   (Tauto.A Tauto.isProp
                      {|
                        RingMicromega.Flhs := EnvRing.PEc 0;
                        RingMicromega.Fop := RingMicromega.OpLt;
                        RingMicromega.Frhs := EnvRing.PEX 1
                      |} tt) None
                   (Tauto.AND
                      (Tauto.A Tauto.isProp
                         {|
                           RingMicromega.Flhs := ...;
                           RingMicromega.Fop := RingMicromega.OpLe;
                           RingMicromega.Frhs := ...
                         |} tt)
                      (Tauto.A Tauto.isProp
                         {|
                           RingMicromega.Flhs := ...;
                           RingMicromega.Fop := RingMicromega.OpLt;
                           RingMicromega.Frhs := ...
                         |} tt))) [] eq_refl
                (VarMap.find 0
                   (VarMap.Elt (Z.pos (shift_nat Int256.wordsize 1))))
                (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1))) H6
             (eq_ind_r
                (fun z : Z =>
                 (0 <=? 0) && (0 <? Int256.modulus) && (z >=? 0) &&
                 (balance state contract_address + 0 <?
                  Int256.modulus) = true)
                (eq_ind_r
                   (fun z : Z =>
                    (...) && (...) && (... >=? 0) &&
                    (z <? Int256.modulus) = true)
                   (andb_true_intro
                      (conj (andb_true_intro (...))
                         (Morphisms.iff_flip_impl_subrelation 
                            (...) (...) (...) (...))))
                   (Z.add_0_r (balance state contract_address)))
                (Z.sub_0_r (balance state backer_addr))))
          (me_address
             (make_machine_env contract_address state
                {|
                  origin := backer_addr;
                  caller := backer_addr;
                  callvalue := 0;
                  coinbase := Int256.zero;
                  chainid := Int256.zero
                |} address_accepts_funds_assumption
                (ZMicromega.ZTautoChecker_sound
                   (Tauto.IMPL
                      (Tauto.A Tauto.isProp
                         {|
                           RingMicromega.Flhs := ...;
                           RingMicromega.Fop := RingMicromega.OpLt;
                           RingMicromega.Frhs := ...
                         |} tt) None
                      (Tauto.AND (Tauto.A Tauto.isProp {| ... |} tt)
                         (Tauto.A Tauto.isProp {| ... |} tt))) []
                   eq_refl (VarMap.find 0 (VarMap.Elt (Z.pos (...))))
                   (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1)))
                H6
                (eq_ind_r
                   (fun z : Z =>
                    (...) && (...) && (z >=? 0) &&
                    (... + 0 <? Int256.modulus) = true)
                   (eq_ind_r
                      (fun z : Z => ... && ... && (...) = true)
                      (andb_true_intro (conj (...) (...)))
                      (Z.add_0_r (balance state contract_address)))
                   (Z.sub_0_r (balance state backer_addr))))));;
     spec4 <-
     gets
       (fun s : GetHighData =>
        get_default 0
          (me_caller
             (make_machine_env contract_address state
                {|
                  origin := backer_addr;
                  caller := backer_addr;
                  callvalue := 0;
                  coinbase := Int256.zero;
                  chainid := Int256.zero
                |} address_accepts_funds_assumption
                (ZMicromega.ZTautoChecker_sound
                   (Tauto.IMPL (Tauto.A Tauto.isProp {| ... |} tt)
                      None (Tauto.AND (...) (...))) [] eq_refl
                   (VarMap.find 0 (VarMap.Elt (...)))
                   (Pos2Z.pos_is_pos (shift_nat Int256.wordsize 1)))
                H6
                (eq_ind_r (fun z : Z => ... && ... && (...) = true)
                   (eq_ind_r (fun ... => ... = true)
                      (andb_true_intro (...)) (Z.add_0_r (...)))
                   (Z.sub_0_r (balance state backer_addr)))))
          (Crowdfunding_backers s));;
     spec5 <- gets Crowdfunding_funded;;
     spec6 <- gets Crowdfunding_goal;;
     (if (spec4 =? 0) || (spec5 || (spec6 <=? spec3))
      then ret tt
      else
       MonadState.modify
         (fun s : GetHighData =>
          update_Crowdfunding_backers
            (set (me_caller (...)) 0 (Crowdfunding_backers s)) s);;
       ret tt;;
       d <- MonadState.get;;
       (let (success, d') :=
          me_transfer
            (make_machine_env contract_address state 
               {| ... |} address_accepts_funds_assumption 
               (...) H6 (...)) (me_caller (...)) spec4 d in
        if (success =? Int256.one)%int256 then put d' else mzero))))
  (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
match
  runStateT (guard (negb (backer_addr =? contract_address)%int256))
    (contract_state state)
with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || (Crowdfunding_goal s0 <=?
                        ContractModel.update_balances backer_addr
                          contract_address 0 (balance state)
                          contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                      (let (success, d') :=
                         if
                          noOverflowOrUnderflowInTransfer
                            contract_address backer_addr ... ... &&
                          address_accepts_funds_assumption ...
                            contract_address backer_addr ...
                         then
                          (Int256.one,
                          update_Outgoing_transfer_recipient_and_amount
                            ... ...)
                         else
                          (Int256.zero,
                          update_Crowdfunding_backers ... s1) in
                       if (success =? Int256.one)%int256
                       then {| runStateT := ... |}
                       else {| runStateT := ... |})
                      (update_Crowdfunding_backers
                         (set backer_addr 0 (Crowdfunding_backers s1))
                         s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
destruct((backer_addr =? contract_address)%int256) eqn:Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = true
match runStateT (guard (negb true)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || (Crowdfunding_goal s0 <=?
                        ContractModel.update_balances backer_addr
                          contract_address 0 (balance state)
                          contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                      (let (success, d') :=
                         if
                          noOverflowOrUnderflowInTransfer
                            contract_address backer_addr ... ... &&
                          address_accepts_funds_assumption ...
                            contract_address backer_addr ...
                         then
                          (Int256.one,
                          update_Outgoing_transfer_recipient_and_amount
                            ... ...)
                         else
                          (Int256.zero,
                          update_Crowdfunding_backers ... s1) in
                       if (success =? Int256.one)%int256
                       then {| runStateT := ... |}
                       else {| runStateT := ... |})
                      (update_Crowdfunding_backers
                         (set backer_addr 0 (Crowdfunding_backers s1))
                         s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = false
match runStateT (guard (negb false)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || 
                    (Crowdfunding_goal s0 <=?
                    ContractModel.update_balances backer_addr
                    contract_address 0 
                    (balance state) contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                    (let 
                    (success, d') :=
                    if
                    noOverflowOrUnderflowInTransfer contract_address
                    backer_addr ... ... &&
                    address_accepts_funds_assumption ...
                    contract_address backer_addr ...
                    then
                    (Int256.one,
                    update_Outgoing_transfer_recipient_and_amount ...
                    ...)
                    else
                    (Int256.zero, update_Crowdfunding_backers ... s1) in
                    if (success =? Int256.one)%int256
                    then {| runStateT := ... |}
                    else {| runStateT := ... |})
                    (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s1)) s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr apply Int256eq_true in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: backer_addr = contract_address
match runStateT (guard (negb true)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || (Crowdfunding_goal s0 <=?
                        ContractModel.update_balances backer_addr
                          contract_address 0 (balance state)
                          contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                      (let (success, d') :=
                         if
                          noOverflowOrUnderflowInTransfer
                            contract_address backer_addr ... ... &&
                          address_accepts_funds_assumption ...
                            contract_address backer_addr ...
                         then
                          (Int256.one,
                          update_Outgoing_transfer_recipient_and_amount
                            ... ...)
                         else
                          (Int256.zero,
                          update_Crowdfunding_backers ... s1) in
                       if (success =? Int256.one)%int256
                       then {| runStateT := ... |}
                       else {| runStateT := ... |})
                      (update_Crowdfunding_backers
                         (set backer_addr 0 (Crowdfunding_backers s1))
                         s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = false
match runStateT (guard (negb false)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || 
                    (Crowdfunding_goal s0 <=?
                    ContractModel.update_balances backer_addr
                    contract_address 0 
                    (balance state) contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                    (let 
                    (success, d') :=
                    if
                    noOverflowOrUnderflowInTransfer contract_address
                    backer_addr ... ... &&
                    address_accepts_funds_assumption ...
                    contract_address backer_addr ...
                    then
                    (Int256.one,
                    update_Outgoing_transfer_recipient_and_amount ...
                    ...)
                    else
                    (Int256.zero, update_Crowdfunding_backers ... s1) in
                    if (success =? Int256.one)%int256
                    then {| runStateT := ... |}
                    else {| runStateT := ... |})
                    (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s1)) s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr symmetry in Case.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: contract_address = backer_addr
match runStateT (guard (negb true)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || (Crowdfunding_goal s0 <=?
                        ContractModel.update_balances backer_addr
                          contract_address 0 (balance state)
                          contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                      (let (success, d') :=
                         if
                          noOverflowOrUnderflowInTransfer
                            contract_address backer_addr ... ... &&
                          address_accepts_funds_assumption ...
                            contract_address backer_addr ...
                         then
                          (Int256.one,
                          update_Outgoing_transfer_recipient_and_amount
                            ... ...)
                         else
                          (Int256.zero,
                          update_Crowdfunding_backers ... s1) in
                       if (success =? Int256.one)%int256
                       then {| runStateT := ... |}
                       else {| runStateT := ... |})
                      (update_Crowdfunding_backers
                         (set backer_addr 0 (Crowdfunding_backers s1))
                         s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = false
match runStateT (guard (negb false)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || 
                    (Crowdfunding_goal s0 <=?
                    ContractModel.update_balances backer_addr
                    contract_address 0 
                    (balance state) contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                    (let 
                    (success, d') :=
                    if
                    noOverflowOrUnderflowInTransfer contract_address
                    backer_addr ... ... &&
                    address_accepts_funds_assumption ...
                    contract_address backer_addr ...
                    then
                    (Int256.one,
                    update_Outgoing_transfer_recipient_and_amount ...
                    ...)
                    else
                    (Int256.zero, update_Crowdfunding_backers ... s1) in
                    if (success =? Int256.one)%int256
                    then {| runStateT := ... |}
                    else {| runStateT := ... |})
                    (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s1)) s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr contradiction.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = false
match runStateT (guard (negb false)) (contract_state state) with
| Some (_, s) =>
    runStateT
      (if
        negb
          (Int256.ltu (Crowdfunding_max_block s) (block_number state))
       then
        {|
          runStateT :=
            fun s0 : global_abstract_data_type => Some (tt, s0)
        |}
       else
        {|
          runStateT :=
            fun s0 : global_abstract_data_type =>
            runStateT
              (if
                (get_default 0 backer_addr (Crowdfunding_backers s0) =?
                 0)
                || (Crowdfunding_funded s0
                    || (Crowdfunding_goal s0 <=?
                        ContractModel.update_balances backer_addr
                          contract_address 0 (balance state)
                          contract_address))
               then
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    Some (tt, s1)
                |}
               else
                {|
                  runStateT :=
                    fun s1 : global_abstract_data_type =>
                    runStateT
                      (let (success, d') :=
                         if
                          noOverflowOrUnderflowInTransfer
                            contract_address backer_addr ... ... &&
                          address_accepts_funds_assumption ...
                            contract_address backer_addr ...
                         then
                          (Int256.one,
                          update_Outgoing_transfer_recipient_and_amount
                            ... ...)
                         else
                          (Int256.zero,
                          update_Crowdfunding_backers ... s1) in
                       if (success =? Int256.one)%int256
                       then {| runStateT := ... |}
                       else {| runStateT := ... |})
                      (update_Crowdfunding_backers
                         (set backer_addr 0 (Crowdfunding_backers s1))
                         s1)
                |}) s0
        |}) s
| None => None
end =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Case: (backer_addr =? contract_address)%int256 = false
runStateT
  (if
    negb
      (Int256.ltu (Crowdfunding_max_block (contract_state state))
         (block_number state))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (if
            (get_default 0 backer_addr (Crowdfunding_backers s) =? 0)
            || (Crowdfunding_funded s
                || (Crowdfunding_goal s <=?
                    ContractModel.update_balances backer_addr
                      contract_address 0 (balance state)
                      contract_address))
           then
            {|
              runStateT :=
                fun s0 : global_abstract_data_type => Some (tt, s0)
            |}
           else
            {|
              runStateT :=
                fun s0 : global_abstract_data_type =>
                runStateT
                  (let (success, d') :=
                     if
                      noOverflowOrUnderflowInTransfer
                        contract_address backer_addr
                        (get_default 0 backer_addr ...)
                        (ContractModel.update_balances backer_addr
                           contract_address 0 ...) &&
                      address_accepts_funds_assumption 
                        (Some ...) contract_address backer_addr
                        (get_default 0 backer_addr ...)
                     then
                      (Int256.one,
                      update_Outgoing_transfer_recipient_and_amount
                        (Some ...)
                        (update_Crowdfunding_backers ... s0))
                     else
                      (Int256.zero,
                      update_Crowdfunding_backers
                        (set backer_addr 0 ...) s0) in
                   if (success =? Int256.one)%int256
                   then {| runStateT := fun ... => Some ... |}
                   else {| runStateT := fun ... => None |})
                  (update_Crowdfunding_backers
                     (set backer_addr 0 (Crowdfunding_backers s0)) s0)
            |}) s
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
destruct ((Int256.ltu (Crowdfunding_max_block (contract_state state))
(block_number state))) eqn:SCase; [|discriminate].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
runStateT
  (if negb true
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (if
            (get_default 0 backer_addr (Crowdfunding_backers s) =? 0)
            || (Crowdfunding_funded s
                || (Crowdfunding_goal s <=?
                    ContractModel.update_balances backer_addr
                      contract_address 0 (balance state)
                      contract_address))
           then
            {|
              runStateT :=
                fun s0 : global_abstract_data_type => Some (tt, s0)
            |}
           else
            {|
              runStateT :=
                fun s0 : global_abstract_data_type =>
                runStateT
                  (let (success, d') :=
                     if
                      noOverflowOrUnderflowInTransfer
                        contract_address backer_addr
                        (get_default 0 backer_addr ...)
                        (ContractModel.update_balances backer_addr
                           contract_address 0 ...) &&
                      address_accepts_funds_assumption 
                        (Some ...) contract_address backer_addr
                        (get_default 0 backer_addr ...)
                     then
                      (Int256.one,
                      update_Outgoing_transfer_recipient_and_amount
                        (Some ...)
                        (update_Crowdfunding_backers ... s0))
                     else
                      (Int256.zero,
                      update_Crowdfunding_backers
                        (set backer_addr 0 ...) s0) in
                   if (success =? Int256.one)%int256
                   then {| runStateT := fun ... => Some ... |}
                   else {| runStateT := fun ... => None |})
                  (update_Crowdfunding_backers
                     (set backer_addr 0 (Crowdfunding_backers s0)) s0)
            |}) s
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
runStateT
  (if
    (get_default 0 backer_addr
       (Crowdfunding_backers (contract_state state)) =? 0)
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
destruct((get_default 0 backer_addr
(Crowdfunding_backers (contract_state state)) =? 0)) eqn:SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
true
runStateT
  (if
    true
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
runStateT
  (if
    false
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 
              (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 
                   (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                    (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
apply Z.eqb_eq in SSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) = 0
runStateT
  (if
    true
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
runStateT
  (if
    false
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 
              (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 
                   (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                    (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
runStateT
  (if
    false
    || (Crowdfunding_funded (contract_state state)
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
destruct ((Crowdfunding_funded (contract_state state))) eqn:SSSCase; [discriminate|].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
runStateT
  (if
    false
    || (false
        || (Crowdfunding_goal (contract_state state) <=?
            ContractModel.update_balances backer_addr
              contract_address 0 (balance state) contract_address))
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
destruct ((Crowdfunding_goal (contract_state state) <=?
ContractModel.update_balances backer_addr
  contract_address 0 (balance state) contract_address)) eqn:SSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = true
runStateT
  (if false || (false || true)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (if false || (false || false)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 
                   (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                    (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
rewrite Z.leb_le in SSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: Crowdfunding_goal (contract_state state) <=
ContractModel.update_balances backer_addr contract_address
  0 (balance state) contract_address
runStateT
  (if false || (false || true)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (if false || (false || false)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 
                   (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                    (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
rewrite addZeroBalance in SSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: Crowdfunding_goal (contract_state state) <=
balance state contract_address
runStateT
  (if false || (false || true)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (if false || (false || false)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 
                   (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                    (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                    (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (if false || (false || false)
   then
    {|
      runStateT := fun s : global_abstract_data_type => Some (tt, s)
    |}
   else
    {|
      runStateT :=
        fun s : global_abstract_data_type =>
        runStateT
          (let (success, d') :=
             if
              noOverflowOrUnderflowInTransfer contract_address
                backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
                (ContractModel.update_balances backer_addr
                   contract_address 0 (balance state)) &&
              address_accepts_funds_assumption
                (Some
                   (update_Crowdfunding_backers
                      (set backer_addr 0 (Crowdfunding_backers s)) s))
                contract_address backer_addr
                (get_default 0 backer_addr
                   (Crowdfunding_backers (contract_state state)))
             then
              (Int256.one,
              update_Outgoing_transfer_recipient_and_amount
                (Some
                   (backer_addr,
                   get_default 0 backer_addr
                     (Crowdfunding_backers (contract_state state))))
                (update_Crowdfunding_backers
                   (set backer_addr 0 (Crowdfunding_backers s)) s))
             else
              (Int256.zero,
              update_Crowdfunding_backers
                (set backer_addr 0 (Crowdfunding_backers s)) s) in
           if (success =? Int256.one)%int256
           then
            {|
              runStateT :=
                fun _ : global_abstract_data_type => Some (tt, d')
            |}
           else
            {|
              runStateT := fun _ : global_abstract_data_type => None
            |})
          (update_Crowdfunding_backers
             (set backer_addr 0 (Crowdfunding_backers s)) s)
    |}) (contract_state state) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (let (success, d') :=
     if
      noOverflowOrUnderflowInTransfer contract_address backer_addr
        (get_default 0 backer_addr
           (Crowdfunding_backers (contract_state state)))
        (ContractModel.update_balances backer_addr contract_address 0
           (balance state)) &&
      address_accepts_funds_assumption
        (Some
           (update_Crowdfunding_backers
              (set backer_addr 0
                 (Crowdfunding_backers (contract_state state)))
              (contract_state state))) contract_address backer_addr
        (get_default 0 backer_addr
           (Crowdfunding_backers (contract_state state)))
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
unfold address_accepts_funds_assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
runStateT
  (let (success, d') :=
     if
      noOverflowOrUnderflowInTransfer contract_address backer_addr
        (get_default 0 backer_addr
           (Crowdfunding_backers (contract_state state)))
        (ContractModel.update_balances backer_addr contract_address 0
           (balance state)) && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

destruct (noOverflowOrUnderflowInTransfer contract_address backer_addr
(get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)))
(ContractModel.update_balances backer_addr contract_address
  0 (balance state))) eqn:SSSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
runStateT
  (let (success, d') :=
     if true && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
Some
  (tt,
  update_Outgoing_transfer_recipient_and_amount
    (Some
       (backer_addr,
       get_default 0 backer_addr
         (Crowdfunding_backers (contract_state state))))
    (update_Crowdfunding_backers
       (set backer_addr 0
          (Crowdfunding_backers (contract_state state)))
       (contract_state state))) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  unfold update_Outgoing_transfer_recipient_and_amount.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some
        (backer_addr,
        get_default 0 backer_addr
          (Crowdfunding_backers (contract_state state)));
    Crowdfunding_owner :=
      Crowdfunding_owner
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_max_block :=
      Crowdfunding_max_block
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_goal :=
      Crowdfunding_goal
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_backers :=
      Crowdfunding_backers
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_funded :=
      Crowdfunding_funded
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state));
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state))
  |}) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some
        (backer_addr,
        get_default 0 backer_addr
          (Crowdfunding_backers (contract_state state)));
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |}) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  rewrite <- H0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |}) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  rewrite SSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = true
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |}) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
runStateT
  (let (success, d') :=
     if false && true
     then
      (Int256.one,
      update_Outgoing_transfer_recipient_and_amount
        (Some
           (backer_addr,
           get_default 0 backer_addr
             (Crowdfunding_backers (contract_state state))))
        (update_Crowdfunding_backers
           (set backer_addr 0
              (Crowdfunding_backers (contract_state state)))
           (contract_state state)))
     else
      (Int256.zero,
      update_Crowdfunding_backers
        (set backer_addr 0
           (Crowdfunding_backers (contract_state state)))
        (contract_state state)) in
   if (success =? Int256.one)%int256
   then
    {|
      runStateT := fun _ : global_abstract_data_type => Some (tt, d')
    |}
   else {| runStateT := fun _ : global_abstract_data_type => None |})
  (update_Crowdfunding_backers
     (set backer_addr 0 (Crowdfunding_backers (contract_state state)))
     (contract_state state)) =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  (* The above is the successful claim case, I think.*)

  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: noOverflowOrUnderflowInTransfer contract_address
  backer_addr
  (get_default 0 backer_addr
     (Crowdfunding_backers (contract_state state)))
  (ContractModel.update_balances backer_addr
     contract_address 0 
     (balance state)) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

  unfold noOverflowOrUnderflowInTransfer in SSSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) &&
(ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  rewrite andb_false_iff in SSSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
SSSSSCase: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) =
false \/
(ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  destruct SSSSSCase.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (ContractModel.update_balances backer_addr contract_address 0
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  exfalso.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (ContractModel.update_balances backer_addr contract_address 0
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

  {
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
False
  assert((forall (k : Int256Tree.elt) (v : Z), Int256Tree.get k (Crowdfunding_backers (contract_state state)) = Some v -> v >= 0 /\ v < Int256.modulus) -> sum (Crowdfunding_backers (contract_state state)) <=
              balance state contract_address ->
              (balance state contract_address -
          Int256Tree.get_default 0 backer_addr
            (Crowdfunding_backers (contract_state state)) >=? 0) = true).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
(forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False
            {
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
(forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
              clear.
contract_address: addr
state: BlockchainState
backer_addr: elt
(forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
              intros.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
              rewrite Z.geb_le.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))

              assert(Int256Tree.get_default 0 backer_addr (Crowdfunding_backers (contract_state state)) <= sum (Crowdfunding_backers (contract_state state))).
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
              apply sum_bound1; try assumption; try lia.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
              intros.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
k: elt
v: Z
H1: get k (Crowdfunding_backers (contract_state state)) = Some v
v >= 0
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) apply H in H1.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
k: elt
v: Z
H1: v >= 0 /\ v < Int256.modulus
v >= 0
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) destruct H1.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
k: elt
v: Z
H1: v >= 0
H2: v < Int256.modulus
v >= 0
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
              lia.
contract_address: addr
state: BlockchainState
backer_addr: elt
H: forall (k : elt) (v : Z),
get k (Crowdfunding_backers (contract_state state)) = Some v ->
v >= 0 /\ v < Int256.modulus
H0: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H1: get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state)) <=
sum (Crowdfunding_backers (contract_state state))
0 <=
balance state contract_address -
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
              lia.
            }
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(ContractModel.update_balances backer_addr contract_address 0
   (balance state) contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False

            unfold ContractModel.update_balances in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
((if (backer_addr =? contract_address)%int256
  then balance state contract_address
  else
   if (contract_address =? backer_addr)%int256
   then balance state backer_addr - 0
   else
    if (contract_address =? contract_address)%int256
    then balance state contract_address + 0
    else balance state contract_address) -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False
            rewrite Int256.eq_true in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
((if (backer_addr =? contract_address)%int256
  then balance state contract_address
  else
   if (contract_address =? backer_addr)%int256
   then balance state backer_addr - 0
   else balance state contract_address + 0) -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False
            rewrite Int256.eq_false in H8 by auto.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
((if (contract_address =? backer_addr)%int256
  then balance state backer_addr - 0
  else balance state contract_address + 0) -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False
            rewrite Int256.eq_false in H8 by auto.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address + 0 -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False
            rewrite Z.add_0_r in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
False

            (* Here, we make use of a previous proof, sufficient_funds_safe *)
            pose proof sufficient_funds_safe as sufficient_funds_safe.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: Safe balance_backed
False
            unfold Safe in sufficient_funds_safe.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
False
            apply sufficient_funds_safe in H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: balance_backed state
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
False
            unfold balance_backed in H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: Crowdfunding_funded (contract_state state) = false ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address /\
(forall (key : elt) (value : Z32),
 get key (Crowdfunding_backers (contract_state state)) =
 Some value -> value >= 0 /\ value < Int256.modulus)
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
False
            destruct H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
Crowdfunding_funded (contract_state state) = false
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
False assumption.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
False
            apply H9 in H; [|assumption].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
False
            assert((0 <=?
            get_default 0 backer_addr
              (Crowdfunding_backers (contract_state state))) = true).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
(0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              unfold get_default.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
(0 <=?
 match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              unfold Z32 in H10.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
(0 <=?
 match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              pose proof (H10 backer_addr).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
get backer_addr (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
(0 <=?
 match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              destruct(@get Z backer_addr (Crowdfunding_backers (contract_state state))).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? z) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              pose proof (H11 z).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H12: Some z = Some z -> z >= 0 /\ z < Int256.modulus
(0 <=? z) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              assert (Some z = Some z) by reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H12: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H13: Some z = Some z
(0 <=? z) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              apply H12 in H13.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H12: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H13: z >= 0 /\ z < Int256.modulus
(0 <=? z) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              destruct H13.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H12: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H13: z >= 0
H14: z < Int256.modulus
(0 <=? z) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              rewrite Z.leb_le.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
z: Z
H11: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H12: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H13: z >= 0
H14: z < Int256.modulus
0 <= z
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <=? 0) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False
              rewrite Z.leb_le.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
0 <= 0
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False

            rewrite H11 in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
False

            assert((get_default 0 backer_addr
            (Crowdfunding_backers
              (contract_state state)) <?
          Int256.modulus) = true).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <? Int256.modulus) =
true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
          unfold get_default.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
(match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              unfold Z32 in H10.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
(match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              pose proof (H10 backer_addr).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
get backer_addr (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
(match
   get backer_addr (Crowdfunding_backers (contract_state state))
 with
 | Some v => v
 | None => 0
 end <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              destruct(@get Z backer_addr (Crowdfunding_backers (contract_state state))).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
(z <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              pose proof (H12 z).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H13: Some z = Some z -> z >= 0 /\ z < Int256.modulus
(z <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              assert (Some z = Some z) by reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H13: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H14: Some z = Some z
(z <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              apply H13 in H14.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H13: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H14: z >= 0 /\ z < Int256.modulus
(z <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              destruct H14.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H13: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H14: z >= 0
H15: z < Int256.modulus
(z <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              rewrite Z.ltb_lt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
z: Z
H12: forall value : Z,
Some z = Some value -> value >= 0 /\ value < Int256.modulus
H13: Some z = Some z -> z >= 0 /\ z < Int256.modulus
H14: z >= 0
H15: z < Int256.modulus
z < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
(0 <? Int256.modulus) = true
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
              rewrite Z.ltb_lt.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
0 < Int256.modulus
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False unfold Int256.modulus, two_power_nat.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: forall value : Z,
None = Some value -> value >= 0 /\ value < Int256.modulus
0 < Z.pos (shift_nat Int256.wordsize 1)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true &&
(get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False

            rewrite H12 in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true && true &&
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
            rewrite H in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true && true && true = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False
            simpl in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: true = false
H9: (forall (k : elt) (v : Z),
 get k (Crowdfunding_backers (contract_state state)) = Some v ->
 v >= 0 /\ v < Int256.modulus) ->
sum (Crowdfunding_backers (contract_state state)) <=
balance state contract_address ->
(balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
sufficient_funds_safe: forall (state : BlockchainState) 
  (s : Step) (l : list Step),
ReachableFromBy initial_state state s l ->
balance_backed state
H: (balance state contract_address -
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) >=? 0) = true
H10: forall (key : elt) (value : Z32),
get key (Crowdfunding_backers (contract_state state)) =
Some value -> value >= 0 /\ value < Int256.modulus
H11: (0 <=?
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state))) = true
H12: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
False

            discriminate.

  }
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (ContractModel.update_balances backer_addr contract_address 0
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
None =
Some
  (tt,
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := false;
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |})
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

  exfalso.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (ContractModel.update_balances backer_addr contract_address 0
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr rewrite H0 in H3.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (ContractModel.update_balances backer_addr contract_address 0
   (balance state) backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  unfold ContractModel.update_balances in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: ((if (backer_addr =? contract_address)%int256
  then balance state backer_addr
  else
   if (backer_addr =? backer_addr)%int256
   then balance state backer_addr - 0
   else
    if (backer_addr =? contract_address)%int256
    then balance state contract_address + 0
    else balance state backer_addr) +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

  rewrite Int256.eq_true in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: ((if (backer_addr =? contract_address)%int256
  then balance state backer_addr
  else balance state backer_addr - 0) +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
            rewrite Int256.eq_false in H8 by auto.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (balance state backer_addr - 0 +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
            (* rewrite Int256.eq_false in H8 by auto. *)
            rewrite Z.sub_0_r in H8.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
SSSCase: Crowdfunding_funded (contract_state state) = false
H4: false = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
SCase: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
H7: true = true
Case: (backer_addr =? contract_address)%int256 = false
SSCase: (get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) =? 0) =
false
SSSSCase: (Crowdfunding_goal (contract_state state) <=?
 ContractModel.update_balances backer_addr
   contract_address 0 
   (balance state) contract_address) = false
H8: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
            clear -H3 H8 H0.
state: BlockchainState
backer_addr: elt
backed_amount: Z
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H3: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = true
H8: (balance state backer_addr +
 get_default 0 backer_addr
   (Crowdfunding_backers (contract_state state)) <?
 Int256.modulus) = false
False
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
            lia.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Outgoing_transfer_recipient_and_amount
  {|
    Outgoing_transfer_recipient_and_amount :=
      Some (backer_addr, backed_amount);
    Crowdfunding_owner := Crowdfunding_owner (contract_state state);
    Crowdfunding_max_block :=
      Crowdfunding_max_block (contract_state state);
    Crowdfunding_goal := Crowdfunding_goal (contract_state state);
    Crowdfunding_backers :=
      set backer_addr 0 (Crowdfunding_backers (contract_state state));
    Crowdfunding_funded := Crowdfunding_funded (contract_state state);
    Crowdfunding_deadlinePassed_msg :=
      Crowdfunding_deadlinePassed_msg (contract_state state);
    Crowdfunding_successfullyDonated_msg :=
      Crowdfunding_successfullyDonated_msg (contract_state state);
    Crowdfunding_alreadyDonated_msg :=
      Crowdfunding_alreadyDonated_msg (contract_state state);
    Crowdfunding_funded_msg :=
      Crowdfunding_funded_msg (contract_state state);
    Crowdfunding_failed_msg :=
      Crowdfunding_failed_msg (contract_state state);
    Crowdfunding_too_early_to_claim_funds_msg :=
      Crowdfunding_too_early_to_claim_funds_msg
        (contract_state state);
    Crowdfunding_too_early_to_reclaim_msg :=
      Crowdfunding_too_early_to_reclaim_msg (contract_state state);
    Crowdfunding_cannot_refund_msg :=
      Crowdfunding_cannot_refund_msg (contract_state state);
    Crowdfunding_here_is_your_money_msg :=
      Crowdfunding_here_is_your_money_msg (contract_state state)
  |} = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr



  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
Some (backer_addr, backed_amount) = Some (backer_addr, backed_amount)
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr
  reflexivity.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
callvalue
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = 0 /\
caller
  {|
    origin := backer_addr;
    caller := backer_addr;
    callvalue := 0;
    coinbase := Int256.zero;
    chainid := Int256.zero
  |} = backer_addr

  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
state: BlockchainState
s: Step
l: list Step
backer_addr: elt
backed_amount: Z
H: ReachableFromBy initial_state state s l
H0: backed_amount =
get_default 0 backer_addr
  (Crowdfunding_backers (contract_state state))
H1: contract_address <> backer_addr
H2: backed_amount > 0
H3: (balance state backer_addr + backed_amount <? Int256.modulus) =
true
H4: Crowdfunding_funded (contract_state state) = false
H5: balance state contract_address <
Crowdfunding_goal (contract_state state)
H6: forall a : addr, 0 <= balance state a < Int256.modulus
H7: Int256.ltu (Crowdfunding_max_block (contract_state state))
  (block_number state) = true
0 = 0 /\ backer_addr = backer_addr auto. (* These are the conditions to ensure that the action is reasonably callable by the backer. *)
Qed.

Opaque Crowdfunding_donate_opt Crowdfunding_getFunds_opt Crowdfunding_claim_opt.





















Require Import Arith.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]

Section Monad.
Class Monad (M : Type -> Type) :=
{
  ret : forall {T : Type}, T -> M T;
  bind : forall {T U : Type}, M T -> (T -> M U) -> M U;
  left_identity_prf : forall {T U : Type} a f, @bind T U (ret a) f = f a;
  right_identity_prf : forall {T : Type} (m : M T), @bind T T m ret = m;
  associativity_prf : forall {T U V : Type} (m : M T) (g : T -> M U) (h : U -> M V),
    @bind U V (@bind T U m g) h = @bind T V m (fun x => @bind U V (g x) h)
}.

Notation "a >>=' b" := (bind a b) (at level 50, left associativity).
Notation "f >=>' g" := (fun x => (f x >>=' g)) (at level 50, left associativity).


Require Import Coq.Logic.FunctionalExtensionality.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]
Lemma kleisli_assoc : forall (A B C D : Type) (m : Type -> Type) `{Monad m}
  (f : A -> m B) (g : B -> m C) (h : C -> m D),
  (f >=>' g) >=>' h = f >=>' (g >=>' h).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (A B C D : Type) (m : Type -> Type) (H : Monad m)
  (f : A -> m B) (g : B -> m C) (h : C -> m D),
f >=>' g >=>' h = f >=>' (g >=>' h)
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (A B C D : Type) (m : Type -> Type) (H : Monad m)
  (f : A -> m B) (g : B -> m C) (h : C -> m D),
f >=>' g >=>' h = f >=>' (g >=>' h)
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
A, B, C, D: Type
m: Type -> Type
H: Monad m
f: A -> m B
g: B -> m C
h: C -> m D
f >=>' g >=>' h = f >=>' (g >=>' h)
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
A, B, C, D: Type
m: Type -> Type
H: Monad m
f: A -> m B
g: B -> m C
h: C -> m D
forall x : A, f x >>=' g >>=' h = f x >>=' (g >=>' h)
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
A, B, C, D: Type
m: Type -> Type
H: Monad m
f: A -> m B
g: B -> m C
h: C -> m D
x: A
f x >>=' g >>=' h = f x >>=' (g >=>' h)
  apply Monad.associativity_prf.
Qed.

Search (forall a f, ret a >>=' f = f a).
left_identity_prf:
  forall {M : Type -> Type} {Monad : Monad M} {T U : Type} 
    (a : T) (f : T -> M U), ret a >>=' f = f a
Search (forall m, m >>=' ret = m).
right_identity_prf:
  forall {M : Type -> Type} {Monad : Monad M} {T : Type} (m : M T),
  m >>=' ret = m
Search (forall m g h, m >>=' g >>=' h = m >>=' (g >=>' h)).
associativity_prf:
  forall {M : Type -> Type} {Monad : Monad M} {T U V : Type}
    (m : M T) (g : T -> M U) (h : U -> M V),
  m >>=' g >>=' h = m >>=' (g >=>' h)


Inductive Maybe (T : Type) : Type :=
  | None' : Maybe T
  | Some' : T -> Maybe T
.
Arguments None' {T}.
Arguments Some' {T} t.

#[refine] Instance : Monad (Maybe) :=
{
  ret T a := Some' a;
  bind T U m f :=
    match m with
        None' => None'
      | Some' a => f a
    end;
  left_identity_prf := _;
  right_identity_prf := _;
  associativity_prf := _
}.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U : Type) (a : T) (f : T -> Maybe U), f a = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T : Type) (m : Maybe T),
match m with
| None' => None'
| Some' a => Some' a
end = m
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U V : Type) 
  (m : Maybe T) (g : T -> Maybe U) 
  (h : U -> Maybe V),
match match m with
      | None' => None'
      | Some' a => g a
      end with
| None' => None'
| Some' a => h a
end =
match m with
| None' => None'
| Some' a => match g a with
             | None' => None'
             | Some' a0 => h a0
             end
end
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U : Type) (a : T) (f : T -> Maybe U), f a = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T : Type) (m : Maybe T),
match m with
| None' => None'
| Some' a => Some' a
end = m
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U V : Type) 
  (m : Maybe T) (g : T -> Maybe U) 
  (h : U -> Maybe V),
match match m with
      | None' => None'
      | Some' a => g a
      end with
| None' => None'
| Some' a => h a
end =
match m with
| None' => None'
| Some' a => match g a with
             | None' => None'
             | Some' a0 => h a0
             end
end
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U : Type) (a : T) (f : T -> Maybe U), f a = f a
    intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U: Type
a: T
f: T -> Maybe U
f a = f a
    reflexivity.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T : Type) (m : Maybe T),
match m with
| None' => None'
| Some' a => Some' a
end = m


    intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T: Type
m: Maybe T
match m with
| None' => None'
| Some' a => Some' a
end = m
    destruct m.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T: Type
None' = None'
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T: Type
t0: T
Some' t0 = Some' t0
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T: Type
None' = None' reflexivity.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T: Type
t0: T
Some' t0 = Some' t0 reflexivity.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (T U V : Type) (m : Maybe T) (g : T -> Maybe U)
  (h : U -> Maybe V),
match match m with
      | None' => None'
      | Some' a => g a
      end with
| None' => None'
| Some' a => h a
end =
match m with
| None' => None'
| Some' a => match g a with
             | None' => None'
             | Some' a0 => h a0
             end
end

    intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U, V: Type
m: Maybe T
g: T -> Maybe U
h: U -> Maybe V
match match m with
      | None' => None'
      | Some' a => g a
      end with
| None' => None'
| Some' a => h a
end =
match m with
| None' => None'
| Some' a => match g a with
             | None' => None'
             | Some' a0 => h a0
             end
end
    destruct m.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U, V: Type
g: T -> Maybe U
h: U -> Maybe V
None' = None'
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U, V: Type
t0: T
g: T -> Maybe U
h: U -> Maybe V
match g t0 with
| None' => None'
| Some' a => h a
end = match g t0 with
      | None' => None'
      | Some' a => h a
      end
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U, V: Type
g: T -> Maybe U
h: U -> Maybe V
None' = None'  reflexivity.
    +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
T, U, V: Type
t0: T
g: T -> Maybe U
h: U -> Maybe V
match g t0 with
| None' => None'
| Some' a => h a
end = match g t0 with
      | None' => None'
      | Some' a => h a
      end  reflexivity.
Defined.

Require Import List.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]
Import ListNotations.

Definition State (St Result : Type) : Type := St -> (Result * St).




Definition bind' {St U V : Type}
  (aU : State St U) (f : U -> State St V) : State St V.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
State St V
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
State St V
unfold State in *.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: St -> U * St
f: U -> St -> V * St
St -> V * St
intro st0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: St -> U * St
f: U -> St -> V * St
st0: St
(V * St)%type
pose proof (aU st0) as (u, st1).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: St -> U * St
f: U -> St -> V * St
st0: St
u: U
st1: St
(V * St)%type
pose proof (f u) as aV.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: St -> U * St
f: U -> St -> V * St
st0: St
u: U
st1: St
aV: St -> V * St
(V * St)%type
pose proof (aV st1) as (v, st2).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: St -> U * St
f: U -> St -> V * St
st0: St
u: U
st1: St
aV: St -> V * St
v: V
st2: St
(V * St)%type
exact (v, st2).
Defined.
#[refine] Instance StateMonad (St : Type) : Monad (State St) := {
  ret := fun (U : Type) (u : U) => fun s => (u, s);
  bind (U V : Type) (aU : State St U) (f : U -> State St V) :=
      (fun (st0 : St) => let (u, st1) := aU st0 in
                          let aV := f u in
                            aV st1)
}.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U : Type) (a : T) (f : T -> State St U),
(fun st0 : St => let aV := f a in aV st0) = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T : Type) (m : State St T),
(fun st0 : St =>
 let (u, st1) := m st0 in let aV := fun s : St => (u, s) in aV st1) =
m
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U V : Type) 
  (m : State St T) (g : T -> State St U) 
  (h : U -> State St V),
(fun st0 : St =>
 let (u, st1) := let (u, st1) := m st0 in let aV := g u in aV st1 in
 let aV := h u in aV st1) =
(fun st0 : St =>
 let (u, st1) := m st0 in
 let aV :=
   fun st2 : St =>
   let (u0, st3) := g u st2 in let aV := h u0 in aV st3 in
 aV st1)
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U : Type) (a : T) (f : T -> State St U),
(fun st0 : St => let aV := f a in aV st0) = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T : Type) (m : State St T),
(fun st0 : St =>
 let (u, st1) := m st0 in let aV := fun s : St => (u, s) in aV st1) =
m
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U V : Type) 
  (m : State St T) (g : T -> State St U) 
  (h : U -> State St V),
(fun st0 : St =>
 let (u, st1) := let (u, st1) := m st0 in let aV := g u in aV st1 in
 let aV := h u in aV st1) =
(fun st0 : St =>
 let (u, st1) := m st0 in
 let aV :=
   fun st2 : St =>
   let (u0, st3) := g u st2 in let aV := h u0 in aV st3 in
 aV st1)
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U : Type) (a : T) (f : T -> State St U),
(fun st0 : St => let aV := f a in aV st0) = f a

  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
(fun st0 : St => let aV := f a in aV st0) = f a
  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
(fun st0 : St => f a st0) = f a intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
(fun st0 : St => f a st0) = f a apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
forall x : St, f a x = f a x intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
x: St
f a x = f a x
  destruct (f a x).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U: Type
a: T
f: T -> State St U
x: St
u: U
s: St
(u, s) = (u, s) reflexivity.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T : Type) (m : State St T),
(fun st0 : St =>
 let (u, st1) := m st0 in let aV := fun s : St => (u, s) in aV st1) =
m

  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: State St T
(fun st0 : St =>
 let (u, st1) := m st0 in let aV := fun s : St => (u, s) in aV st1) =
m
  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: State St T
(fun st0 : St => let (u, st1) := m st0 in (u, st1)) = m unfold State in m.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: St -> T * St
(fun st0 : St => let (u, st1) := m st0 in (u, st1)) = m
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: St -> T * St
forall x : St, (let (u, st1) := m x in (u, st1)) = m x
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: St -> T * St
x: St
(let (u, st1) := m x in (u, st1)) = m x
  destruct (m x).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T: Type
m: St -> T * St
x: St
t0: T
s: St
(t0, s) = (t0, s)
  reflexivity.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St: Type
forall (T U V : Type) (m : State St T) (g : T -> State St U)
  (h : U -> State St V),
(fun st0 : St =>
 let (u, st1) := let (u, st1) := m st0 in let aV := g u in aV st1 in
 let aV := h u in aV st1) =
(fun st0 : St =>
 let (u, st1) := m st0 in
 let aV :=
   fun st2 : St =>
   let (u0, st3) := g u st2 in let aV := h u0 in aV st3 in
 aV st1)
  do 3 intro.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
forall (m : State St T) (g : T -> State St U) (h : U -> State St V),
(fun st0 : St =>
 let (u, st1) := let (u, st1) := m st0 in let aV := g u in aV st1 in
 let aV := h u in aV st1) =
(fun st0 : St =>
 let (u, st1) := m st0 in
 let aV :=
   fun st2 : St =>
   let (u0, st3) := g u st2 in let aV := h u0 in aV st3 in
 aV st1) intros aT g h.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
(fun st0 : St =>
 let (u, st1) := let (u, st1) := aT st0 in let aV := g u in aV st1 in
 let aV := h u in aV st1) =
(fun st0 : St =>
 let (u, st1) := aT st0 in
 let aV :=
   fun st2 : St =>
   let (u0, st3) := g u st2 in let aV := h u0 in aV st3 in
 aV st1)
  simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
(fun st0 : St =>
 let (u, st1) := let (u, st1) := aT st0 in g u st1 in h u st1) =
(fun st0 : St =>
 let (u, st1) := aT st0 in let (u0, st2) := g u st1 in h u0 st2) apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
forall x : St,
(let (u, st1) := let (u, st1) := aT x in g u st1 in h u st1) =
(let (u, st1) := aT x in let (u0, st2) := g u st1 in h u0 st2) intro s.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
s: St
(let (u, st1) := let (u, st1) := aT s in g u st1 in h u st1) =
(let (u, st1) := aT s in let (u0, st2) := g u st1 in h u0 st2)
  destruct (aT s) as [t st0].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
s: St
t: T
st0: St
(let (u, st1) := g t st0 in h u st1) =
(let (u, st1) := g t st0 in h u st1)
  destruct (g t st0) as [u st1].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
s: St
t: T
st0: St
u: U
st1: St
h u st1 = h u st1
  destruct (h u st1) as [v st2].
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, T, U, V: Type
aT: State St T
g: T -> State St U
h: U -> State St V
s: St
t: T
st0: St
u: U
st1: St
v: V
st2: St
(v, st2) = (v, st2)
  reflexivity.
Defined.
Notation "a >>='' b" := (bind' a b) (at level 58, left associativity).
Lemma bindSanityCheck : forall (St U V : Type)
  (aU : State St U) (f : U -> State St V),
    bind' aU f = bind aU f.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (St U V : Type) (aU : State St U) (f : U -> State St V),
aU >>='' f = aU >>=' f
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall (St U V : Type) (aU : State St U) (f : U -> State St V),
aU >>='' f = aU >>=' f
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
aU >>='' f = aU >>=' f
  unfold ">>=''".
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
(fun st0 : St =>
 let (a, b) := aU st0 in let (a0, b0) := f a b in (a0, b0)) =
aU >>=' f simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
(fun st0 : St =>
 let (a, b) := aU st0 in let (a0, b0) := f a b in (a0, b0)) =
(fun st0 : St => let (u, st1) := aU st0 in f u st1) apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
forall x : St,
(let (a, b) := aU x in let (a0, b0) := f a b in (a0, b0)) =
(let (u, st1) := aU x in f u st1)
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
x: St
(let (a, b) := aU x in let (a0, b0) := f a b in (a0, b0)) =
(let (u, st1) := aU x in f u st1) destruct (aU x).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
x: St
u: U
s: St
(let (a, b) := f u s in (a, b)) = f u s destruct (f u s).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
0 <= snapshot_balances a <
Int256.modulus
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
St, U, V: Type
aU: State St U
f: U -> State St V
x: St
u: U
s: St
v: V
s0: St
(v, s0) = (v, s0) reflexivity.
Qed.


Notation "a1 ;;; a2" := (a1 >>=' (fun _ => a2))
  (at level 61, right associativity).
Notation "x <- a1 ;;; a2" := (a1 >>=' (fun x => a2))
  (at level 61, a1 at next level, right associativity).
Notation "' pat <- a1 ;;; a2" :=
  (a1 >>=' (fun x => match x with pat => a2 end))
  (at level 61, pat pattern, a1 at next level, right associativity).

Definition minusOne (x : nat) : Maybe nat :=
  match x with
  | O => None'
  | S x' => Some' x'
end.
Open Scope nat.
Definition add3 (t : nat * nat * nat) : Maybe nat :=
  match t with (a, b, c) =>
    Some' (a + b + c)
  end.
Definition triple (x y z: nat) : Maybe (nat * nat * nat) :=
  Some' (x, y, z).

Eval compute in
  x <- Some' 4 ;;;
  y <- minusOne x;;;
  z <- minusOne y;;;
  t <- triple x y z ;;;
  add3 t.
= Some' 9
: Maybe nat


Eval compute in
  Some' 4 >>=' (fun x =>
    minusOne x >>=' (fun y =>
      minusOne y >>=' (fun z =>
        triple x y z >>=' (fun t =>
          add3 t)))).
= Some' 9
: Maybe nat



Definition Stack := list nat.
Definition pop : Stack -> (nat * Stack) :=
  fun (s : Stack) =>
    match s with
        [] => (0, [])
      | (x :: xs) => (x, xs)
    end.

Definition popTypeExample : State Stack nat := pop.
Definition push (n : nat) : State Stack unit :=
  fun (s : Stack) => (tt, n :: s).
Definition pushTypeExample : nat -> Stack -> (unit * Stack) := push.
Definition stackManipulation1 : State Stack unit :=
  pop >>=' push.
Definition stackManipulation1' : State Stack unit :=
  x <- pop ;;; push x.
Require Import Nat.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]

Definition stackManipulation2 : State Stack nat :=
  push 4;;;
  stackManipulation1;;;
  push 5;;;
  pop.
Eval compute in stackManipulation2 [1;2;3].
= (5, [4; 1; 2; 3])
: nat * Stack


Class MonadState (T : Type) (m : Type -> Type) : Type := {
  get' : m T;
  put : T -> m unit
}.
Instance MonadState_State (St : Type) : MonadState St (State St) := {
  get' := (fun s => (s, s));
  put (newState : St) := (fun _ => (tt, newState))
}.

Section StateTransformerMonad.

Variable m : Type -> Type.
Variable M : Monad m.
Definition StateT `{Monad m} (St : Type) (A : Type) := St -> m (A * St).
Require Import Coq.Setoids.Setoid.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]
Require Import Coq.Classes.Morphisms.
Use of “Require” inside a section is fragile. It is not recommended
to use this functionality in finished proof scripts.
[require-in-section,fragile]
Use of “Require” inside a module is fragile. It is not recommended to
use this functionality in finished proof scripts.
[require-in-module,fragile]
Generalizable All Variables.

Instance pointwise_eq_ext {A B : Type} `(sb : subrelation B RB eq)
      : subrelation (pointwise_relation A RB) eq.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
A, B: Type
RB: relation B
sb: subrelation RB eq
subrelation (pointwise_relation A RB) eq
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
A, B: Type
RB: relation B
sb: subrelation RB eq
subrelation (pointwise_relation A RB) eq intros f g Hfg.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
A, B: Type
RB: relation B
sb: subrelation RB eq
f, g: A -> B
Hfg: pointwise_relation A RB f g
f = g apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
A, B: Type
RB: relation B
sb: subrelation RB eq
f, g: A -> B
Hfg: pointwise_relation A RB f g
forall x : A, f x = g x intro x; apply sb, (Hfg x). Qed.

#[refine] Instance Monad_StateT (St : Type) : Monad (StateT St) := {
  ret (U : Type) (a : U) (s : St) := ret (a, s);
  bind (U V : Type) (aU : StateT St U) (f : U -> StateT St V) :=
    (fun s =>
      ' (u, s') <- aU s ;;;
      f u s'
    )
}.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U : Type) (a : T) (f : T -> StateT St U),
(fun s : St => x <- ret (a, s);;; (let (u, s') := x in f u s')) = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T : Type) (m0 : StateT St T),
m0 >=>' (fun x : T * St => let (u, s') := x in ret (u, s')) = m0
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U V : Type) 
  (m0 : StateT St T) 
  (g : T -> StateT St U) 
  (h : U -> StateT St V),
(fun s : St =>
 x <- (x <- m0 s;;; (let (u, s') := x in g u s'));;;
 (let (u, s') := x in h u s')) =
m0 >=>'
(fun x : T * St =>
 let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U : Type) (a : T) (f : T -> StateT St U),
(fun s : St => x <- ret (a, s);;; (let (u, s') := x in f u s')) = f a
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T : Type) (m0 : StateT St T),
m0 >=>' (fun x : T * St => let (u, s') := x in ret (u, s')) = m0
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U V : Type) 
  (m0 : StateT St T) 
  (g : T -> StateT St U) 
  (h : U -> StateT St V),
(fun s : St =>
 x <- (x <- m0 s;;; (let (u, s') := x in g u s'));;;
 (let (u, s') := x in h u s')) =
m0 >=>'
(fun x : T * St =>
 let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U : Type) (a : T) (f : T -> StateT St U),
(fun s : St => x <- ret (a, s);;; (let (u, s') := x in f u s')) = f a

  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U: Type
a: T
f: T -> StateT St U
(fun s : St => x <- ret (a, s);;; (let (u, s') := x in f u s')) = f a
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U: Type
a: T
f: T -> StateT St U
forall x : St,
x0 <- ret (a, x);;; (let (u, s') := x0 in f u s') = f a x
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U: Type
a: T
f: T -> StateT St U
x: St
x <- ret (a, x);;; (let (u, s') := x in f u s') = f a x

  setoid_rewrite left_identity_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U: Type
a: T
f: T -> StateT St U
x: St
f a x = f a x
  reflexivity.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T : Type) (m0 : StateT St T),
m0 >=>' (fun x : T * St => let (u, s') := x in ret (u, s')) = m0

  intros T aT.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
aT >=>' (fun x : T * St => let (u, s') := x in ret (u, s')) = aT
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
forall x : St,
x0 <- aT x;;; (let (u, s') := x0 in ret (u, s')) = aT x
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
x <- aT x;;; (let (u, s') := x in ret (u, s')) = aT x
  assert (forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
H: forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0
x <- aT x;;; (let (u, s') := x in ret (u, s')) = aT x
  {
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0
    intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
x0: (T * St)%type
(let (a, s') := x0 in ret (a, s')) = ret x0
    destruct x0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
t: T
s: St
ret (t, s) = ret (t, s)
    reflexivity.
  }
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
H: forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0
x <- aT x;;; (let (u, s') := x in ret (u, s')) = aT x
  setoid_rewrite H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T: Type
aT: StateT St T
x: St
H: forall x0 : T * St, (let (a, s') := x0 in ret (a, s')) = ret x0
x <- aT x;;; ret x = aT x
  apply right_identity_prf.
-
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St: Type
forall (T U V : Type) (m0 : StateT St T) (g : T -> StateT St U)
  (h : U -> StateT St V),
(fun s : St =>
 x <- (x <- m0 s;;; (let (u, s') := x in g u s'));;;
 (let (u, s') := x in h u s')) =
m0 >=>'
(fun x : T * St =>
 let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))

  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
(fun s : St =>
 x <- (x <- m0 s;;; (let (u, s') := x in g u s'));;;
 (let (u, s') := x in h u s')) =
m0 >=>'
(fun x : T * St =>
 let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
forall x : St,
x0 <- (x0 <- m0 x;;; (let (u, s') := x0 in g u s'));;;
(let (u, s') := x0 in h u s') =
x0 <- m0 x;;;
(let (u, s') := x0 in
 x1 <- g u s';;; (let (u0, s'0) := x1 in h u0 s'0))
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
x <- (x <- m0 x;;; (let (u, s') := x in g u s'));;;
(let (u, s') := x in h u s') =
x <- m0 x;;;
(let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
  rewrite associativity_prf.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
x <- m0 x;;;
x0 <- (let (u, s') := x in g u s');;; (let (u, s') := x0 in h u s') =
x <- m0 x;;;
(let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
  assert(forall x0 : T * St,
    x1 <- (let (a, s') := x0 in g a s');;;
    (let (a, s') := (x1 : U * St) in h a s')
    =
    (let (a, s') := x0 in x1 <- g a s';;;
    (let (a0, s'0) := (x1 : U * St) in h a0 s'0))).
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
forall x0 : T * St,
x1 <- (let (a, s') := x0 in g a s');;; (let (a, s') := x1 in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 in h a0 s'0))
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
H: forall x0 : T * St,
x1 <- (let (a, s') := x0 in g a s');;;
(let (a, s') := x1 : U * St in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 : U * St in h a0 s'0))
x <- m0 x;;;
x0 <- (let (u, s') := x in g u s');;; (let (u, s') := x0 in h u s') =
x <- m0 x;;;
(let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
    {
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
forall x0 : T * St,
x1 <- (let (a, s') := x0 in g a s');;; (let (a, s') := x1 in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 in h a0 s'0))
      intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
x0: (T * St)%type
x1 <- (let (a, s') := x0 in g a s');;; (let (a, s') := x1 in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 in h a0 s'0))
      destruct x0.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
t: T
s: St
x1 <- g t s;;; (let (a, s') := x1 in h a s') =
x1 <- g t s;;; (let (a0, s'0) := x1 in h a0 s'0)
      reflexivity.
    }
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
H: forall x0 : T * St,
x1 <- (let (a, s') := x0 in g a s');;;
(let (a, s') := x1 : U * St in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 : U * St in h a0 s'0))
x <- m0 x;;;
x0 <- (let (u, s') := x in g u s');;; (let (u, s') := x0 in h u s') =
x <- m0 x;;;
(let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
  setoid_rewrite H.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
m: Type -> Type
M: Monad m
St, T, U, V: Type
m0: StateT St T
g: T -> StateT St U
h: U -> StateT St V
x: St
H: forall x0 : T * St,
x1 <- (let (a, s') := x0 in g a s');;;
(let (a, s') := x1 : U * St in h a s') =
(let (a, s') := x0 in
 x1 <- g a s';;; (let (a0, s'0) := x1 : U * St in h a0 s'0))
x <- m0 x;;;
(let (a, s') := x in
 x1 <- g a s';;; (let (a0, s'0) := x1 in h a0 s'0)) =
x <- m0 x;;;
(let (u, s') := x in
 x0 <- g u s';;; (let (u0, s'0) := x0 in h u0 s'0))
  reflexivity.
Defined.
Instance MonadState_StateT (St : Type) : MonadState St (StateT St) := {
  get' := (fun s => ret (s, s));
  put (newState : St) := (fun _ => ret (tt, newState))
}.
End StateTransformerMonad.

Definition maybeStateT (St : Type) := StateT Maybe St.
Instance Monad_MaybeStateT (St : Type) : Monad (maybeStateT St) :=
  Monad_StateT Maybe _ St.
Instance MonadState_MaybeStateT (St : Type) : MonadState St (maybeStateT St) :=
  MonadState_StateT Maybe _ St.
Definition pop' : Stack -> Maybe (nat * Stack) :=
    fun (s : Stack) =>
      match s with
          [] => None'
        | (x :: xs) => Some' (x, xs)
      end.
Definition pop'TypeExample : StateT Maybe Stack nat := pop'.

Definition push' (n : nat) : StateT Maybe Stack unit :=
    fun (s : Stack) => Some' (tt, n :: s).
Definition push'TypeExample : nat -> Stack -> Maybe (unit * Stack) := push'.
Definition plusStack : maybeStateT Stack nat :=
  a <- pop' ;;;
  b <- pop' ;;;
  ret (a + b).

Eval compute in plusStack [1;5;3].
= Some' (6, [3])
: Maybe (nat * Stack)

Definition plus3Stack : maybeStateT Stack nat :=
  a <- pop' ;;;
  b <- pop' ;;;
  c <- pop' ;;;
  ret (a + b + c).
Definition plus3Stack' : maybeStateT Stack nat :=
  r <- plusStack ;;;
  push' r ;;;
  r2 <- plusStack ;;;
  ret r2.
Lemma plus3Equivalence : plus3Stack = plus3Stack'.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
plus3Stack = plus3Stack'
Proof.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
plus3Stack = plus3Stack'
  apply functional_extensionality.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
forall x : Stack, plus3Stack x = plus3Stack' x
  intros.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
x: Stack
plus3Stack x = plus3Stack' x
  unfold plus3Stack, plus3Stack', plusStack.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
x: Stack
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) x =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) x
  destruct x.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) []
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) (n :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) 
  (n :: x)
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) [] simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
None' = None'  reflexivity.
  -
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) (n :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) 
  (n :: x) destruct x.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n: nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [n] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) [n]
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c))
  (n :: n0 :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2)
  (n :: n0 :: x)
  +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n: nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [n] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) [n] simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n: nat
None' = None'  reflexivity.
  +
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c))
  (n :: n0 :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2)
  (n :: n0 :: x) destruct x.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0: nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [n; n0] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) 
  [n; n0]
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0, n1: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c))
  (n :: n0 :: n1 :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2)
  (n :: n0 :: n1 :: x)
  *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0: nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c)) [n; n0] =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2) 
  [n; n0] simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0: nat
None' = None'  reflexivity.
  *
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0, n1: nat
x: list nat
(a <- pop';;; b <- pop';;; c <- pop';;; ret (a + b + c))
  (n :: n0 :: n1 :: x) =
(r <- (a <- pop';;; b <- pop';;; ret (a + b));;;
 _ <- push' r;;;
 r2 <- (a <- pop';;; b <- pop';;; ret (a + b));;; ret r2)
  (n :: n0 :: n1 :: x) simpl.
snapshot_timestamp, snapshot_number: int256
snapshot_blockhash: int256 -> int256
snapshot_balances: addr -> wei
snapshot_balances_valid_prf: forall a : addr,
(0 <= snapshot_balances a <
 Int256.modulus)%Z
contract_address: addr
address_accepts_funds: option ContractState ->
addr -> addr -> wei -> bool
HmemOps, memModelOps: MemoryModelOps mem
n, n0, n1: nat
x: list nat
Some' (n + n0 + n1, x) = Some' (n + n0 + n1, x)  reflexivity.
Qed.

Record rental_property_storage_type := {
  landlord : nat;
  tenant : nat
}.
Definition update_tenant tenant r := {|
  landlord := landlord r;
  tenant := tenant
|}.
Definition update_landlord landlord r := {|
  landlord := landlord;
  tenant := tenant r
|}.
Record mini_machine_environment := {
  caller' : nat;
  callvalue' : nat
}.

Open Scope nat.

Definition init_rental_property_storage : rental_property_storage_type := {|
  landlord := 4632783269828394728397482347237428347892%nat;
  tenant :=   9857840927384723984723948712383491278373%nat
|}.
To avoid stack overflow, large numbers in nat are interpreted as
applications of of_num_uint. [abstract-large-number,numbers]
To avoid stack overflow, large numbers in nat are interpreted as
applications of of_num_uint. [abstract-large-number,numbers]



Definition DS := StateT Maybe rental_property_storage_type.
Definition gets' {A : Type} f : DS A :=
  a <- get' ;;;
  ret (f a).
Definition puts f : DS unit :=
  a <- get' ;;;
  put (f a).
Definition fail {A : Type} : DS A :=
  fun (s : rental_property_storage_type) => None'.