if (CCTK_Equals(evolution_system,"ADM"))
{

  schedule ADM_ParamCheck at CCTK_PARAMCHECK
  {
   LANG: C
  } "Check parameters"

  STORAGE: ADM_metric_prev,ADM_lapse_prev,ADM_curv_prev,ADM_dtlapse, ADMloop
  STORAGE: icn_group_index

  schedule ADMSetSym at CCTK_BASEGRID
  {
    LANG: Fortran
  } "Set grid function symmetries"

  schedule ADMRegisterSlicing at CCTK_STARTUP
  {
    LANG: C
  } "Register slicings"

  if (store_initial_lapse) 
  {
    STORAGE: ADM_initlapse

    schedule ADM_alp0_init at CCTK_POSTINITIAL
    {
      LANG: Fortran
    }"Save the lapse function at the initial timestep"
  }

  if (CCTK_Equals(bound,"staticrad"))
  {
    STORAGE: ADM_initlapse
    STORAGE: ADM_initial

    schedule ADM_alp0_init at CCTK_POSTINITIAL
    {
      LANG: Fortran
    }"Save the lapse function at the initial timestep"

    schedule ADM_init at CCTK_POSTINITIAL
    {
      LANG: Fortran
    }"Save initial values of variables"
  }

  if (CCTK_Equals(method,"stagleap"))
  {
        # Evolve using Staggered Leapfrog

        STORAGE: ADM_curv_stag,ADM_sources,ADM_extrap,ADM_gauge

	# ADM_Setup evaluates current slicing
        schedule ADM_Setup at CCTK_EVOL before ADM_StaggeredLeapfrog1
        {
             LANG: Fortran
        } "Setup coefficients and internal slicing flags"

	# Evolution routine1 is scheduled before everything which
	# declares itself to be an external slicing (like maximal)
        schedule ADM_StaggeredLeapfrog1 at CCTK_EVOL before ExternalLapse 
        {
             LANG: Fortran
        } "Evolve using Staggered Leapfrog (step 1)"

	# Evolution routine1 is scheduled after external slicing
        schedule ADM_StaggeredLeapfrog2 at CCTK_EVOL after ADM_StaggeredLeapfrog1 after ExternalLapse
        {
             LANG: Fortran
        } "Evolve using Staggered Leapfrog (step 2)"
  }
  else if (CCTK_Equals(method,"leapfrog"))
  { 
        # Evolve using Double Leapfrog

        STORAGE: ADM_sources,ADM_gauge

        schedule ADM_DoubleLeap at CCTK_EVOL before ExternalLapse
        {
             LANG: Fortran
        }"Evolve using Double Leapfrog"

	# Evolution routines are scheduled before everything which
	# declares itself to be an external slicing (like maximal)
        schedule ADM_Setup at CCTK_EVOL before ADM_DoubleLeap
        {
             LANG: Fortran
        } "Flagging if slicing is done externaly"

  }
  else if (CCTK_Equals(method,"icn"))
  {     
        # Evolve using Iterative Crank-Nicholson

        STORAGE: ADM_sources,ADM_gauge

        schedule ADM_ICN_init at CCTK_EVOL before ICN_LOOP 
        {
          LANG: Fortran
        } "Initialize ICN"

        schedule ADM_IterativeCN in ICN_LOOP before ExternalLapse
        {
             LANG: Fortran
        }"Evolve using Iterative Crank-Nicholson" 

        schedule ADM_Setup at CCTK_EVOL before ICN_LOOP
        {
             LANG: Fortran
        } "Slicing is done externally"

        schedule GROUP ICN_LOOP while adm::icn_iteration AT CCTK_EVOL
        {
        } "Iterative Crank-Nicholson Loop"
  
  }
}