Definition Clight_semantics2 (p: program) : semantics:=
    Clight.semantics2 p.Definition Asm_semantics (tp: Asm.program) : semantics:=
    Asm.semantics tp.Definition Sems:= ClightSEM_rec.Definition Semt:= X86SEM_rec.Notation hb1:= (Some hb').Notation hb2:= (Some (S hb')).Notation C1:= (t_ (HybridMachine.ThreadPool hb1 Sems Semt)).Notation C2:= (t_ (HybridMachine.ThreadPool hb2 Sems Semt)).Notation G1:= (semG (HybridMachine.Sem hb1 Sems Semt)) .Notation G2:= (semG (HybridMachine.Sem hb2 Sems Semt)).(*The two following globals must be taken from the program...*)


  (*and they are probaly the smae global??? *)
  Definition genvS:= Clight.globalenv p.Definition genvT:= (Genv.globalenv tp).Definition genv:= (genvS, genvT).(* we extract match_source from the self_simulation of Clight*)

    Parameter Clight_core_inject: meminj -> CC_core -> CC_core -> Prop.Parameter Clight_self_simulation:
      self_simulation (Clight.semantics2 p) _ CC_core_to_CC_state.Definition code_inject_source:=
      match_self (code_inject Clight_self_simulation).Parameter Asm_core_inject: meminj -> Asm.regset -> Asm.regset -> Prop.Parameter Asm_self_simulation:
      self_simulation (Asm_semantics tp) _ (Asm.State).Definition code_inject_target:=
      match_self (code_inject Asm_self_simulation).Instance mem_Proper_match_perm_image:
      Proper (eq ==> mem_equiv ==> mem_equiv ==> iff) perm_image.Instance mem_Proper_match_perm_preimage:
      Proper (eq ==> mem_equiv ==> mem_equiv ==> iff) perm_preimage.Instance mem_Proper_match_mem:
        Proper (eq ==> mem_equiv ==> mem_equiv ==> iff) match_mem.Instance mem_Proper_code_inject_target:
      Proper (eq ==> eq ==> mem_equiv ==> eq ==> mem_equiv ==> iff) code_inject_target.Instance mem_Proper_code_inject_source:
      Proper (eq ==> eq ==> mem_equiv ==> eq ==> mem_equiv ==> iff) code_inject_source.(* Definition code_inject_source:=
      self_simulation.code_inject _ _ (Clight_self_simulation p). *)

    (* we extract match_target from the self_simulation of Asm*)
    (*Definition code_inject_target:=
      self_simulation.code_inject _  _ (Asm_self_simulation tp).*)
    Definition make_state_Clight: CC_core -> mem -> Clight.state:=
      CC_core_to_CC_state.Definition get_state_Clight c:=
      fst (CC_state_to_CC_core c).Definition make_state_Asm
              (reg: X86Machines.ErasedMachine.ThreadPool.code)
              (m: mem): ia32.Asm.state:=
      ia32.Asm.State reg m.Definition get_state_Asm (st:Asm.state): X86Machines.ErasedMachine.ThreadPool.code:=
      match st with
        Asm.State reg _ => reg
      end.Definition compiler_simulation: fsim_properties_inj ( Clight.semantics2 p) (ia32.Asm.semantics tp)
                                                        ( Clight.get_mem) (ia32.Asm.get_mem):=
    simpl_clight_semantic_preservation p tp compiled.Definition compiler_index := Injindex compiler_simulation.Definition compiler_order := Injorder compiler_simulation.Definition compiler_match := Injmatch_states compiler_simulation.Definition match_compiled_states :=
      fun i f c1 m1 c2 m2 =>
        exists c1' m1' c2' m2' f1 f12 f2,
          code_inject_source f1 c1 m1 c1' m1' /\
          compiler_match i f12 (make_state_Clight c1' m1') (make_state_Asm c2' m2') /\
          code_inject_target f2 c2 m2 c2' m2' /\
          inject_incr (compose_meminj f1 (compose_meminj f12 f2)) f.Notation source_match f st1 m1 st2 m2 :=
      (code_inject_source f st1 m1 st2 m2).Notation target_match f st1 m1 st2 m2 :=
      (code_inject_target f st1 m1 st2 m2).Definition HM1:=HybridMachine hb1 Sems Semt.Definition HM2:=HybridMachine hb2 Sems Semt.Notation Sem1:=(ConcurMachineSemantics _ _ _ HM1 U None).Notation Sem2:=(ConcurMachineSemantics _ _ _ HM2 U None) .Inductive condition: Set :=
    running | blocked | resuming | initializing.Inductive condition: Set :=
    running | blocked | resuming | initializing.Inductive condition: Set :=
    running | blocked | resuming | initializing.Inductive condition: Set :=
    running | blocked | resuming | initializing.Inductive condition: Set :=
    running | blocked | resuming | initializing.Definition get_condition {cT} (c:@ctl cT):=
    match c with
    | Krun _ => running
    | Kblocked _ => blocked
    | Kresume _ _ => resuming
    | Kinit _ _ =>  initializing
    end.Definition get_state_inside {cT} (c:@ctl cT):=
    match c with
    | Krun c => Some c
    | Kblocked c => Some c
    | Kresume c _ => Some c
    | Kinit _ _ =>  None
    end.

Lemma same_length_contains: forall {ms1: C1} {ms2: C2} {i}, num_threads ms1 = num_threads ms2 -> containsThread ms1 i -> containsThread ms2 i.