// ***************************************************************************
// p2_deco.c                                         REFACTORED VERSION V2.99f
//
//  Created on: 12.05.2009
//  Author: heinrichs weikamp, contributions by Ralph Lembcke and others
//
// ***************************************************************************

//////////////////////////////////////////////////////////////////////////////
// OSTC - diving computer code
// Copyright (C) 2018 HeinrichsWeikamp GmbH
//
//    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/>.
//
//////////////////////////////////////////////////////////////////////////////

// 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
// 2018/02/17: [rl]  switch-over to new ceiling rounding (V2.98a)
//
//
// Literature:
// Buhlmann, Albert: Tauchmedizin; 4. Auflage [2002];
// Schroeder, Kai & Reith, Steffen; 2000; Saettigungsvorgaenge 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>
#include	"p2_definitions.h"
#define		TEST_MAIN
#include	"shared_definitions.h"


// *********************************************************************************************************************************
//
//                                         C O N S T A N T S   D E F I N I T I O N S
//
// *********************************************************************************************************************************

// conditional compiles
#define		_rx_functions						// if defined, compile transmitter functions   (default:     included *)
//#define	_cave_mode							// if defined, compile cave mode into firmware (default: not included *)   ## OPTION IS UNDER CONSTRUCTION ##
												// * option needs to be included / excluded in hwos.inc, too!

// 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.06270	// 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.70420	// surface desaturation safety factor
#define HYST							1.0E-06	// threshold for tissue graphics on-gassing / off-gassing visualization


// thresholds
#define CNS_WARNING_THRESHOLD			100		// threshold for CNS  warning
#define CNS_ATTENTION_THRESHOLD			 70		// threshold for CNS  attention
#define ppO2_GAP_TO_SETPOINT			 10		// gap between setpoint and max. ppO2 of the pure diluent [cbar]
#define GAS_NEEDS_ATTENTION_THRESHOLD	0.70	// threshold for gas needs attention [1.00 = 100%] 
#define PRESSURE_LIMIT_WARNING			200		// threshold for pressure reading warning  : 20.0 bar
#define PRESSURE_LIMIT_ATTENTION		500		// threshold for pressure reading attention: 50.0 bar
#define O2_CONSUMPTION_LIMIT_ATTENTION	 20		// threshold for O2 "SAC"         attention:  2.0 l/min

// deco engine states and modes - char_O_main_status: controls current tissue and deco status calculation (as-is situation)
#define DECO_COMPLETED_NORM				0x01	// the calculation of a normal       deco plan has just been completed
#define DECO_COMPLETED_ALT				0x02	// the calculation of an alternative deco plan has just been completed
//#define DECO_MODE_MASK				0x0C	// mask for mode selection ==> current diving mode
//#define DECO_MODE_LOOP				0x04	// see below
//#define DECO_MODE_CCR					0x04	// see below
//#define DECO_MODE_PSCR				0x08	// see below

#define DECO_USE_Z_FACTOR				0x10	// =1: figure in Z factor when converting gas volumes <-> pressures
#define DECO_CAVE_MODE					0x20	// =1: activate ascent gas needs calculation under cave constraints
#define DECO_BOTTOM_CALCULATE			0x40	// =1: switch to deco calculator interface
#define DECO_TR_FUNCTIONS				0x80	// =1: activate TR functions (pressure reading) processing

// deco engine states and modes - char_O_deco_status: controls deco plan calculation (to-be scenario)
#define DECO_STATUS_MASK				0x03	// bit mask for values below
#define DECO_STATUS_START				0x00	// value commands the start of a new deco calculation cycle
#define DECO_STATUS_FINISHED			0x00	// value indicates completion of deco calculation
#define DECO_STATUS_STOPS				0x01	// value indicated calculation is ongoing, currently calculating the stops
#define DECO_STATUS_RESULTS				0x02	// value indicates calculation is ongoing, currently calculating the results
#define DECO_STATUS_INIT				0x03	// value to be set once for the first invocation at the begin of a new dive

#define DECO_MODE_MASK					0x0C	// mask for mode selection ==> diving mode during ascent
#define DECO_MODE_LOOP					0x04	// =1: CCR (DECO_MODE_PSCR needs to be cleared) or pSCR mode
#define DECO_MODE_CCR					0x04	// to be used with == operator in combination with DECO_MODE_MASK only!
#define DECO_MODE_PSCR					0x08	// =1: pSCR mode (DECO_MODE_LOOP needs to be set, too)

#define DECO_PLAN_ALTERNATE				0x10	// =1: calculate the 2nd (alternative) deco plan
#define DECO_BAILOUT_MODE				0x20	// =1: do a bailout calculation, i.e. allow gas switches before first deco stop
#define DECO_VOLUME_CALCULATE			0x40	// =1: calculate ascent gas needs
#define DECO_ASCENT_DELAYED				0x80	// =1: calculate a delayed ascent (fTTS)

// deco engine warnings - char_O_deco_warnings
#define DECO_WARNING_IBCD				0x01	// IBCD occurring now
#define DECO_WARNING_IBCD_lock			0x02	// IBCD has occurred during the dive
#define DECO_WARNING_MBUBBLES			0x04	// micro bubbles likely to develop now
#define DECO_WARNING_MBUBBLES_lock		0x08	// ditto, but sometime during the dive
#define DECO_WARNING_OUTSIDE			0x10	// tissue pressures outside the Buhlmann model now
#define DECO_WARNING_OUTSIDE_lock		0x20	// tissue pressures outside the model sometime during the dive
#define DECO_ATTENTION_OUTSIDE			0x40	// tissue pressures are very close to the Buhlmann limit
#define DECO_WARNING_STOPTABLE_OVERFLOW	0x80	// internal error: no more space in the deco stops table

// deco engine status (char_O_deco_info)
#define DECO_FLAG						0x01	// =1: deco ppO2 levels are permitted
#define IND_DOUBLE_SWITCH_FLAG			0x02	// =1: switch to other tank advice active
#define DECO_STEADY						0x04	// =1: fTTS = TTS (not updated when in bailout mode)
#define DECO_DECREASING					0x08	// =1: fTTS < TTS (not updated when in bailout mode)
#define DECO_CEILING					0x10	// =1: ceiling depth > 0
#define GAS_NEEDS_CAVE					0x20	// =1: indicated gas needs are calculated in cave mode

// deco engine control - tissue_increment
#define TIME_MASK						0x7F	// (127 decimal, bits 0-6 set)
#define TISSUE_FLAG						0x80	// (128 decimal, bit   7  set)


// flags used with integer numbers
#define INT_FLAG_INVALID				0x0400	// =1: value not valid
#define INT_FLAG_ZERO					0x0800	// =1: value is zero
#define INT_FLAG_LOW					0x1000	// =1: value is below a lower warning threshold
#define INT_FLAG_NOT_AVAIL				0x1000	// =1: value is not available (not computed)
#define INT_FLAG_HIGH					0x2000	// =1: value is above an upper warning threshold
#define INT_FLAG_OUTDATED				0x2000	// =1: value has not been updated for too long
#define INT_FLAG_ATTENTION				0x4000	// =1: value exceeds the attention threshold
#define INT_FLAG_WARNING				0x8000	// =1: value exceeds the warning threshold
#define INT_FLAG_OUT_OF_RANGE			0x8000	// =1: value exceeds presentable range



// *********************************************************************************************************************************
//
//                                                  ** P R O T O T Y P E S **
//
//                              The Functions are listed in sequence of intended usage / application.
//
// *********************************************************************************************************************************

// Functions used in surface mode
static void			 calc_interval(PARAMETER unsigned char time_increment);
														// Calculates the tissue off-gassing under surface conditions.
static void			 calc_desaturation_time(void);		// Calculates the desaturation and no-fly times.
static void			 clear_tissue(void);				// Resets all tissues to surface pressure equilibrium state.

// Main entry point in dive mode
static void			 calc_hauptroutine(void);			// Sequences all calculations for the real tissues and the deco calculation.

// Functions dedicated to the real tissues
static void			 calc_hauptroutine_data_input(void);// Initializes environment data and sets gas ratios for the real tissues.

// Functions combined for real tissues & deco calculations
static void			 calc_alveolar_pressures(void);		// Computes the partial pressures from the gas ratios and many more parameters,
														// needs either calc_hauptroutine_data_input() be called beforehand or
														// gas_find_current()/gas_find_better() and gas_set_ratios().
static void			 calc_tissues(void);				// Updates the tissues   dependent on the partial pressures of N2 and He.
static void			 calc_CNS(void);					// Updates the CNS value dependent on the partial pressure  of the O2.
static void			 calc_limit(PARAMETER float GF_current);
														// Calculates ceiling, current GF (supersaturation) and some more data.

// Functions dedicated to deco calculations
static void			 clear_deco_table(void);			// Clears the deco stops table, invoked at the start of each calculation cycle.
static void			 gas_find_current(void);			// Sets the first gas used for deco calculation, invoked at start of cycle, too.
static unsigned char gas_find_better(void);				// Checks for, and eventually switches to, a better gas.
static void			 gas_set_ratios(void);				// Sets the gas ratios for use in deco calculation (simulated tissues),
														// needs to be called after each gas change (gas_find_current/_better).
static void			 calc_NDL_time(void);				// Calculates remaining NDL time.
static void			 find_NDL_gas_changes(void);		// Finds the gas changes in an OC bailout ascent that is within NDL
static void			 calc_ascent_to_first_stop(void);	// Calculates ascent to the first deco stop.
static void			 calc_hauptroutine_calc_deco(void);	// Calculates the subsequent ascent until reaching surface.
static unsigned char calc_nextdecodepth(void);			// Calculates the depth of the next required deco stop.
static unsigned char update_deco_table(PARAMETER unsigned char time_increment);
														// Enters a new stop or extends an existing stop in the deco stops table.
static void			 calc_ascenttime(void);				// Calculates the ascent time from current depth and deco stop times.
static void			 gas_volumes(void);					// Calculates required gas volumes and pressures from the data in stops table.

// Functions for results reporting
static void			 publish_deco_table(void);			// Copies the internal deco stops table to the export interface.
static void			 convert_CNS_for_display(void);		// Converts the current     CNS value from float to integer.
static void			 convert_sim_CNS_for_display(void);	// Converts the end-of-dive CNS value from float to integer.
static void			 convert_GF_for_display(void);		// Converts leading tissue supersaturation value from float to integer, 1.0 = 100%.
static void			 convert_ceiling_for_display(void);	// Converts ceiling from float to integer in mbar relative pressure.


// internal helper functions
static unsigned short tmr5(void);						// Reads a hardware timer which is used for preemptive scheduling.
static void			 read_Buhlmann_coefficients(void);	// Reads the a and b coefficients from a ROM table.
static void			 read_Buhlmann_times(PARAMETER char period);
														// Reads pre-computed tissue increment factors from a ROM table.
static void			 read_Buhlmann_ht(void);			// Reads the half-times from a ROM table.
static void			 adopt_Buhlmann_coefficients(void);	// Computes average a and b coefficient by the N2/He tissue ratio.
static void			 temp_tissue_safety(void);			// Applies safety margins to the tissue increments.
static void			 push_tissues_to_vault(void);		// Stores the state of the real tissues during simulator runs.
static void			 pull_tissues_from_vault(void);		// Restores the state of the real tissues after a simulator run.



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

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

// general deco parameters

static float			GF_low;							// initialized from deco parameters
static float			GF_high;						// initialized from deco parameters
static float			GF_delta;						// initialized from deco parameters

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 (5.0 .. 10.0 m/min)
static float			float_deco_distance;			// additional depth below stop depth for tissue, CNS and gas volume calculation
static float			float_saturation_multiplier;	// safety factor for on-gassing rates
static float			float_desaturation_multiplier;	// safety factor for off-gassing rates

static unsigned char	split_N2_He[NUM_COMP];			// used for calculating the desaturation time

// real context: what we are doing now

static float			CNS_fraction;					// current CNS (1.00 = 100%)

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

static float			pres_respiration_sac;			// current depth in absolute pressure, used in SAC calculation
static float			float_sac;						// used in SAC calculation
static unsigned int		max_sac_rate;					// used in SAC calculation to determine SAC rate attention


// simulation context: used to predict ascent

static float			sim_CNS_fraction;				// CNS after predicted ascent, 0.01 = 1%, as float

static unsigned int		int_sim_CNS_fraction;			// CNS after predicted ascent,    1 = 1%, as integer

static unsigned char	sim_depth_limit;				// depth of next stop in meters, used in deco calculations
static unsigned char	NDL_lead_tissue_norm;				// used to cache the tissue to start with when calculating the NDL
static unsigned char	NDL_lead_tissue_alt;				// used to cache the tissue to start with when calculating the NDL


// result values from calculation functions

static float			ceiling;						// minimum tolerated relative pressure (i.e. without surface pressure)
static float			lead_supersat;					// supersaturation of the leading tissue, 1.0 = 100%
static unsigned char	lead_number;					// number of the leading tissue

// stops table

