// **************************************************************
// p2_deco.c							REFACTORED VERSION	V2.95
//																			!!  SPECIAL TESTING VERSION - DO NOT USE FOR REAL DIVES  !!
//  Created on: 12.05.2009													===========================================================
//  Author: chsw															->  This version shows the alternative (bailout) stops   <-
//																			->    instead of the stop from the normal dive plan.     <-
// **************************************************************

//////////////////////////////////////////////////////////////////////////////
// OSTC - diving computer code
// Copyright (C) 2011 HeinrichsWeikamp GbR
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//////////////////////////////////////////////////////////////////////////////

// *****************************
// ** I N T R O D U C T I O N **
// *****************************
//
// OSTC
//
// code:
// p2_deco.c
// part2 of the OSTC code
//
// summary:
// decompression routines
// for the OSTC experimental project
// written by Christian Weikamp
// contributions by Ralph Lembcke
//
//
// history:
// 01/03/08 v100: first release candidate
// 03/13/08 v101: start of programming ppO2 code
// 03/13/25 v101a: backup of interim version with ppO2 calculation
// 03/13/25 v101: open circuit gas change during deco
// 03/13/25 v101: CNS_fraction calculation
// 03/13/26 v101: optimization of tissue calc routines
// 07/xx/08 v102a: debug of bottom time routine
// 09/xx/08 v102d: Gradient Factor Model implementation
// 10/10/08 v104: renamed to build v103 for v118 stable
// 10/14/08	v104: integration of char_I_depth_last_deco for Gradient Model
// 03/31/09 v107: integration of FONT Incon24
// 05/23/10 v109: 5 gas changes & 1 min timer
// 07/13/10 v110: cns vault added
// 12/25/10 v110: split in three files (deco.c, main.c, definitions.h)
// 2011/01/20: [jDG] Create a common file included in ASM and C code.
// 2011/01/24: [jDG] Make ascenttime an short. No more overflow!
// 2011/01/25: [jDG] Fusion deco array for both models.
// 2011/01/25: [jDG] Use CF(54) to reverse deco order.
// 2011/02/11: [jDG] Reworked gradient-factor implementation.
// 2011/02/15: [jDG] Fixed inconsistencies introduced by gas switch delays.
// 2011/03/21: [jDG] Added gas consumption (CF56 & CF57) evaluation for OCR mode.
// 2011/04/15: [jDG] Store low_depth in 32bits (w/o rounding), for a better stability.
// 2011/04/25: [jDG] Added 1mn mode for CNS calculation, to allow it for deco planning.
// 2011/04/27: [jDG] Fixed char_O_gradient_factor calculation when model uses gradient-factor.
// 2011/05/02: [jDG] Added "Future TTS" function (CF58).
// 2011/05/17: [jDG] Various cleanups.
// 2011/08/08: [jDG] Computes CNS during deco planning ascent.
// 2011/11/24: [jDG] Slightly faster and better NDL computation.
// 2011/12/17: [mH]  Remove of the useless debug stuff
// 2012/02/24: [jDG] Remove missed stop bug.
// 2012/02/25: [jDG] Looking for a more stable LOW grad factor reference.
// 2012/09/10: [mH]  Fill char_O_deco_time_for_log for logbook write
// 2012/10/05: [jDG] Better gas_volumes accuracy (average depth, switch between stop).
// 2013/03/05: [jDG] Should vault low_depth too.
// 2013/03/05: [jDG] Wrobell remark: ascent_to_first_stop works better with finer steps (2sec).
// 2013/05/08: [jDG] A. Salm remark: NOAA tables for CNS are in ATA, not bar.
// 2013/12/21: [jDG] Fix CNS calculation in deco plan w/o marked gas switch
// 2014/06/16: [jDG] Fix Helium diluent. Fix volumes with many travel mix.
// 2014/06/29: [mH]  Compute int_O_ceiling
// 2015/06/12: [jDG] Fix NDL prediction while desaturating with the Buhlmann model.
// 2017/08/04: [mH]  Switch to absolute GF everywhere and apply safety margin parameters to both models (GF and non-GF), fixes from Ralph Lembcke
// 2017/10/31: [rl]  enhancements for pSCR mode and introduction of 2nd deco plan computation
// 2017/12/31: [rl]  completion of 2nd deco plan computation and various up-fixes
//
//
// Literature:
// Buhlmann, Albert: Tauchmedizin; 4. Auflage [2002];
// Schr"oder, Kai & Reith, Steffen; 2000; S"attigungsvorg"ange beim Tauchen, das Modell ZH-L16, Funktionsweise von Tauchcomputern; http://www.achim-und-kai.de/kai/tausim/saett_faq
// Morrison, Stuart; 2000; DIY DECOMPRESSION; http://www.lizardland.co.uk/DIYDeco.html
// Balthasar, Steffen; Dekompressionstheorie I: Neo Haldane Modelle; http://www.txfreak.de/dekompressionstheorie_1.pdf
// Baker, Erik C.; Clearing Up The Confusion About "Deep Stops"
// Baker, Erik C.; Understanding M-values; http://www.txfreak.de/understanding_m-values.pdf
//
//

// *********************
// ** I N C L U D E S **
// *********************
#include <math.h>

// ***********************************************
// ** V A R I A B L E S   D E F I N I T I O N S **
// ***********************************************

#include "p2_definitions.h"
#define  TEST_MAIN
#include "shared_definitions.h"


// ambient pressure at different mountain heights
#define P_ambient_1000m					0.880	// [bar]  based on 990 hPa and 20°C at sea level, 15°C at altitude
#define P_ambient_2000m					0.782	// [bar]
#define P_ambient_3000m					0.695	// [bar]

// ambient pressure in aircraft cabin during flying - worst case according to Buhlmann
#define P_ambient_fly					0.600	// [bar], 0.600 bar is the value used by Buhlmann for his flying-after-diving calculations
												//		  0.735 bar is a typical cabin pressure for nowadays commercial jet aircrafts
												//        -----
												//        0.135 bar safety margin

// constants and factors
#define ppWater        					0.0627	// water vapor partial pressure in the lungs
#define METER_TO_BAR   					0.09985	// conversion factor
#define BAR_TO_METER   					10.0150	// conversion factor (1.0/METER_TO_BAR)						
#define SURFACE_DESAT_FACTOR    		0.7042	// surface desaturation safety factor
#define HYST							1.0E-06	// threshold for tissue graphics on-gassing / off-gassing visualization

// thresholds
#define GF_warning_threshold			100		// threshold for GF   warning
#define GF_prewarning_threshold			 70		// threshold for GF   attention
#define CNS_warning_threshold			100		// threshold for CNS  warning
#define CNS_prewarning_threshold		 70		// threshold for CNS  attention
#define ppO2_prewarn_threshold			120		// threshold for ppO2 attention (master warnings come through options_table.asm)
#define GAS_NEEDS_ATTENTION_THRESHOLD	0.70	// threshold for gas needs attention

// deco engine states and modes
#define DECO_STATUS_MASK				0x03
#define DECO_STATUS_START				0x00
#define DECO_STATUS_FINISHED			0x00
#define DECO_STATUS_STOPS				0x01 
#define DECO_STATUS_ASCENT				0x02
#define DECO_STATUS_INIT				0x03

#define DECO_MODE_MASK					0x0C
#define DECO_MODE_LOOP					0x04
#define DECO_MODE_CCR					0x04	// to be used with == operator in combination with DECO_MODE_MASK only!
#define DECO_MODE_PSCR					0x08

#define DECO_PLAN_ALTERNATE				0x10
#define DECO_CNS_CALCULATE 				0x20
#define DECO_VOLUME_CALCULATE	 		0x40
#define DECO_ASCENT_DELAYED 			0x80

// deco engine warnings
#define	DECO_WARNING_IBCD				0x01
#define	DECO_WARNING_IBCD_lock			0x02
#define	DECO_WARNING_MBUBBLES 			0x04
#define	DECO_WARNING_MBUBBLES_lock		0x08
#define	DECO_WARNING_OUTSIDE			0x10
#define	DECO_WARNING_OUTSIDE_lock		0x20
#define DECO_WARNING_STOPTABLE_OVERFLOW	0x40
#define DECO_FLAG						0x80

// flags used with integer numbers
#define INT_FLAG_INVALID				0x0400
#define INT_FLAG_ZERO					0x0800
#define INT_FLAG_LOW					0x1000
#define	INT_FLAG_HIGH					0x2000
#define INT_FLAG_PREWARNING				0x4000
#define	INT_FLAG_WARNING				0x8000



// *************************
// ** P R O T O T Y P E S **
// *************************

static void calc_hauptroutine(void);
static void calc_hauptroutine_data_input(void);
static void calc_hauptroutine_update_tissues(void);
static void calc_hauptroutine_calc_deco(void);
static void calc_tissue(void);
static void calc_limit(void);
static void calc_nullzeit(void);
static void calc_ascenttime(void);
static void calc_dive_interval(void);
static void calc_gradient_factor(void);
static void calc_wo_deco_step_1_min(void);
static void calc_desaturation_time(void);

static void sim_extra_time(void);
static void sim_ascent_to_first_stop(void);
static void sim_limit(PARAMETER float GF_current);

static void update_startvalues(void);
static void gas_switch_set(void);
static void compute_CNS_for_display(void);

static void clear_deco_table(void);
static void clear_tissue(void);

static unsigned char gas_find_better(void);
static unsigned char calc_nextdecodepth(void);
static unsigned char update_deco_table(PARAMETER unsigned char time_increment);


//---- Bank 5 parameters -----------------------------------------------------
#ifndef UNIX
#   pragma udata bank5=0x500
#endif

// general deco parameters

static float			GF_low;							// initialized from deco parameters, constant during all computations
static float			GF_high;						// initialized from deco parameters, constant during all computations
static float			GF_delta;						// initialized from deco parameters, constant during all computations
static float			locked_GF_step_norm;			// GF_delta / low_depth_norm in normal plan
static float			locked_GF_step_alt;				// GF_delta / low_depth_alt  in alternative plan

static float			low_depth_norm;					// Depth of deepest stop in normal plan
static float			low_depth_alt;					// Depth of deepest stop in alternative plan

static float			float_ascent_speed;				// ascent speed from options_table (1.0 .. 10.0 m/min)
static float			float_saturation_multiplier;    // safety factor for on-gassing rates
static float			float_desaturation_multiplier;  // safety factor for off-gassing rates
static float			float_deco_distance;            // additional depth below stop depth for tissue, CNS and gas volume calculation


// real context: what we are doing now.

static float			calc_lead_tissue_limit;     	// minimum tolerated ambient pressure by Buhlmann model
static float			CNS_fraction;                   // current CNS (1.00 = 100%)

static unsigned short	deco_tissue_vector;				// 32 bit vector to memories all tissues that are in decompression
static unsigned short	IBCD_tissue_vector;				// 32 bit vector to memories all tissues that experience IBCD

// simulation context: used to predict ascent.

static float			sim_lead_tissue_limit;			// minimum tolerated ambient pressure by Buhlmann model
static float			CNS_sim_norm_fraction;			// CNS at end of dive in normal plan
static float			CNS_sim_alt_fraction;			// CNS at end of dive in alternative plan

static unsigned char	temp_depth_limit;				// depth of next stop in meters, used in deco calculations
static unsigned char	sim_lead_tissue_no;				// Leading compartment number
static unsigned char	split_N2_He[NUM_COMP];			// used for calculating the desaturation time


// stops table

static unsigned char	internal_deco_depth[NUM_STOPS];	// depth of the stop
static unsigned char	internal_deco_time[NUM_STOPS];	// duration of the stop
static unsigned char	internal_deco_gas[NUM_STOPS];	// gas used at the stop


// transfer variables between calc_desaturation_time() and calc_desaturation_time_helper()

static float			desat_factor;					// used to cache a pre-computed factor
static float			var_ht;							// buffer for a half-time factor
static float 			pres_target;					// target pressure for a compartment
static float			pres_actual;					// current pressure of the compartment
static unsigned short	short_time;						// time it takes for the compartment to reach the target pressure

// transfer variables between gas_volumes() and gas_volumes_helper()
static float			float_depth;					// depth of the stop or half-way point
static float			float_time;						// duration of the stop or ascent phase
static float			volume;							// computed volume of gas
static unsigned char	usage;							// gas usage in l/min


// 44 byte free space left in this bank


//---- Bank 6 parameters -----------------------------------------------------
#ifndef UNIX
#   pragma udata bank6=0x600
#endif

// indexing and sequencing

static unsigned char	ci;								// used as index to the Buhlmann tables
static unsigned char	twosectimer = 0;				// used for timing the tissue updating
static unsigned char	tissue_increment;				// Selector for real/simulated tissues and time increment


// environmental and gas data

static float            pres_respiration;				// current depth in absolute pressure
static float            pres_surface;					// absolute pressure at the surface
static float            temp_deco;						// simulated current depth in abs.pressure, used for deco calculations

static float            O2_ratio;                       // real breathed gas oxygen ratio
static float            N2_ratio;                       // real breathed gas nitrogen ratio
static float            He_ratio;                       // real breathed gas helium ratio

static float			calc_O2_ratio;					// simulated breathed gas oxygen ratio
static float			calc_N2_ratio;                  // simulated breathed gas nitrogen ratio
static float			calc_He_ratio;                  // simulated breathed gas helium ratio

static float			O2_ppO2;						// ppO2 - calculated for pure oxygen at current depth
static float			pSCR_ppO2;						// ppO2 - calculated for breathed from pSCR loop
static float			pure_ppO2;						// ppO2 - calculated for breathed in OC mode

static unsigned char	char_actual_ppO2;				// ppO2 - assumed to be breathed, as integer 100 = 1.00 bar

static float			breathed_ppO2;					// partial pressure of breathed oxygen
static float            ppN2;							// partial pressure of breathed nitrogen
static float            ppHe;							// partial pressure of breathed helium


// Buhlmann model parameters

static float            var_N2_a;                       // Buhlmann a, for current N2 tissue
static float            var_N2_b;                       // Buhlmann b, for current N2 tissue
static float            var_He_a;                       // Buhlmann a, for current He tissue
static float            var_He_b;                       // Buhlmann b, for current He tissue
static float            var_N2_e;                       // exposition, for current N2 tissue
static float            var_He_e;                       // exposition, for current He tissue
static float            var_N2_ht;                      // half-time for current N2 tissue
static float            var_He_ht;                      // half-time for current N2 tissue


// gas switch history

static unsigned char	sim_gas_first_used;				// Number of first used gas, for bottom segment
static unsigned char    sim_gas_last_used;              // number of last  used gas
static unsigned char    sim_gas_last_depth;             // change depth of last used gas


// vault to back-up & restore tissue data

static float			pres_tissue_N2_vault[NUM_COMP];	// stores the nitrogen tissue pressures
static float			pres_tissue_He_vault[NUM_COMP];	// stores the helium tissue pressures
static float			low_depth_norm_vault;			// stores a parameter of the GF model for normal plan
static float			low_depth_alt_vault;			// stores a parameter of the GF model for alternative plan
static float			cns_vault_float;				// stores current CNS (float representation)

static unsigned int		cns_vault_int;					// stores current CNS (integer representation)
static unsigned char	deco_warnings_vault;			// stores warnings status


// auxiliary variables for local data buffering

static float 			N2_equilibrium;					// used for N2 tissue graphics scaling
static float            temp_tissue;					// auxiliary variable to buffer tissue pressures


// 7 byte free space left in this bank


//---- Bank 7 parameters -----------------------------------------------------
#ifndef UNIX
#   pragma udata bank7=0x700
#endif

// Keep order and position of the variables in bank 7 as they are backed-up to & restored from EEPROM 

float					pres_tissue_N2[NUM_COMP];		// 16 floats = 64 bytes
float					pres_tissue_He[NUM_COMP];		// 16 floats = 64 bytes
float					sim_pres_tissue_N2[NUM_COMP];	// 16 floats = 64 bytes
float					sim_pres_tissue_He[NUM_COMP];	// 16 floats = 64 bytes


//---- Bank 8 parameters -----------------------------------------------------
#ifndef UNIX
#   pragma udata overlay bank8=0x800

static char	  md_pi_subst[256];				// Overlay C-code data stack here, too.

#   define C_STACK md_pi_subst
#endif

// Back to bank6 for further tmp data
#ifndef UNIX
#   pragma udata bank6
#endif

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
///////////////////////////// THE LOOKUP TABLES //////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// End of PROM code is 17F00, So push tables on PROM top...
//
#ifndef UNIX
#   pragma romdata Buhlmann_tables = 0x1DD00  // Needs to be in UPPER bank.
#endif

rom const float Buhlmann_ab[4*16] = {
// Data ZH-L16C, from Bühlmann Tauchmedizin 2002, option 1a (4mn)
// a for N2    b for N2     a of He     b for He
	1.2599,     0.5050,     1.7424,     0.4245,
	1.0000,     0.6514,     1.3830,     0.5747,
	0.8618,     0.7222,     1.1919,     0.6527,
	0.7562,     0.7825,     1.0458,     0.7223,
	0.6200,     0.8126,     0.9220,     0.7582,
	0.5043,     0.8434,     0.8205,     0.7957,
	0.4410,     0.8693,     0.7305,     0.8279,
	0.4000,     0.8910,     0.6502,     0.8553,
	0.3750,     0.9092,     0.5950,     0.8757,
	0.3500,     0.9222,     0.5545,     0.8903,
	0.3295,     0.9319,     0.5333,     0.8997,
	0.3065,     0.9403,     0.5189,     0.9073,
	0.2835,     0.9477,     0.5181,     0.9122,
	0.2610,     0.9544,     0.5176,     0.9171,
	0.2480,     0.9602,     0.5172,     0.9217,
	0.2327,     0.9653,     0.5119,     0.9267
};

