Goal forall mu Etgt Esrc m2 m2' (WD: SM_wd mu) m1
(TgtHyp: forall b ofs, Etgt b ofs = true ->
(Mem.valid_block m2 b /\
(locBlocksTgt mu b = false ->
exists b1 delta1, foreign_of mu b1 = Some(b,delta1) /\
Esrc b1 (ofs-delta1) = true /\ Mem.perm m1 b1 (ofs-delta1) Max Nonempty)))
(Unch2: Mem.unchanged_on (fun b z => Etgt b z = false) m2 m2')
(*(SrcHyp: forall b ofs, Esrc b ofs = true -> vis mu b = true)*)
nu (WDnu: SM_wd nu)
(X1: forall b, locBlocksTgt nu b = true -> locBlocksTgt mu b = false)
(X2: forall b1 b2 d, foreign_of mu b1 = Some(b2, d) ->
locBlocksSrc nu b1 || locBlocksTgt nu b2 = true ->
pub_of nu b1 = Some(b2,d)),
Mem.unchanged_on (fun b2 z => locBlocksTgt nu b2 = true /\
forall b1 d, (as_inj nu) b1 = Some (b2,d) ->
loc_out_of_bounds m1 b1 (z-d)) m2 m2'.
Inductive match_freelists (j:meminj): list (block * Z * Z) -> list (block * Z * Z) -> Prop :=
match_freelists_nil: match_freelists j nil nil
| match_freelists_cons: forall b1 lo1 hi1 t1 b2 lo2 hi2 t2 delta,
j b1 = Some (b2,delta) ->
lo2 = lo1+delta -> hi2 = hi1+delta ->
match_freelists j t1 t2 ->
match_freelists j ((b1,lo1,hi1)::t1) ((b2,lo2,hi2)::t2).
(***********************************************************************)
Goal forall mu (WD: SM_wd mu) m1 m2 m2'
(U: Mem.unchanged_on (local_out_of_reach mu m1) m2 m2'),
Mem.unchanged_on (fun b ofs => pubBlocksTgt mu b = true /\
loc_out_of_reach (pub_of mu) m1 b ofs) m2 m2'.
Goal forall mu (WD: SM_wd mu) m1 m2 m2'
(U: Mem.unchanged_on (local_out_of_reach mu m1) m2 m2'),
Mem.unchanged_on (fun b ofs => locBlocksTgt mu b = true /\
pubBlocksTgt mu b = false) m2 m2'.
intros.
eapply mem_unchanged_on_sub; try eassumption.
intros. unfold local_out_of_reach. destruct H.
split; trivial. intros.
remember (pubBlocksSrc mu b0) as d.
destruct d; try (right; reflexivity).
apply eq_sym in Heqd.
destruct (pubSrc _ WD _ Heqd) as [b2 [dd [PUB TGT]]].
apply pub_in_local in PUB. rewrite PUB in H1. inv H1.
rewrite TGT in H0. discriminate.
Qed.
Goal forall mu m1 m2 m2' (WD:SM_wd mu)
(U1: Mem.unchanged_on (fun b ofs => locBlocksTgt mu b = true /\
pubBlocksTgt mu b = false) m2 m2')
(U2: Mem.unchanged_on (fun b ofs => pubBlocksTgt mu b = true /\
loc_out_of_reach (pub_of mu) m1 b ofs) m2 m2'),
Mem.unchanged_on (local_out_of_reach mu m1) m2 m2'.
intros.
destruct U1 as [P1 C1]. destruct U2 as [P2 C2].
split; intros.
clear C1 C2.
specialize (P1 b ofs k p). specialize (P2 b ofs k p).
remember (locBlocksTgt mu b) as d.
destruct d; apply eq_sym in Heqd; simpl in *.
remember (pubBlocksTgt mu b) as q.
destruct q; apply eq_sym in Heqq; simpl in *.
clear P1.
apply P2; trivial. split; trivial.
intros b0; intros.
destruct H. destruct (H2 b0 delta).
apply pub_in_local; trivial.
assumption.
unfold pub_of in H1. destruct mu. simpl in *.  rewrite H3 in H1.  discriminate.
apply P1; trivial. split; trivial.
clear P1.
remember (pubBlocksTgt mu b) as q.
destruct q; apply eq_sym in Heqq; simpl in *.
assert (locBlocksTgt mu b = true). eapply (pubBlocksLocalTgt _ WD). eassumption.
rewrite H1 in Heqd. discriminate.
destruct H. rewrite H in Heqd. discriminate.
destruct H.
clear P1 P2.
specialize (C1 b ofs). specialize (C2 b ofs).
rewrite H in *.
remember (pubBlocksTgt mu b) as d.
destruct d; apply eq_sym in Heqd.
clear C1. apply C2; trivial; clear C2.
split; trivial. intros b1; intros.
destruct (pub_locBlocks _ WD _ _ _ H2).
apply pub_in_local in H2.
destruct (H1 _ _ H2). assumption. rewrite H5 in *. inv H3.
clear C2. apply C1; eauto.
Qed.
(*selected standard assumptions:*)

Lemma eff_after_check5:
forall mu pubSrc' pubTgt' nu
(NuHyp: nu = replace_locals mu pubSrc' pubTgt')
nu' mu' frgnSrc' frgnTgt'
(Mu'Hyp: mu' = replace_externs nu' frgnSrc' frgnTgt')
m1 m2 (SEP: sm_inject_separated nu nu' m1 m2),
sm_inject_separated mu mu' m1 m2.