static unsigned char	internal_deco_depth[NUM_STOPS];	// depths of the stops
static unsigned char	internal_deco_time[NUM_STOPS];	// durations of the stops
static unsigned char	internal_deco_gas[NUM_STOPS];	// gases used on the stops


// 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 int		int_time;						// time it takes for the compartment to reach the target pressure


// transfer variables between gas_volumes() and gas_volumes_helper_1/_2()

static float			float_depth;					// depth of the stop or half-way point
static float			float_time;						// duration of the stop or ascent phase
static unsigned char	char_usage;						// gas usage in l/min
static unsigned char	gas_num;						// number of the gas/tank
static float			volume;							// computed volume of gas
static unsigned int		int_volume;						// required gas volume in liter
static unsigned int		int_pres_need;					// required gas volume in bar


// auxiliary variables for data buffering

static float			N2_equilibrium;					// used for N2 tissue graphics scaling
static float			temp_tissue;					// auxiliary variable to buffer tissue pressures
static float			float_pSCR_factor;				// pre-computed factor for pSCR ppO2 drop calculation
static float			calc_pres_tissue_N2;			// auxiliary variable to buffer tissue N2 pressure
static float			calc_pres_tissue_He;			// auxiliary variable to buffer tissue He pressure
static float 			pres_tissue;					// auxiliary variable to buffer total tissue pressure

// 10 byte free space left in this bank (4 bytes per float, 2 bytes per int/short, 1 byte per char)


//---- 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_surface;					// absolute pressure at the surface

static unsigned char	char_bottom_depth;				// bottom depth in meters, used by ascent time and gas needs calculation

static float			real_pres_respiration;			// current real depth in absolute pressure
static float			real_O2_ratio;					// real breathed gas oxygen ratio
static float			real_N2_ratio;					// real breathed gas nitrogen ratio
static float			real_He_ratio;					// real breathed gas helium ratio
static float			real_pSCR_drop;					// real ppO2 drop in pSCR loop

static float			sim_pres_respiration;			// simulated current depth in abs.pressure, used for deco calculations
static float			sim_O2_ratio;					// simulated breathed gas oxygen ratio
static float			sim_N2_ratio;					// simulated breathed gas nitrogen ratio
static float			sim_He_ratio;					// simulated breathed gas helium ratio
static float			sim_pSCR_drop;					// simulated ppO2 drop in pSCR loop


// result values from calculation functions

static float			O2_ppO2;						// ppO2 - calculated for pure oxygen at current depth
static float			OC_ppO2;						// ppO2 - calculated for breathing in OC   mode
static float			pSCR_ppO2;						// ppO2 - calculated for breathing in pSCR mode

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

static unsigned char	char_ppO2;						// partial pressure of breathed oxygen, as integer 100 = 1.00 bar
static unsigned char	NDL_time;						// time in minutes until reaching NDL
static unsigned int		ascent_time;					// time in minutes needed for the ascent


// 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 He tissue


// gas in use

static unsigned char	sim_gas_current;				// number       of the currently used gas
static unsigned char	sim_gas_current_depth;			// change depth of the currently 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			cns_vault_float;				// stores current CNS (float representation)
static unsigned char	deco_warnings_vault;			// stores warnings status


// 8 byte free space left in this bank (4 bytes per float, 2 bytes per int/short, 1 byte per char)


//---- 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 is full!


//---- 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
// Do not delete this assignment, it is needed by the compiler/linker.
#ifndef UNIX
#   pragma udata bank6
#endif


// *********************************************************************************************************************************
//
//                                               L O O K - U P   T A B L E S
//
// *********************************************************************************************************************************

#ifndef UNIX
#   pragma romdata Buhlmann_tables = 0x1DD00  // needs to be in the 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
//-------------------------------------
};


// *********************************************************************************************************************************
//
//                                                 H E L P E R   F U N C T I O N S
//
// *********************************************************************************************************************************


// moved from 0x0D000 to 0x0C000 in v.108
#ifndef UNIX
#	pragma code p2_deco = 0x0C000
#endif