rom const float Buhlmann_ht[2*16] = {
// Compartment half-life, in minute
//--- N2 ---- He ----------------------
	  4.0,    1.51,
	  8.0,    3.02,
	 12.5,    4.72,
	 18.5,    6.99,
	 27.0,   10.21,
	 38.3,   14.48,
	 54.3,   20.53,
	 77.0,   29.11,
	109.0,   41.20,
	146.0,   55.19,
	187.0,   70.69,
	239.0,   90.34,
	305.0,  115.29,
	390.0,  147.42,
	498.0,  188.24,
	635.0,  240.03
};

rom const float e2secs[2*16] = {
// result of  1 - 2^(-1/(2sec*HT))
//---- N2 ------------- He ------------
	5.75958E-03,    1.51848E-02,  
	2.88395E-03,    7.62144E-03,
	1.84669E-03,    4.88315E-03,
    1.24813E-03,    3.29997E-03,
    8.55371E-04,    2.26041E-03,
    6.03079E-04,    1.59437E-03,
    4.25414E-04,    1.12479E-03,
    3.00019E-04,    7.93395E-04,
    2.11949E-04,    5.60641E-04,
    1.58240E-04,    4.18555E-04,
    1.23548E-04,    3.26795E-04,
    9.66686E-05,    2.55722E-04,
    7.57509E-05,    2.00387E-04,
    5.92416E-05,    1.56716E-04,
    4.63943E-05,    1.22734E-04,
    3.63850E-05,    9.62538E-05
//-------------------------------------
};

rom const float e1min[2*16] = {
// Integration constant for 1 minute,
// Ie. 1- 2^(-1/HT)
//----- N2 --------- e 1min He --------
	1.59104E-01,    3.68109E-01,  	
    8.29960E-02,   	2.05084E-01,     
    5.39424E-02,    1.36579E-01,
    3.67742E-02,    9.44046E-02,
    2.53454E-02,    6.56359E-02,
    1.79351E-02,    4.67416E-02,
    1.26840E-02,    3.31991E-02,
    8.96152E-03,    2.35301E-02,
    6.33897E-03,    1.66832E-02,
    4.73633E-03,    1.24808E-02,
    3.69981E-03,    9.75753E-03,
    2.89600E-03,    7.64329E-03,
    2.27003E-03,    5.99417E-03,
    1.77572E-03,    4.69082E-03,
    1.39089E-03,    3.67548E-03,
    1.09097E-03,    2.88359E-03
//-------------------------------------
};

rom const float e10min[2*16] = {
// The 10 min Value in float notation:
//  result of 1 - 2^(-10/ht)
//---- N2 -------------- He -----------
	8.23223E-01,    9.89851E-01,  
	5.79552E-01,  	8.99258E-01,
    4.25651E-01,    7.69737E-01,
    3.12487E-01,    6.29027E-01,
    2.26416E-01,    4.92821E-01,
    1.65547E-01,    3.80407E-01,
    1.19840E-01,    2.86538E-01,
    8.60863E-02,    2.11886E-01,
    6.16117E-02,    1.54849E-01,
    4.63665E-02,    1.18026E-01,
    3.63881E-02,    9.34005E-02,
    2.85855E-02,    7.38569E-02,
    2.24698E-02,    5.83504E-02,
    1.76160E-02,    4.59303E-02,
    1.38222E-02,    3.61528E-02,
    1.08563E-02,    2.84646E-02
//-------------------------------------
};

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
////////////////////////////// THE SUBROUTINES ///////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// all new in v.102
// moved from 0x0D000 to 0x0C000 in v.108
#ifndef UNIX
#   pragma code p2_deco = 0x0C000
#endif

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
///////////////////////  U T I L I T I E S   /////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// Bump to blue-screen when an assert is wrong
#ifdef __DEBUG
void assert_failed(PARAMETER short int line)
{
}
#endif

//////////////////////////////////////////////////////////////////////////////
// When calling C code from ASM context, the data stack pointer and
// frames should be reset. Bank8 is used by stack

#ifdef CROSS_COMPILE
#       define RESET_C_STACK
#else
#   ifdef __DEBUG
#       define RESET_C_STACK fillDataStack();
        void fillDataStack(void)
        {
            _asm
                LFSR    1,C_STACK
                MOVLW   0xCC
        loop:   MOVWF   POSTINC1,0
                TSTFSZ  FSR1L,0
                BRA     loop

                LFSR    1,C_STACK
                LFSR    2,C_STACK
            _endasm
        }
#   else
#       define RESET_C_STACK    \
        _asm                    \
            LFSR    1, C_STACK  \
            LFSR    2, C_STACK  \
        _endasm
#   endif
#endif

//////////////////////////////////////////////////////////////////////////////
// Fast subroutine to read timer 5.
// Note: result is in 1/32 of milliseconds (30,51757813 us/bit to be precise)
static unsigned short tmr5(void)
{
#ifndef CROSS_COMPILE
    _asm
        movff   0xf7c,PRODL     // TMR5L
        movff   0xf7d,PRODH     // TMR5H
    _endasm                     // result in PRODH:PRODL.
#else
    return 0;
#endif
}

//////////////////////////////////////////////////////////////////////////////
// read Buhlmann tables A and B for compartment ci
//
static void read_Buhlmann_coefficients(void)
{
#ifndef CROSS_COMPILE
    // Note: we don't use far rom pointer, because the
    //       24 bits is too complex, hence we have to set
    //       the UPPER page ourself...
    //       --> Set zero if tables are moved to lower pages !
    _asm
        movlw 1
        movwf TBLPTRU,0
    _endasm
#endif

    assert( ci < NUM_COMP );

    // Use an interleaved array (AoS) to access coefficients with a
    // single addressing.
    {
        overlay rom const float* ptr = &Buhlmann_ab[4*ci];
        var_N2_a = *ptr++;
        var_N2_b = *ptr++;
        var_He_a = *ptr++;
        var_He_b = *ptr++;
    }
}

//////////////////////////////////////////////////////////////////////////////
// read Buhlmann tables for compartment ci
// If period == 0 : 2sec interval
//              1 : 1 min interval
//              2 : 10 min interval.
static void read_Buhlmann_times(PARAMETER char period)
{
#ifndef CROSS_COMPILE
    // Note: we don't use far rom pointer, because the
    //       24 bits is to complex, hence we have to set
    //       the UPPER page ourself...
    //       --> Set zero if tables are moved to lower pages !
    _asm
        movlw 1
        movwf TBLPTRU,0
    _endasm
#endif

    assert( ci < NUM_COMP );

    // Integration intervals.
    switch(period)
    {
    case 0: //---- 2 sec -----------------------------------------------------
        {
            overlay rom const float* ptr = &e2secs[2*ci];
            var_N2_e = *ptr++;
            var_He_e = *ptr++;
        }
        break;

    case 1: //---- 1 min -----------------------------------------------------
       {
            overlay rom const float* ptr = &e1min[2*ci];
            var_N2_e = *ptr++;
            var_He_e = *ptr++;
        }
        break;

    case 2: //---- 10 min ----------------------------------------------------
        {
            overlay rom const float* ptr = &e10min[2*ci];
            var_N2_e = *ptr++;
            var_He_e = *ptr++;
        }
        break;

    default:
        assert(0);  // Never go there...
    }
}

//////////////////////////////////////////////////////////////////////////////
// read Buhlmann tables for compartment ci
//
static void read_Buhlmann_ht(void)
{

#ifndef CROSS_COMPILE
    // Note: we don't use far rom pointer, because the
    //       24 bits is to complex, hence we have to set
    //       the UPPER page ourself...
    //       --> Set zero if tables are moved to lower pages !
    _asm
        movlw 1
        movwf TBLPTRU,0
    _endasm
#endif

    assert( ci < NUM_COMP );
    {
        overlay rom const float* ptr = &Buhlmann_ht[2*ci];
        var_N2_ht = *ptr++;
        var_He_ht = *ptr++;
    }

    assert( 4.0    <= var_N2_ht && var_N2_ht <= 635.0 );
    assert( 1.5099 <= var_He_ht && var_He_ht <= 240.03 );
}

//////////////////////////////////////////////////////////////////////////////
// calc_nextdecodepth
//
// new in v.102
//
// INPUT, changing during dive:
//      temp_deco : current depth in absolute pressure
//
// INPUT, fixed during dive:
//      pres_surface
//      GF_delta
//      GF_high
//      GF_low
//      char_I_depth_last_deco
//
// MODIFIED
//      locked_GF_step_norm/_alt : used for GF model
//      low_depth_norm/_alt      : used for GF model
//
// OUTPUT
//      temp_depth_limit : depth of next stop in meters        (if RETURN == true )
//                         depth we can ascent to without stop (if RETURN == false)
//
// RETURN TRUE if a stop is needed.
//
static unsigned char calc_nextdecodepth(void)
{
    overlay unsigned char need_stop;
	
	// compute current depth in meters
    overlay float depth = (temp_deco - pres_surface) * BAR_TO_METER;

    // compute depth in meters after 1 minute of ascent at float_ascent_speed (5..10 m/min)
    overlay float min_depth = (depth > float_ascent_speed) ? (depth - float_ascent_speed) : 0.0;

	
	 // allow for 200mbar of weather dependent surface pressure change
    assert( depth >= -0.2 );       


	//---- check if a stop is needed for deco reasons ----------------------------
	
    // switch on deco model
    if( char_I_deco_model != 0 )
    {
		//---- ZH-L16 + GRADIENT FACTOR Model ------------------------------------
		
		overlay float locked_GF_step;
		overlay float low_depth;
		overlay float pres_gradient;

        overlay unsigned char first_stop = 0;
		
				
		// calculate minimum depth we can ascent to in absolute pressure
        sim_limit( GF_low );
		
		// ...and convert the depth into relative pressure
        pres_gradient = sim_lead_tissue_limit - pres_surface;	

		// check if we can surface directly
        if( pres_gradient <= 0.0 )
		{
			min_depth = 0.0;		// set minimum depth to 0 meters = surface
			goto no_deco_stop;		// done.
		}

		// convert minimum depth we can ascent to from relative pressure to depth in meters
        pres_gradient *= BAR_TO_METER;							

		// recall low_depth dependent on current plan
		low_depth = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? low_depth_alt : low_depth_norm;
		
        // Store the deepest point needing a deco stop as the LOW reference for GF.
        // NOTE: following stops will be validated using this LOW-HIGH GF scale,
        //       so if we want to keep coherency, we should not validate this stop
        //       yet, but apply the search to it, as for all the following stops afterward.
        if( pres_gradient > low_depth )
        {
			// update GF parameters
            low_depth      = pres_gradient;
            locked_GF_step = GF_delta / low_depth;
			
			// store updated GF parameters dependent on current plan
			if( char_O_deco_status & DECO_PLAN_ALTERNATE )
			{
				low_depth_alt       = low_depth;
				locked_GF_step_alt  = locked_GF_step;
			}
			else
			{
				low_depth_norm      = low_depth;
				locked_GF_step_norm = locked_GF_step;
			}
        }
		else
		{
			// recall locked_GF_step dependent on current plan
			locked_GF_step = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? locked_GF_step_alt : locked_GF_step_norm;
		}

		// invalidate this stop if we can ascent for 1 minute without going above minimum required deco depth
        if( pres_gradient < min_depth ) goto no_deco_stop;         

		
		// if program execution passes here, we need a deco stop
		
        // Round to multiple of 3 meters
        first_stop = 3 * (unsigned char)(0.9995 + pres_gradient * 0.333333);

		// check a constraint
        assert( first_stop < 128 );

        // apply correction for the shallowest stop, use char_I_depth_last_deco (3..6 m) instead
        if( first_stop == 3 ) first_stop = char_I_depth_last_deco;

        // We have a stop candidate.
        // But maybe ascending to the next stop will diminish the constraint,
        // because the GF might decrease more than the pressure gradient...
        while(first_stop > 0)
        {
			// Next depth
            overlay unsigned char next_stop;            

            // invalidate this stop if we can ascent one more minute without going above minimum required deco depth
            if( first_stop <= (unsigned char)min_depth ) goto no_deco_stop;

			// compute depth of next stop
            if      ( first_stop <= char_I_depth_last_deco ) next_stop = 0;
            else if ( first_stop == 6                      ) next_stop = char_I_depth_last_deco;
            else                                             next_stop = first_stop - 3;

            // compute total pressure at the new stop candidate
            pres_gradient = next_stop * METER_TO_BAR + pres_surface;

            // compute limit for the new stop candidate
            if( (low_depth == 0.0) || (next_stop > low_depth) ) sim_limit( GF_low );
            else                                                sim_limit( GF_high - next_stop * locked_GF_step );

            // check if ascent to the next stop candidate is possible
            if( sim_lead_tissue_limit >= pres_gradient ) goto deco_stop_found;	// no - ascent to next_stop forbidden

            // else, validate that stop and loop...
            first_stop = next_stop;
        }

no_deco_stop:
		need_stop        = 0;              				// set flag for stop needed to 'no'
		temp_depth_limit = (unsigned char)min_depth;	// report depth we can ascent to without stop
		goto done;

deco_stop_found:
		need_stop        = 1;              				// set flag for stop needed to 'yes'
		temp_depth_limit = (unsigned char)first_stop;	// stop depth, in meters

done:
        ;
    }
    else
    {
		//---- ZH-L16 model -------------------------------------------------
		
        overlay float pres_gradient;

		
        // calculate minimum depth we can ascent to in absolute pressure
        sim_limit(1.0);

		// ...and convert the depth into relative pressure 
        pres_gradient = sim_lead_tissue_limit - pres_surface;

		// check if we can surface directly
        if (pres_gradient >= 0)
        {
			// no - set flag for stop needed to 'yes'
            need_stop = 1;

			// convert stop depth in relative pressure to stop index
            pres_gradient *= BAR_TO_METER / 3;

			// convert stop index to depth in meters, rounded to multiple of 3 meters
            temp_depth_limit = 3 * (short) (pres_gradient + 0.99);

            // correct last stop to 4m/5m/6m
            if( temp_depth_limit == 3 ) temp_depth_limit = char_I_depth_last_deco;
        }
        else
		{
			// yes - set flag for stop needed to 'no'
			need_stop        = 0;
			
			// set depth we can ascent to as 0 = surface
            temp_depth_limit = 0;
		}
    }

	
	// After the first deco stop, gas changes are only done at deco stops now!
	
	// check if a stop is found and there is a better gas to switch to
	if( need_stop && gas_find_better() )
	{
		// set the new calculation ratios for N2, He and O2
		gas_switch_set();

		// prime the deco stop with the gas change time
		update_deco_table(char_I_gas_change_time); 
	}

    return need_stop;
}

