Section TRANSLATION.
Variable prog: Csharpminor.program.
Variable tprog: Cminor.program.
Hypothesis TRANSL: transl_program prog = OK tprog.
Let ge : Csharpminor.genv := Genv.globalenv prog.
(*Let gce : compilenv := build_global_compilenv prog.*)
Let tge: genv := Genv.globalenv tprog.
Let core_data := CSharpMin_core.
(*Lenb -- meminj_preserves_globales is new, and needed since this property is now required by the simulation realtions, rather than only at/efterexternal clauses*)
Inductive match_cores: core_data -> meminj -> CSharpMin_core -> mem -> CMin_core -> mem -> Prop :=
| MC_states:
forall d fn s k e le m tfn ts tk sp te tm cenv xenv j lo hi cs sz
(TRF: transl_funbody cenv sz fn = OK tfn)
(TR: transl_stmt cenv xenv s = OK ts)
(MINJ: Mem.inject j m tm)
(MCS: match_callstack prog j m tm
(Frame cenv tfn e le te sp lo hi :: cs)
(Mem.nextblock m) (Mem.nextblock tm))
(MK: match_cont k tk  cenv xenv cs)
(PG: meminj_preserves_globals ge j),
match_cores d j (CSharpMin_State fn s k e le) m
(CMin_State tfn ts tk (Vptr sp Int.zero) te) tm
| MC_state_seq:
forall d fn s1 s2 k e le m tfn ts1 tk sp te tm cenv xenv j lo hi cs sz
(TRF: transl_funbody cenv sz fn = OK tfn)
(TR: transl_stmt cenv xenv s1 = OK ts1)
(MINJ: Mem.inject j m tm)
(MCS: match_callstack prog j m tm
(Frame cenv tfn e le te sp lo hi :: cs)
(Mem.nextblock m) (Mem.nextblock tm))
(MK: match_cont (Csharpminor.Kseq s2 k) tk cenv xenv cs)
(PG: meminj_preserves_globals ge j),
match_cores d j (CSharpMin_State fn (Csharpminor.Sseq s1 s2) k e le) m
(CMin_State tfn ts1 tk (Vptr sp Int.zero) te) tm
| MC_callstate:
forall d fd args k m tfd targs tk tm j cs cenv
(TR: transl_fundef fd = OK tfd)
(MINJ: Mem.inject j m tm)
(MCS: match_callstack prog j m tm cs (Mem.nextblock m) (Mem.nextblock tm))
(MK: match_cont k tk cenv nil cs)
(ISCC: Csharpminor.is_call_cont k)
(ARGSINJ: val_list_inject j args targs)
(PG: meminj_preserves_globals ge j),
match_cores d j (CSharpMin_Callstate fd args k) m
(CMin_Callstate tfd targs tk) tm
| MC_returnstate:
forall d v k m tv tk tm j cs cenv
(MINJ: Mem.inject j m tm)
(MCS: match_callstack prog j m tm cs (Mem.nextblock m) (Mem.nextblock tm))
(MK: match_cont k tk cenv nil cs)
(RESINJ: val_inject j v tv)
(PG: meminj_preserves_globals ge j),
match_cores d j (CSharpMin_Returnstate v k) m
(CMin_Returnstate tv tk) tm.
(*--------------------------------------------------------------------*)
(****************The following three conditions are new******************)
(****************The following three conditions are new******************)
(* In the third clause, we now stepfrom  m' to m, and also from f' to f and from tm' to tm******************)

Lemma MS_match_callstack_alloc_variables:
forall tm1 sp tm2 m1 vars e m2 cenv f1 cs fn le te,
Mem.alloc tm1 0 (fn_stackspace fn) = (tm2, sp) ->
fn_stackspace fn <= Int.max_unsigned ->
alloc_variables empty_env m1 vars e m2 ->
list_norepet (map fst vars) ->
cenv_compat cenv vars (fn_stackspace fn) ->
cenv_separated cenv vars ->
(forall id ofs, cenv!id = Some ofs -> In id (map fst vars)) ->
Mem.inject f1 m1 tm1 ->
match_callstack prog f1 m1 tm1 cs (Mem.nextblock m1) (Mem.nextblock tm1) ->
match_temps f1 le te ->
exists f2,
match_callstack prog f2 m2 tm2 (Frame cenv fn e le te sp (Mem.nextblock m1) (Mem.nextblock m2) :: cs)
(Mem.nextblock m2) (Mem.nextblock tm2)
/\ Mem.inject f2 m2 tm2
/\ (*LENB: THIS IS NEW*) inject_incr f1 f2
/\ (*LENB this clause in new in coop-sim proof*) inject_separated f1 f2 m1 tm1.