//////////////////////////////////////////////////////////////////////////////
// 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 coefficients a and b for compartment ci
//
static void read_Buhlmann_coefficients(void)
{
#ifndef CROSS_COMPILE
	// Note: We don't use far ROM pointer, because handling
	//       24 bit is too complex, hence we have to set the
	//       UPPER page ourself...
	//       -> Set to 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 increments for compartment ci
// If period == 0 :  2 sec 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 handling
	//       24 bit is to complex, hence we have to set the
	//       UPPER page ourself...
	//       -> set to 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 half-times for compartment ci
//
static void read_Buhlmann_ht(void)
{

#ifndef CROSS_COMPILE
	// Note: We don't use far ROM pointer, because handling
	//       24 bit is to complex, hence we have to set the
	//       UPPER page ourself...
	//       -> Set to 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 );
}


//////////////////////////////////////////////////////////////////////////////
// compute adopted Buhlmann coefficients
//
static void adopt_Buhlmann_coefficients(void)
{
	// adopt a and b coefficients to current N2/He ratio inside the tissue
	var_N2_a = (var_N2_a * calc_pres_tissue_N2 + var_He_a * calc_pres_tissue_He) / pres_tissue;
	var_N2_b = (var_N2_b * calc_pres_tissue_N2 + var_He_b * calc_pres_tissue_He) / pres_tissue;
}


// *********************************************************************************************************************************
//
//                                                J U M P  I N   F U N C T I O N S
//
// *********************************************************************************************************************************


//////////////////////////////////////////////////////////////////////////////
// deco_calc_hauptroutine
//
// called from: divemode.asm
//
// Called every second during diving,
// updates tissues on 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, and
// - sets status to zero (so we can check there is new results).
//
void deco_calc_hauptroutine(void)
{
	RESET_C_STACK
	calc_hauptroutine();
}

//////////////////////////////////////////////////////////////////////////////
// deco_clear_tissue
//
// called from: start.asm
//              menu_tree.asm
//              simulator.asm
//
// Sets all tissues to equilibrium with Air at ambient pressure,
// resets all CNS values, any warnings and resets all model output.
//
void deco_clear_tissue(void)
{
	RESET_C_STACK
	clear_tissue();
}

//////////////////////////////////////////////////////////////////////////////
// deco_calc_dive_interval
//
// called from: simulator.asm
//
// Updates tissues and CNS value for char_I_dive_interval minutes on air
// at ambient pressure and calculates resulting GF factor and ceiling for
// a GF-high of 100% (ceiling and GF factor not used by simulator.asm)
//
void deco_calc_dive_interval(void)
{
	RESET_C_STACK
	calc_interval(char_I_dive_interval);
}

//////////////////////////////////////////////////////////////////////////////
// deco_calc_dive_interval_1min
//
// called from: start.asm
//              sleepmode.asm
//              surfmode.asm
//              menu_tree.asm
//              ghostwriter.asm
//
// Updates tissues and CNS value for 1 minute on air at ambient pressure and
// calculates resulting GF factor and ceiling for a GF-high of 100% (ceiling
// is not used by *.asm files).
//
void deco_calc_dive_interval_1min(void)
{
	RESET_C_STACK
	calc_interval(1);
}


//////////////////////////////////////////////////////////////////////////////
// deco_calc_dive_interval_10min
//
// called from: sleepmode.asm
//
// Updates tissues and CNS value for 10 minutes on air at ambient pressure and
// calculates resulting GF factor and ceiling for a GF-high of 100% (ceiling
// is not used by sleepmode.asm).
//
void deco_calc_dive_interval_10min(void)
{
	RESET_C_STACK
	calc_interval(10);
}


//////////////////////////////////////////////////////////////////////////////
// deco_calc_desaturation_time
//
// called from: start.asm
//              surfmode.asm
//              menu_tree.asm
//              ghostwriter.asm
//
// Computes desaturation and no-fly times.
//
void deco_calc_desaturation_time(void)
{
	RESET_C_STACK
	calc_desaturation_time();
}

//////////////////////////////////////////////////////////////////////////////
// deco_push_tissues_to_vault
//
// called from: simulator.asm
//
// Makes a backup of the state of the real tissues and the deco engine.
//
void deco_push_tissues_to_vault(void)
{
	RESET_C_STACK
	push_tissues_to_vault();
}

//////////////////////////////////////////////////////////////////////////////
// deco_pull_tissues_from_vault
//
// called from: simulator.asm
//              ghostwriter.asm
//
// Restores the state of the real tissues and the deco engine from the backup.
//
void deco_pull_tissues_from_vault(void)
{
	RESET_C_STACK
	pull_tissues_from_vault();
}


// *********************************************************************************************************************************
//
//                                                    M A I N   F U N C T I O N S
//
// *********************************************************************************************************************************


//////////////////////////////////////////////////////////////////////////////
// calc_nextdecodepth
//
// INPUT, changing during dive:
//        sim_pres_respiration     : 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
//        sim_depth_limit          : depth of next stop in meters     (if RETURN == true )
//                                   next possible depth without stop (if RETURN == false)
//
// RETURN TRUE if a stop is needed, else false
//
static unsigned char calc_nextdecodepth(void)
{
	overlay unsigned char need_stop;

	// compute current depth in meters
	overlay float depth = (sim_pres_respiration - 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;


	// target the simulated tissues
	tissue_increment = 0;

	//---- 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 limit_depth;

		overlay unsigned char first_stop = 0;


		// calculate minimum depth we can ascent to in bar relative pressure
		calc_limit(GF_low);

		// check if we can surface directly
		if( ceiling <= 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
		limit_depth = ceiling * 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( limit_depth > low_depth )
		{
			// update GF parameters
			low_depth      = limit_depth;
			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 of 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( limit_depth < min_depth ) goto no_deco_stop;


		//---- if program execution passes here, we need a deco stop --------------------------------

		// round to multiple of 3 meters (limit depth is in meters of depth)
		first_stop = 3 * (unsigned char)(0.4999 + limit_depth * 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 limit with the GF of the new stop candidate
			if( (low_depth == 0.0) || (next_stop > low_depth) ) calc_limit(GF_low);
			else                                                calc_limit(GF_high - next_stop * locked_GF_step);

			// check if ascent to the next stop candidate is possible
			if( ceiling * BAR_TO_METER >= next_stop )
				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'
		sim_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'
		sim_depth_limit = (unsigned char)first_stop;	// stop depth, in meters

done:
		;
	}
	else
	{
		//---- ZH-L16 model -------------------------------------------------

		overlay float limit_depth;


		// calculate minimum depth we can ascent to in bar relative pressure
		calc_limit(1.0);

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

			// convert stop depth in relative pressure to stop index
			limit_depth = ceiling * BAR_TO_METER / 3.0;

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

			// correct last stop to 4m/5m/6m
			if( sim_depth_limit == 3 ) sim_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
			sim_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         )
	if( gas_find_better() )
	{
		// set the new calculation ratios for N2, He and O2
		gas_set_ratios();

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

	return need_stop;
}


//////////////////////////////////////////////////////////////////////////////
// publish_deco_table
//
// Buffer the stops, once computed, so we can continue to display them
// while computing the next set.
//
static void publish_deco_table(void)
{
	overlay unsigned char x, y;


	// 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];

	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 when the last transfer is done.
		if( x == 0 ) break;
	}

	//---- Third: fill table with null until end
	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;
}


//////////////////////////////////////////////////////////////////////////////
// Find current gas in the list (if any) and get its change depth
//
// Input:  char_I_current_gas    : 1..5 or 6
//
// Output: sim_gas_current       : 1..6 or 0 for the manually configured gas/dil
//         sim_gas_current_depth : change depth (MOD) of the gas/dil in meters
//
static void gas_find_current(void)
{
	assert( 1 <= char_I_current_gas && char_I_current_gas <= 6 );

	if( char_I_current_gas <= NUM_GAS )			// gas/diluent 1-5
	{
		sim_gas_current       = char_I_current_gas;
		sim_gas_current_depth = char_I_deco_gas_change[sim_gas_current-1];
	}
	else
	{
		sim_gas_current       = 0;
		sim_gas_current_depth = char_I_gas6_depth;
	}
}


//////////////////////////////////////////////////////////////////////////////
// Find the deco gas with the shallowest change depth below or at the current depth
//
// INPUT    sim_depth_limit          : current depth in meters
//          sim_gas_current          : number of the currently used gas/dil
//          sim_gas_current_depth    : change depth of the currently used gas/dil
//          char_I_deco_gas_type[]   : types         of the gases/dils
//          char_I_deco_gas_change[] : change depths of the gases/dils
//
// MODIFIED sim_gas_current          : index of the gas (1..5) - only if return value is true
//          sim_gas_current_depth    : switch depth            - 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
	if( (char_O_deco_status & DECO_MODE_MASK) == DECO_MODE_CCR ) 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 gas not the one we are already breathing?
		if( j+1 != sim_gas_current )

		// Is this -                      an (active) deco gas,
		//         - or if in deco phase, any gas but disabled
		//         - or if in bailout,    any gas but disabled,
		//         - or if in pSCR mode,  any gas but disabled?
		if(   (                                               ( char_I_deco_gas_type[j] == 3 ) )
		   || ( ( char_O_deco_info   & DECO_FLAG         ) && ( char_I_deco_gas_type[j] != 0 ) )
		   || ( ( char_O_deco_status & DECO_BAILOUT_MODE ) && ( char_I_deco_gas_type[j] != 0 ) )
		   || ( ( char_O_main_status & DECO_MODE_PSCR    ) && ( char_I_deco_gas_type[j] != 0 ) ) )

		// Is the change depth of the this gas deeper than or
		// at least equal to the current depth?
		if( char_I_deco_gas_change[j] >= sim_depth_limit )

		// Is the change depth of this gas shallower than the
		// change depth of the gas we are currently on?
		if( char_I_deco_gas_change[j] < sim_gas_current_depth )

		// Is the change depth of this gas shallower than the change
		// depth of the best gas found so far, or is it the first
		// better gas found?
		if( char_I_deco_gas_change[j] < switch_depth )

		// If there is a yes to all these questions, we have a better gas!
		{
			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 - set the better gas as the new gas
		sim_gas_current       = switch_gas;

		// set its change depth as the last used change depth
		sim_gas_current_depth = switch_depth;

		assert( sim_gas_current_depth < switch_depth );

		// signal a better gas was found
		return 1;
	}
	else
	{
		// NO - signal no better gas was found
		return 0;
	}
}


//////////////////////////////////////////////////////////////////////////////
// Set calc_N2/He/O2_ratios by sim_gas_current
//
// Input:  sim_gas_current              : index of gas to use
//         real_O2_ratio, real_He_ratio : if gas =    0 (the manually set gas)
//         char_I_deco_O2/He_ratio[]    : if gas = 1..5 (the configured gases)
//
// Output: sim_N2_ratio, sim_He_ratio   : ratios of the inert gases
//         sim_pSCR_drop                : ppO2 drop in pSCR loop
//
static void gas_set_ratios(void)
{
	overlay float sim_IG_ratio;

	assert( 0 <= sim_gas_current <= NUM_GAS );


	// get gas ratios
	if( sim_gas_current == 0 )
	{
		sim_O2_ratio = real_O2_ratio;
		sim_He_ratio = real_He_ratio;
	}
	else
	{
		sim_O2_ratio = 0.01 * char_I_deco_O2_ratio[sim_gas_current-1];
		sim_He_ratio = 0.01 * char_I_deco_He_ratio[sim_gas_current-1];
	}

	// inert gas ratio (local helper variable)
	sim_IG_ratio  = 1.00 - sim_O2_ratio;

	// N2 ratio
	sim_N2_ratio  = sim_IG_ratio - sim_He_ratio;

	// ppO2 drop in pSCR loop
	sim_pSCR_drop = sim_IG_ratio * float_pSCR_factor;


	assert( 0.0 <=  sim_N2_ratio && sim_N2_ratio  <= 0.95 );
	assert( 0.0 <=  sim_He_ratio && sim_He_ratio  <= 0.95 );
	assert(        (sim_N2_ratio +  sim_He_ratio) <= 0.95 );
}


//////////////////////////////////////////////////////////////////////////////
// Compute respired ppO2, ppN2 and ppHe
//
// Input:  tissue_increment           : selector for targeting simulated or real tissues
//         char_O_main_status         : breathing mode for real      tissues
//         char_O_deco_status         : breathing mode for simulated tissues
//         sim_/real_O2_ratio         : (simulated) O2 ratio breathed
//         sim_/real_N2_ratio         : (simulated) N2 ratio breathed
//         sim_/real_He_ratio         : (simulated) He ratio breathed
//         sim_/real_pres_respiration : (simulated) respiration pressure [bar]
//         sim_/real_pSCR_drop        : (simulated) pSCR O2 drop
//         pres_surface               : surface pressure [bar]
//         char_I_const_ppO2          : ppO2 reported from sensors or setpoint [cbar]
//         float_deco_distance        : safety factor, additional depth below stop depth [bar]
//         ppWater                    : water-vapor pressure inside respiratory tract [bar]
//
// Output: ppN2                       : respired N2 partial pressure
//         ppHe                       : respired He partial pressure
//         char_ppO2                  : breathed ppO2 in %, used in CNS calculation
//
void calc_alveolar_pressures(void)
{
	overlay float calc_pres_respiration;
	overlay float calc_O2_ratio;
	overlay float calc_N2_ratio;
	overlay float calc_He_ratio;
	overlay float calc_pSCR_drop;

	overlay unsigned char status;


	assert( 0.00 <= real_N2_ratio && real_N2_ratio <= 1.00 );
	assert( 0.00 <= real_He_ratio && real_He_ratio <= 1.00 );
	assert(        (real_N2_ratio + real_He_ratio) <= 1.00 );
	assert( 0.800 < real_pres_respiration && real_pres_respiration < 14.0 );

	assert( 0.00 <= sim_N2_ratio && real_N2_ratio <= 1.00 );
	assert( 0.00 <= sim_He_ratio && real_He_ratio <= 1.00 );
	assert(         (sim_N2_ratio + sim_He_ratio) <= 1.00 );
	assert( 0.800 < sim_pres_respiration && sim_pres_respiration < 14.0 );


	// get input data according to context
	if( tissue_increment & TISSUE_FLAG )
	{
		//---- real tissues -----------------------------------------------------------
		status                = char_O_main_status;
		calc_pres_respiration = real_pres_respiration;
		calc_pSCR_drop        = real_pSCR_drop;

		calc_O2_ratio         = real_O2_ratio;
		calc_N2_ratio         = real_N2_ratio;
		calc_He_ratio         = real_He_ratio;
	}
	else
	{
		//---- simulated tissues ------------------------------------------------------
		status                = char_O_deco_status;
		calc_pres_respiration = sim_pres_respiration;
		calc_pSCR_drop        = sim_pSCR_drop;

		calc_O2_ratio         = sim_O2_ratio;
		calc_N2_ratio         = sim_N2_ratio;
		calc_He_ratio         = sim_He_ratio;
	}

	//---- OC, CCR and Bailout Mode Gas Calculations -----------------------------------

	// calculate ppO2 of pure oxygen
	O2_ppO2 = calc_pres_respiration - ppWater;

	// capture failure condition in case real_pres_respiration is < ppWater (should never happen...)
	if( O2_ppO2 < 0.0 ) O2_ppO2 = 0.0;

	// calculate ppO2 of the pure gas (OC, diluent)
	OC_ppO2 = O2_ppO2 * calc_O2_ratio;

	// calculate pSCR ppO2
	pSCR_ppO2 = OC_ppO2 - calc_pSCR_drop;

	// capture failure condition in 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( status & DECO_MODE_LOOP )
	{
		overlay float const_ppO2;
		overlay float   max_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, the ppO2 can be further reduced to account for exhaled inert gases
		// accumulating in the loop by the user-adjustable setting char_I_cc_max_frac_o2.
		// (ppWater is neglected here)
		max_ppO2 = 0.01 * char_I_cc_max_frac_o2 * calc_pres_respiration;

		if( const_ppO2 > max_ppO2 ) const_ppO2 = max_ppO2;

		// check which kind of loop we are on
		if( status & DECO_MODE_PSCR )
		{
			//---- pSCR Mode --------------------------------------------------------------------------

			// Use the sensor value if available, but only in real tissue context!
			// In all other cases use calculated ppO2.
			if( char_I_const_ppO2 && (tissue_increment & TISSUE_FLAG)) ppO2 = const_ppO2;
			else                                                       ppO2 = pSCR_ppO2;
		}
		else
		{
			//---- CCR Mode ---------------------------------------------------------------------------

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

		// adjust overall gas pressure for change in ppO2 due to setpoint (CCR) or drop (pSCR),
		// capture potential failure conditions first:
		if(    ( calc_pres_respiration <  ppO2 )     // sensor reading or selected setpoint is higher than ambient pressure
		    || ( calc_O2_ratio         > 0.995 ) )   // diluent is pure O2, i.e. calc_N2_ratio + calc_He_ratio = 0 yielding a div/0
		{
			// failure condition present, set predetermined result
			calc_pres_respiration = 0.0;
		}
		else
		{
			// no failure conditions present, equation can be executed
			calc_pres_respiration -= ppO2;
			calc_pres_respiration /= calc_N2_ratio + calc_He_ratio;
		}
	}
	else
	{
		//---- OC mode ---------------------------------------------------------------------------------

		// breathed ppO2 is ppO2 of pure gas
		ppO2 = OC_ppO2;
	}


	//---- derive char_ppO2 in [cbar], used for calculating CNS% ---------------------------------------

	if      ( ppO2 <  0.01  ) char_ppO2  =   0;
	else if ( ppO2 >= 2.545 ) char_ppO2  = 255;
	else                      char_ppO2  = (unsigned char)(100 * ppO2 + 0.5);


	//---- calculate ppN2 and ppHe ---------------------------------------------------------------------

	// add deco safety distance when working on simulated tissues
	if( !(tissue_increment & TISSUE_FLAG) ) calc_pres_respiration += float_deco_distance;

	// compute ppN2 and ppHe, capture potential failure conditions first:
	if( calc_pres_respiration > ppWater )
	{
		// subtract water vapor pressure
		calc_pres_respiration -= ppWater;

		// calculate partial pressures
		ppN2 = calc_N2_ratio * calc_pres_respiration;
		ppHe = calc_He_ratio * calc_pres_respiration;
	}
	else
	{
		// calculated respired pressure is < water vapor pressure, thus set ppN2 and ppHe to 0
		ppN2 = 0.0;
		ppHe = 0.0;
	}
}


//////////////////////////////////////////////////////////////////////////////
// clear_tissue
//
// optimized in v.101 (var_N2_a)
//
// Reset all tissues to surface pressure equilibrium state.
//
static void clear_tissue(void)
{
	// safety limit to prevent improper initialization values
	if( int_I_pres_respiration < 500) int_I_pres_respiration = 500;		// min. respiration pressure = 500 mbar

	real_pres_respiration = 0.001  * int_I_pres_respiration;
	N2_equilibrium        = 0.7902 * (real_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
	}

	// reset CNS values
	CNS_fraction = 0.0;
	int_O_CNS_fraction = int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = 0;


	// reset any warnings and status data
	char_O_deco_warnings		= 0;
	char_O_deco_status			= 0;

	// reset some more vars to their defaults
	char_O_nullzeit				= 240;
	int_O_ascenttime			= 0;
	int_O_alternate_ascenttime	= 0;
	int_O_gradient_factor		= 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)
{
	overlay unsigned int int_ppO2_min;
	overlay unsigned int int_ppO2_max;
	overlay unsigned int int_ppO2_max_dil;
	overlay unsigned int int_ppO2_max_max;
	overlay float        EAD;
	overlay float        END;


	//--- Set-up Part --------------------------------------------------------------------------------

	// clear flags indicating a calculation has been completed
	char_O_main_status &= ~( DECO_COMPLETED_NORM + DECO_COMPLETED_ALT );

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

	// do initializations that need to be done only once at the beginning of a dive
	if( (char_O_deco_status & DECO_STATUS_MASK) == DECO_STATUS_INIT )
	{
		// compute a factor that will be used later on in pSCR calculations
		float_pSCR_factor = 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio;
	}


	//---- Calculations Part ----------------------------------------------------------------------

	// acquire current environment data
	calc_hauptroutine_data_input();

	// target the real tissues with 2 second increments by default
	tissue_increment = TISSUE_FLAG | 0;

	// calculate ppO2, ppN2 and ppHe
	calc_alveolar_pressures();

	// All deco code is invoked every second. But as the tissue and CNS updates are based
	// on 2 seconds periods, each update is done only on each 2nd second. In case a "fast
	// forward" of the tissues is commanded, the 2-seconds rule is over-raided.
	if( twosectimer || char_I_sim_advance_time )
	{
		// 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 "fast forward" tissue updating
			tissue_increment = TISSUE_FLAG | char_I_sim_advance_time;

			// clear the "mailbox"
			char_I_sim_advance_time = 0;
		}

		// calculate the real tissues
		calc_tissues();

		// update the CNS value for the real tissues
		calc_CNS();

		// calculate ceiling (at GF_high or 100%) and leading tissue supersaturation
		if( char_I_deco_model ) calc_limit(GF_high);		// GF factors enabled
		else                    calc_limit(  1.0  );		// classic Buhlmann

		// convert ceiling from float to integer for export [mbar relative pressure]
		convert_ceiling_for_display();

		// convert leading tissue supersaturation value from float to integer for export [%]
		convert_GF_for_display();

		// convert CNS value from float to integer for export
		convert_CNS_for_display();
	}

	//---- Calculate and Export EAD and END ------------------------------------------------------

	// calculate EAD (Equivalent Air Depth): equivalent depth for the same N2 level with plain air
	EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER;

	// calculate END (Equivalent Narcotic Depth): here O2 is treated as narcotic, too
	// Source cited: The Physiology and Medicine of Diving by Peter Bennett and David Elliott,
	//               4th edition, 1993, W.B.Saunders Company Ltd, London.
	END = (real_pres_respiration - ppHe - pres_surface) * BAR_TO_METER;

	// export EAD
	if( (EAD < 0.0) || (EAD > 245.5) ) char_O_EAD = 0;
	else                               char_O_EAD = (unsigned char)(EAD + 0.5);

	// export END
	if( (END < 0.0) || (END > 245.5) ) char_O_END = 0;
	else                               char_O_END = (unsigned char)(END + 0.5);


	//---- Compute ppO2 Values in [cbar] ---------------------------------------------------------

	// 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 ( OC_ppO2       <  0.01  ) int_O_pure_ppO2     =   0;
	else if ( OC_ppO2       >= 9.995 ) int_O_pure_ppO2     = 999;
	else                               int_O_pure_ppO2     = (unsigned int)(100 *   OC_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 ( ppO2          <  0.01  ) int_O_breathed_ppO2 =   0;
	else if ( ppO2          >= 9.995 ) int_O_breathed_ppO2 = 999;
	else                               int_O_breathed_ppO2 = (unsigned int)(100 *      ppO2 + 0.5);


	//---- Set/Reset Deco Mode --------------------------------------------------------------------

	// Set the deco mode flag if:
	// - breathing an OC deco gas (gas type 3), or
	// - breathing a gas or diluent that officially is disabled (type 0), or
	// - if nearby or above the deepest deco stop (nearby means 1 meter below, the additional 0.9 serves rounding effects)
	if  (    ( char_I_current_gas_type == 3                                                                           )
	      || ( char_I_current_gas_type == 0                                                                           )
	      || ( (unsigned char)((real_pres_respiration - pres_surface) * BAR_TO_METER - 1.9) < char_O_first_deco_depth )
		)
			char_O_deco_info |=  DECO_FLAG;
	else
			char_O_deco_info &= ~DECO_FLAG;


	//---- 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_info   & DECO_FLAG     ) ? (unsigned int)char_I_ppO2_max_deco : (unsigned int)char_I_ppO2_max;

	// get biggest of char_I_ppO2_max / char_I_ppO2_max_deco
	int_ppO2_max_max = ( char_I_ppO2_max_deco > char_I_ppO2_max ) ? char_I_ppO2_max_deco : char_I_ppO2_max;

	// default value for the upper diluent ppO2 warning threshold is the normal upper warning threshold
	int_ppO2_max_dil = int_ppO2_max;

	// when in CCR mode, the upper diluent warning threshold gets adjust according to the current setpoint
	if( (char_O_main_status & DECO_MODE_MASK) == DECO_MODE_CCR )
	{
		overlay unsigned int max_dil;

		//  The upper diluent ppO2 threshold is ppO2_GAP_TO_SETPOINT below the setpoint...
		// (the condition protects from negative numbers which would cause a wrap-around in unsigned integers)
		max_dil = (char_I_const_ppO2 > ppO2_GAP_TO_SETPOINT) ? (unsigned int)(char_I_const_ppO2 - ppO2_GAP_TO_SETPOINT) : 0;

		// ...but never above int_ppO2_max.
		if( max_dil < int_ppO2_max ) int_ppO2_max_dil = max_dil;

		// We do not need to guard int_ppO2_max_dil against becoming lower than char_I_ppO2_min because the check
		// against char_I_ppO2_min is done first and will then raise a low warning and inhibit further checks.
	}

	// 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_max ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH;
	else if ( char_O_deco_info    &                DECO_FLAG        ) ; // no attention generated in deco mode
	else if ( char_O_main_status  &                DECO_MODE_LOOP   ) ; // no attention generated in loop modes
	else if ( int_O_breathed_ppO2 >= (unsigned int)char_I_ppO2_max  ) int_O_breathed_ppO2 |= INT_FLAG_ATTENTION;

	// 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;
	else if ( int_O_pure_ppO2     >=               int_ppO2_max_dil ) int_O_pure_ppO2     |= INT_FLAG_ATTENTION;

	// 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;


#ifdef _rx_functions

	//---- Process Pressure Readings (OSTC TR only) -----------------------------------------------

	// only for OSTC TR model with TR functions enabled
	if( char_O_main_status & DECO_TR_FUNCTIONS )
	{
		// pressure warnings for reading 1, but only if enabled and pressure value available
		if( (char_I_pressure_gas[0] > 0) && !(int_IO_pressure_value[0] & INT_FLAG_NOT_AVAIL) )
		{
			overlay unsigned int pressure_value = int_IO_pressure_value[0] & ~INT_FLAG_OUTDATED;

			if( (char_I_pressure_gas[0] < 6 ) && !(int_O_pressure_need[0] & INT_FLAG_NOT_AVAIL) )
			{
				// not a dil and need available: warning & attention by need
				     if( pressure_value <= int_O_pressure_need[0])
				         int_IO_pressure_value[0] |= INT_FLAG_WARNING;
				else if( pressure_value <= int_O_pressure_need[0] + int_O_pressure_need[0] / 2 )
				         int_IO_pressure_value[0] |= INT_FLAG_ATTENTION;
			}
			else
			{
				// a dil or need not available: warning & attention by fixed thresholds
				if     ( pressure_value <= PRESSURE_LIMIT_WARNING   ) int_IO_pressure_value[0] |= INT_FLAG_WARNING;
				else if( pressure_value <= PRESSURE_LIMIT_ATTENTION ) int_IO_pressure_value[0] |= INT_FLAG_ATTENTION;
			}
		}

		// pressure warnings for reading 2, but only if enabled and pressure value available
		if( (char_I_pressure_gas[1] > 0) && !(int_IO_pressure_value[1] & INT_FLAG_NOT_AVAIL) )
		{
			overlay unsigned int pressure_value = int_IO_pressure_value[1] & ~INT_FLAG_OUTDATED;

			if( (char_I_pressure_gas[1] < 6 ) && !(int_O_pressure_need[1] & INT_FLAG_NOT_AVAIL) )
			{
				// not a dil and need available: warning & attention by need
				     if( pressure_value <= int_O_pressure_need[1])
				         int_IO_pressure_value[1] |= INT_FLAG_WARNING;
				else if( pressure_value <= int_O_pressure_need[1] + int_O_pressure_need[1] / 2 )
				         int_IO_pressure_value[1] |= INT_FLAG_ATTENTION;
			}
			else
			{
				// a dil or need not available: warning & attention by fixed thresholds
				     if( pressure_value <= PRESSURE_LIMIT_WARNING   ) int_IO_pressure_value[1] |= INT_FLAG_WARNING;
				else if( pressure_value <= PRESSURE_LIMIT_ATTENTION ) int_IO_pressure_value[1] |= INT_FLAG_ATTENTION;
			}
		}

		//--- SAC Calculation ---------------------------------------------------------------------
		//
		// char_I_SAC_mode =0: disabled
		//                 =1: SAC from 1st reading
		//                 =2: SAC from 2nd reading
		//                 =3: SAC from higher one of both pressure drops (independent double mode)
		//                 =4: SAC (O2 usage) from 2nd reading without real_pres_respiration term

		// set SAC rate to not available by default
		int_O_sac_rate = 0 + INT_FLAG_NOT_AVAIL;

		// get a copy of the current absolute pressure
		pres_respiration_sac = real_pres_respiration;

		// set threshold for SAC rate attention
		max_sac_rate = (char_O_deco_info & DECO_FLAG) ? char_I_deco_usage : char_I_bottom_usage;

		// char_I_deco_usage / char_I_bottom_usage are in l/min, max_sac_rate is in 0.1 l/min
		max_sac_rate *= 10;


		// pre-process SAC mode 3 (independent double)
		if( char_I_SAC_mode == 3 )
		{
			overlay unsigned char  reading1_gas;
			overlay unsigned char  reading2_gas;
			overlay unsigned char  reading1_tanksize;
			overlay unsigned char  reading2_tanksize;
			overlay unsigned short reading1_press;
			overlay unsigned short reading2_press;
			overlay unsigned short reading1_drop;
			overlay unsigned short reading2_drop;

			// get gas numbers (1-10) of both readings
			reading1_gas = char_I_pressure_gas[0];
			reading2_gas = char_I_pressure_gas[1];

			// default to no SAC calculation
			char_I_SAC_mode = 0;

			// clear switch advice by default
			char_O_deco_info &= ~IND_DOUBLE_SWITCH_FLAG;

			// check if both readings are configured and available
			if(  reading1_gas                                    )
			if(  reading2_gas                                    )
			if( !(int_IO_pressure_value[0] & INT_FLAG_NOT_AVAIL) )
			if( !(int_IO_pressure_value[1] & INT_FLAG_NOT_AVAIL) )
			if( !(int_I_pressure_drop[0]   & INT_FLAG_NOT_AVAIL) )
			if( !(int_I_pressure_drop[1]   & INT_FLAG_NOT_AVAIL) )
			{
				// get tank pressures, stripping flags
				reading1_press = int_IO_pressure_value[0] & 0x0FFF;			// in 0.1 bar
				reading2_press = int_IO_pressure_value[1] & 0x0FFF;			// in 0.1 bar

				// get pressure drops as integers, stripping flags and shifting right
				// to avoid an overflow when multiplying with the tank size later on
				reading1_drop = (int_I_pressure_drop[0] & 0x0FFF) >> 2;
				reading2_drop = (int_I_pressure_drop[1] & 0x0FFF) >> 2;

				// get tank sizes
				reading1_tanksize = char_I_tank_size[reading1_gas-1];
				reading2_tanksize = char_I_tank_size[reading2_gas-1];

				// set mode to calculate SAC on the reading with the higher absolute drop
				char_I_SAC_mode = (reading1_drop * reading1_tanksize > reading2_drop * reading2_tanksize) ? 1 : 2;

				// compute switch advice if pressure (in 0.1 bar) of tank breathed from is
				// more than char_I_max_pres_diff (in bar) below pressure of the other tank.
				if( char_I_SAC_mode == 1 )
				{
					// breathing from reading 1, switch advice if pressure on reading 1 lower than on 2
					if( (reading1_press + 10*char_I_max_pres_diff) <= reading2_press )
						char_O_deco_info |= IND_DOUBLE_SWITCH_FLAG;
				}
				else
				{
					// breathing from reading 2, switch advice if pressure on reading 2 lower than on 1
					if( (reading2_press + 10*char_I_max_pres_diff) <= reading1_press )
						char_O_deco_info |= IND_DOUBLE_SWITCH_FLAG;
				}
			}
		}


		// pre-process SAC mode 4 (O2 usage by reading 2)
		if( char_I_SAC_mode == 4 )
		{
			// O2 usage on CCR is independent from absolute pressure
			pres_respiration_sac = 1.0;

			// O2 pressure drop is measured via reading 2
			char_I_SAC_mode = 2;

			// reconfigure max SAC rate to O2 consumption attention threshold
			max_sac_rate = O2_CONSUMPTION_LIMIT_ATTENTION;
		}


		// calculate SAC - modes 1 & 2
		if( (char_I_SAC_mode == 1) || (char_I_SAC_mode == 2) )
		{
			overlay unsigned char reading_index;
			overlay unsigned char reading_gas;
			overlay unsigned char reading_tanksize;
			overlay float         reading_drop;

			// set index: char_I_SAC_mode = 1 -> reading one, index 0
			//                            = 2 ->         two,       1
			reading_index = char_I_SAC_mode - 1;

			// get gas number (1-10)
			reading_gas = char_I_pressure_gas[reading_index];

			// check if reading is configured and available
			if(  reading_gas                                               )
			if( !(int_I_pressure_drop[reading_index] & INT_FLAG_NOT_AVAIL) )
			{
				// get tank size (in liter)
				reading_tanksize = char_I_tank_size[reading_gas-1];

				// get pressure drop as float, stripping flags (in 1/5120 bar/sec)
				reading_drop = (float)(int_I_pressure_drop[reading_index] & 0x0FFF);

				// check if pressure drop is within range
				if( !(int_I_pressure_drop[reading_index] & INT_FLAG_OUT_OF_RANGE) )
				{
					// calculate SAC,   10 is factor to have result in 0.1 liter/min
					//                  60 is factor for 60 seconds per 1 minute,
					//                5120 accounts for reading_drop being in 1/5120 bar/sec
					//                10*60/5120 = 60/512 = 15/128
					float_sac = reading_drop * 15/128 * reading_tanksize / pres_respiration_sac;

					// limit result to 999 (99.9 liter/min)
					if ( float_sac >= 998.5 )
					{
						int_O_sac_rate = 999 + INT_FLAG_ATTENTION;
					}
					else
					{
						// convert float to integer
						int_O_sac_rate = (unsigned short)(float_sac + 0.5);

						// set attention flag if exceeding SAC threshold, but only if pressure drop is not outdated
						if( !(int_I_pressure_drop[reading_index] & INT_FLAG_OUTDATED) )
						if( int_O_sac_rate >= max_sac_rate )
						{
							int_O_sac_rate |= INT_FLAG_ATTENTION;
						}
					}
				}
				else
				{
					// pressure drop is out of range, so SAC will be set out of range, too
					int_O_sac_rate = 999 + INT_FLAG_ATTENTION;
				}

				// copy outdated flag from int_I_pressure_drop to int_O_sac_rate
				if( int_I_pressure_drop[reading_index] & INT_FLAG_OUTDATED )
				{
					int_O_sac_rate |= INT_FLAG_OUTDATED;
				}
			}
		}
	} // TR functions

#endif


	//---- End of Computations for the real Tissues -----------------------------------------------
	//
	//=============================================================================================
	//
	//---- Begin of Computations for Ascent and Decompression -------------------------------------

	// branch to the code for the current phase the deco calculations are in, i.e.
	// toggle between calculating NDL (remaining bottom time), deco stops, and results
	switch( char_O_deco_status & DECO_STATUS_MASK )
	{
		overlay unsigned char i;

	default:

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

		// clear the internal stops table from remains lasting from the previous dive or deco calculator run
		clear_deco_table();

		// publish the cleared stops table to the display functions
		publish_deco_table();

		// clear the gas needs table
		for( i = 0; i < NUM_GAS; ++i )
		{
			int_O_ascent_volumes[i]   = 0;
			int_O_ascent_pres_need[i] = 0 + INT_FLAG_ZERO;
		}

		// safety limits to prevent eventual infinite looping (bricking the OSTC)
		if( char_I_ascent_speed            <  5 ) char_I_ascent_speed            =  5;	// min.  5 m/min
		if( char_I_deco_distance           > 20 ) char_I_deco_distance           = 20;	// max. 20 dm (= 2 m)
		if( char_I_desaturation_multiplier < 50 ) char_I_desaturation_multiplier = 50;	// min. 50 %

		// initialize values that are constant during the course of the dive
		float_ascent_speed            = 1.00 * char_I_ascent_speed;						// in meter/minute
		float_deco_distance           = 0.01 * char_I_deco_distance;					// in bar
		float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier;			// as factor, 1.0 = 100%
		float_saturation_multiplier   = 0.01 * char_I_saturation_multiplier;			// as factor, 1.0 = 100%

		// initialize values that will be recalculated later on periodically
		char_O_nullzeit               = 0;		// reset NDL time for the normal plan
		char_O_alternate_nullzeit     = 0;		// reset NDL time for the alternative plan
		int_O_ascenttime              = 0;		// reset ascent time for the normal plan
		int_O_alternate_ascenttime    = 0;		// reset ascent time for the alternative plan
		char_O_deco_warnings          = 0;		// reset all deco warnings
		char_O_deco_info              = 0;		// reset all deco infos
		deco_tissue_vector            = 0;		// reset tissue deco vector
		IBCD_tissue_vector            = 0;		// reset tissue IBCD vector
		NDL_lead_tissue_norm          = 0;		// reset first tissue to look at during NDL calculation
		NDL_lead_tissue_alt           = 0;		// reset first tissue to look at during NDL calculation

		// tag desaturation time as invalid (it will not be computed during a dive)
		int_O_desaturation_time       = 65535;

		// initialize values for first stop depth and GF slope
		low_depth_norm                = 0.0;	// reset depth of first stop in normal      plan
		locked_GF_step_norm           = 0.0;	// reset GF slope            in normal      plan
		low_depth_alt                 = 0.0;	// reset depth of first stop in alternative plan
		locked_GF_step_alt            = 0.0;	// reset GF slope            in alternative plan

		// initialize CNS values
		int_O_normal_CNS_fraction     = int_O_alternate_CNS_fraction = int_O_CNS_fraction;

		//
		// --> code execution continues in state DECO_STATUS_START
		//

	case DECO_STATUS_START: //---- Start a new deco calculation cycle --------------

		// clear the internal(!) stops table
		clear_deco_table();

		// initialize the simulated tissues with the current state of the real tissues
		for( i = 0; i < NUM_COMP; i++ )
		{
			sim_pres_tissue_N2[i] = pres_tissue_N2[i];
			sim_pres_tissue_He[i] = pres_tissue_He[i];
		}

		// initialize the simulated CNS value with the current CNS of the real tissues
		sim_CNS_fraction = CNS_fraction;

		// initialize the simulated depth with the current depth (in absolute pressure)
		sim_pres_respiration = real_pres_respiration;

		// Lookup the current gas and store it also as the first gas used.
		// This gas will be used until gas_find_better() is invoked and finds
		// a better gas to switch to.
		gas_find_current();

		// Setup the calculation ratio's for N2, He and O2 (sim_N2/He/_O2_ratio).
		// These ratios will be used and remain valid to use until a gas switch
		// is done. Thus, if a call to gas_find_better() has found a better gas,
		// gas_set_ratios() needs to be called again.
		gas_set_ratios();

		// Calculate the effect of extended bottom time due to delayed ascent,
		// if requested.
		if( char_O_deco_status & DECO_ASCENT_DELAYED )
		{
			// program interval on simulated tissues (flag bit 7 = 0)
			tissue_increment = char_I_extra_time;

			// calculate ppO2, ppN2 and ppHe from sim_N2/real_He_ratio
			calc_alveolar_pressures();

			// update the tissues
			calc_tissues();

			// update the CNS value
			calc_CNS();
		}

		// Calculate the remaining no decompression limit (NDL) time. calc_NDL_time()
		// is very fast in detecting if being beyond NDL, so there is enough time left
		// in this phase to do the initial ascent calculation if found to be outside NDL.
		calc_NDL_time();

		if( NDL_time == 0 )
		{
			// calculate ascent to first stop using the set ascent rate,
			// re-calculating the tissues and limits every minute along the ascent.
			calc_ascent_to_first_stop();

			// continue in next cycle(s) with calculating the initial ascent and stops
			char_O_deco_status &= ~DECO_STATUS_MASK;
			char_O_deco_status |=  DECO_STATUS_STOPS;
		}
		else
		{
			// within NDL - continue in next cycle with gathering all results
			char_O_deco_status &= ~DECO_STATUS_MASK;
			char_O_deco_status |=  DECO_STATUS_RESULTS;
		}

		break;


	case DECO_STATUS_STOPS: //---- Calculate Stops ---------------------------------

		// calculate the stops
		calc_hauptroutine_calc_deco();

		// calc_hauptroutine_calc_deco() iterates in this phase as long as it is
		// calculating the stops. Once done, it will set the status to doing the
		// results gathering.

		break;


	case DECO_STATUS_RESULTS: //--- Gather Results ---------------------------------

		// if in normal plan, publish the stops table
		if( !(char_O_deco_status & DECO_PLAN_ALTERNATE) )
		{
			// publish the stops table to the display functions
			publish_deco_table();

			// When entering deco and the ceiling depth becomes > 0 but the
			// deco calculation reveals no distinct deco stop yet because
			// the deco obligation will vanish during the ascent, create an
			// artificial stop to signal that expedite surfacing ("popping
			// up") is not allowed anymore.
			if( char_O_first_deco_depth == 0 )		// simulation  reveals no stop required
			if( int_O_ceiling           >  0 )		// real status reveals a ceiling
			{
				// set a pro forma stop at 3 meters
				char_O_first_deco_depth = 3;

				// set a stop time of 0 minute, this will be displayed as "..'"
				char_O_first_deco_time  = 0;
			}
		}

		// The current depth is needed by calc_ascenttime() and gas_volumes(). As we
		// don't want it to be calculated multiple times, it's done here on stockpile.
		char_bottom_depth = (unsigned char)((real_pres_respiration - pres_surface) * BAR_TO_METER + 0.5);

		// results to publish depend whether within NDL or in deco
		if( NDL_time )
		{
			//---- within NDL ----------------------------------------------

			// check which plan we are on
			if( char_O_deco_status & DECO_PLAN_ALTERNATE )
			{
				//---- alternate dive plan ---------------------------------

				// output NDL time
				char_O_alternate_nullzeit  = NDL_time;

				// clear ascent time
				int_O_alternate_ascenttime = 0;

				// As we are in no stop, CNS at end of dive is more or less
				// the same CNS as we have right now.
				int_O_alternate_CNS_fraction = int_O_CNS_fraction;
			}
			else
			{
				//---- normal dive plan ------------------------------------

				// output NDL time
				char_O_nullzeit = NDL_time;

				// clear ascent time
				int_O_ascenttime = 0;

				// As we are in no stop, CNS at end of dive is more or less
				// the same CNS as we have right now.
				int_O_normal_CNS_fraction = int_O_CNS_fraction;
			}
		} // NDL
		else
		{
			//---- in DECO -------------------------------------------------

			// calculate the ascent time
			calc_ascenttime();

			// check which plan we are on
			if( char_O_deco_status & DECO_PLAN_ALTERNATE )
			{
				//---- alternative plan ----------------------------------------------------

				// clear the NDL time
				char_O_alternate_nullzeit = 0;

				// export the ascent time
				int_O_alternate_ascenttime = ascent_time;

				// convert the CNS value to integer for export
				convert_sim_CNS_for_display();

				// export the integer CNS value
				int_O_alternate_CNS_fraction = int_sim_CNS_fraction;

			} // alternative plan
			else
			{
				//---- normal plan ---------------------------------------------------------

				// clear the NDL time
				char_O_nullzeit  = 0;

				// export the ascent time
				int_O_ascenttime = ascent_time;

				// convert the CNS value to integer for export
				convert_sim_CNS_for_display();

				// export the integer CNS value
				int_O_normal_CNS_fraction = int_sim_CNS_fraction;

			} // normal plan
		} // NDL / DECO


		// Check if deco obligation is steady or decreasing. This works only when an alternative plan is enabled and
		// if it is not a bailout plan, thus DECO_BAILOUT_MODE must not be set while doing the DECO_PLAN_ALTERNATE.
		if( (char_O_deco_status & DECO_PLAN_ALTERNATE) && !(char_O_deco_status & DECO_BAILOUT_MODE) )
		{
			// Set DECO_DECREASING flag when fTTS < TTS and DECO_STEADY flag when fTTS = TTS.
			     if ( int_O_alternate_ascenttime <  int_O_ascenttime ) char_O_deco_info |= DECO_DECREASING;
			else if ( int_O_alternate_ascenttime == int_O_ascenttime ) char_O_deco_info |= DECO_STEADY;
		}

		// Clear DECO_DECREASING flag when fTTS >= TTS and DECO_STEADY flag when fTTS > TTS.
		// This works in any planning mode combination.
		     if ( int_O_alternate_ascenttime >  int_O_ascenttime ) char_O_deco_info &= ~(DECO_DECREASING + DECO_STEADY);
		else if ( int_O_alternate_ascenttime == int_O_ascenttime ) char_O_deco_info &= ~(DECO_DECREASING              );

		// If requested, calculate the required gas volumes and tank pressures at the end of the dive.
		if( char_O_deco_status & DECO_VOLUME_CALCULATE )
		{
			// When in bailout mode and within NDL, find the gas changes along the ascent and put
			// them into the stops table for use by gas_volumes(). The stops table can be "polluted"
			// by now because the table has already been published in "clean" state before.
			if( (NDL_time) && ( char_O_deco_status & DECO_BAILOUT_MODE ) )
			{
				// find the gas changes and put them into the stops table
				find_NDL_gas_changes();
			}

			// calculate the required gas volumes and tank pressures
			gas_volumes();
		}

		// set the computation cycle to finished
		char_O_deco_status &= ~DECO_STATUS_MASK;

		// set flag indicating that deco calculation has been completed
		if( char_O_deco_status & DECO_PLAN_ALTERNATE ) char_O_main_status |= DECO_COMPLETED_ALT;
		else                                           char_O_main_status |= DECO_COMPLETED_NORM;


		break;

	} // switch
}

//////////////////////////////////////////////////////////////////////////////
// calc_hauptroutine_data_input
//
// Set all C-code dive parameters from their ASM-code values.
// Detect gas change condition.
//
void calc_hauptroutine_data_input(void)
{
	overlay float IG_ratio;

	// safety limits to prevent eventual infinite looping (bricking the OSTC)
	if( int_I_pres_surface     < 500) int_I_pres_surface     = 500;		// min. surface     pressure = 500 mbar
	if( int_I_pres_respiration < 500) int_I_pres_respiration = 500;		// min. respiration pressure = 500 mbar

	// safe-guard further parameters to protect the tissue-flag
	if( char_I_sim_advance_time > 127 ) char_I_sim_advance_time = 127;
	if( char_I_extra_time       > 127 ) char_I_extra_time       = 127;
	if( char_I_gas_change_time  >  99 ) char_I_gas_change_time  =  99;

	// get the current pressures
	pres_surface          = 0.001  * int_I_pres_surface;
	real_pres_respiration = 0.001  * int_I_pres_respiration;

	// N2 tissue pressure at surface equilibrium, used for tissue graphics scaling
	N2_equilibrium   = 0.7902 * (pres_surface - ppWater);

	// read the GF settings (they may have been switch between GF/aGF)
	GF_high  = 0.01 * char_I_GF_High_percentage;
	GF_low   = 0.01 * char_I_GF_Low_percentage;
	GF_delta = GF_high - GF_low;

	// get the currently breathed gas mixture
	real_O2_ratio = 0.01 * char_I_O2_ratio;
	real_He_ratio = 0.01 * char_I_He_ratio;

	// inert gas ratio (local helper variable)
	IG_ratio = 1.00 - real_O2_ratio;

	// N2 ratio
	real_N2_ratio  = IG_ratio - real_He_ratio;

	// compute values for ppO2 drop in pSCR loop
	real_pSCR_drop = IG_ratio * float_pSCR_factor;
}


//////////////////////////////////////////////////////////////////////////////
// Compute stops
//
// Note: because this can be very long, break on 16 iterations, or after
//       512 ms, whichever comes first. Set state to DECO_STATUS_RESULTS
//       when finished, or keep DECO_STATUS_STOPS when needing to continue.
//
void calc_hauptroutine_calc_deco(void)
{
	overlay unsigned char loop;

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

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

			//---- stop required at sim_depth_limit ----------------------

			// convert stop depth in meters to absolute pressure
			sim_pres_respiration = sim_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 --------------------------------------

			// convert next depth (without stop requirement) to absolute pressure
			sim_pres_respiration = sim_depth_limit * METER_TO_BAR + pres_surface;

			// finish deco calculation if surface is reached
			if( sim_pres_respiration <= pres_surface )
			{
Surface:
				// continue with gathering all results in the next calculation phase
				char_O_deco_status &= ~DECO_STATUS_MASK;
				char_O_deco_status |=  DECO_STATUS_RESULTS;

				return;
			}
		}

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

		// program 1 minute interval on simulated tissues
		tissue_increment = 1;

		// compute current ppO2, ppN2 and ppHe
		calc_alveolar_pressures();

		// update the tissues
		calc_tissues();

		// update the CNS value
		calc_CNS();
	}
}


//////////////////////////////////////////////////////////////////////////////
// Find gas changes on an NDL ascent
//
// This function is a variant of calc_ascent_to_first_stop() to be used solely
// for finding the gas changes in an OC bailout ascent that is within NDL.
//
// Input    : char_bottom_depth : depth at which the ascent starts, in meters
//
// Output   : gas change stops put into stops table
//
// Destroyed: sim_depth_limit
//            sim_gas_current
//            sim_gas_current_depth
//
void find_NDL_gas_changes(void)
{
	overlay unsigned char old_depth_limit;

	// set gas to start with
	gas_find_current();

	// loop in ascending until reaching a depth of 3 meters, no gas switches considered thereafter
	for( sim_depth_limit = char_bottom_depth; sim_depth_limit >= 3; )
	{
		// memorize the depth we came from
		old_depth_limit = sim_depth_limit;

		// ascent - initially in steps of 10 m, then slowing down to 1 m steps to not miss a O2 gas
		if( sim_depth_limit > 10 ) sim_depth_limit -= 10;
		else                       sim_depth_limit -=  1;

		// check if there is a better gas to switch to
		if( gas_find_better() )
		{
			// adjust sim_depth_limit to the gas change depth, but not deeper than the depth we came from
			sim_depth_limit = (sim_gas_current_depth < old_depth_limit) ? sim_gas_current_depth : old_depth_limit;

			// create a stop for the gas change in the stops table
			update_deco_table(char_I_gas_change_time);
		}
	} // for()
}


//////////////////////////////////////////////////////////////////////////////
// Calculate ascent to first deco stop
//
// Modified : sim_pres_respiration : current depth in ascent and deco simulation, in bar absolute pressure
//
// Output   : sim_depth_limit      : depth in meters of the 1st stop, if a stop is found
//
// Destroyed: tissue_increment     : tissue and update period selector
//
void calc_ascent_to_first_stop(void)
{
	overlay float         old_pres_respiration;
	overlay unsigned char fast = 1;					// 0: 2 seconds step, 1: 1 minute step

	// target the simulated tissues
	tissue_increment = 0;

	// loop until first deco stop or the surface is reached
	for(;;)
	{
		// memorize depth in absolute pressure we came from
		old_pres_respiration = sim_pres_respiration;

		// try ascending 1 full minute (fast) or 2 seconds (!fast)
		if( fast ) sim_pres_respiration -=          float_ascent_speed * METER_TO_BAR;	// 1 min at float_ascent_speed ( 5 .. 10  m)
		else       sim_pres_respiration -= 0.0333 * float_ascent_speed * METER_TO_BAR;	// 2 sec at float_ascent_speed (17 .. 33 cm)

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

		// compute ceiling of the simulated tissues
		if( char_I_deco_model != 0 ) calc_limit(GF_low);
		else                         calc_limit(1.0);

		// did we overshoot the ceiling?
		if( sim_pres_respiration < (ceiling + pres_surface) )
		{
			// YES - back to memorized depth
			sim_pres_respiration = old_pres_respiration;

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

		// if code execution passes along here, we did not overshoot the ceiling

		// did we reach the surface? If yes, deco has vanished, no stop required, done.
		if( sim_pres_respiration == pres_surface ) break;

		// depth in meters where we are now (no round-up)
		sim_depth_limit = (unsigned char)((sim_pres_respiration - pres_surface) * BAR_TO_METER);

		// program interval on simulated tissues:
		// fast = 1 -> 1 minute,
		// fast = 0 -> 2 seconds
		tissue_increment = fast;

		// Check if there is a better gas to switch to, but only if bailout mode is enabled.
		// If yes, introduce a stop for the gas change.
		if( char_O_deco_status & DECO_BAILOUT_MODE )
		if( gas_find_better() )
		{
			overlay unsigned char old_depth_limit;

			// set the new calculation values for N2, He and O2
			gas_set_ratios();

			// add gas change time: a gas change time of
			//    0 minutes will keep the 1 minute / 2 seconds interval selection,
			// >= 1 minute  will add the the 1 minute interval but overrule a 2 seconds interval.
			tissue_increment += char_I_gas_change_time;

			// depth in meters we came from
			old_depth_limit = (unsigned char)((old_pres_respiration - pres_surface) * BAR_TO_METER);

			// adjust sim_depth_limit to the gas change depth, but not deeper than the depth we came from
			sim_depth_limit = (sim_gas_current_depth < old_depth_limit) ? sim_gas_current_depth : old_depth_limit;

			// Adjust the depth for the tissue update to the current depth. In case of fast mode,
			// this imposes that the ascent from the 'old_pres_respiration' depth to this depth
			// took one minute although we might have only ascended one or two meters...
			sim_pres_respiration = sim_depth_limit * METER_TO_BAR + pres_surface;

			// create a stop for the gas change in the stops table
			update_deco_table(char_I_gas_change_time);
		}

		// omit the 2 seconds interval updates (do only updates for >= 1 minute)
		// It's a trade-off between computational effort and accuracy...
		if( tissue_increment )
		{
			// compute ppO2, ppN2 and ppHe for current depth from sim_pres_respiration
			calc_alveolar_pressures();

			// update the tissues
			calc_tissues();

			// update the CNS value
			calc_CNS();
		}

	} // for()
}


//////////////////////////////////////////////////////////////////////////////
// calc_tissues
//
// INPUT:    ppN2                          : partial pressure of inspired N2
//           ppHe                          : partial pressure of inspired He
//           tissue_increment              : integration time and tissue selector (real or simulated)
//
// MODIFIED: pres_tissue_N2[]              : tissue N2 pressures (in real tissues context)
//           pres_tissue_He[]              : tissue He pressures (in real tissues context)
//           sim_pres_tissue_N2[]          : tissue N2 pressures (in simulated tissues context)
//           sim_pres_tissue_He[]          : tissue He pressures (in simulated tissues context)
//
// OUTPUT:   char_O_tissue_N2_saturation[] : tissue N2 pressures scaled for display purpose (in real tissues context)
//           char_O_tissue_He_saturation[] : tissue He pressures scaled for display purpose (in real tissues context)
//
static void calc_tissues()
{
	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 & TIME_MASK;	// 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 & TISSUE_FLAG) ? pres_tissue_N2[ci] : sim_pres_tissue_N2[ci];

			temp_tissue = (ppN2 - temp_tissue) * var_N2_e;

			temp_tissue_safety();

			if( tissue_increment & TISSUE_FLAG )
			{
				temp_tissue_N2      = temp_tissue;
				pres_tissue_N2[ci] += temp_tissue;
			}
			else
			{
				sim_pres_tissue_N2[ci] += temp_tissue;
			}


			//---- He -------------------------------------------------------------------------------

			temp_tissue = (tissue_increment & TISSUE_FLAG) ? pres_tissue_He[ci] : sim_pres_tissue_He[ci];

			temp_tissue = (ppHe - temp_tissue) * var_He_e;

			temp_tissue_safety();

			if( tissue_increment & TISSUE_FLAG )
			{
				temp_tissue_He      = temp_tissue;
				pres_tissue_He[ci] += temp_tissue;
			}
			else
			{
				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 & TISSUE_FLAG )
		{
			// 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 * (real_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;
		} //if

	} // for
}

//////////////////////////////////////////////////////////////////////////////
// calc_limit
//
// Input:
//        tissue_increment       : selector for context: real or simulated tissues
//        sim_pres_tissue_N2/_He : tissue pressures (used in simulated tissues context)
//        pres_tissue_N2/_He     : tissue pressures (used in real      tissues context)
//
// Output:
//        lead_supersat          : supersaturation of the leading tissue, 1.0 = 100%
//        ceiling                : ceiling in bar relative pressure
//
// Modified:
//        char_O_deco_warnings   : for IBCD, microbubbles and outside warning (only in real tissues context)
//
static void calc_limit(PARAMETER float GF_parameter)
{
	overlay float lead_tissue_limit = 0.0;


	// set leading tissue number to not yet computed
	lead_number = 0;

	// initialize leading tissue supersaturation value to null
	lead_supersat  = 0.0;

	// check context
	if( tissue_increment & TISSUE_FLAG )
	{
		// 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 + DECO_ATTENTION_OUTSIDE );
	}

	// loop over all tissues
	for( ci = 0; ci < NUM_COMP; ci++ )
	{
		overlay float pres_min;

		// get the tissue pressures
		if( tissue_increment & TISSUE_FLAG )
		{
			// context is real tissues
			calc_pres_tissue_N2 = pres_tissue_N2[ci];
			calc_pres_tissue_He = pres_tissue_He[ci];
		}
		else
		{
			// context is simulated tissues
			calc_pres_tissue_N2 = sim_pres_tissue_N2[ci];
			calc_pres_tissue_He = sim_pres_tissue_He[ci];
		}

		// overall tissue pressure
		pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He;

		// get the coefficients for tissue ci
		read_Buhlmann_coefficients();

		// adopt a and b coefficients to current N2/He ratio inside the tissue
		adopt_Buhlmann_coefficients();

		// calculate minimum ambient pressure that the tissue can withstand according to straight Buhlmann
		pres_min = (pres_tissue - var_N2_a) * var_N2_b;

		// next calculations are only relevant when invoked on the real tissues
		if( tissue_increment & TISSUE_FLAG )
		{
			overlay float supersat;
			overlay float baseline_threshold;

			// calculate current supersaturation value (1.0 = 100%) of this tissue according to straight Buhlmann
			supersat = (pres_tissue - real_pres_respiration) / (pres_tissue - pres_min);

			// check if tissue is in supersaturation
			if( supersat > 0.0 )
			{
				// memorize highest supersaturation found
				if( supersat > lead_supersat ) lead_supersat = supersat;

				// tissue-dependent baseline threshold for micro bubbles and outside warnings
				baseline_threshold = 0.02 * ci + 1.0;

				// micro bubbles warning: supersaturation > baseline threshold
				if( supersat > baseline_threshold )
					char_O_deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock);

				// outside warning: supersaturation > baseline threshold + additional 5% margin
				if( supersat > baseline_threshold + 0.05 )
					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, so that can change which is the
		//       leading tissue...            (this equation [1] is the inverse of equation [2])
		if( char_I_deco_model != 0 ) pres_min =   ( pres_tissue        - (var_N2_a     * GF_parameter) )
		                                        / ( 1.0 - GF_parameter + (GF_parameter / var_N2_b    ) );

		// check if this tissue requires a higher ambient pressure than was found to be needed up to now
		if( pres_min > lead_tissue_limit )
		{
			lead_tissue_limit = pres_min;
			lead_number       = ci;
		}
	} // for


	// compute ceiling for the real tissues in bar relative pressure
	ceiling = lead_tissue_limit - pres_surface;


	// next in real tissue context only
	if( tissue_increment & TISSUE_FLAG )
	{
		// check if the leading tissue is in IBCD condition
		if(    (IBCD_tissue_vector & (1 << lead_number))
		    && ((pres_tissue_N2[lead_number] + pres_tissue_He[lead_number]) > real_pres_respiration) )
		{
			// leading tissue is in IBCD condition and in super-saturation, so issue a warning
			char_O_deco_warnings |= (DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock);
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
// calc_NDL_time
//
// calculation of the remaining bottom time (NDL: no decompression limit)
//
// NOTE: Erik Baker's closed formula works for Nitrox. Trimix adds a second
//       exponential term to the M-value equation, making it impossible to
//       invert. So we have to solve the problem with an iterative approach.
//
// Input:  ppN2
//         ppHe
//
// Output: NDL_time
//
static void calc_NDL_time(void)
{
	overlay unsigned char new_NDL_lead_tissue = 0;
	overlay unsigned char i;


	// initialize NDL_time to 240 minutes
	NDL_time = 240;

	for( i = 0; i < NUM_COMP; i++ )
	{
		overlay unsigned char period		= 10;		// start with iterations of 10 minutes
		overlay unsigned char NDL_tissue;				// loop variable
		overlay float         GF_factor;				// gradient factor to be applied
		overlay float         next_pres_tissue;			// auxiliary variable to cache a calculation result


		// select gradient factor to use
		GF_factor = (char_I_deco_model != 0) ? GF_high : 1.0;

		// the fastest way to find out if already being beyond NDL is to start with
		// the tissue that was the leading one during the last NDL computation...
		ci =  (char_O_deco_status & DECO_PLAN_ALTERNATE) ? (NDL_lead_tissue_alt + i) : (NDL_lead_tissue_norm + i);

		// wrap around after the 16th tissue
		if( ci >= NUM_COMP ) ci -= NUM_COMP;

		// read the loading factors for 10 minute iterations
		read_Buhlmann_times(2);

		// get the tissue pressures for N2 and He
		calc_pres_tissue_N2 = sim_pres_tissue_N2[ci];
		calc_pres_tissue_He = sim_pres_tissue_He[ci];

		// calculate the total pressure tissue
		pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He;

		// Simulate an increasing bottom time and check when we hit the NDL.
		// It is not needed to simulate for longer than the already found NDL.
		for( NDL_tissue = 0; NDL_tissue < NDL_time; )
		{
			overlay float pres_limit;
			overlay float delta_pres_tissue_N2;
			overlay float delta_pres_tissue_He;


			// read Buhlmann a and b coefficients for tissue ci, they need to be re-read on each
			// iteration because adopt_Buhlmann_coefficients() twiddles with the N2 coefficients
			read_Buhlmann_coefficients();

			// adopt a and b coefficients to current N2/He ratio inside the tissue
			adopt_Buhlmann_coefficients();

			// compute the maximum tissue pressure allowed to be exposed to an ambient pressure equaling
			// the surface pressure                   (this equation [2] is the inverse of equation [1])
			pres_limit = (1.0 - GF_factor + GF_factor / var_N2_b) * pres_surface + GF_factor * var_N2_a;

			// check if this tissue is already beyond the NDL
			if( pres_tissue > pres_limit)
			{
				// beyond NDL - finish the outer loop, ...
				i = NUM_COMP;

				// ... and finish the inner loop
				break;
			}

			// compute tissue pressure deltas for 10 or 1 minute of time ahead
			delta_pres_tissue_N2 = (ppN2 - calc_pres_tissue_N2) * var_N2_e;
			delta_pres_tissue_He = (ppHe - calc_pres_tissue_He) * var_He_e;

			// apply safety factors to the pressure deltas
			// NDL can be computed while ascending, so we have to check if the tissues is saturating or desaturating
			if( delta_pres_tissue_N2 > 0.0 ) delta_pres_tissue_N2 *= float_saturation_multiplier;
			else                             delta_pres_tissue_N2 *= float_desaturation_multiplier;

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

			// simulate off-gassing while going to surface - well, maybe some day we'll do that...
			// delta_pres_tissue_N2 -= exp( ... ascent time ... ppN2...)
			// delta_pres_tissue_He -= exp( ... ascent time ... ppHe...)

			// calculate tissue pressure for given time ahead
			next_pres_tissue = pres_tissue + delta_pres_tissue_N2 + delta_pres_tissue_He;

			// within NDL now, but still within NDL in 10 or 1 minute from now?
			if( next_pres_tissue <= pres_limit )
			{
				// YES - apply the pressure deltas to the tissues
				calc_pres_tissue_N2 += delta_pres_tissue_N2;
				calc_pres_tissue_He += delta_pres_tissue_He;

				// update the overall tissue pressure
				pres_tissue = next_pres_tissue;

				// increment the NDL
				NDL_tissue += period;

				// do next iteration
				continue;
			}

			// NO - if delta pressures were for 10 minutes of time ahead, continue with trying for 1 minute ahead
			if( period == 10 )
			{
				// reduce period to 1 minute
				period = 1;

				// read the loading factors for 1 minute periods
				read_Buhlmann_times(1);

				// do next iteration
				continue;
			}

			// less than a full minute of NDL time left, so finish the inner loop
			break;

		} // inner for-loop simulating increasing bottom time

		// is the current NDL shorter than the shortest so far?
		if ( NDL_tissue < NDL_time )
		{
			// keep the current's tissue NDL as the new shortest NDL
			NDL_time = NDL_tissue;

			// store the causing tissue
			new_NDL_lead_tissue = ci;
		}
		
		// If NDL is > 0 the outer loop will continues with the next tissue.
		// If NDL found to be overrun, outer loop will be terminated by means of the i = NUM_COMP statement.

	} // outer for-loop iterating over all tissues

	// store the NDL dominating tissue for to start with in the next NDL calculation
	if( char_O_deco_status & DECO_PLAN_ALTERNATE ) NDL_lead_tissue_alt  = new_NDL_lead_tissue;
	else                                           NDL_lead_tissue_norm = new_NDL_lead_tissue;
}


//////////////////////////////////////////////////////////////////////////////
// calc_ascenttime
//
// Sum up ascent from bottom to surface at float_ascent_speed, slowing down to
// 1 minute per meter for the final ascent when in deco, and all stop times.
//
// Input:  char_I_depth_last_deco
//         char_I_ascent_speed
//         char_bottom_depth
//         internal_deco_depth[]
//         internal_deco_time[]
//
// Output: ascent_time
//
static void calc_ascenttime(void)
{
	overlay unsigned char x;		// loop counter
	overlay unsigned char ascent;	// meters to go from bottom to last stop
	overlay unsigned char final;	// meters to go from last stop to surface


	// check if there are stops
	if( internal_deco_depth[0] )
	{
		// stops / in deco

		// check if already at last stop depth or shallower
		if( char_bottom_depth <= char_I_depth_last_deco)
		{
			// YES
			ascent = 0;
			final  = char_bottom_depth;
		}
		else
		{
			// NO
			ascent = char_bottom_depth - char_I_depth_last_deco;
			final  = char_I_depth_last_deco;
		}
	}
	else
	{
		// no stops / within NDL
		ascent = char_bottom_depth;
		final  = 0;
	}


	// initialize ascent time
	ascent_time = 0;

	// time for the ascent part (bottom to last stop), if existing
	if( ascent ) ascent_time += ascent / char_I_ascent_speed + 1;

	// add time for the final ascent (last stop to surface) at 1 min/m
	ascent_time += final;

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

	// limit result to display max.
	if( ascent_time > 999) ascent_time = 999;

	// tag result as invalid if there is an overflow in the stops table
	if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) ascent_time |= INT_FLAG_INVALID;
}


//////////////////////////////////////////////////////////////////////////////
// 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;
		internal_deco_gas[x]   = 0;
	}

	// clear stop table overflow warning
	char_O_deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW;
}

//////////////////////////////////////////////////////////////////////////////
// update_deco_table
//
// Add time to a stop at sim_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 is depth == 0.
//
// Input:   sim_depth_limit       : stop's depth, in meters
//          sim_gas_current       : gas used at stop, as index 1..5 or 0 for gas 6
//          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( sim_depth_limit > 0 );		// no stop at surface

	// loop through internal deco table
	for( x = 0; x < NUM_STOPS; ++x )
	{
		// In case the first deco stop is to be placed deeper than previously recorded
		// stops for gas changes during the initial ascent (this may happen because the
		// deco stops are placed at the next deeper multiple of 3 meters instead of the
		// real stop's depth), relocate the deco stop to the depth of the last gas change.
		// The resulting combined stop's duration will be the sum of the configured gas
		// change time plus the duration of the deco stop itself.
		if( internal_deco_depth[x] && (sim_depth_limit > internal_deco_depth[x]) )
			sim_depth_limit = internal_deco_depth[x];

		// Is there already a stop entry for our current depth?
		if( internal_deco_depth[x] == sim_depth_limit )
		{
			// Yes - increment stop time if possible
			// Stop time entries are limited to 99 minutes because of display constraints.
			if( internal_deco_time[x] < (100 - 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] = sim_depth_limit;		// ... depth, and
			internal_deco_gas[x]   = sim_gas_current;		// ... 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_desaturation_time
//
// Helper function
//
static 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/falls and N2/He ratio is being adjusted.
		int_time = (unsigned int)( (var_ht * log(pres_ratio) / desat_factor) + 0.9 );
	}
	else
	{									// NO  - desaturation state reached, no remaining time
		int_time = 0;
	}
}

/////////////////////////////////////////////////////////////////////////////
// calc_desaturation_time
//
// Inputs:  int_I_pres_surface, ppWater, char_I_desaturation_multiplier
// Outputs: int_O_desaturation_time, int_O_nofly_time
//
// Calculate the time needed for the tissues to equilibrate with surface pressure
//
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 );


	// safety limit to prevent eventual infinite looping (bricking the OSTC)
	if( int_I_pres_surface < 500) int_I_pres_surface = 500;

	// fraction of inert gases in respired air
	real_N2_ratio  = 0.7902;
	real_He_ratio  = 0.0;

	// surface pressure in bar
	pres_surface   = 0.001    * int_I_pres_surface;

	// partial pressure of N2 in respired air
	N2_equilibrium = real_N2_ratio * (pres_surface - ppWater);

	// pre-computed term for later use: 10 [Min] * 0.01 [%] * 0.6931 [=log(2)] * ...
	desat_factor   = 0.06931  * char_I_desaturation_multiplier * SURFACE_DESAT_FACTOR;

	// initialize vars
	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 int nofly_N2   =  0;
		overlay unsigned int nofly_He   =  0;
		overlay unsigned int 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 = P_ambient_altitude +
			                  0.01 * char_I_GF_High_percentage * (pres_tissue_max - 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( int_time > int_O_desaturation_time) int_O_desaturation_time = int_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 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( int_time > int_O_desaturation_time) int_O_desaturation_time = int_time;


		//
		// no-fly time
		//

		// initialize split_N2_He in case there was a hard reboot / memory clear.
		if( split_N2_He[ci] == 0 ) split_N2_He[ci] = 90;

		// 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 = int_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 = (0.01 * (100 - split_N2_He[ci])) * (pres_tissue_max - N2_equilibrium);

			calc_desaturation_time_helper();
			nofly_He = int_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 < 100%.
	// The current gradient factor is calculated by calc_interval() while not in diving mode.
	// 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 < 100 )
		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
	                               + DECO_ATTENTION_OUTSIDE                             );

}

//////////////////////////////////////////////////////////////////////////////
// Calculate desaturation of the real tissues for a given time interval
//
// Caution: Works on the real tissues!
//          If in doubt, use this function only inside a context surrounded with
//          push_tissues_to_vault() / pull_tissues_from_vault() !
//
// Input:    int_I_pres_surface : surface pressure in mbar
//           time_interval      : time interval in minutes, must be limited to 254 at max
//
// Modified: tissue pressures   : N2 and He pressures of the tissues
//           CNS_fraction       : current CNS value
//           ceiling            : minimum allowed depth in mbar relative pressure
//           lead_supersat      : supersaturation of the leading tissue
//           int_O_gradient_factor : current GF factor
//
static void calc_interval(PARAMETER unsigned char time_interval)
{
	overlay unsigned char time;

	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 );


	// safety limit to prevent eventual infinite looping (bricking the OSTC)
	if( int_I_pres_surface < 500) int_I_pres_surface = 500;		// min. surface pressure = 500 mbar

	// setup input data for deco routines
	real_pres_respiration = pres_surface = 0.001 * int_I_pres_surface;

	real_N2_ratio  = 0.7902;											// according to Buhlmann
	N2_equilibrium = real_N2_ratio * (pres_surface          - ppWater);	// used for N2 tissue graphics scaling
	ppN2           = real_N2_ratio * (real_pres_respiration - ppWater);
	ppHe           = 0.0;

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


	// Calculate the tissues:
	// Because calc_tissues() can calculate for 127 minutes at max,
	// the tissue updating may need to be done in two chunks.

	time = time_interval;

	// first chunk for the part exceeding 127 minutes
	if( time > 127)
	{
		// do a full 127 minutes on the real tissues
		tissue_increment = TISSUE_FLAG | 127;
		calc_tissues();

		// determine the remaining part
		time -= 127;
	}

	// program the remaining part (or full part if not exceeding 127 minutes)
	tissue_increment = TISSUE_FLAG | time;

	// update the N2 and He pressures in the tissues
	calc_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.

	time = time_interval;

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

	// compute integer copy of CNS value
	convert_CNS_for_display();

	// calculate GF value (for a GF high of 100%)
	calc_limit(1.0);

	// compute integer copy of GF value
	convert_GF_for_display();
}


//////////////////////////////////////////////////////////////////////////////
// calc_CNS
//
// Input:    char_ppO2        : current ppO2 [decibars]
//           tissue_increment : time increment and tissue selector
//
// Modified:     CNS_fraction   accumulated CNS (real      tissue context)
//           sim_CNS_fraction : accumulated CNS (simulated tissue context)
//
static void calc_CNS(void)
{
	overlay float CNS_fraction_inc;			// increment of CNS load, 0.01 = 1%
	overlay float time_factor;				// factor for time increment

	assert( char_ppO2 > 15 );

	// adjust time factor to 2 seconds (factor = 1.0) or minute-based interval (factor = N * 30.0)
	if( tissue_increment & TIME_MASK ) time_factor = (float)(tissue_increment & TIME_MASK) * 30.0;
	else                               time_factor =                                          1.0;

	//------------------------------------------------------------------------
	// No CNS increase below 0.5 bar ppO2
	     if (char_ppO2 <  50) CNS_fraction_inc = 0.0;
	//------------------------------------------------------------------------
	// Below (and including) 1.60 bar
	else if (char_ppO2 <  61) CNS_fraction_inc = time_factor/(-533.07 * char_ppO2 + 54000.0);
	else if (char_ppO2 <  71) CNS_fraction_inc = time_factor/(-444.22 * char_ppO2 + 48600.0);
	else if (char_ppO2 <  81) CNS_fraction_inc = time_factor/(-355.38 * char_ppO2 + 42300.0);
	else if (char_ppO2 <  91) CNS_fraction_inc = time_factor/(-266.53 * char_ppO2 + 35100.0);
	else if (char_ppO2 < 111) CNS_fraction_inc = time_factor/(-177.69 * char_ppO2 + 27000.0);
	else if (char_ppO2 < 152) CNS_fraction_inc = time_factor/( -88.84 * char_ppO2 + 17100.0);
	else if (char_ppO2 < 167) CNS_fraction_inc = time_factor/(-222.11 * char_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_ppO2 < 172) CNS_fraction_inc = time_factor * 0.00102;
	else if (char_ppO2 < 177) CNS_fraction_inc = time_factor * 0.00136;
	else if (char_ppO2 < 182) CNS_fraction_inc = time_factor * 0.00180;
	else if (char_ppO2 < 187) CNS_fraction_inc = time_factor * 0.00237;
	else if (char_ppO2 < 192) CNS_fraction_inc = time_factor * 0.00310;
	else if (char_ppO2 < 198) CNS_fraction_inc = time_factor * 0.00401;
	else if (char_ppO2 < 203) CNS_fraction_inc = time_factor * 0.00517;
	else if (char_ppO2 < 233) CNS_fraction_inc = time_factor * 0.02090;
	else                      CNS_fraction_inc = time_factor * 0.04820; // value for 2.5 bar, used for 2.33 bar and above

	// update the CNS accumulator
	if( tissue_increment & TISSUE_FLAG )     CNS_fraction += CNS_fraction_inc;	// real tissues
	else                                 sim_CNS_fraction += CNS_fraction_inc;	// simulated tissues
}


//////////////////////////////////////////////////////////////////////////////
// gas_volumes
//
// calculates volumes and required tank fill pressures for each gas.
//
// Input:	char_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
//			internal_deco_depth[]	depth of the stops
//			internal_deco_time[]	duration of the stops
//			internal_deco_gas[]		gas breathed at the stops
//			NDL_time				remaining NDL time, used to adjust speed of final ascent
//			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_ascent_volumes[]	 amount of gas needed, in liters
//			int_O_ascent_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 is invalid
//
static void gas_volumes_helper_1(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 * char_usage;

	return;
}

static void gas_volume_helper_2(void)
{
	// Convert a gas volume in liters given as a float into an integer number
	// and computes the equivalent tank pressure in bar, including all flags.

	if( volume >= 65534.5 )
	{
		int_volume    = 65535;
		int_pres_need = 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[gas_num];

		// No distinct rounding done here because volumes are not accurate to the single liter anyhow

		// convert gas volumes to integers
		int_volume    = (unsigned short)volume;

		// compute how much pressure in the tank will be needed [in bar]  (integer-division)
		int_pres_need = (unsigned short)(int_volume / char_I_tank_size[gas_num]);

		// limit to 999 bar because of display constraints
		if( int_pres_need > 999 ) int_pres_need = 999;

		// set flags for fast evaluation by divemode check_for_warnings
		if     ( int_pres_need ==                                              0 ) int_pres_need |= INT_FLAG_ZERO;
		else if( int_pres_need >=                                 tank_pres_fill ) int_pres_need |= INT_FLAG_WARNING;
		else if( int_pres_need >= GAS_NEEDS_ATTENTION_THRESHOLD * tank_pres_fill ) int_pres_need |= INT_FLAG_ATTENTION;
	}

	return;
}

static 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( gas_num = 0; gas_num < NUM_GAS; ++gas_num ) volumes[gas_num] = 0.0;

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


	//---- bottom demand -----------------------------------------------------

	// sim_gas_current  : gas used during bottom segment (0, 1-5)
	// char_bottom_depth: depth of the bottom segment

	// get the gas used during bottom segment
	gas_find_current();

	// initialize variables
	stop_gas_last = stop_gas = sim_gas_current;

	// set the usage (SAC rate) to bottom usage rate for bottom part and initial ascent
	char_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_bottom_depth;

		// calculate either bottom segment or just the fTTS/bailout delayed part
		if( char_O_main_status & DECO_BOTTOM_CALCULATE )
		{
			// duration of bottom segment
			float_time = (float)char_I_bottom_time;
		}
		else
		{
			// duration of delayed ascent
			float_time = (float)char_I_extra_time;
		}

		// calculate gas demand
		gas_volumes_helper_1();

		// 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_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_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_bottom_depth - float_depth * 0.5;

			// calculate gas demand
			gas_volumes_helper_1();

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

	// switch the usage (SAC rate) to deco usage rate
	// for stops, intermediate and final ascent
	char_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_1();

	// 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_1();

		// 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];

	// in case of end-of-table, keep the last gas
	if( !stop_gas ) stop_gas = stop_gas_last;

	// do 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_1();

		// 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_1();

		// 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 dependent on deco status
		if( NDL_time )
		{
			// within NDL - ascent with float_ascent_speed
			float_time = float_depth / float_ascent_speed;
		}
		else
		{
			// in deco - reduce ascent speed to 1 meter per minute
			float_time = float_depth;
		}

		// set half-way depth
		float_depth *= 0.5;

		// calculate gas demand
		gas_volumes_helper_1();

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


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

#ifdef _rx_functions
	// only for OSTC TR model with TR functions enabled
	if( char_O_main_status & DECO_TR_FUNCTIONS )
	{
		// invalidate pressure needs to pressure readings
		int_O_pressure_need[0] = 0 + INT_FLAG_NOT_AVAIL;
		int_O_pressure_need[1] = 0 + INT_FLAG_NOT_AVAIL;
	}
#endif

	for( gas_num = 0; gas_num < NUM_GAS; ++gas_num )
	{
		volume = volumes[gas_num];

		// compute int_volume and int_pres_need from volume and gas_num
		gas_volume_helper_2();

		// set invalid flag if there is an overflow in the stops table
		if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
			int_pres_need |= INT_FLAG_INVALID;

		// copy result data to ASM interface
		int_O_ascent_volumes[gas_num]   = int_volume;
		int_O_ascent_pres_need[gas_num] = int_pres_need;

#ifdef _rx_functions
		// only for OSTC TR model with TR functions enabled
		if( char_O_main_status & DECO_TR_FUNCTIONS )
		{
			// char_I_pressure_gas[] uses gas numbers 1-10, gas_num runs from 0 to 4
			overlay unsigned char gas = gas_num + 1;

			// check if the current gas is configured on pressure reading 1 or 2
			if( (gas == char_I_pressure_gas[0]) || (gas == char_I_pressure_gas[1]) )
			{
				// strip all flags from int_pres_need
				int_pres_need &= 1023;

				// limit to 400 bar and multiply by 10 to get result in 0.1 bar
				int_pres_need = (int_pres_need > 400) ? (4000 | INT_FLAG_OUT_OF_RANGE) : (10 * int_pres_need);

				// tag as not available if there is an overflow in the stops table
				if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
					int_pres_need |= INT_FLAG_NOT_AVAIL;

				// copy to result vars (in both readings the same gas could be configured)
				if( gas == char_I_pressure_gas[0] ) int_O_pressure_need[0] = int_pres_need;
				if( gas == char_I_pressure_gas[1] ) int_O_pressure_need[1] = int_pres_need;
			}
		} // TR functions
#endif

	} // for
}

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