//////////////////////////////////////////////////////////////////////////////
// copy_deco_table
//
// Buffer the stops, once computed, so we can continue to display them
// while computing the next set.
//
static void copy_deco_table(void)
{
    // Copy depth of the first (deepest) stop, because when reversing
    // order, it will be hard to find...
    char_O_first_deco_depth = internal_deco_depth[0];
    char_O_first_deco_time  = internal_deco_time [0];

    {
        overlay unsigned char x, y;

        for(x=0; x<NUM_STOPS; x++)
        {
            char_O_deco_depth[x] = internal_deco_depth[x];
            char_O_deco_time [x] = internal_deco_time [x];
            char_O_deco_gas  [x] = internal_deco_gas  [x];
        }

        //Now fill the char_O_deco_time_for_log array
        //---- First: search the first non-null depth
        for(x=(NUM_STOPS-1); x != 0; --x)
            if( internal_deco_depth[x] != 0 ) break;

        //---- Second: copy to output table (in reverse order)
        for(y=0; y<NUM_STOPS; y++, --x)
        {
            char_O_deco_time_for_log[y] = internal_deco_time [x];

            // Stop only once the last transfer is done.
            if( x == 0 ) break;
        }

        //---- Third: fill table end with null
        for(y++; y<NUM_STOPS; y++)
        {
            char_O_deco_time_for_log[y] = 0;
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// temp_tissue_safety
//
// outsourced in v.102
//
// Apply safety factors for both ZH-L16 models.
//
static void temp_tissue_safety(void)
{
    assert( 0.0 <  float_desaturation_multiplier && float_desaturation_multiplier <= 1.0 );
    assert( 1.0 <= float_saturation_multiplier   && float_saturation_multiplier   <= 2.0 );

	if( temp_tissue < 0.0 ) temp_tissue *= float_desaturation_multiplier;
	else                    temp_tissue *= float_saturation_multiplier;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// ** THE JUMP-IN CODE **
// ** for the asm code **
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// Called every second during diving.
// updates tissues every second invocation.
//
// Every few seconds (or slower when TTS > 16):
//    - updates deco table (char_O_deco_time/depth) with new values.
//    - updates ascent time,
//    - sets status to zero (so we can check there is new results).
//
void deco_calc_hauptroutine(void)
{
    RESET_C_STACK
    calc_hauptroutine();
}

//////////////////////////////////////////////////////////////////////////////
// Reset decompression model:
// + Set all tissues to equilibrium with Air at ambient pressure.
// + Reset last stop to 0m
// + Reset all model output.
void deco_clear_tissue(void)
{
    RESET_C_STACK
    clear_tissue();
}

//////////////////////////////////////////////////////////////////////////////

void deco_calc_wo_deco_step_1_min(void)
{
    RESET_C_STACK
    calc_wo_deco_step_1_min();
 }

//////////////////////////////////////////////////////////////////////////////

void deco_calc_desaturation_time(void)
{
    RESET_C_STACK
    calc_desaturation_time();
}

//////////////////////////////////////////////////////////////////////////////

void deco_calc_dive_interval(void)
{
    RESET_C_STACK
    calc_dive_interval();
}

//////////////////////////////////////////////////////////////////////////////
// Find current gas in the list (if any) and get its change depth
//
// Input:  char_I_current_gas : 1..6
//
// Output: sim_gas_last_used  : 1..6 or 0 if it is the gas set as FIRST
//         sim_gas_last_depth : change depth in meters or 0 if it is the gas set as FIRST
//
static void gas_find_current(void)
{
    assert( 0 <= char_I_current_gas && char_I_current_gas <= NUM_GAS );

    if( char_I_current_gas <= NUM_GAS )					// Gas1..Gas5
    {
        sim_gas_last_used = sim_gas_first_used = char_I_current_gas;

        // If current gas is a deco gas get it's change depth.
		// Set change depth to 0 if the current gas is the first gas or 
		// a travel/normal gas, i.e. if it can be breathed at "any" depth.
        if( char_I_deco_gas_change[sim_gas_last_used-1] ) sim_gas_last_depth = char_I_deco_gas_change[sim_gas_last_used-1];
		else                                              sim_gas_last_depth = 0;
    }
    else
	{
        sim_gas_last_used = sim_gas_first_used = 0;		// Gas 6 (the manually set one) has number 0 here
		sim_gas_last_depth                     = 0;		// handle it as a travel/normal gas
	}
}


//////////////////////////////////////////////////////////////////////////////
// Find the deco gas with the shallowest change depth beyond current depth
//
// INPUT   temp_depth_limit	        : current depth in meters
//         char_I_deco_gas_change[] : change depths of the deco gases
//		   sim_gas_last_depth       : change depth of the currently used gas, 0 if on the gas set as FIRST
//
// OUTPUT  sim_gas_last_depth       : switch depth            - only if return value is true
//         sim_gas_last_used        : index of the gas (1..5) - only if return value is true
//
// RETURNS TRUE if a better gas is available
//
static unsigned char gas_find_better(void)
{
	overlay unsigned char switch_depth = 255;
	overlay unsigned char switch_gas   = 0;
	overlay unsigned char j;
	
	
	// no automatic gas changes in CCR mode and - as of now - in pSCR mode
	if( char_O_deco_status & DECO_MODE_LOOP ) return 0;

	// Loop over all deco gases to find the shallowest one below or at current depth.
	for(j=0; j<NUM_GAS; ++j)
	{
		// Is this the gas we are already breathing?
		// If yes, skip this gas.
		if( j+1 == sim_gas_last_used ) continue;

		// Is the change depth of the gas shallower than the current depth?
		// If yes, skip this gas as it is not to be used yet.
		// Remark: this check will also skip all disabled gases and the gas set
		//         as 'first' because these have their change depth set to 0.
		if( temp_depth_limit > char_I_deco_gas_change[j] ) continue;

		// Is the change depth of the gas deeper than the change depth of the
		// gas we are currently one?
		// If yes, skip this gas as it is not better than the current one.
		// Remark: if there is more than one gas with the same change depth,
		//         the last one from the list will be taken.
		if( sim_gas_last_depth && (char_I_deco_gas_change[j] > sim_gas_last_depth) ) continue;

		// Is the change depth of the gas shallower or equal to the change depth
		// of the best gas found so far, or is it the first better gas found?
		// If yes, we have a better gas
		if( char_I_deco_gas_change[j] <= switch_depth )
		{
			switch_gas   = j+1;							// remember this gas (1..5)
			switch_depth = char_I_deco_gas_change[j];	// remember its change depth
		}
	}	// continue looping through all gases to eventually find an even better gas

	// has a better gas been found?
	if( switch_gas )
	{
		// yes
		sim_gas_last_used  = switch_gas;				// report the index of the better
		sim_gas_last_depth = switch_depth;				// report its change depth

		assert( sim_gas_last_depth < switch_depth );
		
		return 1;										// signal a better gas was found
	}
	else
	{
		return 0;										// signal no better gas was found
	}
}

//////////////////////////////////////////////////////////////////////////////
// Set calc_N2/He/O2_ratios by sim_gas_last_used
//
// Input:  sim_gas_last_used  : index of gas to use
//         N2_ratio, He_ratio : if gas 0 = the manually set gas is in use
//
// Output: calc_N2_ratio, calc_He_ratio, calc_O2ratio
//
static void gas_switch_set(void)
{
	assert( 0 <= sim_gas_last_used <= NUM_GAS );

	if( sim_gas_last_used == 0 )    // Gas6 = manually set gas.
	{
		calc_O2_ratio = O2_ratio;
		calc_He_ratio = He_ratio;
	}
	else
	{
	calc_O2_ratio = char_I_deco_O2_ratio[sim_gas_last_used-1] * 0.01;
	calc_He_ratio = char_I_deco_He_ratio[sim_gas_last_used-1] * 0.01;
	}

	calc_N2_ratio = 1.0 - calc_O2_ratio - calc_He_ratio;

	assert( 0.0 <= calc_N2_ratio && calc_N2_ratio <= 0.95 );
	assert( 0.0 <= calc_He_ratio && calc_He_ratio <= 1.00 );
	assert( (calc_N2_ratio + calc_He_ratio) <= 1.00 );
}

//////////////////////////////////////////////////////////////////////////////
// Compute ppN2 and ppHe
//
// Input: calc_N2_ratio, calc_He_ratio : simulated gas mix.
//        temp_deco                    : simulated respiration pressure
//        float_deco_distance          : safety factor
//        ppWater                      : water-vapor pressure inside respiratory tract
//
// Output: ppN2, ppHe.
//
static void sim_alveolar_presures(void)
{
    overlay float deco_diluent = temp_deco;
	
	// read ppO2 reported from sensors or by setpoint		// TODO: can be deleted
	// char_actual_ppO2 = char_I_const_ppO2;


    // Take deco offset into account, but not at surface.
    // Note: this should be done on ambient pressure, hence before
    //       computing the diluent partial pressure...
    if( deco_diluent > pres_surface ) deco_diluent += float_deco_distance;

	if( char_O_deco_status & DECO_MODE_LOOP )
    {
		//---- Loop mode : adjust ppN2 and ppHe for change in ppO2 due to setpoint (CCR) or drop (pSCR)-------

		// get current setpoint (CCR) or sensor value (CCR, for pSCR see text below) as default
		overlay float const_ppO2 = char_I_const_ppO2 * 0.01;
		
		if( char_O_deco_status & DECO_MODE_PSCR )
		{
			//---- PSCR mode : compute loop gas ----------------------------------------
			//
			// As the ppO2 in the loop changes with water depth, we can not use the current
			// sensor value as with CCR mode, but need to compute the ppO2 for the given depth.
			// Then we continue with the CCR mode code which calculates the increases of ppN2
			// and ppH2 due to the reduction of the ppO2 in the loop. Essentially, diving a
			// PSCR is like diving a CCR with a setpoint lower than the ambient pressure x the
			// O2 fraction of the diluent would yield...
			//

			// deco_diluent          is 0.0 ...     in bar
			// calc_O2_ratio         is 0.0 ...   1 as factor
			// char_I_PSCR_drop      is 0   ...  15 as %
			// char_I_PSCR_lungratio is 5   ...  20 as %
			// const_ppO2		     is 0.0 ...     in bar

			const_ppO2 = (deco_diluent * calc_O2_ratio) - (1 - calc_O2_ratio) * 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio;
		
			// capture failure condition
			if( const_ppO2 < 0.0 ) const_ppO2 = 0.0;
		}		
		else
		{
			
			//---- CCR mode ------------------------------------------------------------ 
		
			// Limit the setpoint to the maximum physically possible ppO2. This prevents for
			// example calculating with a setpoint of 1.3 bar in only 2 meters of depth.
			// Additionally, if limiting occurs, the ppO2 can be further reduced to account
			// for residual inert gases by the user-adjustable setting char_I_cc_max_frac_o2.
		
			if( const_ppO2 > deco_diluent )		// no ppWater subtracted here to give some margin for
			{										// sensors delivering data a little bit over target
			
				const_ppO2 = 0.01 * char_I_cc_max_frac_o2 * (deco_diluent - ppWater);
			}
		}

		if      ( const_ppO2 == 0.0   ) char_actual_ppO2 =   0;
		else if ( const_ppO2 >  2.545 )	char_actual_ppO2 = 255;
		else                            char_actual_ppO2 = (unsigned char)(const_ppO2*100 + 0.5);

        // Note: ppO2 and ratios are known outside the lungs, so there is no ppWater in the equations below:
        deco_diluent -= const_ppO2;
        deco_diluent /= calc_N2_ratio + calc_He_ratio;
        
		// capture all failure conditions, including div/0 in case diluent is pure O2
		if( (deco_diluent < 0.0) || (calc_O2_ratio > 99.5) )
		{
			deco_diluent = 0.0;
			
			char_actual_ppO2 = (unsigned char)(temp_deco*100 + 0.5);	// without float_deco_distance here as this situation
																		// is likely to occur only at 6 meters or shallower
		}
    }
	else 
	{
		//---- OC mode: char_actual_ppO2 will be needed for CNS calculation later --------------------------------

		overlay float ppO2 = pres_respiration * calc_O2_ratio;
		
		if   ( ppO2 > 2.545 ) char_actual_ppO2 = 255;
		else                  char_actual_ppO2 = (unsigned char)(ppO2*100 + 0.5);
	}

	
    if( deco_diluent > ppWater )
    {
        ppN2 = calc_N2_ratio * (deco_diluent - ppWater);
        ppHe = calc_He_ratio * (deco_diluent - ppWater);
    }
    else
    {
        ppN2 = 0.0;
        ppHe = 0.0;
    }

    assert( 0.0 <= ppN2 && ppN2 < 14.0 );
    assert( 0.0 <= ppHe && ppHe < 14.0 );
}

//////////////////////////////////////////////////////////////////////////////
// clear_tissue
//
// optimized in v.101 (var_N2_a)
//
// preload tissues with standard pressure for the given ambient pressure.
// Note: fixed N2_ratio for standard air.
//
static void clear_tissue(void)
{
	pres_respiration = 0.001  * int_I_pres_respiration;
	N2_equilibrium   = 0.7902 * (pres_respiration - ppWater);
	
    for(ci=0; ci<NUM_COMP; ci++)
    {
        // cycle through the 16 Buhlmann N2 tissues
		pres_tissue_N2[ci] 				= N2_equilibrium;	// initialize data for "real" tissue
		char_O_tissue_N2_saturation[ci] = 11;				// initialize data for tissue graphics
			

        // cycle through the 16 Buhlmann He tissues
        pres_tissue_He[ci] 				= 0.0;				// initialize data for "real" tissue
		char_O_tissue_He_saturation[ci] = 0;				// initialize data for tissue graphics
    }

	clear_CNS_fraction();
	
    clear_deco_table();
	
	char_O_main_status		= 0;
    char_O_deco_status		= 0;
    char_O_nullzeit			= 0;
	char_O_gtissue_no		= 0;
	char_O_deco_warnings	= 0;

    int_O_ascenttime		= 0;
    int_O_gradient_factor	= 0;

	calc_lead_tissue_limit	= 0.0;
}

//////////////////////////////////////////////////////////////////////////////
// calc_hauptroutine
//
// this is the major code in dive mode calculates:
// 		the tissues,
//		the bottom time,
//		and simulates the ascend with all deco stops.
//
//
static void calc_hauptroutine(void)
{
	unsigned int int_ppO2_min;
	unsigned int int_ppO2_max;


	//--- set-up part --------------------------------------------------------------------------------
	
	// twosectimer:
	// calc_hauptroutine is now invoked every second to speed up the deco planning.
	// Because the tissue and CNS calculations are based on a 2 seconds period, the
	// the following toggle-timer will be used by the respective routines to skip
	// every 2nd invocation.
	twosectimer = (twosectimer) ? 0 : 1;			// toggle the toggle-timer
	

	// set up normal tissue updating or "fast forward" updating for simulator sim+5' function
	// and deco calculator bottom time calculation
	if( char_I_sim_advance_time > 0 )
	{
		// configure char_I_sim_advance_time minutes of tissue updating
		tissue_increment = char_I_sim_advance_time	// given number of minutes, limited to 127
						 | 128;						// set flag for updating the "real" tissues & CNS

		char_I_sim_advance_time = 0;				// clear "mailbox"
	}
	else
	{
		// configure 2 seconds of tissue updating
		tissue_increment = 0						// encoding for 2 seconds update
						 | 128;						// set flag for updating the "real" tissues & CNS
	}

	//---- calculate the real tissue's data -----------------------------------------------------------------
	
	calc_hauptroutine_data_input();			// acquire current environment data 
	
	calc_hauptroutine_update_tissues();		// update tissue pressures, also sets char_actual_ppO2
	
	calc_CNS_fraction();					// calculate CNS% for the real tissues
	
	compute_CNS_for_display();				// compute integer copy of CNS value for display purpose
		
	calc_gradient_factor();					// compute current GF


	//---- compute ppO2 warnings ------------------------------------------------------------------------------
	
	// compute conditional min/max values
	int_ppO2_min = (char_O_main_status   & DECO_MODE_LOOP) ? (unsigned int)char_I_ppO2_min_loop : (unsigned int)char_I_ppO2_min;
	int_ppO2_max = (char_O_deco_warnings & DECO_FLAG     ) ? (unsigned int)char_I_ppO2_max_deco : (unsigned int)char_I_ppO2_max;

	// check for safe range of pure oxygen
	if		( int_O_O2_ppO2   	  >=           int_ppO2_max    ) int_O_O2_ppO2 		 |= INT_FLAG_WARNING + INT_FLAG_HIGH;

	// check for safe range of breathed gas
	if		( int_O_breathed_ppO2 <=           int_ppO2_min    ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW;
	else if ( int_O_breathed_ppO2 >=           int_ppO2_max    ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH;
	else if ( int_O_breathed_ppO2 >= ppO2_prewarn_threshold    ) int_O_breathed_ppO2 |= INT_FLAG_PREWARNING;
		
	// check for safe range of pure diluent
	if		( int_O_pure_ppO2 <= (unsigned int)char_I_ppO2_min ) int_O_pure_ppO2 	 |= INT_FLAG_WARNING + INT_FLAG_LOW;
	else if	( int_O_pure_ppO2 >=               int_ppO2_max    ) int_O_pure_ppO2 	 |= INT_FLAG_WARNING + INT_FLAG_HIGH;
		
	// check for safe range of calculated pSCR loop gas
	if		( int_O_pSCR_ppO2 <=               int_ppO2_min    ) int_O_pSCR_ppO2 	 |= INT_FLAG_WARNING + INT_FLAG_LOW;
	else if	( int_O_pSCR_ppO2 >=               int_ppO2_max    ) int_O_pSCR_ppO2 	 |= INT_FLAG_WARNING + INT_FLAG_HIGH;
	

    //---- toggle between calculation for NDL (bottom time), deco stops and more deco stops (continue) ------

	switch( char_O_deco_status & DECO_STATUS_MASK )
    {
		overlay unsigned char i;

	case DECO_STATUS_INIT: //---- At surface: start a new dive ---------------------

		clear_deco_table();
        copy_deco_table();
		
		char_I_ascent_speed    = 10;	// DEBUG - remove before flight!
		char_I_gas_change_time = 1;		// DEBUG - remove before flight!
		
		float_ascent_speed            = 1.00 * char_I_ascent_speed;
		float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier;
		float_saturation_multiplier   = 0.01 * char_I_saturation_multiplier;
		float_deco_distance           = 0.01 * char_I_deco_distance;
		
        int_O_ascenttime			  = 0;		// Reset ascent time in normal plan
		int_O_alternate_ascenttime    = 0; 		// Reset ascent time in alternative plan
		char_O_nullzeit               = 0;		// Reset no decompression limit (NDL) in normal plan
		char_O_alternate_nullzeit     = 0;		// Reset no decompression limit (NDL) in alternative plan
		char_O_deco_warnings          = 0;		// Reset all deco warning flags
		deco_tissue_vector		      = 0;		// Reset tissue deco vector
		IBCD_tissue_vector            = 0;		// Reset tissue IBCD vector
		
		int_O_desaturation_time       = 65535;	// tag desaturation time as invalid (it will not be computed during a dive)
		

		for(i=0; i<NUM_GAS; ++i)
		{
			int_O_gas_volumes[i]    = 0;
			int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO;	// 0 bar + flag for 0 bar
		}

		for(i=0; i<NUM_COMP; ++i)
		{		
			split_N2_He[i] = 90;							// used for calculation of no-fly time
		}
		
		
		// init CNS counters
		CNS_sim_norm_fraction     = CNS_sim_alt_fraction         = CNS_fraction;		// the floats
		int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = int_O_CNS_fraction;	// the integers

		
        // Values that should be reset just once for the full real dive.
        // This is used to record the lowest stop for the whole dive,
        // including ACCROSS all simulated ascents.
        low_depth_norm      = low_depth_alt      = 0.0;
        locked_GF_step_norm = locked_GF_step_alt = 0.0;


		// continue in state DECO_STATUS_START to calculate the bottom-part of the dive and the NDL
		char_O_deco_status &= ~DECO_STATUS_MASK;	
		
		// code execution continues in state DECO_STATUS_START
		
		
	case DECO_STATUS_START: //---- bottom time -------------------------------------
    default:

		// reread the GF settings in case there was a switch between GF/aGF
		GF_low   = char_I_GF_Low_percentage  * 0.01;
		GF_high  = char_I_GF_High_percentage * 0.01;
		GF_delta = GF_high - GF_low;

        // Lookup current gas and store it also as the first gas used. This gas will be used for the bottom
		// segment of the dive and for the period of delayed ascent when calculating fTTS or bailout.
		gas_find_current();		
		
		// setup the calculation ratio's for N2, He and O2
        gas_switch_set();		

		// clear the internal(!) stops table
		clear_deco_table();		
		
		// initialize the simulated tissues with the current state of the real tissues
		update_startvalues();	

		// calculate the effect of extended bottom time due to delayed ascent / fTTS on current gas
		if( char_O_deco_status & DECO_ASCENT_DELAYED ) sim_extra_time();
		
		// calculate if we are within no decompression limit (NDL)
        calc_nullzeit();

		// check which plan we are on
		if( char_O_deco_status & DECO_PLAN_ALTERNATE )
		{
			// alternate dive plan
			if( char_O_alternate_nullzeit > 0 )	// Some NDL time left in alternate plan?
			{
				copy_deco_table();	// DEBUG to be removed again
				
				// clear tank pressure needs
				if( char_O_deco_status & DECO_VOLUME_CALCULATE )
					for(i=0; i<NUM_GAS; ++i) int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO; // 0 bar + flag for 0 bar
					
				// calculate the CNS% at the end of the dive if requested:
				// as we are in no stop, CNS at end of dive is more or less the same CNS we have now
				if( char_O_deco_status & DECO_CNS_CALCULATE ) int_O_alternate_CNS_fraction = int_O_CNS_fraction;
				
				// clear fTTS ascent time
				int_O_alternate_ascenttime = 0;

				char_O_deco_status &= ~DECO_STATUS_MASK;	// YES: computation of alternate plan completed
			}
			else
			{
				char_O_deco_status &= ~DECO_STATUS_MASK;	// NO: clear status bits and set status bits
				char_O_deco_status |=  DECO_STATUS_ASCENT;	// for calculation of ascent on next invocation
			}
		}
		else
		{
			// normal dive plan
			if( char_O_nullzeit > 0 )						// Some NDL time left in normal plan?
			{
				//copy_deco_table();			DEBUG original - comment in again				// copy (erased) internal to external stops table

				// commented out - char_O_deco_last_stop not used for anything
				// char_O_deco_last_stop = 0;				// set last stop to 0 (for OSTC menu animation)
				
				// clear tank pressure needs
				if( char_O_deco_status & DECO_VOLUME_CALCULATE )
					for(i=0; i<NUM_GAS; ++i) int_O_tank_pres_need[i] = 0 + INT_FLAG_ZERO;	// 0 bar + flag for 0 bar

				// calculate the CNS% at the end of the dive if requested:
				// as we are in no stop, CNS at end of dive is more or less the same CNS we have now
				if( char_O_deco_status & DECO_CNS_CALCULATE ) int_O_normal_CNS_fraction = int_O_CNS_fraction;

				char_O_deco_status &= ~DECO_STATUS_MASK;	// computation of normal plan completed
			}
			else
			{
				char_O_deco_status &= ~DECO_STATUS_MASK;	// clear status bits and set status bits
				char_O_deco_status |=  DECO_STATUS_ASCENT;	// for calculation of ascent on next invocation
			}
		}

		break;

		
	case DECO_STATUS_ASCENT: //---- Simulate ascent to first stop -------------------
		
		// initialize depth (in abs.pressure) for ascent and deco simulation, start from current real depth
		temp_deco = pres_respiration;
		
		// calculate ascent to first stop
        sim_ascent_to_first_stop();

        // calculate all further stops next time
		char_O_deco_status &= ~DECO_STATUS_MASK;	// clear status bits and set status bits
		char_O_deco_status |=  DECO_STATUS_STOPS;	// for calculation of stops on next invocation
		
        break;


	case DECO_STATUS_STOPS: //---- Simulate stops ----------------------------------
	
        calc_hauptroutine_calc_deco();

		// If simulation is finished, do some more computations if requested
		// and restore the GF low reference so that the next ascent simulation
		// is done from the current depth: 
		if( !(char_O_deco_status & DECO_STATUS_MASK) )
        {
			// Calculate ascent time, result in int_O_ascenttime or int_O_alternate_ascenttime
            calc_ascenttime();

			// the current depth is needed by calc_CNS_planning() and gas_volumes()
			char_I_bottom_depth = (unsigned char)((pres_respiration - pres_surface)*BAR_TO_METER);
			
			// if requested, calculate the CNS% at the end of the dive (including the deco stops)
			if( char_O_deco_status & DECO_CNS_CALCULATE    ) calc_CNS_planning();
			
			// if requested, calculate the required gas volumes and tank pressures at the end of the dive.
			if( char_O_deco_status & DECO_VOLUME_CALCULATE ) gas_volumes();			
			
			// some more aftermath dependent on the current plan
			if( char_O_deco_status & DECO_PLAN_ALTERNATE   )
			{
				//---- alternative plan ----------------------------------------------------

copy_deco_table();			// DEBUG to be removed again

				// was CNS at end of dive calculated?
				if( char_O_deco_status & DECO_CNS_CALCULATE )
				{
					// yes - compute CNS value to display
					if		( CNS_sim_alt_fraction < 0.01  ) int_O_alternate_CNS_fraction = 0;
					else if ( CNS_sim_alt_fraction > 9.985 ) int_O_alternate_CNS_fraction = 999 + INT_FLAG_WARNING;
					else
					{	
						// convert float to integer
						int_O_alternate_CNS_fraction = (unsigned short)(100 * CNS_sim_alt_fraction + 0.5);
	
						// set warning flag if CNS is >= 100%
						if( int_O_alternate_CNS_fraction >= 100 )
						int_O_alternate_CNS_fraction |= INT_FLAG_WARNING;
				
						// set invalid flag if there is an overflow in the stops table
						if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
						int_O_alternate_CNS_fraction |= INT_FLAG_INVALID;
					}
				}
				else
				{
					// no - invalidate value (value = 0, invalid flag set)
					int_O_alternate_CNS_fraction = INT_FLAG_INVALID;
				}
			}
			else
			{
				//---- normal plan ---------------------------------------------------------

				// publish the stops table
//				copy_deco_table();			// DEBUG original

				// was CNS at end of dive calculated?
				if( char_O_deco_status & DECO_CNS_CALCULATE )
				{
					// yes - compute CNS value to display
					if		( CNS_sim_norm_fraction <  0.01  ) int_O_normal_CNS_fraction = 0;
					else if ( CNS_sim_norm_fraction >= 9.985 ) int_O_normal_CNS_fraction = 999 + INT_FLAG_WARNING;
					else
					{	
						// convert float to integer
						int_O_normal_CNS_fraction = (unsigned short)(100 * CNS_sim_norm_fraction + 0.5);
	
						// set warning flag if CNS is >= 100%
						if( int_O_normal_CNS_fraction >= 100 )
							int_O_normal_CNS_fraction |= INT_FLAG_WARNING;
				
						// set invalid flag if there is an overflow in the stops table
						if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
							int_O_normal_CNS_fraction |= INT_FLAG_INVALID;
					}
				}
				else
				{
					// no - invalidate value (value = 0, invalid flag set)
					int_O_normal_CNS_fraction = INT_FLAG_INVALID;
				}

			} // aftermath
		} // if
		
        break;
		
    } // switch
}

//////////////////////////////////////////////////////////////////////////////
// calc_hauptroutine_data_input
//
// Reset all C-code dive parameters from their ASM-code values.
// Detect gas change condition.
//
void calc_hauptroutine_data_input(void)
{
	// get the current pressures
	pres_respiration = 0.001 * int_I_pres_respiration;
    pres_surface     = 0.001 * int_I_pres_surface;

	// get the currently breathed gas mixture
	O2_ratio         = 0.01 * char_I_O2_ratio;
    He_ratio         = 0.01 * char_I_He_ratio;

	// N2 ratios are computed within p2_deco.c from the O2 and He ratios
	N2_ratio         = 1.0 - O2_ratio - He_ratio;
	
	// N2 tissue pressure at surface equilibrium, used for tissue graphics scaling
	N2_equilibrium   = 0.7902 * (pres_surface - ppWater);
}

//////////////////////////////////////////////////////////////////////////////
//
//
void calc_hauptroutine_update_tissues(void)
{
    overlay float pres_diluent = pres_respiration;

	
    assert( 0.00 <= N2_ratio && N2_ratio <= 1.00 );
    assert( 0.00 <= He_ratio && He_ratio <= 1.00 );
    assert( (N2_ratio + He_ratio) <= 1.00 );
    assert( 0.800 < pres_respiration && pres_respiration < 14.0 );

	
	//---- OC, CCR and Bailout Mode Gas Calculations ------------------------------------------------------------
	
	// calculate ppO2 of pure oxygen
	O2_ppO2 = (pres_respiration - ppWater);

	// capture failure condition in case pres_respiration is < ppWater (should never happen...)
	if( O2_ppO2 < 0.0 ) O2_ppO2 = 0.0;
	
	// calculate ppO2 of the pure gas (diluent)
	pure_ppO2 = O2_ppO2 * O2_ratio;

	
	//---- PSCR Mode Gas Calculation-----------------------------------------------------------
	
	// With flags set for PSCR we compute the ppO2 in the loop from the diluent's O2
	// ratio and the PSCR parameters. This figure will be used in the pSCR custom view.
	// If sensors are used (char_I_const_ppO2 > 0), we will override the calculated ppO2
	// with the sensor data. Then we continue with the CCR mode code which calculates
	// the increase of ppN2 and ppH2 due to the reduction of the ppO2 in the loop.
	// Essentially, diving a pSCR is like diving a CCR with a setpoint set lower than
	// the ambient pressure multiplied with the O2 fraction of the diluent...
			
	// calculate pSCR ppO2
	//
	// pres_respiration      is 0.0 ...       in bar
	// O2_ratio              is 0.0 ...   1.0 as factor
	// char_I_PSCR_drop      is 0   ...  15   as %
	// char_I_PSCR_lungratio is 5   ...  20   as %
	// pSCRppO2				 is 0.0 ...       in bar

	pSCR_ppO2 = (pres_respiration * O2_ratio) - (1 - O2_ratio) * 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio;

	// capture failure condition if case pSCR_ppO2 becomes negative
	if( pSCR_ppO2 < 0.0 ) pSCR_ppO2 = 0.0;	
	
	
	//---- Loop modes : adjust ppN2 and ppHe for change in ppO2 due to setpoint (CCR) or drop (pSCR) ------------
	if ( char_O_main_status & DECO_MODE_LOOP )
    {
		overlay float const_ppO2;

		// get the current sensor reading (CCR / pSCR if fitted) or the fixed setpoint (CCR) / a zero (pSCR)
        const_ppO2 = 0.01 * char_I_const_ppO2;
		
		// Limit the setpoint to the maximum physically possible ppO2. This prevents for
		// example calculating with a setpoint of 1.3 bar in only 2 meters of depth.
		// Additionally, if limiting occurs, the ppO2 can be further reduced to account
		// for residual inert gases by the user-adjustable setting char_I_cc_max_frac_o2.
		
		if( const_ppO2 > pres_respiration )	// no ppWater subtracted here to give some margin for
		{									// sensors delivering data a little bit over target
			
			const_ppO2 = 0.01 * char_I_cc_max_frac_o2 * (pres_respiration - ppWater);
		}
				
		// check which kind of loop we are on
		if( char_O_main_status & DECO_MODE_PSCR ) 
		{
			//---- pSCR Mode --------------------------------------------------------------------------

			// check if a sensor is fitted
			if( char_I_const_ppO2 ) breathed_ppO2 = const_ppO2;	// yes - derive ppO2s from (char_I_)const_ppO2
			else                    breathed_ppO2 = pSCR_ppO2;	// no  - derive ppO2s from calculated ppO2
		}
		else
		{
			//---- CCR Mode ---------------------------------------------------------------------------

			// derive breathed ppO2 from (char_I_)const_ppO2, which holds sensor reading or fixed setpoint
			breathed_ppO2 = const_ppO2;
		}

		// adjust diluent pressure (ppN2 + ppHe) for change in ppO2 due to setpoint (CCR) or drop (pSCR)
        pres_diluent -= const_ppO2;
        pres_diluent /= N2_ratio + He_ratio;

		// capture all failure conditions, including div/0 in case diluent is pure O2
		if( (pres_diluent < 0.0) || (char_I_O2_ratio == 100) )
		{
			pres_diluent  = 0.0;
			breathed_ppO2 = pure_ppO2;
		}

	}
	else
	{	//---- OC mode -----------------------------------------------------------------------------------------
	
		// breathed ppO2 is ppO2 of pure gas
		breathed_ppO2 = pure_ppO2;
	}


	// derive char_actual_ppO2 in [cbar], used for calculating CNS%
	if      ( breathed_ppO2 <  0.01  ) char_actual_ppO2  =   0;
	else if ( breathed_ppO2 >= 2.545 ) char_actual_ppO2  = 255;
	else                               char_actual_ppO2  = (unsigned char)(100 * breathed_ppO2 + 0.5);

	
	//---- export ppO2 values in [cbar] for warning generation and display purpose ------------------------------

	// pure oxygen ppO2
	if		( O2_ppO2       <  0.01  ) int_O_O2_ppO2       =   0;
	else if ( O2_ppO2       >= 9.995 ) int_O_O2_ppO2       = 999;
	else                               int_O_O2_ppO2       = (unsigned int)(100 *       O2_ppO2 + 0.5);
	
	// pure gas ppO2
	if      ( pure_ppO2     <  0.01  ) int_O_pure_ppO2     =   0;
	else if ( pure_ppO2     >= 9.995 ) int_O_pure_ppO2     = 999;
	else                               int_O_pure_ppO2     = (unsigned int)(100 *     pure_ppO2 + 0.5);
	
	// calculated pSCR ppO2
	if		( pSCR_ppO2     <  0.01  ) int_O_pSCR_ppO2     =   0;
	else if ( pSCR_ppO2     >= 9.995 ) int_O_pSCR_ppO2     = 999;
	else                               int_O_pSCR_ppO2     = (unsigned int)(100 *     pSCR_ppO2 + 0.5);

	// breathed ppO2
	if		( breathed_ppO2 <  0.01  ) int_O_breathed_ppO2 =   0;
	else if ( breathed_ppO2 >= 9.995 ) int_O_breathed_ppO2 = 999;
	else                               int_O_breathed_ppO2 = (unsigned int)(100 * breathed_ppO2 + 0.5);
	

	//---- calculate ppN2, ppHe and EAD, END -------------------------------------------------------------------
	
    if( pres_diluent > ppWater )
    {
        overlay float EAD, END;

        ppN2 = N2_ratio * (pres_diluent - ppWater);
        ppHe = He_ratio * (pres_diluent - ppWater);

        // EAD : Equivalent Air Depth. Equivalent depth for the same N2 level with plain air.
        //       ppN2 = 79% * (P_EAD - ppWater)
        //       EAD = (P_EAD - Psurface) * 10
        //   ie: EAD = (ppN2 / 0.7902 + ppWater -Psurface) * 10

        EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER;

        if( (EAD < 0.0) || (EAD > 245.5) ) EAD = 0.0;

        char_O_EAD = (unsigned char)(EAD + 0.5);

		
        // END : Equivalent Narcotic Depth.
        //       Here we count O2 as narcotic too. Hence everything but helium (has a narcosis
        //       factor of 0.23 btw). Hence the formula becomes:
        //       END * BarPerMeter * (1.0 - 0.0) - ppWater + Psurface == Pambient - ppHe - ppWater
        //  ie:  END = (Pambient - ppHe - Psurface) * BAR_TO_METER
        //
        // Source cited:
        //       The Physiology and Medicine of Diving by Peter Bennett and David Elliott,
        //       4th edition, 1993, W.B.Saunders Company Ltd, London.

        END = (pres_respiration - ppHe - pres_surface) * BAR_TO_METER;

        if( (END < 0.0) || (END > 245.5) ) END = 0.0;

		char_O_END = (unsigned char)(END + 0.5);
    }
    else
    {
        ppN2 = ppHe = 0.0;
		
		char_O_EAD = char_O_END = 0;
    }


	//---- calculate decompression status ----------------------------------------------------------------------
		
	// Calculate tissues
	calc_tissue();

    // Calculate limit for surface, ie. GF_high.
    calc_limit();
	

    // Fill int_O_ceiling (in mbar) if ceiling is below the surface
    if( (calc_lead_tissue_limit - pres_surface) > 0 )
	{	

// compatibility version
        int_O_ceiling = (short)((calc_lead_tissue_limit - pres_surface) * 1000);

// new version
//		// Round up to next 10 cm so that the ceiling disappears on the display only when the ceiling
//		// limit is really zero. This will coincident then with TTS switching back to NDL time.
//		int_O_ceiling = (short)((calc_lead_tissue_limit-pres_surface)*1000+9);
				

		// limit int_O_ceiling to 16000 mbar (150 m)
		if( int_O_ceiling > 16000) int_O_ceiling = 16000;
	}
    else
	{
        int_O_ceiling = 0;
	}

    int_O_gtissue_press = (short)((pres_tissue_N2[char_O_gtissue_no] + pres_tissue_He[char_O_gtissue_no]) * 1000);
}


//////////////////////////////////////////////////////////////////////////////
// Compute stops.
//
// Note: because this can be very long, break on 16 iterations, and set state
//       to DECO_STATUS_FINISHED when finished, or to DECO_STATUS_STOPS when
//       needing to continue.
// Note: because each iteration might be very long too (~ 66 ms in 1.84beta),
//       break the loop when elapsed time exceeds 512 milliseconds.
//
void calc_hauptroutine_calc_deco(void)
{
	overlay unsigned char loop;

	for(loop = 0; loop < 16; ++loop)
	{
		// limit loops to 512ms, using timer 5
		if( tmr5() & (512*32) ) break;

		// calc_nextdecodepth()
		//
		// INPUT  temp_deco        : current depth in absolute pressure
		// OUTPUT temp_depth_limit : depth of next stop in meters
		// RETURN true if a stop is needed
		//
		// The function manages gas changes by itself, including priming
		// the deco stop with the configured gas change time.
		//
		if( calc_nextdecodepth() )
		{
			if( temp_depth_limit == 0 ) goto Surface;	// this check should not bee needed as in
														// this case the RETURN value will be false

			//---- stop required at temp_depth_limit -------------------------------------

			// convert stop depth in meters to absolute pressure
			temp_deco = temp_depth_limit * METER_TO_BAR + pres_surface;

			// add one minute to the current stop, or add a new stop,
			// or abort deco calculation if the deco table is full.
			if( !update_deco_table(1) ) goto Surface;
		}
		else
		{
			//---- no stop required --------------------------------------
			
			// ascend by float_ascent_speed for 1 minute
			temp_deco -= float_ascent_speed * METER_TO_BAR;

			// finish deco calculation if surface is reached
			if( temp_deco <= pres_surface )
			{
Surface:
				// set deco engine status to done (DECO_STATUS_FINISHED)
				char_O_deco_status &= ~DECO_STATUS_MASK;
			
				// commented out - char_O_deco_last_stop not used for anything
				// surface reached (to animate menu)
				// if( !(char_O_deco_status & DECO_PLAN_ALTERNATE)) char_O_deco_last_stop = 0;
				
				return;
			}
		}


		//---- as one minute as passed now, update the tissues ----------------------

		// program 1 minute interval on simulated tissues (Flagbit 7 = 0)
		tissue_increment = 1;
		
		// compute current ppN2 and ppHe
		sim_alveolar_presures();
		
		// update the tissues
		calc_tissue();
	}

	// commented out - char_O_deco_last_stop not used for anything
	// surface not reached, need more stops... store reached depth for menu animation.
	// if( !(char_O_deco_status & DECO_PLAN_ALTERNATE) ) char_O_deco_last_stop = temp_depth_limit;
}


//////////////////////////////////////////////////////////////////////////////
// Simulate ascent to first deco stop.
//
//
// Modified: temp_deco : current depth in ascent and deco simulation, in bar absolute pressure
//
void sim_ascent_to_first_stop(void)
{
	overlay unsigned char fast      = 1;	// 1 = 1 minute steps,  0 = 2 seconds steps
	overlay unsigned char gaschange = 0;	// 1 = do a gas change, 0 = no better gas available
	
	
	//---- Loop until first deco stop or surface is reached ----------
	for(;;)
	{
		// depth in absolute pressure we came from
		overlay float old_deco = temp_deco;
		
		// try ascending 1 full minute (fast) or 2 seconds (!fast)
		if	( fast ) temp_deco -=  float_ascent_speed       * METER_TO_BAR;	// 1 min at float_ascent_speed ( 5 .. 10  m/min)
		else         temp_deco -= (float_ascent_speed/30.0) * METER_TO_BAR;	// 2 sec at float_ascent_speed (17 .. 33 cm/min)

		// but don't go over surface
		if( temp_deco < pres_surface ) temp_deco = pres_surface;

		// compute sim_lead_tissue_limit
		if   ( char_I_deco_model != 0 ) sim_limit(GF_low);
		else                            sim_limit(1.0);

		// did we overshoot the first deco stop?
		if( temp_deco < sim_lead_tissue_limit )
		{
			// YES - back to last depth below first stop
			temp_deco = old_deco;

			// switch to 2 seconds ascent if not yet in, else done
			if( fast )
			{
				fast = 0;				// retry with 2 seconds ascent steps
				continue;
			}
			else
			{
				break;					// done...
			}
		}

		// If code execution passes along here, we did not overshoot the first stop.
		
		// did we reach the surface? if yes, done!
		if( temp_deco == pres_surface ) break;

		// depth in meters where we are now (no round-up)
		temp_depth_limit = (unsigned char)((temp_deco - pres_surface) * BAR_TO_METER);
		
		// Check if there is a better gas to switch to, but only in alternative plan mode.
		// If yes, introduce a stop for the gas change.
		if( (char_O_deco_status & DECO_PLAN_ALTERNATE) && gas_find_better() )
		{
			// depth in meters we came from
			overlay unsigned char old_depth_limit = (unsigned char)((old_deco - pres_surface) * BAR_TO_METER);			
			
			// adjust temp_depth_limit to the gas change depth, but not deeper than the depth we came from
			temp_depth_limit = (sim_gas_last_depth < old_depth_limit) ? sim_gas_last_depth : old_depth_limit;
			
			// create a stop for the gas change
			update_deco_table(char_I_gas_change_time);

			// set the new calculation values for N2, He and O2
			gas_switch_set();
			
			// signal to create a stop for the gas change and update the tissues
			gaschange = char_I_gas_change_time;
			
			// Adjust the depth for the tissue update to the stop depth. In case of fast mode, this
			// imposes that the ascent from the 'old_deco' depth to this stop took 1 minute although
			// we might have only ascended one or two meters...
			temp_deco = temp_depth_limit * METER_TO_BAR + pres_surface;
		}	
		
		// Did one minute pass by and/or do we have a gas change?
		// Remark: The 2 seconds ascent iterations towards the first deco stop in !fast speed may take
		// up to 28 seconds in total - for this rough half of a minute no tissue updates will be computed.
		// Well, it could be done by setting tissue_increment = 0 in !fast condition and making calls to
		// sim_alveolar_presures() and calc_tissue() - see code commented out.
		if( fast || gaschange )
		{
			// program interval on simulated tissues (flag bit 7 = 0)
			tissue_increment = fast + gaschange;
			
			// clear gas change signal
			gaschange = 0;
	//	}
	//	else
	//	{
	//		// program 2 seconds interval on simulated tissues (flag bit 7 = 0)
	//		tissue_increment = 0;
	//	}
	//	{
			// compute ppN2/ppHe for current depth from temp_deco
			sim_alveolar_presures();
			
			// update the tissues
			calc_tissue();
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
// Simulate extra time at the current depth.
//
// This routine is used for the futureTTS / delayed ascent feature.
//
void sim_extra_time(void)
{
 	overlay unsigned char backup = tissue_increment;	// back-up tissue_increment

	tissue_increment  = char_I_extra_time;				// program interval on simulated tissues (Flagbit 7 = 0)
	
	calc_tissue();										// update the tissues
	
	tissue_increment = backup;							// restore tissue_increment
}

//////////////////////////////////////////////////////////////////////////////
// calc_tissue
//
// optimized in v.101
//
// INPUT:	 ppN2, ppHe, tissue_increment
// MODIFIED: pres_tissue_N2[], pres_tissue_He[]
// OUTPUT:	 char_O_tissue_N2_saturation[], char_O_tissue_He_saturation[]
//
static void calc_tissue()
{
	overlay float			temp_tissue_N2;
	overlay float			temp_tissue_He;
	overlay unsigned char	period;
	overlay unsigned char	i;
		
		
    assert( 0.00 <= ppN2 && ppN2 < 11.2 );  // 80% N2 at 130m
    assert( 0.00 <= ppHe && ppHe < 12.6 );  // 90% He at 130m
	
	
    for (ci=0;ci<NUM_COMP;ci++)			// iterate through all compartments
    {
		i = tissue_increment & 127;		// extract number of minutes to do    (if i > 0)
										// or if one 2 second period is to do (if i = 0)
		
		if( i == 0 )					// check if we shall do one 2-seconds period
		{
			read_Buhlmann_times(0); 	// YES, program coefficients for a 2 seconds period
			period = 1;					//      set period length (in cycles)
			i      = 1;					//      and one cycle to do
		}
		else if( i > 9 )				// check if we can start with 10 minutes periods
		{
			read_Buhlmann_times(2);		// YES, program coefficients for 10 minutes periods
			period = 10;				//      set period length (in cycles) to ten
		}
		else							// we shall do 1 to 9 minutes
		{
			read_Buhlmann_times(1);		//      program coefficients for 1 minute periods
			period = 1;					//      set period length (in cycles) to one
		}

		do
		{
			//---- N2 -------------------------------------------------------------------------------

			temp_tissue = (tissue_increment & 128) ? pres_tissue_N2[ci] : sim_pres_tissue_N2[ci];

			temp_tissue = (ppN2 - temp_tissue) * var_N2_e;

			temp_tissue_safety();

			if( tissue_increment & 128 )
			{
				// The temp variable takes on purpose just the tissue increment from the last loop's iteration.
				temp_tissue_N2 = temp_tissue;
				
				// Update the real tissues if either we are on the 2 seconds interval,
				// or if we shall advance the tissues on a one or several minutes basis.
				if( twosectimer || (tissue_increment & 127) ) pres_tissue_N2[ci] += temp_tissue;
			}
			else
			{
				// Updates of the sim-tissues always comes on a 1 minutes basis,
				// so we do not need to check of the 2 seconds interval.
				sim_pres_tissue_N2[ci] += temp_tissue;
			}


			//---- He -------------------------------------------------------------------------------
			
			temp_tissue = (tissue_increment & 128) ? pres_tissue_He[ci] : sim_pres_tissue_He[ci];

			temp_tissue = (ppHe - temp_tissue) * var_He_e;

			temp_tissue_safety();

			if( tissue_increment & 128 )
			{
				// The temp variable takes on purpose just the tissue increment from the last loop's iteration.
				temp_tissue_He = temp_tissue;
				
				// Update the real tissues if either we are on the 2 seconds interval,
				// or if we shall advance the tissues on a one or several minutes basis.
				if( twosectimer || (tissue_increment & 127) ) pres_tissue_He[ci] += temp_tissue;

			}
			else
			{
				// Updates of the sim-tissues always comes on a 1 minutes basis,
				// so we do not need to check of the 2 seconds interval.
				sim_pres_tissue_He[ci] += temp_tissue;
			}
			

			// decrement loop counter
			i -= period;
			
			// check if we need to switch from 10 minute periods to 1 minute periods
			if( (i > 0) && (period = 10) && (i < 10) )
			{
				read_Buhlmann_times(1); 	// program coefficients for 1 minute periods
				period = 1;					// set period length (in cycles) to one
			}
		}
		while( i );
			
			
		// have the computations been done for the "real" tissues?
		if( (tissue_increment & 128) && (twosectimer || (tissue_increment & 127)) )
		{
			// net tissue balance
			temp_tissue = temp_tissue_N2 + temp_tissue_He;
			
			// check tissue on-/off-gassing and IBCD with applying a threshold of +/-HYST
			//
			if		( temp_tissue < -HYST )				// Check if the tissue is off-gassing
			{
				deco_tissue_vector	|=  (1 << ci);		// tag tissue as being in decompression
				IBCD_tissue_vector	&= ~(1 << ci);		// tag tissue as not experiencing mentionable IBCD
			}
			else if ( temp_tissue > +HYST )				// check if the tissue in on-gassing
			{
				deco_tissue_vector	&= ~(1 << ci);		// tag tissue as not being in decompression
				
				if(		((temp_tissue_N2 > 0.0) && (temp_tissue_He < 0.0))		// check for counter diffusion
					||	((temp_tissue_N2 < 0.0) && (temp_tissue_He > 0.0)) )
				{
					IBCD_tissue_vector |= (1 << ci);	// tag tissue as experiencing mentionable IBCD
				}
			}

			
			// keep the saturating / desaturating flags from last invocation
			char_O_tissue_N2_saturation[ci] &= 128;
			char_O_tissue_He_saturation[ci]	&= 128;
			
			// flip the flags applying a hysteresis of HYST (actual value: see #define of HYST)
				 if( temp_tissue_N2 > +HYST ) char_O_tissue_N2_saturation[ci] = 128; // set flag for tissue pressure is increasing
			else if( temp_tissue_N2 < -HYST ) char_O_tissue_N2_saturation[ci] =   0; // clear flag (-> tissue pressure is decreasing)

				 if( temp_tissue_He > +HYST ) char_O_tissue_He_saturation[ci] = 128; // set flag for tissue pressure is increasing
			else if( temp_tissue_He < -HYST ) char_O_tissue_He_saturation[ci] =   0; // clear flag (-> tissue pressure is decreasing)
			
			
			// For N2 tissue display purpose:
			// Scale tissue press so that saturation in 70m on AIR gives a value of approx. 80.
			// The surface steady-state tissue loading of [0.7902 * (pres_respiration - ppWater)] bar
			// gives then a 10. If N2 is completely washed out of the tissue, result will be 0.
			// This scaling is adapted to the capabilities of the tissue graphics in the custom views.
			temp_tissue = (pres_tissue_N2[ci] / N2_equilibrium) * 10;

			 // limit to 127 to leave space for sat/desat flag
			if (temp_tissue > 127) temp_tissue = 127;

			// export as integer
			char_O_tissue_N2_saturation[ci] += (unsigned char)temp_tissue;

			
			// For H2 tissue display purpose:
			// Scale tissue press so that saturation in 120m on TMX 10/70 gives a value of approx. 70.
			// With no He in a tissue, result will be 0.
			// This scaling is adapted to the capabilities of the tissue graphics in the custom views.
			temp_tissue = pres_tissue_He[ci] * 7.7;

			// limit to 127 to leave space for sat/desat flag
			if (temp_tissue > 127) temp_tissue = 127; 
			
			// export as integer
			char_O_tissue_He_saturation[ci] += (unsigned char)temp_tissue;
		}
				
    }// for
}

//////////////////////////////////////////////////////////////////////////////
// calc_limit
//
// New in v.111 : separated from calc_tissue(), and depends on GF value.
//
static void calc_limit(void)
{
    char_O_gtissue_no 		= 0;
    calc_lead_tissue_limit 	= 0.0;

	// clear IBCD, microbubbles and outside warning flags (locked warnings will be preserved)
	char_O_deco_warnings &= ~(DECO_WARNING_IBCD + DECO_WARNING_MBUBBLES + DECO_WARNING_OUTSIDE);


    for(ci=0; ci<NUM_COMP; ci++)
    {
        overlay float N2 = pres_tissue_N2[ci];
        overlay float He = pres_tissue_He[ci];
		overlay float pres_tissue = N2 + He;
		overlay float pres_min;
		overlay float gf;
		overlay float threshold;

        read_Buhlmann_coefficients();
        var_N2_a = (var_N2_a * N2 + var_He_a * He) / pres_tissue;
        var_N2_b = (var_N2_b * N2 + var_He_b * He) / pres_tissue;

		// calculate minimum ambient pressure that the tissue can withstand according to straight Buhlmann
		pres_min = (pres_tissue - var_N2_a) * var_N2_b;
		
		// calculate current gf value (1.0 = 100%) of this tissue
		gf = (pres_tissue - pres_respiration) / (pres_tissue - pres_min);
		if( gf < 0.0 ) gf = 0.0;
		
		// calculate a threshold value for use below
		// ToDo: finalize the definition of the threshold
		threshold = 0.02 * ci + 0.9;

		// check if this tissue is likely to develop microbubbles
		// and/or if this tissue is outside the Buhlmann model
		if( ci <= 5 )
		{
			if( gf >= threshold )
			{
				char_O_deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock);
				
				if( gf >= 1.0 )
				{
					char_O_deco_warnings |= (DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock);
				}
			}
		}
		else
		{
			if( gf >= 1.0 )
			{
				char_O_deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock);
	
				if( gf >= threshold )
				{
					char_O_deco_warnings |= (DECO_WARNING_OUTSIDE + DECO_WARNING_OUTSIDE_lock);
				}
			}
		}
		
		
        // Apply the Eric Baker's varying gradient factor correction if the GF-Model is selected.
        // Note: the correction factor depends both on GF and b,
        //       Actual values are in the 1.5 .. 1.0 range (for a GF=30%),
        //       so that can change who is the leading gas...
        // Note: Also depends of the GF. So the calculus is different for GF_low, current GF, or GF_high...
        //       *BUT* calc_tissue() is used to compute bottom time, hence what would happen at surface,
        //       hence at GF_high.
		if( char_I_deco_model != 0 ) pres_min =   ( pres_tissue - var_N2_a * (      GF_high) ) * var_N2_b
		                                        / ( GF_high     + var_N2_b * (1.0 - GF_high) );

		// check if this tissue requires a higher ambient pressure than was found to be needed up to now
        if( pres_min > calc_lead_tissue_limit )
        {
            char_O_gtissue_no      = ci;
            calc_lead_tissue_limit = pres_min;
        }
    }
	
	// check IBCD condition
	if( !IBCD_tissue_vector )
	{
		char_O_deco_warnings &= ~DECO_WARNING_IBCD;					// no IBCD in any tissue, clear flag
	}
	else if(    (IBCD_tissue_vector & (1 << char_O_gtissue_no))
	         && ((pres_tissue_N2[char_O_gtissue_no] + pres_tissue_He[char_O_gtissue_no]) > pres_respiration) )
	{
		// leading tissue is in IBCD condition and in super-saturation, set flags.
		char_O_deco_warnings |= (DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock);
	}
	
	// check if is any tissue off-gassing
	if	(deco_tissue_vector) char_O_deco_warnings |=  DECO_FLAG;	// yes,  set deco flag
	else                     char_O_deco_warnings &= ~DECO_FLAG;	// no, clear deco flag 


    assert( char_O_gtissue_no < NUM_COMP );
    assert( 0.0 <= calc_lead_tissue_limit && calc_lead_tissue_limit <= 14.0);
}

//////////////////////////////////////////////////////////////////////////////
// calc_nullzeit
//
// calculates the remaining bottom time
//
// NOTE: Erik Baker's closed formula works for Nitroxes. Trimix adds a second
//       exponential term to the M-value equation, making it impossible to
//       invert... So we have to make a fast-simu until we find a better way.
//
// Input:  pres_respiration
// Output: char_O_nullzeit / char_O_alternate_nullzeit
//
static void calc_nullzeit(void)
{
	overlay unsigned char nullzeit = 240;
	
	
    //---- Compute ppN2 and ppHe ---------------------------------------------
    temp_deco = pres_respiration;
    sim_alveolar_presures();
	
    for(ci=0; ci<NUM_COMP; ci++)
    {
        //---- Read A/B values and loading factor for N2 and He --------------

		overlay float tN2 = sim_pres_tissue_N2[ci];
        overlay float tHe = sim_pres_tissue_He[ci];
		
        overlay float t = tN2 + tHe;
        overlay unsigned char ndl;
        overlay unsigned char period = 10;

        read_Buhlmann_coefficients();
        read_Buhlmann_times(2);             // Starts with a 10min period.

        //---- Simulate for that tissue --------------------------------------
        // NOTE: No need to simulate for longer than the already found NDL.
		for(ndl=0; ndl<nullzeit;)
        {
			//---- Compute updated mix M-value at surface
			overlay float a = (var_N2_a * tN2 + var_He_a * tHe) / t;
			overlay float b = (var_N2_b * tN2 + var_He_b * tHe) / t;
			overlay float M0 = (a + pres_surface/b);

			//---- Add 10min/1min to N2/He tissues
			overlay float dTN2 = (ppN2 - tN2) * var_N2_e;
			overlay float dTHe = (ppHe - tHe) * var_He_e;

			//---- Apply safety margin for both models
			// NDL can be computed while ascending... SO we have
			// to check if we are saturating or desaturating.
			if( dTN2 > 0.0 ) dTN2 *= float_saturation_multiplier;
			else             dTN2 *= float_desaturation_multiplier;

			if( dTHe > 0.0 ) dTHe *= float_saturation_multiplier;
			else             dTHe *= float_saturation_multiplier;

			// adopt M0 value when using the GF extension
			if (char_I_deco_model != 0 ) M0 = GF_high * (M0 - pres_surface) + pres_surface;

            //---- Simulate off-gassing while going to surface
            // TODO !
            // dTN2 -= exp( ... ascent time ... ppN2...)
            // dTHe -= exp( ... ascent time ... ppHe...)

            //---- Ok now, and still ok to surface after 1 or 10 minutes ?
            if( (t <= M0) && (t + dTN2 + dTHe <= M0) )
            {
                tN2 += dTN2;		// YES: apply gas loadings,
                tHe += dTHe;
				t    = tN2 + tHe;				
				
                ndl += period;		// increment NDL,

                continue;			// and loop.
            }

            //---- Should we retry with smaller steps ?
            if( period == 10 )
            {
                read_Buhlmann_times(1); // 1min coefs.
                period = 1;

                continue;
            }

            //---- ELSE make a linear approx for the last minute
            // Useful to have a meaningful rounding of NDL.
            // But ONLY if positive (negative casted to unsigned is bad).
            if( M0 > t ) ndl += (unsigned char)(0.5f + (M0-t)/(dTN2+dTHe));
			
            break;
        }

        // Keep the shortest NDL found
		if ( ndl < nullzeit ) nullzeit = ndl;
    }
	
	if( char_O_deco_status & DECO_PLAN_ALTERNATE) char_O_alternate_nullzeit = nullzeit;
	else                                          char_O_nullzeit           = nullzeit;
}

//////////////////////////////////////////////////////////////////////////////
// calc_ascenttime
//
// Sum up ascent from bottom to surface at float_ascent_speed,
// but 1 minute per meter for the final ascent, and all stops.
//
// Result in int_O_ascenttime,
//        or int_O_alternate_ascenttime if doing the alternative plan.
//
static void calc_ascenttime(void)
{
    overlay unsigned char  x;
    overlay unsigned short sum;
	
	// preset final ascent
	overlay float final  = (float)char_I_depth_last_deco;

    // calculate depth
    overlay float ascent = (pres_respiration - pres_surface) * BAR_TO_METER;
	
	// check if we are already in final ascent
    if (ascent <= final)
	{
		// yes - all ascent is final ascent
		final  = ascent;
		ascent = 0.0;
	}
	else
	{
		// no - subtract final ascent part from overall ascent
		ascent -= final;
		
		// compute time for ascent part without final ascent
		ascent /= float_ascent_speed;		
	}
	
	// add 1 minute for each meter of  final ascent
	ascent += final;
	
	// convert to integer
    sum = (unsigned short)(ascent + 0.5);

	// add all stop times
    for(x=0; x<NUM_STOPS && internal_deco_depth[x]; x++)
        sum += (unsigned short)internal_deco_time[x];

	// limit result to display max.
	if( sum > 999) sum = 999;
	
	// tag result as invalid if there is an overflow in the stops table
	if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) sum |= INT_FLAG_INVALID;
	
	// route result to output variable
	if( char_O_deco_status & DECO_PLAN_ALTERNATE ) int_O_alternate_ascenttime = sum;
    else                                           int_O_ascenttime           = sum;
}

//////////////////////////////////////////////////////////////////////////////
// update_startvalues
//
// updated in v.102
//
void update_startvalues(void)
{
    overlay unsigned char x;

    // Start ascent simulation with current tissue partial pressures.
    for(x=0; x<NUM_COMP; x++)
    {
        sim_pres_tissue_N2[x] = pres_tissue_N2[x];
        sim_pres_tissue_He[x] = pres_tissue_He[x];
    }

    // No leading tissue (yet) for this ascent simulation.
    sim_lead_tissue_limit = 0.0;
    sim_lead_tissue_no    = 1;
}

//////////////////////////////////////////////////////////////////////////////
// sim_limit()
//
// New in v.111
//
// Function separated from calc_tissue() to allow recomputing limit on
// different depth, because it depends on current gradient factor.
//
static void sim_limit(PARAMETER float GF_current)
{
    assert( 0.0 < GF_current && GF_current <= 1.0 );

    sim_lead_tissue_limit = 0.0;
    sim_lead_tissue_no    = 0;		// If no one is critic, keep first tissue.

    for(ci=0; ci<NUM_COMP; ci++)
    {
        overlay float N2 = sim_pres_tissue_N2[ci];
        overlay float He = sim_pres_tissue_He[ci];
        overlay float p = N2 + He;

        read_Buhlmann_coefficients();
        var_N2_a = (var_N2_a * N2 + var_He_a * He) / p;
        var_N2_b = (var_N2_b * N2 + var_He_b * He) / p;

        // Apply the Eric Baker's varying gradient factor correction.
        // Note: the correction factor depends both on GF and b,
        //       Actual values are in the 1.5 .. 1.0 range (for a GF=30%),
        //       so that can change who is the leading gas...
        // Note: Also depends of the GF_current...
		if( char_I_deco_model != 0 )  p =   ( p                - (var_N2_a   * GF_current) )
		                                  / ( 1.0 - GF_current + (GF_current / var_N2_b  ) );

		else                          p =   (p - var_N2_a) * var_N2_b;


        if( p > sim_lead_tissue_limit )
        {
            sim_lead_tissue_no    = ci;
            sim_lead_tissue_limit = p;
        }
    } // for ci

    assert( sim_lead_tissue_no < NUM_COMP );
    assert( 0.0 <= sim_lead_tissue_limit && sim_lead_tissue_limit <= 14.0 );
}

//////////////////////////////////////////////////////////////////////////////
// clear_deco_table
//
//
static void clear_deco_table(void)
{
    overlay unsigned char x;

    for(x=0; x<NUM_STOPS; ++x)
    {
        internal_deco_time [x] = 0;
        internal_deco_depth[x] = 0;
    }
	
	// clear stop table overflow warning
	char_O_deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW;
}

//////////////////////////////////////////////////////////////////////////////
// update_deco_table
//
// Add time to a stop at temp_depth_limit
//
// It is possible to create stops with a duration of 0 minutes, e.g. to
// note a gas change "on the fly" while ascending. Therefore the criteria
// to have reached the end of the list needs always to be depth == 0.
//
// Input:   temp_depth_limit  : stop's depth, in meters.
//          sim_gas_last_used : gas used at stop, as index 1..5
//			PARAMETER time_increment    : number of minutes to add to the stop
//
// Updated: internal_deco_depth[] : depth    (in meters)  of each stop
//          internal_deco_time [] : time     (in minutes) of each stop
//          internal_deco_gas  [] : gas used (index 1-5)  at each stop
//
static unsigned char update_deco_table(PARAMETER unsigned char time_increment)
{
	overlay unsigned char x;

	assert( temp_depth_limit > 0 );		// No stop at surface...

	// loop through internal deco table
	for(x=0; x<NUM_STOPS; ++x)
	{
		// Make sure deco-stops are recorded in order:
		assert( !internal_deco_depth[x] || temp_depth_limit <= internal_deco_depth[x] );

		// Is there already a stop entry for our current depth?
		if( internal_deco_depth[x] == temp_depth_limit )
		{
			// Yes - increment stop time if possible
			// Stop time entries are limited to 99 minutes because of display constraints.
			// Else a limit of 254 would account because of constrains in calc_CNS_planning().
			if( internal_deco_time[x] < (99 - time_increment) )
			{
				internal_deco_time[x] += time_increment;	// increment stop time
				return 1;									// return with status 'success'
			}
		}

		// If program flow passes here, there is either no stop entry for the current depth yet, or
		// the existing entry is saturated with 99 minutes. So we are looking for the next unused
		// table entry.
		if( internal_deco_depth[x] == 0 )
		{
			internal_deco_time[x]  = time_increment;		// initialize entry with first stop's time,
			internal_deco_depth[x] = temp_depth_limit;		// ... depth, and
			internal_deco_gas[x]   = sim_gas_last_used;		// ... gas
			return 1;										// return with status 'success'
		}
	}

	// If program flow passes here, all deco table entries are used up.
	
	// set overflow warning
	char_O_deco_warnings |= DECO_WARNING_STOPTABLE_OVERFLOW;
	
	
	// return with status 'failed'.
	return 0;
}

//////////////////////////////////////////////////////////////////////////////
// calc_gradient_factor
//
// optimized in v.101 (var_N2_a)
// new code in v.102
//
static void calc_gradient_factor(void)
{
    overlay float gf;
    overlay float N2 = pres_tissue_N2[char_O_gtissue_no];
    overlay float He = pres_tissue_He[char_O_gtissue_no];

    assert( char_O_gtissue_no < NUM_COMP );
    assert( 0.800 <= pres_respiration && pres_respiration < 14.0 );

    // tissue > respiration (currently off-gassing)
    // GF = 0.00 when respiration == tissue, ie. dissolved gases are at equilibrium.
    // GF = 1.00 when respiration == limit.
    temp_tissue = N2 + He;
    if( temp_tissue <= pres_respiration )
	{
        gf = 0.0;
		int_O_gradient_factor = 0;
	}
    else
    {
        overlay float limit = calc_lead_tissue_limit;
        // NOTE: in GF model, calc_lead_tissue_limit include already the
        //       correction due to gradient factor. To compute the actual
        //       current GF, we need to (re-)compute the raw ambient-pressure
        //       limit from the Buhlmann model.
        if( char_I_deco_model != 0 )
        {
            ci = char_O_gtissue_no;

            read_Buhlmann_coefficients();

            var_N2_a = (var_N2_a * N2 + var_He_a * He) / temp_tissue;
            var_N2_b = (var_N2_b * N2 + var_He_b * He) / temp_tissue;

            limit    = (temp_tissue - var_N2_a) * var_N2_b;
        }

        gf = (temp_tissue - pres_respiration) / (temp_tissue - limit);
		
		// limit to 255 because of constraints in ghostwriter code
		if     ( gf <= 0.0   ) int_O_gradient_factor = 0;
        else if( gf >  2.545 ) int_O_gradient_factor = 255 + INT_FLAG_WARNING;
        else
		{
			int_O_gradient_factor = (unsigned int)(100 * gf + 0.5);
		
			if 		( int_O_gradient_factor >= GF_warning_threshold    ) int_O_gradient_factor |= INT_FLAG_WARNING;
			else if ( int_O_gradient_factor >= GF_prewarning_threshold ) int_O_gradient_factor |= INT_FLAG_PREWARNING;
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
// calc_desaturation_time
//
// FIXED N2_ratio
// unchanged in v.101
// Inputs:  int_I_pres_surface, ppWater, char_I_desaturation_multiplier
// Outputs: int_O_desaturation_time, int_O_nofly_time
//
// Helper function
//
void calc_desaturation_time_helper(void)
{
	if( pres_actual > pres_target )					// check if actual pressure is higher then target pressure
	{												// YES - compute remaining time
		overlay	float pres_ratio;
		
		pres_ratio = pres_actual / pres_target;

		// Compute desaturation time with result rounded up to multiples of 10 minutes.
		// Main purpose is to avoid confusion, because the times do not clock down in one minute steps any more
		// but get constantly re-computed according to current ambient pressure and may therefor make steps of
		// several minutes forwards and backwards as ambient pressure rises and falls.
		short_time = (unsigned short)( (var_ht * log(pres_ratio) / desat_factor) + 0.9 );
	}
	else
	{												// NO  - desaturation state reached, no remaining time
		short_time = 0;
	}
}

/////////////////////////////////////////////////////////////////////////////
// Main function
//
void calc_desaturation_time(void)
{
    assert( 800 < int_I_pres_surface             && int_I_pres_surface             < 1100 );
    assert( 0   < char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100 );


    N2_ratio       = 0.7902; 															// fraction of N2 in respired air
	pres_surface   = 0.001    * int_I_pres_surface;										// surface pressure in bar
	N2_equilibrium = N2_ratio * (pres_surface - ppWater); 								// partial pressure of N2 in respired air
	desat_factor   = 0.06931  * char_I_desaturation_multiplier * SURFACE_DESAT_FACTOR;	// pre-computed term for later use: 
																						// 10 [Min] * 0.01 [%] * 0.6931 [ln(2)] * ...
	int_O_desaturation_time = 0;
	int_O_nofly_time		= 0;
	

    for(ci=NUM_COMP; ci>0;)
    {
		overlay float			pres_tissue_max;
		overlay float			P_ambient_altitude;
		overlay signed char		search_direction;
		overlay unsigned short	nofly_N2   =  0;
		overlay unsigned short	nofly_He   =  0;
		overlay unsigned short	nofly_last = ~0;

		
		ci -= 1;
		
        read_Buhlmann_ht();
		read_Buhlmann_coefficients();
		
		// get selected target altitude
		switch( char_I_altitude_wait )
		{
			case 1:  P_ambient_altitude = P_ambient_1000m;	break;
			case 2:  P_ambient_altitude = P_ambient_2000m;	break;
			case 3:  P_ambient_altitude = P_ambient_3000m;	break;
			default: P_ambient_altitude = P_ambient_fly;	break;
		}
		
		// Target pressure for the tissue is the Buhlmann limit. We use the Buhlmann
		// coefficients for N2 also for He because it is easier to calculate and the
		// N2 coefficients are more conservative than those for He, so we are on the
		// safe side, too.
        pres_tissue_max = (P_ambient_altitude/var_N2_b + var_N2_a);
		
		// Adjust target pressure in case the GF model is in use by GF-high
		if( char_I_deco_model != 0 )
		{
			pres_tissue_max = ((pres_tissue_max - P_ambient_altitude) * char_I_GF_High_percentage * 0.01) + P_ambient_altitude;			
		}
		

		//
		// Desaturation time
		//

		// N2: actual amount of tissue pressure above equilibrium.
		pres_actual = pres_tissue_N2[ci] - N2_equilibrium;
		
		// N2: half-time of the current tissue
		var_ht		= var_N2_ht;

		// Calculate desaturation time for N2 in tissue.
		// Desaturated state is defined as residual tissue pressure <= 1.05 x ppN2 respired

		pres_target = 0.05 * N2_equilibrium;

		calc_desaturation_time_helper();

		if( short_time > int_O_desaturation_time) int_O_desaturation_time = short_time;


		// He: actual amount of tissue pressure above equilibrium.
		pres_actual = pres_tissue_He[ci];								// equilibrium for He is 0 bar

		// He: half-time of the current tissue
		var_ht		= var_He_ht;
		
		// Calculate desaturation time for He in the tissue.
		// Desaturated state is defined as residual tissue pressure <= 0.05 x ppN2 respired

		pres_target = 0.05 * N2_equilibrium;

		calc_desaturation_time_helper();

		if( short_time > int_O_desaturation_time) int_O_desaturation_time = short_time;			


		//
		// no-fly time
		//

		// initialize search direction
		search_direction = 0;
		
		for(;;)
		{
			// N2: actual amount of tissue pressure above equilibrium.
			pres_actual = pres_tissue_N2[ci] - N2_equilibrium;
		
			// N2: half-time of the current tissue
			var_ht		= var_N2_ht;
		
			// Calculate no-fly time for N2 in the tissue.
			// Flying is permitted when the N2 pressure fits into the assigned fraction above equilibrium.

			pres_target = (split_N2_He[ci] * 0.01) * (pres_tissue_max - N2_equilibrium);

			if( pres_target < 0.0 )						// check if desaturation to fly target is possible
			{
				int_O_nofly_time = 288;					// NO  - set no-fly time to 288 * 10 min = 48 h
				break;									// done for this compartment
			}
			else 
			{
				calc_desaturation_time_helper();
				nofly_N2 = short_time;
			}
		
			// He: actual amount of tissue pressure above equilibrium - equilibrium for He is 0 bar.
			pres_actual = pres_tissue_He[ci];

			// He: half-time of the current tissue
			var_ht		= var_He_ht;
		
			// Calculate no-fly time for He in the tissue.
			// Flying is permitted when the He pressure fits into the assigned fraction.

			pres_target = ((100 - split_N2_He[ci]) * 0.01) * (pres_tissue_max - N2_equilibrium);

			calc_desaturation_time_helper();
			nofly_He = short_time;


			// Because the sum of N2 and He tissue pressures needs to fit into the Buhlmann limit for
			// no-fly time calculation, each gas gets assigned a fraction of the available total pressure
			// limit. The optimum split between the two gases can not be computed by a single formular,
			// because this would require the inversion of a function with two exponential terms, which is
			// not possible. We do not want to do a computational complex simulation here like it is done
			// in the deco calculation code (although we tackle the same base problem here), so we just let
			// the computer try out which split will balance the no-fly times induced by the N2 and the He
			// at best.
			
			// first of all, skip any optimization in case the current compartment is not the leading one
			if( (nofly_N2 <= int_O_nofly_time) && (nofly_He <= int_O_nofly_time) ) break;

			// check if the N2 requires more waiting time than the He
			if( nofly_N2 >= nofly_He )							
			{
				// check if the search direction has changed, which means we are beyond the
				// optimum now, or if we are at the upper stop limit of split_N2_He
				if( (search_direction < 0) || (split_N2_He[ci] == 99) )
				{	
					// Either the just completed iteration was more close to the optimum or the one before
					// was, so we take the best (i.e. shortest) time of both as the final no-fly time.
					int_O_nofly_time = (nofly_N2 < nofly_last) ? nofly_N2 : nofly_last;
					break;
				}

				// store the no-fly time found in this iteration
				nofly_last = nofly_N2;				
				
				// increase the N2 fraction of the split and set search direction towards more N2
				split_N2_He[ci]  +=  1;
				search_direction  = +1;
			}
			else
			{
				// check if the search direction has changed, which means we are beyond the
				// optimum now, or if we are at the lower stop limit of split_N2_He
				if( (search_direction > 0) || (split_N2_He[ci] == 1) )
				{	
					// Either the just completed iteration was more close to the optimum or the one before
					// was, so we take the best (i.e. shortest) time of both as the final no-fly time.
					int_O_nofly_time = (nofly_He < nofly_last) ? nofly_He : nofly_last;
					break;
				}

				// store the no-fly time found in this iteration
				nofly_last = nofly_He;				
				
				// decrease the N2 fraction of the split and set search direction towards less N2
				split_N2_He[ci]  -=  1;
				search_direction  = -1;	
			}
			
		} // for(;;)

	} // for(compartments)

		
	// Rescale int_O_desaturation_time and int_O_nofly_time to full minutes for display purpose
	int_O_desaturation_time *= 10;
	int_O_nofly_time		*= 10;
		
	// Limit int_O_desaturation_time and int_O_nofly_time to 5999 = 99 hours + 59 minutes
	// because of display space constraints and rounding done above.
	if( int_O_desaturation_time > 5999 ) int_O_desaturation_time = 5999;
	if( int_O_nofly_time        > 5999 ) int_O_nofly_time        = 5999;


	// Clear the microbubbles warning when the current gradient factor is < GF_warning_threshold.
	// As the locked warning will stay set, this will cause the warning be be displayed in attention
	// color instead of warning color.
	if( int_O_gradient_factor < GF_warning_threshold ) char_O_deco_warnings &= ~DECO_WARNING_MBUBBLES;
	
	// clear some warnings when the desaturation time has become zero
	if( int_O_desaturation_time == 0 ) char_O_deco_warnings &= ~(   DECO_WARNING_IBCD     + DECO_WARNING_IBCD_lock
																  + DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock
																  + DECO_WARNING_OUTSIDE  + DECO_WARNING_OUTSIDE_lock  );

}

//////////////////////////////////////////////////////////////////////////////
// calc_wo_deco_step_1_min
//
// optimized in v.101 (...saturation_multiplier)
// desaturation slowed down to 70,42%
//
// Input: int_I_pres_surface [mbar]
//
static void calc_wo_deco_step_1_min(void)
{
    assert( 800 <  int_I_pres_surface             && int_I_pres_surface             <  1100 );
    assert( 100 <= char_I_saturation_multiplier   && char_I_saturation_multiplier   <  200  );
    assert( 0   <  char_I_desaturation_multiplier && char_I_desaturation_multiplier <= 100  );

	// setup input data for deco routines
    pres_respiration = pres_surface = int_I_pres_surface * 0.001;
	
	N2_ratio       = 0.7902; 									// according to Buhlmann
	N2_equilibrium = N2_ratio * (pres_surface     - ppWater);	// used for N2 tissue graphics scaling
    ppN2           = N2_ratio * (pres_respiration - ppWater);
    ppHe           = 0.0;

    float_desaturation_multiplier = char_I_desaturation_multiplier * 0.01 * SURFACE_DESAT_FACTOR;
    float_saturation_multiplier   = char_I_saturation_multiplier   * 0.01;


	// program what to do: 128 = Flag for "real" tissues, 1 = 1 minute
	tissue_increment = 128 + 1;

	// update the pressure in the tissues N2/He in accordance with the new ambient pressure
	calc_tissue();		
	
	// clock down CNS by a 1 minute step
	CNS_fraction *= 0.992327946;
	
	// compute integer copy of CNS value
	compute_CNS_for_display();
	
	// reset deco engine start condition (probably not needed to be done here...)
	char_O_deco_status &= ~DECO_STATUS_MASK;	// clear bits
	char_O_deco_status |= DECO_STATUS_INIT;		// set bits
	
	// reset some more data that are not applicable in surface mode
    char_O_nullzeit            = 0;
    int_O_ascenttime           = 0;
	int_O_alternate_ascenttime = 0;
	clear_deco_table();
	
	// calculate gradient factor
    calc_gradient_factor();
}

//////////////////////////////////////////////////////////////////////////////
// calc_dive_interval
//
// Prepare tissue for delay before the next dive simulation.
//
// Inputs:   char_I_dive_interval == delay before dive (in 1 Minute steps).
// Modified: CNS_fraction, int_O_CNS_fraction
// 			 pres_tissue_N2/He[]
//
// Should be protected by deco_push_tissues_to_vault(),
//                        deco_pull_tissues_from_vault()
//
// desaturation slowed down to 70,42%.
//
static void calc_dive_interval(void)
{
    overlay unsigned char t;
    
    //---- Initialize simulation parameters ----------------------------------
    pres_respiration = pres_surface = int_I_pres_surface * 0.001;
	
	N2_ratio       = 0.7902; 									// according to buehlmann
	N2_equilibrium = N2_ratio * (pres_surface     - ppWater);	// used for N2 tissue graphics scaling
    ppN2           = N2_ratio * (pres_respiration - ppWater);
    ppHe           = 0.0;
	
    float_desaturation_multiplier = char_I_desaturation_multiplier * 0.01 * SURFACE_DESAT_FACTOR;
    float_saturation_multiplier   = char_I_saturation_multiplier   * 0.01;
	
    //---- Perform simulation ------------------------------------------------

	// Calculate tissues:
	// Because tissue_increment is limited to 127 minutes, we have to do two passes
	// in case char_I_dive_interval is bigger than 127.
	// Ops: char_I_dive_interval must be limited to 254!

	t = char_I_dive_interval;

	if ( t == 255 ) t = 254;

	if ( t > 127 )							// extra pass needed?
	{
		tissue_increment = 127				// dive interval length in minutes
						 | 128;				// Flag to update the "real" tissues			
		
		calc_tissue();						// update tissues
		
		t -= 127;							// calculate remaining dive interval length
	}

	tissue_increment = t 					// dive interval length in minutes to do
					 | 128;					// Flag to update the "real" tissues
	calc_tissue();							// update tissues
	

	// Calculate CNS:
	// To speed up things and because on most invocations of this code char_I_dive_interval
	// is a multiple of 10 minutes, we loop the loop-counter down using two speeds.

	t = char_I_dive_interval;

	while ( t )
	{
		if( t > 9 )
		{
			CNS_fraction *= 0.925874712;	// Half-time = 90min -> 10 min: (1/2)^(1/9)
			t            -= 10;				// fast speed looping
		}
		else
		{
			CNS_fraction *= 0.992327946;	// Half-time = 90min ->  1 min: (1/2)^(1/90)
			t            -= 1;				// slow speed looping
		}
	}	

	// compute integer copy of CNS value
	compute_CNS_for_display();
}

//////////////////////////////////////////////////////////////////////////////
// clear_CNS_fraction
//
// new in v.101
//
void clear_CNS_fraction(void)
{
	CNS_fraction       = CNS_sim_norm_fraction     = CNS_sim_alt_fraction         = 0;
	int_O_CNS_fraction = int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = 0;
}

//////////////////////////////////////////////////////////////////////////////
// calc_CNS_fraction
//
// Input:  char_actual_ppO2     : current ppO2 [decibars]
//         tissue_increment  	: time increment and tissue selector
//         CNS_fraction         : current CNS% as float before period
//
// Output: CNS_fraction,          int_O_CNS_fraction 			- for the real tissues
//         CNS_sim_norm_fraction, int_O_normal_CNS_fraction		- in simulation mode, normal plan
//         CNS_sim_alt_fraction,  int_O_alternate_CNS_fraction  - in simulation mode, alternative plan
//
void calc_CNS_fraction(void)
{
    overlay float time_factor       = 1.0;		// default is 2sec
	overlay float CNS_fraction_temp = 0.0;
	
    assert( char_actual_ppO2 > 15 );
	
	// All deco code is now invoked every second. But as the CNS update is based on
	// 2 seconds periods, we skip every 2nd seconds-based invocation of this function.
	// 128 = 128 (flag for "real" CNS) + 0 (2 seconds period)
	// To distribute computational load, the CNS% is calculated in "the other second"
	// than the tissues.
	if( (tissue_increment == 128) && (twosectimer) ) return;
	
	// adjust time factor if minute-based stepping is commanded, mask out flag bit
	if( tissue_increment & 127 ) time_factor = 30.0 * (float)(tissue_increment & 127);

		
    //------------------------------------------------------------------------
    // Don't increase CNS below 0.5 bar, but keep it steady.
    if (char_actual_ppO2 < 50)
        ;   // no changes
    //------------------------------------------------------------------------
    // Below (and including) 1.60 bar
    else if (char_actual_ppO2 < 61)
        CNS_fraction_temp = time_factor/(-533.07 * char_actual_ppO2 + 54000.0);
    else if (char_actual_ppO2 < 71)
        CNS_fraction_temp = time_factor/(-444.22 * char_actual_ppO2 + 48600.0);
    else if (char_actual_ppO2 < 81)
        CNS_fraction_temp = time_factor/(-355.38 * char_actual_ppO2 + 42300.0);
    else if (char_actual_ppO2 < 91)
        CNS_fraction_temp = time_factor/(-266.53 * char_actual_ppO2 + 35100.0);
    else if (char_actual_ppO2 < 111)
        CNS_fraction_temp = time_factor/(-177.69 * char_actual_ppO2 + 27000.0);
    else if (char_actual_ppO2 < 152)
        CNS_fraction_temp = time_factor/( -88.84 * char_actual_ppO2 + 17100.0);
    else if (char_actual_ppO2 < 167)
        CNS_fraction_temp = time_factor/(-222.11 * char_actual_ppO2 + 37350.0);
    //------------------------------------------------------------------------
    // Arieli et all.(2002): Modeling pulmonary and CNS O2 toxicity:
    // J Appl Physiol 92: 248--256, 2002, doi:10.1152/japplphysiol.00434.2001
    // Formula (A1) based on value for 1.55 and c=20
    // example calculation: Sqrt((1.7/1.55)^20)*0.000404
    else if (char_actual_ppO2 < 172)
        CNS_fraction_temp = time_factor*0.00102;
    else if (char_actual_ppO2 < 177)
        CNS_fraction_temp = time_factor*0.00136;
    else if (char_actual_ppO2 < 182)
        CNS_fraction_temp = time_factor*0.00180;
    else if (char_actual_ppO2 < 187)
        CNS_fraction_temp = time_factor*0.00237;
    else if (char_actual_ppO2 < 192)
        CNS_fraction_temp = time_factor*0.00310;
    else if (char_actual_ppO2 < 198)
        CNS_fraction_temp = time_factor*0.00401;
    else if (char_actual_ppO2 < 203)
        CNS_fraction_temp = time_factor*0.00517;
    else if (char_actual_ppO2 < 233)
        CNS_fraction_temp = time_factor*0.0209;
    else
        CNS_fraction_temp = time_factor*0.0482; // value for 2.5 bar, used for 2.33 bar and above


	// Check from where we were called:
	// flag (bit 7) is  set -> we were called from calc_hauptroutine()
	// flag (bit 7) not set -> we were called from the deco planning routines
	if       ( tissue_increment   & 128                 ) CNS_fraction          += CNS_fraction_temp;	// real tissues
	else if  ( char_O_deco_status & DECO_PLAN_ALTERNATE ) CNS_sim_alt_fraction  += CNS_fraction_temp;	// alternative plan
	     else                                             CNS_sim_norm_fraction += CNS_fraction_temp;	// normal plan

}

//////////////////////////////////////////////////////////////////////////////
// calc_CNS_planning
//
// Compute CNS during predicted ascent.
//
// Note:    Needs a call to deco_push_tissues_to_vault(),
//          deco_pull_tissues_from_vault() to avoid trashing everything...
//
// Input:   CNS_fraction, internal_deco_time[], internal_deco_depth[], internal_deco_gas[]
// Output:  CNS_fraction, int_O_normal_CNS_fraction / int_O_alternate_CNS_fraction
//
void calc_CNS_planning(void)
{
	// start with CNS% we already have
	if( char_O_deco_status & DECO_PLAN_ALTERNATE ) CNS_sim_alt_fraction  = CNS_fraction;
	else                                           CNS_sim_norm_fraction = CNS_fraction;

	
    //---- CCR mode : do the full TTS at once ---------------------------------

	if( ((char_O_deco_status & DECO_MODE_MASK) == DECO_MODE_CCR) )
    {
		overlay unsigned short t;       				// needs 16 bits here !

		// get current ppO2 from sensors or setpoint
        char_actual_ppO2 = char_I_const_ppO2;

		// calculate CNS% for the period of additional staying at bottom depth (fTTS / delayed ascent)
		if( char_O_deco_status & DECO_ASCENT_DELAYED)
		{
			tissue_increment  = char_I_extra_time;		// must be limited to 127, is limited by range of char_I_extra_time
			calc_CNS_fraction();
		}
		
		// get the ascent time dependent on the current plan
		t = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? int_O_alternate_ascenttime : int_O_ascenttime;
		
		// start simulating CNS% in chunks of 127 minutes
		tissue_increment = 127;

		while( t > 127 )
		{
			t -= 127;									// tissue_increment is limited to 127 minutes because of flag in bit 7
			calc_CNS_fraction();						// calculate CNS in chunks of full 127 minutes
		}

		tissue_increment = (char)t;						// get the remaining minutes <= 127
		calc_CNS_fraction();							// calculate CNS for the remaining minutes
    }
	else //---- OC mode and pSCR without sensors: have to follow all gas switches... -----
    {
		overlay float float_actual_ppO2;
		overlay float abs_pres;

		overlay unsigned char stop_depth;
		overlay unsigned char last_gas;
		overlay unsigned char i;    					// stop table index

		
		// retrieve bottom gas 0 (manual gas) or 1-5 (configured gases)
		last_gas = sim_gas_last_used = sim_gas_first_used;

		// get the calc_N2/He/O2_ratios of the bottom gas
		gas_switch_set();             

		// calculate absolute pressure
		abs_pres = pres_surface + char_I_bottom_depth * METER_TO_BAR;
		
		// switch on deco mode pSCR / OC
		if( char_O_deco_status & DECO_MODE_PSCR )
		{
			//---- pSCR calculated --------------------------------------------

			// abs_pres              is 0.0 ...     in bar
			// calc_O2_ratio		 is 0.0 ...   1.0 as factor
			// char_I_PSCR_drop      is 0   ...  15 as %
			// char_I_PSCR_lungratio is 5   ...  20 as %
			// float_actual_ppO2     is 0.0 ...     in cbar (!)

			float_actual_ppO2 =   (100 * abs_pres * calc_O2_ratio)
			                    - (1.0 - calc_O2_ratio) * char_I_PSCR_drop * char_I_PSCR_lungratio;
		}
		else
		{
			//---- OC ---------------------------------------------------------
			
			float_actual_ppO2 = abs_pres * calc_O2_ratio * 100; // in cbar (!)
		}
	
		// caution: float_actual_ppO2 is in cbar here!
		if      ( float_actual_ppO2 < 0.0   ) char_actual_ppO2 =   0;
        else if ( float_actual_ppO2 > 254.5 ) char_actual_ppO2 = 255;
        else                                  char_actual_ppO2 = (unsigned char)(float_actual_ppO2 + 0.5);
		

		// simulate extended bottom time (fTTS) / delay before ascent (bailout) if configured
		if( char_O_deco_status & DECO_ASCENT_DELAYED )
		{
			tissue_increment  = char_I_extra_time;		// must be limited to 127, is limited by range of char_I_extra_time
			calc_CNS_fraction();			
		}

		
		// For simplicity reason (non-linearity of the relation between ppO2 and CNS increments), the
		// whole ascent is calculated with bottom ppO2. This errs, but it does so to the safe side.
		
		// calculate ascent time (integer division and generous round-up)
		tissue_increment = char_I_bottom_depth / char_I_ascent_speed + 1;
		
		// commented out - not needed when char_I_ascent_speed is limited to a
		//                 minimum of 2.something, it is indeed limited to 5.
		// limit tissue_increment to 127 minutes
		// if( tissue_increment > 127 ) tissue_increment = 127;			

		// simulate the CNS increase
		calc_CNS_fraction();


        //---- Stops ---------------------------------------------------------
		
        for(i=0; i<NUM_STOPS; ++i)
        {
			// get the depth of the stop
			stop_depth = internal_deco_depth[i];

			// did we reach the last entry (depth = 0)? if yes, done
			if (stop_depth == 0) break;

			// get the duration of the stop and the gas breathed
			tissue_increment  = internal_deco_time[i];
            sim_gas_last_used = internal_deco_gas[i];
			
            // do we have a gas switch?
            if( sim_gas_last_used != last_gas )
            {
				// yes - get new calc ratios
				gas_switch_set();				

				// remember new gas as last gas
				last_gas = sim_gas_last_used;
			}

            // calculate absolute pressure at stop depth
			abs_pres = pres_surface + stop_depth * METER_TO_BAR;
			
			// pSCR mode
			if( char_O_deco_status & DECO_MODE_PSCR )
			{
				// abs_pres              is 0.0 ...     in bar
				// calc_O2_ratio		 is 0.0 ...   1.0 as factor
				// char_I_PSCR_drop      is 0   ...  15 as %
				// char_I_PSCR_lungratio is 5   ...  20 as %
				// float_actual_ppO2     is 0.0 ...     in cbar (!)

				float_actual_ppO2 =   (100 * abs_pres * calc_O2_ratio)
				                    - (1.0 - calc_O2_ratio) * char_I_PSCR_drop * char_I_PSCR_lungratio;
			}
			else // OC mode
			{
				float_actual_ppO2 = abs_pres * calc_O2_ratio * 100;	// in cbar (!)
			}

			// caution: float_actual_ppO2 is in cbar here!
			if      ( float_actual_ppO2 < 0.0   ) char_actual_ppO2 =   0;
			else if ( float_actual_ppO2 > 254.5 ) char_actual_ppO2 = 255;
			else                                  char_actual_ppO2 = (unsigned char)(float_actual_ppO2 + 0.5);

			
			// ** Currently, stop times per stop entry are limited to 99 minutes in update_deco_table(),
			// ** so the following code block is not needed at times.
			//
			// // tissue_increment is limited to 127 when fed to deco_calc_CNS_fraction(),
			// // so if the stop is longer than 127 minutes (but not longer than 254 minutes!)
			// // we need to calculate the CNS in two chunks.
			// if( tissue_increment > 127)
			// {
			//		tissue_increment -= 127;	// subtract full 127 minutes and do the "remaining" minutes first
			//		calc_CNS_fraction();
			//		tissue_increment  = 127;	// catch up with the previously subtracted full 127 minutes
			// }

            // calculate CNS% for the stop			
			calc_CNS_fraction();
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// deco_calc_CNS_decrease_15min
//
// new in v.101
//
// calculates the half time of 90 minutes in 6 steps of 15 min
// (Used in sleep mode, for low battery mode).
//
// Output: int_O_CNS_fraction
// Uses and Updates: CNS_fraction
//
void deco_calc_CNS_decrease_15min(void)
{
    RESET_C_STACK
 
	// clock down CNS
    CNS_fraction =  0.890899 * CNS_fraction;
	
	// compute integer copy of CNS value
	compute_CNS_for_display();
}


//////////////////////////////////////////////////////////////////////////////
// gas_volumes
//
// calculates volumes and required tank fill pressures for each gas.
//
// Input:   char_I_bottom_depth		 depth of the bottom segment
//			char_I_bottom_time		 duration of the bottom segment
//			char_I_extra_time		 extra bottom time for fTTS / delayed ascent
//			float_ascent_speed       ascent speed, in meters/minute
//          sim_gas_first_used 		 the bottom gas (1-5 for configured gases, 0 for the manual gas)
//          internal_deco_depth[]	 depth of the stops
//			internal_deco_time[]	 duration of the stops
//			internal_deco_gas[]      gas breathed at the stops
//          char_I_bottom_usage 	 gas consumption during bottom part and initial ascent, in liters/minute
//          char_I_deco_usage 		 gas consumption during stops and following ascents, in liters/minute
//			char_I_tank_size[]       size of the tanks for gas 1-5, in liters
//			char_I_tank_pres_fill[]  fill pressure of the tanks
//
// Output:  int_O_gas_volumes[]      amount of gas needed, in liters
//			int_O_tank_pres_need[]   in bar, + flags for fast evaluation by dive mode warnings:
//											   2^15: pres_need >= pres_fill
//											   2^14: pres_need >= press_fill * GAS_NEEDS_ATTENTION_THRESHOLD
//											   2^11: pres_need == 0
//											   2^10: pres_need invalid
//
void gas_volumes_helper(void)
{
	// Calculate the gas volume needed at a given depth, time and usage (SAC rate).
	// We use 1.0 for the surface pressure to have stable results when used through
	// the deco calculator (simulation mode).
	volume = (float_depth * METER_TO_BAR + 1.0) * float_time * usage;
	
	return;
}

void gas_volumes(void)
{
	overlay float volumes[NUM_GAS];

	overlay unsigned char stop_gas;
	overlay unsigned char stop_gas_last;
	overlay unsigned char stop_time;
	overlay unsigned char stop_depth;
	overlay unsigned char stop_depth_last;
	overlay unsigned char i;

	
    //---- initialization ----------------------------------------------------
	
	// null the volume accumulators
    for(i=0; i<NUM_GAS; ++i) volumes[i] = 0.0;

	// quit for CCR and pSCR mode
	if( char_O_deco_status & DECO_MODE_LOOP ) goto done;


    //---- bottom demand -----------------------------------------------------
	
	// sim_gas_first_used : gas used during bottom segment (0, 1-5)
	// char_I_bottom_depth: depth of the bottom segment
	
	assert(0 <= sim_gas_first_used && sim_gas_first_used <= NUM_GAS);

	// get the gas used during bottom segment
	stop_gas_last = stop_gas = sim_gas_first_used;
	
	// set the usage (SAC rate) to bottom usage rate for bottom part and initial ascent
	usage = char_I_bottom_usage;
		
	// volumes are only calculated for gases 1-5, but not the manually configured one
	if( stop_gas )
	{
		// set the bottom depth
		float_depth = (float)char_I_bottom_depth;
		
		// calculate either bottom segment or fTTS / delayed ascent
		if( char_O_deco_status & DECO_ASCENT_DELAYED )
		{
			// duration of delayed ascent
			float_time = (float)char_I_extra_time;
		}
		else
		{
			// duration of bottom segment
			float_time = (float)char_I_bottom_time;
		}
		
		// calculate gas demand
		gas_volumes_helper();
		
		// take result
		volumes[stop_gas-1] = volume;
	}
	
	
	// initialize stop index with first stop
	i = 0;

	
	//---- initial ascent demand ---------------------------------------------
	
	// stop_gas                : gas from bottom segment
	// char_I_bottom_depth     : depth of the bottom segment
	// internal_deco_depth[i=0]: depth of the first stop, may be 0 if no stop exists
	
	// get the data of the first stop	
	stop_depth = internal_deco_depth[i];
	stop_time  = internal_deco_time[i];
	
	// volumes are only calculated for gases 1-5, but not the manually configured one
	if( stop_gas )
	{
		// compute distance between bottom and first stop
		float_depth = (float)char_I_bottom_depth - (float)stop_depth;
		
		// initial ascent exists only if ascent distance is > 0
		if( float_depth > 0.0 )
		{
			// compute ascent time
			float_time = float_depth / float_ascent_speed;
		
			// compute average depth between bottom and first stop
			float_depth = (float)char_I_bottom_depth - float_depth * 0.5;

			// calculate gas demand
			gas_volumes_helper();

			// add result
			volumes[stop_gas-1] += volume;
		}
	}

	// switch the usage (SAC rate) to deco usage rate
	// for stops, intermediate and final ascent
	usage = char_I_deco_usage;
	
	// is there a (first) stop? if yes, goto stops processing
	if( stop_depth ) goto stops;
	
	// add demand of a 3 minutes safety stop at 5 meters, at least for contingency...
	float_time  = 3.0;
	float_depth = 5.0;

	// calculate gas demand
	gas_volumes_helper();

	// add result
	volumes[stop_gas-1] += volume;

	// proceed to volume conversion and pressure calculations
	goto done;			

	
	//---- intermediate ascent demand ---------------------------------------
inter_ascents:

	// store last stop depth and gas
	stop_depth_last = stop_depth;
	stop_gas_last   = stop_gas;
	
	// check if we are at the end of the stops table
	if( i < NUM_STOPS-1 )
	{
		// there are more entries - get the next stop data
		i++;

		// get the next stop depth
		stop_depth = internal_deco_depth[i];

		// check if there is indeed another stop,
		// if not (depth = 0) treat as end of table
		if( stop_depth == 0 ) goto end_of_table;

		// get the next stop duration
		stop_time = internal_deco_time[i];
	}
	else
	{
end_of_table:

		// End of the stops table reached or no more stops: Split the remaining
		// ascent into an intermediate ascent and a final ascent by creating a
		// dummy stop at the usual last deco stop depth. Stop gas doesn't change.
		stop_time  = 0;
		stop_depth = char_I_depth_last_deco;
	}

	// volumes are only calculated for gases 1-5, but not the manually configured one
	if( stop_gas_last )
	{
		// compute distance between the two stops:
		// last stop will always be deeper than current stop
		float_depth = (float)(stop_depth_last - stop_depth);

		// compute ascent time
		float_time = float_depth / float_ascent_speed;
		
		// compute average depth between the two stops
		float_depth = (float)stop_depth_last - float_depth * 0.5;

		// calculate gas demand
		gas_volumes_helper();

		// add result
		volumes[stop_gas_last-1] += volume;
	}


	//---- next stop demand -------------------------------------------------
stops:
	
	// convert depth of the stop
	float_depth = (float)stop_depth;
	
	// get the next gas
	stop_gas = internal_deco_gas[i];
	
	// do we we have a gas change?
	if( stop_gas_last && (stop_gas != stop_gas_last) )
	{
		// yes - spend an additional char_I_gas_change_time on the old gas
		float_time = (float)char_I_gas_change_time;
		
		// calculate gas demand
		gas_volumes_helper();

		// add result
		volumes[stop_gas_last-1] += volume;
	}
	
	// calculate and add demand on new gas for the full stop duration
	if( stop_gas )
	{
		// get the duration of the stop
		float_time = (float)stop_time;
				
		// calculate gas demand
		gas_volumes_helper();

		// add result to last gas
		volumes[stop_gas-1] += volume;
	}

	// continue with the next intermediate ascent if this was not the last stop
	if( stop_depth > char_I_depth_last_deco ) goto inter_ascents;


	//---- final ascent demand -----------------------------------------------
final_ascent:

	// float_depth: depth of last stop
	// stop_gas   : gas from last stop (0 or 1-5)
	
	// volumes are only calculated for gases 1-5, but not the manually configured one	
	if( stop_gas )
	{
		// set ascent time according to an ascent speed of 1 meter per minute
		float_time = float_depth;
		
		// set half-way depth
		float_depth *= 0.5;
		
		// calculate gas demand
		gas_volumes_helper();

		// add result
		volumes[stop_gas-1] += volume;
	}


    //---- convert results for the assembler interface -----------------------------
done:

    for(i=0; i<NUM_GAS; ++i)
	{
        if( volumes[i] >= 65534.5 )
		{
			int_O_gas_volumes[i]	= 65535;
			int_O_tank_pres_need[i]	= 999 + INT_FLAG_WARNING; // 999 bar + warning flag for > pres_fill
		}
		else
		{
			overlay unsigned short tank_pres_fill = 10.0 * (unsigned short)char_I_tank_pres_fill[i];
			
			// No distinct rounding done here because volumes are not accurate to the single liter anyhow
			
			// convert gas volumes to integers
            int_O_gas_volumes[i]     = (unsigned short)volumes[i];
		
			// compute how much pressure in the tank will be needed [in bar]  (integer-division)
			int_O_tank_pres_need[i]  = (unsigned short)(int_O_gas_volumes[i] / char_I_tank_size[i]);
			
			// limit to 999 bar because of display constraints
			if( int_O_tank_pres_need[i] > 999 ) int_O_tank_pres_need[i] = 999;
			
			// set flags for fast evaluation by divemode check for warnings
			if     ( int_O_tank_pres_need[i] == 0 )
			{
				// set flag for 0 bar
				int_O_tank_pres_need[i] |= INT_FLAG_ZERO;
			}
			else if( int_O_tank_pres_need[i] >= tank_pres_fill )
			{
				// set warning flag
				int_O_tank_pres_need[i] |= INT_FLAG_WARNING;

			}
			else if( int_O_tank_pres_need[i] >= tank_pres_fill * GAS_NEEDS_ATTENTION_THRESHOLD )
			{
				// set pre-warning flag
				int_O_tank_pres_need[i] |= INT_FLAG_PREWARNING;	
			}			

			// set invalid flag if there is an overflow in the stops table
			if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
				int_O_tank_pres_need[i] |= INT_FLAG_INVALID;
			
		} // if( volumes[i] )
	} // for
}

//////////////////////////////////////////////////////////////////////////////

void compute_CNS_for_display(void)
{
	if		( CNS_fraction <  0.01  ) int_O_CNS_fraction = 0;
	else if ( CNS_fraction >= 9.985 ) int_O_CNS_fraction = 999 + INT_FLAG_WARNING;
	else
	{
		// convert float to integer
		int_O_CNS_fraction = (unsigned short)(100 * CNS_fraction + 0.5);
	
		// compute warnings
		if		( int_O_CNS_fraction >= CNS_warning_threshold    )
		{
			// reset pre-warning and set main warning flag
			int_O_CNS_fraction &= ~INT_FLAG_PREWARNING;			
			int_O_CNS_fraction |=  INT_FLAG_WARNING;
		}
		else if	( int_O_CNS_fraction >= CNS_prewarning_threshold )
		{
			// reset main warning but set pre-warning flag
			int_O_CNS_fraction &= ~INT_FLAG_WARNING;
			int_O_CNS_fraction |=  INT_FLAG_PREWARNING;
		}
		else
		{
			// clear both warnings
			int_O_CNS_fraction &= ~(INT_FLAG_WARNING + INT_FLAG_PREWARNING);
		}
	}
}

//////////////////////////////////////////////////////////////////////////////

void deco_push_tissues_to_vault(void)
{
    overlay unsigned char x;

    RESET_C_STACK

	low_depth_norm_vault = low_depth_norm;
	low_depth_alt_vault  = low_depth_alt;
    cns_vault_float      = CNS_fraction;
	cns_vault_int        = int_O_CNS_fraction;
	deco_warnings_vault  = char_O_deco_warnings;

    for (x=0;x<NUM_COMP;x++)
    {
        pres_tissue_N2_vault[x] = pres_tissue_N2[x];
        pres_tissue_He_vault[x] = pres_tissue_He[x];
    }
}

void deco_pull_tissues_from_vault(void)
{
    overlay unsigned char x;

    RESET_C_STACK

	low_depth_norm       = low_depth_norm_vault;
	low_depth_alt        = low_depth_alt_vault;
    CNS_fraction         = cns_vault_float;
    int_O_CNS_fraction   = cns_vault_int;
	char_O_deco_warnings = deco_warnings_vault;
	
	locked_GF_step_norm  = GF_delta / low_depth_norm;
	locked_GF_step_alt   = GF_delta / low_depth_alt;
	
    for (x=0; x<NUM_COMP; x++)
    {
        pres_tissue_N2[x] = pres_tissue_N2_vault[x];
        pres_tissue_He[x] = pres_tissue_He_vault[x];
    }
}

//////////////////////////////////////////////////////////////////////////////
//
#ifndef CROSS_COMPILE
void main() {}
#endif