static void convert_CNS_for_display(void)
{
	     if( CNS_fraction <  0.010 ) 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);

		// set warning & attention flags
		     if( int_O_CNS_fraction >= CNS_WARNING_THRESHOLD   ) int_O_CNS_fraction |= INT_FLAG_WARNING;
		else if( int_O_CNS_fraction >= CNS_ATTENTION_THRESHOLD ) int_O_CNS_fraction |= INT_FLAG_ATTENTION;
	}
}

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

static void convert_sim_CNS_for_display(void)
{
	     if( sim_CNS_fraction <  0.010 ) int_sim_CNS_fraction = 0;
	else if( sim_CNS_fraction >= 9.985 ) int_sim_CNS_fraction = 999 + INT_FLAG_WARNING;
	else
	{
		// convert float to integer
		int_sim_CNS_fraction = (unsigned short)(100 * sim_CNS_fraction + 0.5);

		// set warning & attention flags
		if      ( int_sim_CNS_fraction >= CNS_WARNING_THRESHOLD    ) int_sim_CNS_fraction |= INT_FLAG_WARNING;
		else if ( int_sim_CNS_fraction >= CNS_ATTENTION_THRESHOLD  ) int_sim_CNS_fraction |= INT_FLAG_ATTENTION;
	}

	// set invalid flag if there is an overflow in the stops table
	if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_sim_CNS_fraction |= INT_FLAG_INVALID;
}

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

static void convert_GF_for_display(void)
{
	// convert supersaturation of the leading tissue to int_O_gradient_factor in % (1.0 = 100%)
	// limit to 255 because of constraints in ghostwriter code
	     if( lead_supersat <= 0.000 ) int_O_gradient_factor = 0;
	else if( lead_supersat >  2.545 ) int_O_gradient_factor = 255 + INT_FLAG_WARNING;
	else
	{
		int_O_gradient_factor = (unsigned int)(100 * lead_supersat + 0.5);

		if( char_I_deco_model != 0 )
		{
			// GF factors enabled
			if     ( int_O_gradient_factor > 99 )
			{
				int_O_gradient_factor |= INT_FLAG_WARNING;			// make GF factor shown in red
			}
			else if( int_O_gradient_factor > char_I_GF_High_percentage )
			{
				int_O_gradient_factor |= INT_FLAG_ATTENTION;		// make GF factor shown in yellow
				char_O_deco_warnings  |= DECO_ATTENTION_OUTSIDE;	// make depth blink     in yellow
			}
		}
		else
		{
			// straight Buhlmann
			if      ( int_O_gradient_factor > 100 )
				int_O_gradient_factor |= INT_FLAG_WARNING;			// make GF factor shown in red

			else if ( int_O_gradient_factor >  99 )
			{
				int_O_gradient_factor |= INT_FLAG_ATTENTION;		// make GF factor shown in yellow
				char_O_deco_warnings  |= DECO_ATTENTION_OUTSIDE;	// make depth blink     in yellow
			}
		}
	}

	// export also the number of the leading tissue
	char_O_lead_number = lead_number;
}

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

static void convert_ceiling_for_display(void)
{
	// Convert ceiling to int_O_ceiling in mbar relative pressure.
	// Round up to next 10 cm so that the ceiling disappears only
	// when the ceiling limit is really zero. This will coincident
	// with TTS switching back to NDL time.
	     if( ceiling <=  0.0 ) int_O_ceiling = 0;
	else if( ceiling >  16.0 ) int_O_ceiling = 16000;
	else                       int_O_ceiling = (short)(ceiling * 1000 + 9);

	// set/reset ceiling flag
	if( int_O_ceiling ) char_O_deco_info |=  DECO_CEILING;
	else                char_O_deco_info &= ~DECO_CEILING;
}

//////////////////////////////////////////////////////////////////////////////
// push_tissues_to_vault & pull_tissues_from_vault
//
// ATTENTION: Do not use from inside the deco engine!
//            The vault is exclusively reserved to back-up and restore the real
//            tissues and related data when entering / leaving simulation mode!
//

static void push_tissues_to_vault(void)
{
	overlay unsigned char x;

	cns_vault_float      = 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];
	}
}

static void pull_tissues_from_vault(void)
{
	overlay unsigned char x;

	CNS_fraction         = cns_vault_float;
	char_O_deco_warnings = deco_warnings_vault;

	convert_CNS_for_display();

	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