hwos_code: src/p2_deco.c comparison

comparison src/p2_deco.c @ 623:c40025d8e750

3.03 beta released

author	heinrichsweikamp
date	Mon, 03 Jun 2019 14:01:48 +0200
parents	7b3903536213
children	cd58f7fc86db

comparison

equal deleted inserted replaced

-:02d1386429a6
+:c40025d8e750
 // ***************************************************************************
-// p2_deco.c                                         REFACTORED VERSION V2.99f
+// p2_deco.c                                  combined next generation V3.03.4
 //
 //  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
+//    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
+//    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/>.
+//    along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
 //////////////////////////////////////////////////////////////////////////////
-// history:
+// 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/25 v101: CNS_fraction_real calculation
 // 03/13/26 v101: optimization of tissue calc routines
-// 07/xx/08 v102a: debug of bottom time routine
+// 07/xx/2008 v102a: debug of bottom time routine
-// 09/xx/08 v102d: Gradient Factor Model implementation
+// 09/xx/2008 v102d: Gradient Factor Model implementation
-// 10/10/08 v104: renamed to build v103 for v118 stable
+// 10/10/2008 v104: renamed to build v103 for v118 stable
-// 10/14/08 v104: integration of char_I_depth_last_deco for Gradient Model
+// 10/14/2008 v104: integration of char_I_depth_last_deco for Gradient Model
-// 03/31/09 v107: integration of FONT Incon24
+// 03/31/2009 v107: integration of FONT Incon24
-// 05/23/10 v109: 5 gas changes & 1 min timer
+// 05/23/2010 v109: 5 gas changes & 1 min timer
-// 07/13/10 v110: cns vault added
+// 07/13/2010 v110: cns vault added
-// 12/25/10 v110: split in three files (deco.c, main.c, definitions.h)
+// 12/25/2010 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/24: [jDG] Make ascent time 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/15: [jDG] Store GF_low_depth in 32 bits (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).
+// 2012/10/05: [jDG] Better calc_gas_needs_ascent accuracy (average depth, switch between stop).
-// 2013/03/05: [jDG] Should vault low_depth too.
+// 2013/03/05: [jDG] Should vault GF_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
 //
 //                                                     I N C L U D E S
 //
 // *********************************************************************************************************************************
 #include	<math.h>
 #include	"p2_definitions.h"
 #define		TEST_MAIN
 #include	"shared_definitions.h"
+#include	"configuration.inc"
 // *********************************************************************************************************************************
 //
 //                                         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 *)
+// deco engine scheduling
-//#define	_cave_mode							// if defined, compile cave mode into firmware (default: not included *)   ## OPTION IS UNDER CONSTRUCTION ##
+#define INVOKES_PER_SECOND				2		// number of invocations of the deco engine per second (use powers of 2 only: 1, 2, 4, ...)
-												// * option needs to be included / excluded in hwos.inc, too!
+#define BUDGET_PER_SECOND				640		// [ms] total time budget per second for the deco engine, each invocation will preempt after BUDGET_PER_SECOND / INVOKES_PER_SECOND
 // 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]
 #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
+#define ppO2_MARGIN_ON_MAX				  3		// [cbar] margin on ppO2 max to compensate for surface pressures > 1.000 mbar
-// 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
+// deco engine states and modes - (char_O_)main_status: controls current tissue and deco status calculation (as-is situation)
-#define DECO_COMPLETED_ALT				0x02	// the calculation of an alternative deco plan has just been completed
+#define CALC_VOLUME						0x01	// =1: calculate gas needs
-//#define DECO_MODE_MASK				0x0C	// mask for mode selection ==> current diving mode
+#define CALCULATE_BOTTOM				0x02	// =1: calculate gas needs in deco calculator mode, =0: in dive mode
-//#define DECO_MODE_LOOP				0x04	// see below
+#define CAVE_MODE						0x04	// =1: calculate ascent and gas needs using backtracking data
-//#define DECO_MODE_CCR					0x04	// see below
+#define USE_Z_FACTOR					0x08	// =1: calculate with Z factor when converting gas volumes <-> pressures
-//#define DECO_MODE_PSCR				0x08	// see below
+#define TR_FUNCTIONS					0x10	// =1: calculate TR functions (pressure reading) processing
-#define DECO_USE_Z_FACTOR				0x10	// =1: figure in Z factor when converting gas volumes <-> pressures
+#define EXTENDED_STOPS					0x20	// =1: allow placement of gas switches below the depth of the 1st stop
-#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 MODE_MASK						0xC0	// mask for real tissues mode selection
-#define DECO_TR_FUNCTIONS				0x80	// =1: activate TR functions (pressure reading) processing
+#define MODE_LOOP						0x40	// =1: CCR (MODE_PSCR needs to be cleared) or pSCR mode
+#define MODE_CCR						0x40	// to be used with == operator in combination with MODE_MASK only!
-// deco engine states and modes - char_O_deco_status: controls deco plan calculation (to-be scenario)
+#define MODE_PSCR						0x80	// =1: pSCR mode (MODE_LOOP needs to be set, too)
-#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
+// deco engine states and modes - (char_O_)deco_status: controls deco plan calculation (to-be scenario)
-#define DECO_STATUS_FINISHED			0x00	// value indicates completion of deco calculation
+#define PLAN_MASK						0x03	// bit mask covering normal & alternative plan flag
-#define DECO_STATUS_STOPS				0x01	// value indicated calculation is ongoing, currently calculating the stops
+#define COMMAND_MASK					0x07	// bit mask covering all command flags
-#define DECO_STATUS_RESULTS				0x02	// value indicates calculation is ongoing, currently calculating the results
+#define CALCULATING						0x00	// calculations are ongoing
-#define DECO_STATUS_INIT				0x03	// value to be set once for the first invocation at the begin of a new dive
+#define START_NORM						0x01	// input:    start calculation of a  normal      deco plan
+#define CALC_NORM						0x01	// internal: calculating          a  normal      deco plan
-#define DECO_MODE_MASK					0x0C	// mask for mode selection ==> diving mode during ascent
+#define COMPLETED_NORM					0x01	// output:   calculation       of a  normal      deco plan has completed
-#define DECO_MODE_LOOP					0x04	// =1: CCR (DECO_MODE_PSCR needs to be cleared) or pSCR mode
+#define START_ALT						0x02	// input:    start calculation of an alternative deco plan
-#define DECO_MODE_CCR					0x04	// to be used with == operator in combination with DECO_MODE_MASK only!
+#define CALC_ALT						0x02	// internal: calculating          an alternative deco plan
-#define DECO_MODE_PSCR					0x08	// =1: pSCR mode (DECO_MODE_LOOP needs to be set, too)
+#define COMPLETED_ALT					0x02	// output:   calculation of       an alternative deco plan has completed
+#define INITIALIZE						0x04	// input:    initialize deco engine
-#define DECO_PLAN_ALTERNATE				0x10	// =1: calculate the 2nd (alternative) deco plan
+#define INITIALIZE_START_NORM			0x05	// input:    initialize deco engine and start calculation of a normal       deco plan
-#define DECO_BAILOUT_MODE				0x20	// =1: do a bailout calculation, i.e. allow gas switches before first deco stop
+#define INITIALIZE_START_ALT			0x06	// input:    initialize deco engine and start calculation of an alternative deco plan
-#define DECO_VOLUME_CALCULATE			0x40	// =1: calculate ascent gas needs
+//										0x08	// unused - reserved for further deco engine commands
-#define DECO_ASCENT_DELAYED				0x80	// =1: calculate a delayed ascent (fTTS)
+#define BAILOUT_MODE					0x10	// =1: allow gas switches before first deco stop
-// deco engine warnings - char_O_deco_warnings
+#define DELAYED_ASCENT					0x20	// =1: figure in a delayed ascent (fTTS)
+//      MODE_MASK						0xC0	// mask for simulated tissues mode selection
+//      MODE_LOOP						0x40	// =1: CCR (MODE_PSCR needs to be cleared) or pSCR mode
+//      MODE_CCR						0x40	// to be used with == operator in combination with MODE_MASK only!
+//      MODE_PSCR						0x80	// =1: pSCR mode (MODE_LOOP needs to be set, too)
+// 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)
+// 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)
+//										0x04	// --- unused
-#define DECO_DECREASING					0x08	// =1: fTTS < TTS (not updated when in bailout mode)
+#define DECO_ZONE						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
+#define DECO_STOPS						0x20	// =1: deco stops found
+#define GAS_NEEDS_CAVE					0x40	// =1: indicated gas needs are calculated in cave mode
+//										0x80	// --- unused
 // deco engine control - tissue_increment
-#define TIME_MASK						0x7F	// (127 decimal, bits 0-6 set)
+#define TIME_MASK						0x7F	// =0: time increment is 2 seconds, 1..127: time increments is 1..127 minutes
-#define TISSUE_FLAG						0x80	// (128 decimal, bit   7  set)
+#define TISSUE_SELECTOR					0x80	// =1: calculate on real tissues, =0: calculate on simulated tissues
+// deco engine control - next_planning_phase
+#define PHASE_00_DONE					0x00	// calculation cycle finished
+#define PHASE_10_DIVE_INIT				0x10	// once-per-dive    initialization of the deco engine
+#define PHASE_11_CYCLIC_INIT			0x11	// once-every-cycle initialization of the deco engine
+#define PHASE_20_EXTENDED_BOTTOM_TIME	0x20	// calculate extended bottom time
+#define PHASE_30_NDL_TIME				0x30	// calculate NDL time
+#define PHASE_40_CAVE_ASCENT			0x40	// calculate cave mode return/ascent
+#define PHASE_60_DECO_ASCENT			0x60	// calculate open water deco ascent
+#define PHASE_70_RESULTS				0x70	// results - initialization
+#define PHASE_71_RESULTS_STOPS_TABLE	0x71	// results - publish stops table
+#define PHASE_72_RESULTS_NDL			0x72	// results - publish data / within NDL
+#define PHASE_73_RESULTS_DECO			0x73	// results - publish data / in deco
+#define PHASE_80_GAS_NEEDS_SWITCHES		0x80	// calculate gas needs - find gas switches in NDL bailout mode
+#define PHASE_81_GAS_NEEDS_ASCENT		0x81	// calculate gas needs - needs of bottom segment and ascent
+#define PHASE_82_GAS_NEEDS_PRESSURES	0x82	// calculate gas needs - conversion from volumes to pressures
+#define PHASE_90_FINISH					0x90	// finish calculation cycle
+// gas needs calculation - gas_needs_next_phase
+#define GAS_NEEDS_INIT					0x00	// initialization
+#define GAS_NEEDS_BOTTOM_SEGMENT		0x10	// demand during bottom segment
+#define GAS_NEEDS_INITIAL_ASCENT		0x20	// demand of initial ascent
+#define GAS_NEEDS_STOP					0x30	// demand on a stop
+#define GAS_NEEDS_INTERMEDIATE_ASCENT	0x40	// demand on ascent between two stops
+#define GAS_NEEDS_FINAL_ASCENT			0x50	// demand during final ascent
+#define GAS_NEEDS_DONE					0x60	// calculation finished
 // flags used with integer numbers
 #define INT_FLAG_INVALID				0x0400	// =1: value not valid
+#define INT_FLAG_NOT_COMPUTED_YET		0x0800	// =1: value not computed yet
 #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
 //
 //                              The Functions are listed in sequence of intended usage / application.
 //
 // *********************************************************************************************************************************
-// Functions used in surface mode
+// 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.
+static void			 init_output_vars(void);			// Initializes all deco engine output variables to defaults
-// Main entry point in dive mode
+// 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
+// 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
+// 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
+// Functions for TR
+#ifdef _rx_functions
+static void			 calc_TR_functions(void);			// Calculates SAC etc.
+#endif
+// 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			 calc_NDL_time_tissue(void);		// Calculates the remaining NDL time for a given tissue.
-static void			 find_NDL_gas_changes(void);		// Finds the gas changes in an OC bailout ascent that is within NDL
+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 unsigned char find_next_stop(void);				// Finds the next stop when in a deco ascent.
-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.
+static void			 calc_gas_needs_ascent(void);		// Calculates required gas volumes and pressures from the data in stops table.
+static void			 calc_due_by_depth_time_sac(void);	// Calculates gas volume required for a given depth, time and usage (SAC rate).
-// Functions for results reporting
+static void			 convert_gas_needs_to_press(void);	// Converts gas volumes into pressures and sets respective flags.
+// 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_cur_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_sat_for_display(void);		// Converts leading tissue saturation 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
+// internal helper Functions
-static unsigned short tmr5(void);						// Reads a hardware timer which is used for preemptive scheduling.
+static void			 load_tmr5(void);					// Loads  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_tmr5(void);					// Reads  a hardware timer which is used for preemptive scheduling.
+static void			 read_CNS_ab_coefficient(void);		// Reads the CNS      a and b coefficients from a ROM table.
+static void			 read_CNS_c_coefficient(void);		// Reads the CNS      c       coefficient  from a ROM table.
+static void			 read_Buhlmann_coefficients(void);	// Reads the Buhlmann 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.
+static void			 calc_N2_equilibrium(void);			// Calculate partial pressure of N2 in respired air at surface pressure
+static void			 get_saturation_factors(void);		// Get, safeguard and convert the saturation and desaturation factors
+static void			 apply_saturation_factors(void);	// Applies saturation and desaturation factors
 // *********************************************************************************************************************************
 //
 //                                         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
+// Environmental and Gas Data (52 byte)
-static float			GF_low;							// initialized from deco parameters
+static float			pres_surface;					// absolute pressure at the surface
-static float			GF_high;						// initialized from deco parameters
-static float			GF_delta;						// initialized from deco parameters
+static float			float_depth_real;				// current real      depth in meters, float
+static unsigned char	char_depth_real;				// current real      depth in meters, integer
-static float			locked_GF_step_norm;			// GF_delta / low_depth_norm in normal plan
+static unsigned char	char_depth_sim;					// current simulated depth in meters, integer
-static float			locked_GF_step_alt;				// GF_delta / low_depth_alt  in alternative plan
+static unsigned char	char_depth_last;				// last    simulated depth in meters, integer
+static unsigned char	char_depth_bottom;				// bottom            depth in meters, integer
-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			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
+// general Deco Parameters (57 byte)
+static float			GF_low;							// gradient factor to determine 1st stop
+static float			GF_high;						// gradient factor to determine surfacing
+static unsigned char	GF_low_last;					// last GF low,  used to detect changes
+static unsigned char	GF_high_last;					// last GF high, used to detect changes
+static unsigned char	GF_low_depth;					// GF low reference depth in current calculation cycle
+static unsigned char	GF_low_depth_norm;				// GF low reference depth in normal plan
+static unsigned char	GF_low_depth_alt;				// GF low reference depth in alternative plan
+static float			GF_slope;						// (GF_high - GF_low) / GF_low_depth      in current calculation cycle
+static float			GF_slope_norm;					// (GF_high - GF_low) / GF_low_depth_norm in normal plan
+static float			GF_slope_alt;					// (GF_high - GF_low) / GF_low_depth_alt  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_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
+// real Context: what we are doing now (16 byte)
-static float			CNS_fraction;					// current CNS (1.00 = 100%)
+static float			CNS_fraction_real;				// current real 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			pres_respiration_sac;			// used in SAC calculation: current depth in absolute pressure
-static float			float_sac;						// used in SAC calculation
+static float			float_sac;						// used in SAC calculation: SAC value in float
-static unsigned int		max_sac_rate;					// used in SAC calculation to determine SAC rate attention
+static unsigned short	max_sac_rate;					// used in SAC calculation: threshold for SAC rate attention
-// simulation context: used to predict ascent
+// simulated Context: used to calculate Ascent (11 byte)
-static float			sim_CNS_fraction;				// CNS after predicted ascent, 0.01 = 1%, as float
+static float			CNS_fraction_sim;				// CNS after predicted ascent, 0.01 = 1%, as float
+static unsigned short	int_sim_CNS_fraction;			// CNS after predicted ascent,    1 = 1%, as integer
-static unsigned int		int_sim_CNS_fraction;			// CNS after predicted ascent,    1 = 1%, as integer
+static unsigned char	NDL_tissue_start_norm;			// tissue to start with when calculating the normal      NDL time
+static unsigned char	NDL_tissue_start_alt;			// tissue to start with when calculating the alternative NDL time
-static unsigned char	sim_depth_limit;				// depth of next stop in meters, used in deco calculations
+static unsigned char	NDL_tissue_start;				// tissue to start with                    in current cycle
-static unsigned char	NDL_lead_tissue_norm;				// used to cache the tissue to start with when calculating the NDL
+static unsigned char	NDL_tissue_lead;				// tissue with the shortest NDL time found in current cycle
-static unsigned char	NDL_lead_tissue_alt;				// used to cache the tissue to start with when calculating the NDL
+static unsigned char	NDL_tissue;						// tissue for which the NDL is calculated right now
+// Result Values from Calculation Functions (9 byte)
-// 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
+static unsigned char	lead_tissue;					// number of the leading tissue
-// stops table
+// Transfer Variables between calc_desaturation_time() and calc_desaturation_time_helper() (18 byte)
-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
+static unsigned short	int_time;						// time it takes for the compartment to reach the target pressure
-// transfer variables between gas_volumes() and gas_volumes_helper_1/_2()
+// Gas in Use and Gas Needs (30 byte)
-static float			float_depth;					// depth of the stop or half-way point
+static unsigned char	sim_gas_current_num;			// number       of the currently used gas
-static float			float_time;						// duration of the stop or ascent phase
+static unsigned char	sim_gas_current_depth;			// change depth of the currently used gas
-static unsigned char	char_usage;						// gas usage in l/min
-static unsigned char	gas_num;						// number of the gas/tank
+static unsigned char	gas_needs_stop_time;			// duration of the stop in minutes
-static float			volume;							// computed volume of gas
+static unsigned char	gas_needs_stop_gas;				// gas used now    (1-5 or 0)
-static unsigned int		int_volume;						// required gas volume in liter
+static unsigned char	gas_needs_stop_gas_last;		// gas used before (1-5 or 0)
-static unsigned int		int_pres_need;					// required gas volume in bar
+static unsigned char	gas_needs_stop_depth;			// depth of the stop      in meters
+static unsigned char	gas_needs_stop_depth_last;		// depth of the last stop in meters
+static unsigned char	gas_needs_stop_index;			// index to the stop table
-// auxiliary variables for data buffering
+static unsigned char	gas_needs_gas_index;			// index to the gas and tank data arrays
+static unsigned char	gas_needs_next_phase;			// next phase within the ascent gas needs calculation
+static float			gas_volume_need[NUM_GAS];		// gas volumes required for return/ascent in liters
+// Transfer Variables between calc_gas_needs_ascent() and calc_due_by_depth_time_sac() (13 byte)
+static float			gas_needs_float_depth;			// depth of the stop or half-way point
+static float			gas_needs_float_time;			// duration of the stop or ascent phase
+static unsigned char	gas_needs_stop_usage;			// gas usage in l/min
+static float			gas_needs_volume_due;			// computed due of gas volume required
+// CNS Coefficients (10 byte)
+static float			var_cns_a;						// two coefficients approximation, gain
+static float			var_cns_b;						// two coefficients approximation, offset
+static unsigned short	var_cns_c;						// one coefficient  approximation, value
+// Transfer values for convert_float_int and convert_float_to_char() (7 byte)
+static float			float_value;					// input value,   float
+static unsigned short	int_value;						// output value, 16 bit
+static unsigned char	char_value;						// output value,  8 bit
+// Auxiliary Variables for Data Buffering (28 byte)
 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
+static float			pres_tissue;					// auxiliary variable to buffer total tissue pressure
+static float			old_pres_respiration;			// auxiliary variable to buffer sim_pres_respiration
-// 10 byte free space left in this bank (4 bytes per float, 2 bytes per int/short, 1 byte per char)
+// Performance Profiling (4 byte)
+static unsigned short	profiling_runtime;				// performance measurement: runtime of current invocation
+static unsigned char	profiling_runs;					// performance measurement: invocations per deco calculation cycle
+static unsigned char	profiling_phase;				// performance measurement: current calculation phase
+// 255 byte used, 1 byte left in this bank (4 bytes per float, 2 bytes per short, 1 byte per char)
 //---- Bank 6 parameters -----------------------------------------------------
 #ifndef UNIX
 #   pragma udata bank6=0x600
 #endif
-// indexing and sequencing
+// Timer5 Interface (3 byte) - Attention: keep order and keep at beginning of bank 6, i.e. at address 0x600 !
-static unsigned char	ci;								// used as index to the Buhlmann tables
+static volatile unsigned short	tmr5_value;				// timer 5 value buffer		MUST be at address 0x600
-static unsigned char	twosectimer = 0;				// used for timing the tissue updating
+static volatile unsigned char	tmr5_overflow;			// timer 5 overflow flag	MUST be at address 0x602
+// Modes, Sequencing and Indexing (11 byte)
+static unsigned char	main_status;					// shadow register for char_O_main_status
+static unsigned char	deco_status;					// shadow register for char_O_deco_status
+static unsigned char	deco_info;						// shadow register for char_O_deco_info
+static unsigned char	deco_warnings;					// shadow register for char_O_deco_warnings
+static unsigned char	next_planning_phase;			// next calculation phase to be executed
 static unsigned char	tissue_increment;				// selector for real/simulated tissues and time increment
+static unsigned char	sequence_timer;					// timer to sequence deco engine tasks
+static unsigned char	ci;								// index to the Buhlmann tables (compartment index)
-// environmental and gas data
+static unsigned char	cns_i;							// index to the CNS      tables (ppO2 range  index)
+static unsigned char	i;								// general purpose loop counter and index
-static float			pres_surface;					// absolute pressure at the surface
+static unsigned char	fast;							// selects 1 minute or 2 second ascent steps
-static unsigned char	char_bottom_depth;				// bottom depth in meters, used by ascent time and gas needs calculation
+// Result Values from Calculation Functions (28 byte)
-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			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
+static unsigned short	ascent_time;					// time in minutes needed for the ascent
-// Buhlmann model parameters
+// Buhlmann Model Parameters (40 byte)
 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_a;							// Buhlmann a, adopted to current N2/He ratio
+static float			var_b;							// Buhlmann b, adopted to current N2/He ratio
 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
+// Vault to back-up & restore Tissue related Data (134 byte)
-static unsigned char	sim_gas_current;				// number       of the currently used gas
+static float			vault_pres_tissue_N2[NUM_COMP];	// stores the nitrogen tissue pressures
-static unsigned char	sim_gas_current_depth;			// change depth of the currently used gas
+static float			vault_pres_tissue_He[NUM_COMP];	// stores the helium tissue pressures
+static float			vault_CNS_fraction_real;		// stores current CNS (float representation)
+static unsigned char	vault_deco_warnings;			// stores warnings status
-// vault to back-up & restore tissue data
+static unsigned char	vault_deco_info;				// stores info status
-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
+// 7 byte occupied by compiler-placed vars
-static float			cns_vault_float;				// stores current CNS (float representation)
-static unsigned char	deco_warnings_vault;			// stores warnings status
+// 223 byte used, 33 byte left in this bank (4 bytes per float, 2 bytes per short, 1 byte per char)
-// 8 byte free space left in this bank (4 bytes per float, 2 bytes per int/short, 1 byte per char)
+//---- Bank 12 parameters -----------------------------------------------------
+#ifndef UNIX
+#   pragma udata bank12=0xc00
+#endif
+// stops table (96 byte)
+static unsigned char	internal_deco_depth[NUM_STOPS];	// depths     of the stops in meters
+static unsigned char	internal_deco_time[NUM_STOPS];	// durations  of the stops in minutes
+static unsigned char	internal_deco_gas[NUM_STOPS];	// gases used on the stops (0 / 1-5)
+// 96 byte used, 160 byte left in this bank (4 bytes per float, 2 bytes per 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
+static float			real_pres_tissue_N2[NUM_COMP];		// 16 floats = 64 bytes
-float					pres_tissue_He[NUM_COMP];		// 16 floats = 64 bytes
+static float			real_pres_tissue_He[NUM_COMP];		// 16 floats = 64 bytes
-float					sim_pres_tissue_N2[NUM_COMP];	// 16 floats = 64 bytes
+static float			sim_pres_tissue_N2[NUM_COMP];		// 16 floats = 64 bytes
-float					sim_pres_tissue_He[NUM_COMP];	// 16 floats = 64 bytes
+static float			sim_pres_tissue_He[NUM_COMP];		// 16 floats = 64 bytes
-// bank is full!
+// 256 byte used, bank is full
 //---- Bank 8 parameters -----------------------------------------------------
 #ifndef UNIX
 #   pragma udata overlay bank8=0x800
 // *********************************************************************************************************************************
 //
 //                                               L O O K - U P   T A B L E S
 //
 // *********************************************************************************************************************************
+#ifndef UNIX
+#   pragma romdata CNS_tables = 0x1DC80  // needs to be in the UPPER bank
+#endif
+rom const float CNS_ab[2*11] = {
+// CNS increment per 2sec = 1 / (a*ppO2 + b) with ppO2 in [cbar]
+//   a          b       for ppO2 cbar range
+	-533.07,    54000,	//  51 -  60   (index  0)
+	-444.22,    48600,	//  61 -  70   (index  1)
+	-355.38,    42300,	//  71 -  80   (index  2)
+	-266.53,    35100,	//  81 -  90   (index  3)
+	-177.69,    27000,	//  91 - 100   (index  4)
+	-177.69,    27000,	// 101 - 110   (index  5)
+	 -88.84,    17100,	// 111 - 120   (index  6)
+	 -88.84,    17100,	// 121 - 130   (index  7)
+	 -88.84,    17100,	// 131 - 140   (index  8)
+	 -88.84,    17100,	// 141 - 150   (index  9)
+	-222.11,    37350	// 151 - 160   (index 10)
+};
+rom const unsigned short CNS_c[1*20] = {
+//  CNS increment per 2sec = c / 100000.0
+//   c in [1/100000]   for ppO2 cbar range
+	  75,				// 161 - 165   (index  0)
+	 102,				// 166 - 170   (index  1)
+	 136,				// 171 - 175   (index  2)
+	 180,				// 176 - 180   (index  3)
+	 237,				// 181 - 185   (index  4)
+	 310,				// 186 - 190   (index  5)
+	 401,				// 191 - 195   (index  6)
+	 517,				// 196 - 200   (index  7)
+	 760,				// 201 - 205   (index  8)
+	1100,				// 206 - 210   (index  9)
+	1500,				// 211 - 215   (index 10)
+	2090,				// 216 - 220   (index 11)
+	2900,				// 221 - 225   (index 12)
+	3900,				// 226 - 230   (index 13)
+	4820,				// 231 - 235   (index 14)
+	4820,				// 236 - 240   (index 15)
+	4820,				// 241 - 245   (index 16)
+	4820,				// 246 - 250   (index 17)
+	4820,				// 251 - 255   (index 18)
+	   0				// not used, just to fill up the memory block
+};
 #ifndef UNIX
 #   pragma romdata Buhlmann_tables = 0x1DD00  // needs to be in the UPPER bank
 #endif
 };
 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,
 #endif
 //////////////////////////////////////////////////////////////////////////////
 // Bump to blue-screen when an assert is wrong
-#ifdef __DEBUG
+#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
+// frames should be reset. Bank 8 is used by stack.
 #ifdef CROSS_COMPILE
 #	define RESET_C_STACK
 #else
-#	ifdef __DEBUG
+#	ifdef _DEBUG
 #		define RESET_C_STACK fillDataStack();
 		void fillDataStack(void)
 		{
 			_asm
 				LFSR	1,C_STACK
 #	endif
 #endif
 //////////////////////////////////////////////////////////////////////////////
-// Fast subroutine to read timer 5
+// Reset timer 5
-// Note: result is in 1/32 of milliseconds (30.51757813 us/bit to be precise)
+//
-static unsigned short tmr5(void)
+// Note: TMR5 is configured in 16 bit mode: a value written to TMR5H is buffered
+//       and will be written to TMR5 together with a successive write to TMR5L.
+//       As we don't know in which bank the code will be executed, we use either
+//       the bank-save "movff" command, or address mapping via access bank (",0").
+//
+static void load_tmr5(void)
 {
 #ifndef CROSS_COMPILE
 	_asm
-		movff	0xf7c,PRODL		// TMR5L
+		movff	0x601,0xF7D		// bank-safe load TMR5H from C variable tmr5_value first
-		movff	0xf7d,PRODH		// TMR5H
+		movff	0x600,0xF7C		// bank-safe load TMR5L from c variable tmr5_value thereafter
-	_endasm						// result in PRODH:PRODL
+		bcf		0xFBA,1,0		// clear timer 5 overrun flag (0xFBA = PIR5, bit 1 = TMR5IF)
+	_endasm
 #else
-	return 0;
+	return;
 #endif
 }
 //////////////////////////////////////////////////////////////////////////////
-// read Buhlmann coefficients a and b for compartment ci
+// Read timer 5
+//
+// Note: TMR5 reads in multiples of 1/32 ms, 30.51757813 us/bit to be precise.
+//       TMR5 is configured in 16 bit mode: on reading of TMR5L the contents of
+//       TMR5H is latched and can be read afterwards without potential rollover.
+//       As we don't know in which bank the code will be executed, we use either
+//       the bank-save "movff" command, or address mapping via access bank (",0").
+//
+static void read_tmr5(void)
+{
+#ifndef CROSS_COMPILE
+	_asm
+		movff	0xF7C,0x600		// copy TMR5L to C variable tmr5_value, low  byte first
+		movff	0xF7D,0x601		// copy TMR5H to C variable tmr5_value, high byte thereafter
+		clrf	WREG,0			// clear WREG to 0x00 = no overrun by default
+		btfsc	0xFBA,1,0		// did timer 5 overrun? (0xFBA = PIR5, bit 1 = TMR5IF)
+		setf	WREG,0			// YES - set WREG to 0xff = overrun detected
+		movff	WREG,0x602		// copy WREG to C variable tmr5_overflow
+	_endasm
+#else
+	return;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+// Read CNS coefficients a and b
+//
+static void read_CNS_ab_coefficient(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
+	{
+		overlay rom const float* ptr = &CNS_ab[2*cns_i];
+		var_cns_a = *ptr++;
+		var_cns_b = *ptr++;
+	}
+}
+//////////////////////////////////////////////////////////////////////////////
+// Read CNS coefficient c
+//
+static void read_CNS_c_coefficient(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
+	{
+		overlay rom const unsigned short* ptr = &CNS_c[cns_i];
+		var_cns_c = *ptr++;
+	}
+}
+//////////////////////////////////////////////////////////////////////////////
+// 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
 	}
 }
 //////////////////////////////////////////////////////////////////////////////
-// read Buhlmann increments for compartment ci
+// 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)
 {
 	_endasm
 #endif
 	assert( ci < NUM_COMP );
-	// Integration intervals
+	// Integration Intervals
 	switch(period)
 	{
 	case 0: //---- 2 sec -----------------------------------------------------
 		{
 			overlay rom const float* ptr = &e2secs[2*ci];
 		{
 			overlay rom const float* ptr = &e10min[2*ci];
 			var_N2_e = *ptr++;
 			var_He_e = *ptr++;
 		}
-	break;
+		break;
 	default:
-		assert(0);  // Never go there...
+		assert(0);	// code execution shall never pass along here!
 	}
 }
 //////////////////////////////////////////////////////////////////////////////
-// read Buhlmann half-times for compartment ci
+// Read Buhlmann half-times for compartment ci
 //
 static void read_Buhlmann_ht(void)
 {
 #ifndef CROSS_COMPILE
 	assert( 1.5099 <= var_He_ht && var_He_ht <= 240.03 );
 }
 //////////////////////////////////////////////////////////////////////////////
-// compute adopted Buhlmann coefficients
+// Calculate adopted Buhlmann coefficients
+//
+// Input:  var_N2_a, var_N2_b       coefficients for N2
+//         var_He_a, var_He_b       coefficients for He
+//         calc_pres_tissue_N2      partial pressure of N2 in tissue
+//         calc_pres_tissue_He      partial pressure of He in tissue
+//         pres_tissue              total pressure in tissue
+//
+// Output: var_a, var_b             coefficients adopted by N2/He ratio
 //
 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;
+#ifdef _helium
+	var_a = (var_N2_a * calc_pres_tissue_N2 + var_He_a * calc_pres_tissue_He) / pres_tissue;
+	var_b = (var_N2_b * calc_pres_tissue_N2 + var_He_b * calc_pres_tissue_He) / pres_tissue;
+#else
+	var_a = var_N2_a;
+	var_b = var_N2_b;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+// Calculate partial pressure of N2 in respired air at surface pressure
+//
+// Input:  pres_surface     surface pressure
+//
+// Output: N2_equilibrium   partial pressure of N2 in surface air
+//
+static void calc_N2_equilibrium(void)
+{
+	N2_equilibrium = 0.7902 * (pres_surface - ppWater);
+}
+//////////////////////////////////////////////////////////////////////////////
+// Get, safeguard and convert the saturation and desaturation factors
+//
+// Input:  char_I_saturation_multiplier     saturation   factor (integer)
+//         char_I_desaturation_multiplier   desaturation factor (integer)
+//
+// Output: float_saturation_multiplier      saturation   factor (float)
+//         float_desaturation_multiplier    desaturation factor (float)
+//
+static void get_saturation_factors(void)
+{
+	// safeguard input parameters that are constant during the course of the dive
+	if( char_I_saturation_multiplier   < 100 ) char_I_saturation_multiplier   = 100;
+	if( char_I_saturation_multiplier   > 140 ) char_I_saturation_multiplier   = 140;
+	if( char_I_desaturation_multiplier <  60 ) char_I_desaturation_multiplier =  60;
+	if( char_I_desaturation_multiplier > 100 ) char_I_desaturation_multiplier = 100;
+	// convert input parameters to float numbers
+	float_saturation_multiplier   = 0.01 * char_I_saturation_multiplier;
+	float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier;
+}
+//////////////////////////////////////////////////////////////////////////////
+// apply_saturation_factors
+//
+// Apply safety factors for both ZH-L16 models.
+//
+// Modified:  temp_tissue  safeguarded tissue increment/decrement
+//
+static void apply_saturation_factors(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;
+}
+//////////////////////////////////////////////////////////////////////////////
+// convert_float_to_int
+//
+// Converts a float within range 0.0 - 9.99 into 16 bit integer scaled in 1/100.
+//
+static void convert_float_to_int(void)
+{
+		if      ( float_value <  0.005 ) int_value =   0;
+		else if ( float_value >= 9.985 ) int_value = 999;
+		else                             int_value = (unsigned short)(100 * float_value + 0.5);
+}
+//////////////////////////////////////////////////////////////////////////////
+// convert_float_to_char
+//
+// Converts a float within range 0.0 - 255 into 8 bit integer
+//
+static void convert_float_to_char(void)
+{
+		if      (float_value <    0.0) char_value = 0;
+		else if (float_value >= 254.5) char_value = 255;
+		else                           char_value = (unsigned char)(float_value + 0.5);
 }
 // *********************************************************************************************************************************
 //
 {
 	RESET_C_STACK
 	calc_hauptroutine();
 }
+//////////////////////////////////////////////////////////////////////////////
+// deco_init_output_vars
+//
+// called from divemode.asm
+//
+// Initializes all output variables to their default values.
+//
+void deco_init_output_vars(void)
+{
+	RESET_C_STACK
+	init_output_vars();
+}
 //////////////////////////////////////////////////////////////////////////////
 // deco_clear_tissue
 //
 // called from: start.asm
 //              menu_tree.asm
 {
 	RESET_C_STACK
 	clear_tissue();
 }
 //////////////////////////////////////////////////////////////////////////////
 // deco_calc_dive_interval
 //
 // called from: 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
 {
 	RESET_C_STACK
 	calc_desaturation_time();
 }
 //////////////////////////////////////////////////////////////////////////////
 // deco_push_tissues_to_vault
 //
 // called from: simulator.asm
 //
 {
 	RESET_C_STACK
 	push_tissues_to_vault();
 }
 //////////////////////////////////////////////////////////////////////////////
 // deco_pull_tissues_from_vault
 //
 // called from: simulator.asm
 //              ghostwriter.asm
 //
 // *********************************************************************************************************************************
 //////////////////////////////////////////////////////////////////////////////
-// calc_nextdecodepth
+// find_next_stop
+//
+// INPUT, fixed during dive:
+//        pres_surface             : surface pressure (as absolute pressure)
+//        char_I_depth_last_deco   : depth of the last deco stop
 //
 // INPUT, changing during dive:
-//        sim_pres_respiration     : current depth in absolute pressure
+//        float_depth_real         : current real depth in meters (float)
-//
+//        char_depth_real          : current real depth in meters (integer)
-// INPUT, fixed during dive:
+//        GF_high                  : GF high factor
-//        pres_surface
+//        GF_low                   : GF low  factor
-//        GF_delta
+//
-//        GF_high
+// INPUT & OUTPUT
-//        GF_low
+//        char_depth_sim           : simulated depth in meters
-//        char_I_depth_last_deco
+//        GF_low_depth             : GF low  depth in current calculation cycle
-//
+//        GF_slope                 : GF slope      in current calculation cycle
-// MODIFIED
+//        GF_low_depth_norm/_alt   : frozen GF low depth reference
-//        locked_GF_step_norm/_alt : used for GF model
+//        GF_slope_norm/_alt       : frozen GF slope
-//        low_depth_norm/_alt      : used for GF model
 //
 // OUTPUT
-//        sim_depth_limit          : depth of next stop in meters     (if RETURN == true )
+//        char_depth_last          : depth we came from
-//                                   next possible depth without stop (if RETURN == false)
+//        sim_pres_respiration     : simulated depth in absolute pressure
 //
-// RETURN TRUE if a stop is needed, else false
+// RETURN
-//
+//        TRUE: a stop is needed, FALSE: no stop needed
-static unsigned char calc_nextdecodepth(void)
+//
-{
+static unsigned char find_next_stop(void)
+{
+	overlay unsigned char depth_1min;
+	overlay unsigned char depth_limit;
+	overlay unsigned char first_stop;
 	overlay unsigned char need_stop;
-	// compute current depth in meters
-	overlay float depth = (sim_pres_respiration - pres_surface) * BAR_TO_METER;
+	// -----------------------------------------------------------------------
+	// we start with the assumption that a stop is not required
-	// 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;
+	need_stop = 0;
-	// target the simulated tissues
+	// remember the depth we came from
-	tissue_increment = 0;
+	char_depth_last = char_depth_sim;
-	//---- check if a stop is needed for deco reasons ----------------------------
+	// calculate the limit for the current depth
+	     if( char_I_deco_model == 0            ) calc_limit(1.0);											// straight Buhlmann
-	// switch on deco model
+	else if( char_depth_sim    >= GF_low_depth ) calc_limit(GF_low);										// with GF, below low depth reference
-	if( char_I_deco_model != 0 )
+	else                                         calc_limit(GF_high - GF_slope * (float)char_depth_sim);	// with GF, above low depth reference
-	{
-		//---- ZH-L16 + GRADIENT FACTOR Model ------------------------------------
+	// check if we can surface directly
+	if( ceiling <= 0.0 )
-		overlay float locked_GF_step;
+	{
-		overlay float low_depth;
+		// YES - ascent to surface is allowed
-		overlay float limit_depth;
+		char_depth_sim = 0;
-		overlay unsigned char first_stop = 0;
+		//     - done
+		goto done;
+	}
-		// calculate minimum depth we can ascent to in bar relative pressure
-		calc_limit(GF_low);
+	// -----------------------------------------------------------------------
+	// a stop is required, but maybe not yet within the running minute
-		// check if we can surface directly
+	// -----------------------------------------------------------------------
-		if( ceiling <= 0.0 )
-		{
+	// convert the depth we can ascent to from relative pressure to meters,
-			min_depth = 0.0;		// set minimum depth to 0 meters = surface
+	// rounded up (i.e. made deeper) to next full meter.
-			goto no_deco_stop;		// done
+	depth_limit = (unsigned char)(ceiling * BAR_TO_METER + 0.99);
-		}
+	// calculate the stop depth, i.e. round up to the next multiple of 3 meters
-		// convert minimum depth we can ascent to from relative pressure to depth in meters
+	// using integer arithmetics
-		limit_depth = ceiling * BAR_TO_METER;
+	first_stop = 3 * ( (depth_limit + 2) / 3 );
-		// recall low_depth dependent on current plan
+	// apply correction for the shallowest stop
-		low_depth = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? low_depth_alt : low_depth_norm;
+	if( first_stop == 3 ) first_stop = char_I_depth_last_deco;
-		// Store the deepest point needing a deco stop as the LOW reference for GF.
+	// compute depth in meters that will be reached in 1 minute of ascent
-		// NOTE: following stops will be validated using this LOW-HIGH GF scale,
+	// at a speed of char_I_ascent_speed (5..10 m/min)
-		//       so if we want to keep coherency, we should not validate this stop
+	if( char_depth_sim > char_I_ascent_speed )
-		//       yet, but apply the search to it, as for all the following stops afterward.
+	{
-		if( limit_depth > low_depth )
+		depth_1min = char_depth_sim - char_I_ascent_speed;
-		{
+	}
-			// update GF parameters
+	else
-			low_depth      = limit_depth;
+	{
-			locked_GF_step = GF_delta / low_depth;
+		depth_1min = 0;
+	}
-			// store updated GF parameters dependent on current plan
-			if( char_O_deco_status & DECO_PLAN_ALTERNATE )
+	// is the stop shallower than the depth that can be reached within 1 minute?
-			{
+	if( depth_1min > first_stop )
-				low_depth_alt       = low_depth;
+	{
-				locked_GF_step_alt  = locked_GF_step;
+		// YES - report the depth that will be reached within 1 minute of ascent
-			}
+		char_depth_sim = depth_1min;
-			else
-			{
+		//     - done
-				low_depth_norm      = low_depth;
+		goto done;
-				locked_GF_step_norm = locked_GF_step;
+	}
-			}
+	// -----------------------------------------------------------------------
+	// we need to make a stop now
+	// -----------------------------------------------------------------------
+	// set stop data
+	need_stop      = 1;
+	char_depth_sim = first_stop;
+	// done so far if using straight Buhlmann
+	if( char_I_deco_model == 0 ) goto done;
+	// -----------------------------------------------------------------------
+	// we need to make a stop now and we are using the GF extension
+	// -----------------------------------------------------------------------
+	// is the depth limit deeper than the GF low depth reference used up to now?
+	if( depth_limit > GF_low_depth )
+	{
+		// YES - update the reference
+		GF_low_depth = depth_limit;
+		GF_slope     = (GF_high - GF_low) / (float)GF_low_depth;
+		// store for use in next cycles
+		if( deco_status & CALC_NORM )
+		{
+			GF_low_depth_norm = GF_low_depth;
+			GF_slope_norm     = GF_slope;
 		}
 		else
 		{
-			// recall locked_GF_step dependent of current plan
+			GF_low_depth_alt = GF_low_depth;
-			locked_GF_step = (char_O_deco_status & DECO_PLAN_ALTERNATE) ? locked_GF_step_alt : locked_GF_step_norm;
+			GF_slope_alt     = GF_slope;
 		}
+	}
-		// 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;
+	// keep the stop as it is when it is the first stop
+	// (i.e. there are no stops in the stops table yet)
+	if( internal_deco_depth[0] == 0  ) goto done;
-		//---- if program execution passes here, we need a deco stop --------------------------------
+	// keep the stop as it is when extended stops are activated
-		// round to multiple of 3 meters (limit depth is in meters of depth)
+	if( main_status & EXTENDED_STOPS ) goto done;
-		first_stop = 3 * (unsigned char)(0.4999 + limit_depth * 0.333333);
+	// We have a (first) stop. But with a steep GF slope, the stop(s) after this
-		// check a constraint
+	// first stop may be allowed to ascent to, too. This is because the gradient
-		assert( first_stop < 128 );
+	// factor that will be used at the next depth(s) will allow more tissue super-
+	// saturation, maybe so much more that the next stop(s) will be allowed to
-		// apply correction for the shallowest stop, use char_I_depth_last_deco (3..6 m) instead
+	// ascent to. So we have to probe the next stops that are within the reach of
-		if( first_stop == 3 ) first_stop = char_I_depth_last_deco;
+	// 1 minute of ascent as well.
-		// We have a stop candidate.
+	// no need to probe for a stop that is beyond 1 minute of ascent
-		// But maybe ascending to the next stop will diminish the constraint,
+	while( first_stop >= (depth_1min + 3) )
-		// because the GF might decrease more than the pressure gradient...
+	{
-		while( first_stop > 0 )
+		overlay unsigned char next_stop;
-		{
-			// next depth
+		// compute the depth of the next stop
-			overlay unsigned char 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;
-			// invalidate this stop if we can ascent one more minute without going above minimum required deco depth
+		else                                             next_stop = first_stop - 3;
-			if( first_stop <= (unsigned char)min_depth ) goto no_deco_stop;
+		// compute the depth limit at the next stop depth
-			// compute depth of next stop
+		calc_limit(GF_high - GF_slope * (float)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;
+		// check if ascent to the next stop is allowed
-			else                                             next_stop = first_stop - 3;
+		if( next_stop < (unsigned char)(ceiling * BAR_TO_METER + 0.99) )
+		{
-			// compute limit with the GF of the new stop candidate
+			// NO - the next stop would be too shallow
-			if( (low_depth == 0.0) || (next_stop > low_depth) ) calc_limit(GF_low);
+			break;
-			else                                                calc_limit(GF_high - next_stop * locked_GF_step);
+		}
+		else
-			// check if ascent to the next stop candidate is possible
+		{
-			if( ceiling * BAR_TO_METER >= next_stop )
+			// YES - the next stop is allowed
-				goto deco_stop_found;					// no - ascent to next_stop forbidden
+			char_depth_sim = next_stop;
-			// else, validate that stop and loop...
+			//     - ascent to next stop
 			first_stop = next_stop;
-		}
+			//     - loop to probe the stop following next
-no_deco_stop:
+			continue;
-		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'
+	// common end for straight Buhlmann and Buhlmann with GF extension
-		sim_depth_limit = (unsigned char)first_stop;	// stop depth, in meters
+	// -----------------------------------------------------------------------
 done:
-		;
+	// calculate absolute pressure at the depth found
+	sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface;
+	return need_stop;
+}
+//////////////////////////////////////////////////////////////////////////////
+// publish_deco_table
+//
+// Input:  internal_deco_depth[]      depth in internal stops table
+//         internal_deco_time[]       times ...
+//         internal_deco_gas[]        gases ...
+//
+// Output: char_O_deco_depth[]        depth in the external stops table
+//         char_O_deco_time[]         times ...
+//         char_O_deco_gas[]          gases ...
+//         char_O_deco_time_for_log   times in reverse order
+//
+static void publish_deco_table(void)
+{
+	overlay unsigned char x = 0;
+	overlay unsigned char y;
+	// copy all entries from internal to external stops table
+	for( y = 0; y < NUM_STOPS; y++ )
+	{
+		// remember index of last entry with a non-null depth
+		if( internal_deco_depth[y] > 0 ) x = y;
+		// copy depth, time and gas
+		char_O_deco_depth[y] = internal_deco_depth[y];
+		char_O_deco_time [y] = internal_deco_time [y];
+		char_O_deco_gas  [y] = internal_deco_gas  [y];
+	}
+	// copy times of shallowest stops to logging table
+	for( y = 0; y < NUM_STOPS_LOG; y++, --x )
+	{
+		char_O_deco_time_for_log[y] = internal_deco_time [x];
+		// stop when all entries are copied
+		if( x == 0 ) break;
+	}
+	// fill the remainder of the logging table with null
+	// if it is not completely filled already
+	for( y++; y < NUM_STOPS_LOG; y++ )
+		char_O_deco_time_for_log[y] = 0;
+}
+//////////////////////////////////////////////////////////////////////////////
+// Find current gas in the list (if any) and get its change depth
+//
+// Input:  char_I_current_gas_num   number of current gas (1..5 or 6)
+//
+// Output: sim_gas_current_num      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_num && char_I_current_gas_num <= 6 );
+	if( char_I_current_gas_num <= NUM_GAS )			// gas/diluent 1-5
+	{
+		sim_gas_current_num   = char_I_current_gas_num;
+		sim_gas_current_depth = char_I_deco_gas_change[sim_gas_current_num-1];
 	}
 	else
 	{
-		//---- ZH-L16 model -------------------------------------------------
+		sim_gas_current_num   = 0;
-		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
+// Input:    char_depth_sim             simulated depth in meters
-//          sim_gas_current          : number of the currently used gas/dil
+//           sim_gas_current_num        number of the currently used gas/dil
-//          sim_gas_current_depth    : change depth 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_type[]     types         of the gases/dils
-//          char_I_deco_gas_change[] : change depths 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
+// Modified: sim_gas_current_num        index of the gas (1..5) - only if return value is true
-//          sim_gas_current_depth    : switch depth            - 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
+// Return value is 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
+	//	// no automatic gas changes in CCR mode
-	if( (char_O_deco_status & DECO_MODE_MASK) == DECO_MODE_CCR ) return 0;
+	//	if( (deco_status & MODE_MASK) == 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 )
+		if( j+1 != sim_gas_current_num )
-		// Is this -                      an (active) deco gas,
+		// Is this gas available?
-		//         - or if in deco phase, any gas but disabled
+		if( char_I_deco_gas_type[j] > 0 )
-		//         - 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 )
+		if( char_I_deco_gas_change[j] >= char_depth_sim )
 		// 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 )
 	// has a better gas been found?
 	if( switch_gas )
 	{
 		// YES - set the better gas as the new gas
-		sim_gas_current       = switch_gas;
+		sim_gas_current_num   = 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 );
 	}
 }
 //////////////////////////////////////////////////////////////////////////////
-// Set calc_N2/He/O2_ratios by sim_gas_current
+// Set calc_N2/He/O2_ratios by sim_gas_current_num
 //
-// Input:  sim_gas_current              : index of gas to use
+// Input:  sim_gas_current_num           index of gas to use
-//         real_O2_ratio, real_He_ratio : if gas =    0 (the manually set gas)
+//         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)
+//         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
+// Output: sim_N2_ratio, sim_He_ratio    ratios of the inert gases
-//         sim_pSCR_drop                : ppO2 drop in pSCR loop
+//         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 );
+	assert( 0 <= sim_gas_current_num <= NUM_GAS );
+#ifdef _helium
 	// get gas ratios
-	if( sim_gas_current == 0 )
+	if( sim_gas_current_num == 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_O2_ratio = 0.01 * char_I_deco_O2_ratio[sim_gas_current_num-1];
-		sim_He_ratio = 0.01 * char_I_deco_He_ratio[sim_gas_current-1];
+		sim_He_ratio = 0.01 * char_I_deco_He_ratio[sim_gas_current_num-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;
+#else
+	// get O2 ratio
+	sim_O2_ratio = ( sim_gas_current_num == 0 ) ? real_O2_ratio : 0.01 * char_I_deco_O2_ratio[sim_gas_current_num-1];
+	// set H2 ratio to zero
+	sim_He_ratio = 0.0;
+	// inert gas ratio (local helper variable)
+	sim_IG_ratio  = 1.00 - sim_O2_ratio;
+	// N2 ratio
+	sim_N2_ratio  = sim_IG_ratio;
+#endif
+#ifdef _ccr_pscr
 	// ppO2 drop in pSCR loop
 	sim_pSCR_drop = sim_IG_ratio * float_pSCR_factor;
+#endif
 	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
+//         main_status                : breathing mode for real      tissues
-//         char_O_deco_status         : breathing mode for simulated tissues
+//         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
 //         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
+//         char_ppO2                  : breathed ppO2 in %, used for CNS calculation
 //
 void calc_alveolar_pressures(void)
 {
 	overlay float calc_pres_respiration;
 	overlay float calc_O2_ratio;
 	overlay float calc_N2_ratio;
+#ifdef _helium
 	overlay float calc_He_ratio;
+#endif
+#ifdef _ccr_pscr
 	overlay float calc_pSCR_drop;
+#endif
 	overlay unsigned char status;
-	assert( 0.00 <= real_N2_ratio && real_N2_ratio <= 1.00 );
+	assert( 0.00 <= real_N2_ratio && real_N2_ratio  <= 1.00 );
-	assert( 0.00 <= real_He_ratio && real_He_ratio <= 1.00 );
+	assert( 0.00 <= real_He_ratio && real_He_ratio  <= 1.00 );
-	assert(        (real_N2_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_N2_ratio && real_N2_ratio  <= 1.00 );
-	assert( 0.00 <= sim_He_ratio && real_He_ratio <= 1.00 );
+	assert( 0.00 <= sim_He_ratio && real_He_ratio  <= 1.00 );
-	assert(         (sim_N2_ratio + sim_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 )
+	if( tissue_increment & TISSUE_SELECTOR )
 	{
 		//---- real tissues -----------------------------------------------------------
-		status                = char_O_main_status;
 		calc_pres_respiration = real_pres_respiration;
-		calc_pSCR_drop        = real_pSCR_drop;
+		status                = main_status;
 		calc_O2_ratio         = real_O2_ratio;
 		calc_N2_ratio         = real_N2_ratio;
+#ifdef _helium
 		calc_He_ratio         = real_He_ratio;
+#endif
+#ifdef _ccr_pscr
+		calc_pSCR_drop        = real_pSCR_drop;
+#endif
 	}
 	else
 	{
 		//---- simulated tissues ------------------------------------------------------
-		status                = char_O_deco_status;
-		calc_pres_respiration = sim_pres_respiration;
+		// correct sim_pres_respiration if shallower than calculated stop depth
-		calc_pSCR_drop        = sim_pSCR_drop;
+		calc_pres_respiration = ( real_pres_respiration < sim_pres_respiration ) ? real_pres_respiration : sim_pres_respiration;
+		status                = deco_status;
 		calc_O2_ratio         = sim_O2_ratio;
 		calc_N2_ratio         = sim_N2_ratio;
+#ifdef _helium
 		calc_He_ratio         = sim_He_ratio;
+#endif
+#ifdef _ccr_pscr
+		calc_pSCR_drop        = sim_pSCR_drop;
+#endif
 	}
 	//---- OC, CCR and Bailout Mode Gas Calculations -----------------------------------
 	// calculate ppO2 of pure oxygen
 	if( O2_ppO2 < 0.0 ) O2_ppO2 = 0.0;
 	// calculate ppO2 of the pure gas (OC, diluent)
 	OC_ppO2 = O2_ppO2 * calc_O2_ratio;
+#ifdef _ccr_pscr
 	// 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 )
+	if( status & 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.
+		// 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;
+		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 )
+		if( status & 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;
+			if   ( char_I_const_ppO2 && (tissue_increment & TISSUE_SELECTOR)) ppO2 = const_ppO2;
-			else                                                       ppO2 = pSCR_ppO2;
+			else                                                              ppO2 = pSCR_ppO2;
 		}
 		else
 		{
 			//---- CCR Mode ---------------------------------------------------------------------------
 		}
 		// 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
+		    || ( calc_O2_ratio         > 0.995 ) )   // diluent is pure O2, i.e. calc_N2_ratio + calc_He_ratio = 0 would give 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;
+#ifdef _helium
 			calc_pres_respiration /= calc_N2_ratio + calc_He_ratio;
+#else
+			calc_pres_respiration /= calc_N2_ratio;
+#endif
 		}
 	}
 	else
+#endif	// _ccr_pscr
 	{
 		//---- OC mode ---------------------------------------------------------------------------------
 		// breathed ppO2 is ppO2 of pure gas
 		ppO2 = OC_ppO2;
 	//---- calculate ppN2 and ppHe ---------------------------------------------------------------------
 	// add deco safety distance when working on simulated tissues
-	if( !(tissue_increment & TISSUE_FLAG) ) calc_pres_respiration += float_deco_distance;
+	if( !(tissue_increment & TISSUE_SELECTOR) ) 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;
+#ifdef _helium
 		ppHe = calc_He_ratio * calc_pres_respiration;
+#else
+		ppHe = 0.0;
+#endif
 	}
 	else
 	{
 		// calculated respired pressure is < water vapor pressure, thus set ppN2 and ppHe to 0
 		ppN2 = 0.0;
 	}
 }
 //////////////////////////////////////////////////////////////////////////////
+// init_output_vars
+//
+// Initializes all output variables to their default values
+//
+static void init_output_vars(void)
+{
+	// 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 published gas needs in volume and pressure
+	for( i = 0; i < NUM_GAS; ++i )
+	{
+		int_O_gas_need_vol[i]  = 0;
+		int_O_gas_need_pres[i] = 0 + INT_FLAG_ZERO + INT_FLAG_INVALID;
+	}
+	// values initially to be set to zero
+	int_O_ceiling           = 0;						// ceiling depth in mbar
+	char_O_deco_info        = 0;						// clear all deco information flags
+	char_O_deco_warnings    = 0;						// clear all deco warning     flags
+	// default desaturation time to 24 hours (it will not be computed during a dive)
+	int_O_desaturation_time = 1440;
+	// initialize CNS values
+	int_O_CNS_norm          = 0 + INT_FLAG_INVALID;
+	int_O_CNS_alt           = 0 + INT_FLAG_INVALID;
+	// initialize NDL times
+	char_O_NDL_norm         = 240;
+	char_O_NDL_alt          = 240;
+	// initialize ascent times
+	int_O_TTS_norm          = 0;
+	int_O_TTS_alt           = 0 + INT_FLAG_INVALID + INT_FLAG_NOT_COMPUTED_YET;
+#ifdef _rx_functions
+	// clear TR values
+	int_O_SAC_measured      = 0 + INT_FLAG_NOT_AVAIL;	// SAC rate
+	int_O_pressure_need[0]  = 0 + INT_FLAG_NOT_AVAIL;	// pressure need to reading 1
+	int_O_pressure_need[1]  = 0 + INT_FLAG_NOT_AVAIL;	// pressure need to reading 2
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
 // clear_tissue
 //
-// optimized in v.101 (var_N2_a)
+// Reset all tissues to surface pressure equilibrium state
 //
-// Reset all tissues to surface pressure equilibrium state.
+// Input:  int_I_pres_surface             current surface pressure in hPa (mbar)
+//
+// Output: real_pres_tissue_N2[]          partial pressure of N2 in real tissues
+//         real_pres_tissue_He[]          partial pressure of He in real tissues
+//         char_O_tissue_pres_N2[]        partial pressure of N2 for tissue graphics
+//         char_O_tissue_pres_He[]        partial pressure of He for tissue graphics
+//         char_O_tissue_pressure[]       total   pressure       for tissue graphics
+//         CNS_fraction_real              internal CNS value
+//         int_O_CNS_current              current CNS value
+//         int_O_CNS_norm                 CNS value at end of normal      dive plan
+//         int_O_CNS_alt                  CNS value at end of alternative dive plan
+//         char_O_deco_warnings           deco warnings vector
+//         char_O_NDL_norm                remaining NDL time in normal      dive plan
+//         char_O_NDL_alt                 remaining NDL time in alternative dive plan
+//         int_O_TTS_norm                 ascent time (TTS)  in normal      dive plan
+//         int_O_TTS_alt                  ascent time (TTS)  in alternative dive plan
+//         int_O_lead_supersat            supersaturation of the leading tissue
 //
 static void clear_tissue(void)
 {
-	// safety limit to prevent improper initialization values
+	// safeguard and convert the surface pressure (mbar -> bar) (*)
-	if( int_I_pres_respiration < 500) int_I_pres_respiration = 500;		// min. respiration pressure = 500 mbar
+	if( int_I_pres_surface < 500 ) pres_surface = 0.500;
+	else                           pres_surface = 0.001 * int_I_pres_surface;
-	real_pres_respiration = 0.001  * int_I_pres_respiration;
-	N2_equilibrium        = 0.7902 * (real_pres_respiration - ppWater);
+	// calculate partial pressure of N2 in respired air at surface pressure
+	calc_N2_equilibrium();
+	// cycle through the 16 Buhlmann tissues
 	for( ci = 0; ci < NUM_COMP; ci++ )
 	{
-		// cycle through the 16 Buhlmann N2 tissues
+		// reset tissue pressures
-		pres_tissue_N2[ci]              = N2_equilibrium;	// initialize data for "real" tissue
+		real_pres_tissue_He[ci]    = 0.0;				// He
-		char_O_tissue_N2_saturation[ci] = 11;				// initialize data for tissue graphics
+		real_pres_tissue_N2[ci]    = N2_equilibrium;	// N2
-		// cycle through the 16 Buhlmann He tissues
+		// reset tissue pressures for scaled for tissue graphics
-		pres_tissue_He[ci]              = 0.0;				// initialize data for "real" tissue
+		char_O_tissue_pres_He[ci]  = 0;					// He
-		char_O_tissue_He_saturation[ci] = 0;				// initialize data for tissue graphics
+		char_O_tissue_pres_N2[ci]  = 10;				// N2
+		char_O_tissue_pressure[ci] = 10;				// combined
 	}
 	// reset CNS values
-	CNS_fraction = 0.0;
+	CNS_fraction_real = 0.0;
-	int_O_CNS_fraction = int_O_normal_CNS_fraction = int_O_alternate_CNS_fraction = 0;
+	int_O_CNS_current = int_O_CNS_norm = int_O_CNS_alt = 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;
+	char_O_NDL_norm       = 240;
-	int_O_ascenttime			= 0;
+	char_O_NDL_alt        = 240;
-	int_O_alternate_ascenttime	= 0;
+	int_O_TTS_norm        = 0;
-	int_O_gradient_factor		= 0;
+	int_O_TTS_alt         = 0;
+	int_O_lead_supersat   = 0;
+	// reset all warning and info flags
+	char_O_deco_warnings  = 0;
+	char_O_deco_info      = 0;
 }
 //////////////////////////////////////////////////////////////////////////////
 // calc_hauptroutine
 //
-// this is the major code in dive mode calculates:
+// This is the major code in dive mode, it calculates the tissue pressures,
-//      the tissues,
+// the bottom time, and it calculates the ascend with all deco stops, etc.
-//      the bottom time,
+//
-//      and simulates the ascend with all deco stops.
+// Input:    char_O_main_status              deco engine control and real      tissues mode
+//           char_O_deco_status              deco engine control and simulated tissues mode
+//           char_I_sim_advance_time         mailbox for bottom time incrementing
+//
+//           char_I_SAC_work                 gas usage rate during working    phase in l/min
+//           char_I_SAC_deco                 gas usage rate during deco stops phase in l/min
+//
+//           char_I_deco_model               selector for GF extension
+//           char_I_ascent_speed             ascent speed
+//           char_I_deco_distance            safety distance between stop depth and calculated depth
+//           char_I_saturation_multiplier    safety factor for tissue saturation
+//           char_I_desaturation_multiplier  safety factor for tissue desaturation
+//
+//           char_I_pressure_gas[]           amount of gas available for ascent in bar
+//           int_I_pressure_drop[]           pressure drop used to calculate SAC rate
+//           char_I_gas_avail_size[]         size of the tanks in liters
+//
+// Output:   int_O_O2_ppO2                   partial pressure of pure O2 at current depth
+//           int_O_pure_ppO2                 partial pressure of O2 in gas at current depth
+//           int_O_pSCR_ppO2                 partial pressure of O2 in gas at current depth, corrected for pSCR mode
+//           int_O_breathed_ppO2             partial pressure of O2 currently breathed
+//
+//           char_O_deco_status              deco engine computations status
+//           char_O_deco_info                deco engine information vector
+//           char_O_deco_warnings            deco engine warnings    vector
+//
+//           char_O_NDL_norm                 remaining NDL time in normal      dive plan
+//           char_O_NDL_alt                  remaining NDL time in alternative dive plan
+//           int_O_TTS_norm                  ascent time (TTS)  in normal      dive plan
+//           int_O_TTS_alt                   ascent time (TTS)  in alternative dive plan
+//           int_O_CNS_norm                  CNS value at end   of normal      dive plan
+//           int_O_CNS_alt                   CNS value at end   of alternative dive plan
+//
+//           int_O_gas_need_vol              calculated gas volumes   needed for ascent
+//           int_O_gas_need_pres             calculated gas pressures needed for ascent
+//
+//           int_O_SAC_measured              measured surface air consumption (SAC) rate in l/min
+//
+// Modified: int_IO_pressure_value[]         warning flags added to pressure reading 1 & 2
+//           int_IO_pressure_need[]          pressure needs      to pressure reading 1 & 2
 //
 static void calc_hauptroutine(void)
 {
-	overlay unsigned int int_ppO2_min;
+	overlay unsigned short int_ppO2_min;
-	overlay unsigned int int_ppO2_max;
+	overlay unsigned short int_ppO2_max;
-	overlay unsigned int int_ppO2_max_dil;
+	overlay unsigned short int_ppO2_max_dil;
-	overlay unsigned int int_ppO2_max_max;
+	overlay unsigned short int_ppO2_max_max;
-	overlay float        EAD;
+	overlay float          EAD;
-	overlay float        END;
+	overlay float          END;
+	//=============================================================================================
-	//--- Set-up Part --------------------------------------------------------------------------------
+	//
-	// clear flags indicating a calculation has been completed
+	//--- Setup Part ---------------------------------------------------------------------------------
-	char_O_main_status &= ~( DECO_COMPLETED_NORM + DECO_COMPLETED_ALT );
+	//
-	// twosectimer:
+	// set time limit for preempting deco calculations, timer is 16 bit and increments every 1/32 ms
-	// calc_hauptroutine is now invoked every second to speed up the deco planning.
+	tmr5_value = 65535 - (32 * BUDGET_PER_SECOND / INVOKES_PER_SECOND);
-	// Because the tissue and CNS calculations are based on a two seconds period, a
-	// toggle-timer is used to skip every 2nd invocation.
+	// load timer
-	twosectimer = (twosectimer) ? 0 : 1;
+	load_tmr5();
-	// do initializations that need to be done only once at the beginning of a dive
+	// read command flags and set up what to do
-	if( (char_O_deco_status & DECO_STATUS_MASK) == DECO_STATUS_INIT )
+	switch( char_O_deco_status & COMMAND_MASK )
 	{
-		// 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;
+	case INITIALIZE:
-	}
+	case INITIALIZE_START_NORM:
+	case INITIALIZE_START_ALT:
-	//---- Calculations Part ----------------------------------------------------------------------
+		// copy master modes to shadow registers
+		main_status = char_O_main_status;
-	// acquire current environment data
+		deco_status = char_O_deco_status;
-	calc_hauptroutine_data_input();
+		// clear all command flags on the master mode to signal that the command is read
+		char_O_deco_status &= ~COMMAND_MASK;
+		// clear the initialization flag on the shadow copy
+		deco_status &= ~INITIALIZE;
+		// initialize the sequence timer
+		sequence_timer = 0;
+		// set the calculation phase to start with to doing the once-per-dive initialization
+		next_planning_phase = PHASE_10_DIVE_INIT;
+		break;
+	case START_NORM:
+	case START_ALT:
+		// copy master modes to shadow registers
+		main_status = char_O_main_status;
+		deco_status = char_O_deco_status;
+		// clear all command flags on the master mode to signal that the command is read
+		char_O_deco_status &= ~COMMAND_MASK;
+		// set the calculation phase to start with to doing the cyclic initialization
+		next_planning_phase = PHASE_11_CYCLIC_INIT;
+		// continue in CALCULATING
+	case CALCULATING:
+		// keep current calculation phase
+		// step the sequence timer
+		sequence_timer = (sequence_timer < INVOKES_PER_SECOND * 2 - 1) ? sequence_timer + 1 : 0;
+		break;
+	}
+	//
+	//--- End of Setup Part -----------------------------------------------------------------------
+	//
+	//=============================================================================================
+	//
+	//---- Calculations Part (real Tissues) -------------------------------------------------------
+	//
 	// target the real tissues with 2 second increments by default
-	tissue_increment = TISSUE_FLAG | 0;
+	tissue_increment = TISSUE_SELECTOR | 0;
-	// calculate ppO2, ppN2 and ppHe
-	calc_alveolar_pressures();
+	// Tasks every second, if more than 1 invocation per second: on the first section of the second.
+	// Requests for tissue "fast forward" are executed immediately.
-	// All deco code is invoked every second. But as the tissue and CNS updates are based
+#if (INVOKES_PER_SECOND > 1)
-	// on 2 seconds periods, each update is done only on each 2nd second. In case a "fast
+	if(    ( sequence_timer          == 0                  )
-	// forward" of the tissues is commanded, the 2-seconds rule is over-raided.
+	    || ( sequence_timer          == INVOKES_PER_SECOND )
-	if( twosectimer || char_I_sim_advance_time )
+	    || ( char_I_sim_advance_time  > 0                  )
-	{
+	)
+#endif
+	{
+		// acquire current environmental data
+		calc_hauptroutine_data_input();
+		// calculate ppO2, ppN2 and ppHe
+		calc_alveolar_pressures();
+		// add decent calculation here and include trigger in above if-statement
+		// TODO
+	} // tasks every second, on the first section of the second
+	// Tasks every 2 seconds, on the first section of the respective second.
+	// Requests for tissue "fast forward" are executed immediately.
+	if(    ( sequence_timer           == 0 )
+	    || ( char_I_sim_advance_time   > 0 )
+	)
+	{
+		// Tissue and CNS updates are based on 2 seconds periods!
 		// 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;
+			tissue_increment = TISSUE_SELECTOR | char_I_sim_advance_time;
-			// clear the "mailbox"
+			// clear the request
 			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
+		if   ( char_I_deco_model ) calc_limit(GF_high);		// GF factors enabled
-		else                    calc_limit(  1.0  );		// classic Buhlmann
+		else                       calc_limit(  1.0  );		// classic Buhlmann
-		// convert ceiling from float to integer for export [mbar relative pressure]
+		// convert the ceiling value to integer
 		convert_ceiling_for_display();
-		// convert leading tissue supersaturation value from float to integer for export [%]
+		// convert the saturation value of the leading tissue to integer
-		convert_GF_for_display();
+		convert_sat_for_display();
-		// convert CNS value from float to integer for export
+		// convert the CNS value to integer
-		convert_CNS_for_display();
+		convert_cur_CNS_for_display();
-	}
+	} // tasks every 2 seconds
-	//---- Calculate and Export EAD and END ------------------------------------------------------
-	// calculate EAD (Equivalent Air Depth): equivalent depth for the same N2 level with plain air
+	// Tasks every second, if more than 1 invocation per second: on the first section of the second.
-	EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER;
+#if (INVOKES_PER_SECOND > 1)
+	if(    ( sequence_timer == 0                  )
-	// calculate END (Equivalent Narcotic Depth): here O2 is treated as narcotic, too
+	    || ( sequence_timer == INVOKES_PER_SECOND )
-	// Source cited: The Physiology and Medicine of Diving by Peter Bennett and David Elliott,
+	)
-	//               4th edition, 1993, W.B.Saunders Company Ltd, London.
+#endif
-	END = (real_pres_respiration - ppHe - pres_surface) * BAR_TO_METER;
+	{
+		//---- Calculate and Export EAD and END ------------------------------------------------------
-	// export EAD
-	if( (EAD < 0.0) || (EAD > 245.5) ) char_O_EAD = 0;
+		// calculate EAD (Equivalent Air Depth): equivalent depth for the same N2 level with plain air
-	else                               char_O_EAD = (unsigned char)(EAD + 0.5);
+		EAD = (ppN2 / 0.7902 + ppWater - pres_surface) * BAR_TO_METER;
-	// export END
+		// calculate END (Equivalent Narcotic Depth): here O2 is treated as narcotic, too
-	if( (END < 0.0) || (END > 245.5) ) char_O_END = 0;
+		// Source cited: The Physiology and Medicine of Diving by Peter Bennett and David Elliott,
-	else                               char_O_END = (unsigned char)(END + 0.5);
+		//               4th edition, 1993, W.B.Saunders Company Ltd, London.
+		END = (real_pres_respiration - ppHe - pres_surface) * BAR_TO_METER;
-	//---- Compute ppO2 Values in [cbar] ---------------------------------------------------------
+		// export EAD
+		float_value = EAD; convert_float_to_char(); char_O_EAD = char_value;
-	// pure oxygen ppO2
-	     if ( O2_ppO2       <  0.01  ) int_O_O2_ppO2       =   0;
+		// export END
-	else if ( O2_ppO2       >= 9.995 ) int_O_O2_ppO2       = 999;
+		float_value = END; convert_float_to_char(); char_O_END = char_value;
-	else                               int_O_O2_ppO2       = (unsigned int)(100 *   O2_ppO2 + 0.5);
-	// pure gas ppO2
+		//---- Compute ppO2 Values in [cbar] ---------------------------------------------------------
-	     if ( OC_ppO2       <  0.01  ) int_O_pure_ppO2     =   0;
-	else if ( OC_ppO2       >= 9.995 ) int_O_pure_ppO2     = 999;
+		float_value = ppO2;      convert_float_to_int(); int_O_breathed_ppO2 = int_value;	// breathed gas
-	else                               int_O_pure_ppO2     = (unsigned int)(100 *   OC_ppO2 + 0.5);
+#ifdef _ccr_pscr
+		float_value = O2_ppO2;   convert_float_to_int(); int_O_O2_ppO2       = int_value;	// pure oxygen
-	// calculated pSCR ppO2
+		float_value = OC_ppO2;   convert_float_to_int(); int_O_pure_ppO2     = int_value;	// pure gas
-	     if ( pSCR_ppO2     <  0.01  ) int_O_pSCR_ppO2     =   0;
+		float_value = pSCR_ppO2; convert_float_to_int(); int_O_pSCR_ppO2     = int_value;	// pSCR calculated
-	else if ( pSCR_ppO2     >= 9.995 ) int_O_pSCR_ppO2     = 999;
+#endif
-	else                               int_O_pSCR_ppO2     = (unsigned int)(100 * pSCR_ppO2 + 0.5);
-	// breathed ppO2
+		//---- Set/Reset Deco Mode --------------------------------------------------------------------
-	     if ( ppO2          <  0.01  ) int_O_breathed_ppO2 =   0;
-	else if ( ppO2          >= 9.995 ) int_O_breathed_ppO2 = 999;
+		// Set the deco mode flag if:
-	else                               int_O_breathed_ppO2 = (unsigned int)(100 *      ppO2 + 0.5);
+		//     deco mode is not set
+		// AND     breathing an OC deco gas (gas type 3)
+		//     OR  breathing a gas or diluent that officially is disabled (type 0)
-	//---- Set/Reset Deco Mode --------------------------------------------------------------------
+		//     OR  there is a deco stop and we are less deep than 1 meter below the deepest deco stop
+		if (    ( deco_info & DECO_FLAG ) == 0                                                      )
-	// Set the deco mode flag if:
+		if (    ( char_I_current_gas_type == 3                                                      )
-	// - breathing an OC deco gas (gas type 3), or
+		     || ( char_I_current_gas_type == 0                                                      )
-	// - breathing a gas or diluent that officially is disabled (type 0), or
+		     || ( ( char_O_deco_depth[0]   > 0 ) && ( char_depth_real <= char_O_deco_depth[0] + 1 ) )
-	// - 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                                                                           )
+				deco_info |=  DECO_FLAG;
-	      || ( char_I_current_gas_type == 0                                                                           )
-	      || ( (unsigned char)((real_pres_respiration - pres_surface) * BAR_TO_METER - 1.9) < char_O_first_deco_depth )
+		// Clear the deco mode flag if:
-		)
+		//      deco mode is set
-			char_O_deco_info |=  DECO_FLAG;
+		// AND  deeper than 7 meters below deepest deco stop (7 meters = 2 stop depth intervals plus 1 meter below stop)
-	else
+		if (    ( deco_info   & DECO_FLAG      )  > 0                                               )
-			char_O_deco_info &= ~DECO_FLAG;
+		if (    ( char_depth_real                 > char_O_deco_depth[0] + 7                        )
+		   )
+				deco_info &= ~DECO_FLAG;
-	//---- Compute ppO2 Warnings ------------------------------------------------------------------
-	// compute conditional min/max values
+		//---- Compute ppO2 Warnings ------------------------------------------------------------------
-	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;
+		// compute conditional min values
+#ifdef _ccr_pscr
-	// get biggest of char_I_ppO2_max / char_I_ppO2_max_deco
+		int_ppO2_min = ( main_status & MODE_LOOP ) ? (unsigned short)char_I_ppO2_min_loop : (unsigned short)char_I_ppO2_min;
-	int_ppO2_max_max = ( char_I_ppO2_max_deco > char_I_ppO2_max ) ? char_I_ppO2_max_deco : char_I_ppO2_max;
+#else
+		int_ppO2_min = (unsigned short)char_I_ppO2_min;
-	// default value for the upper diluent ppO2 warning threshold is the normal upper warning threshold
+#endif
-	int_ppO2_max_dil = int_ppO2_max;
+		// compute conditional max values
-	// when in CCR mode, the upper diluent warning threshold gets adjust according to the current setpoint
+		int_ppO2_max = ( deco_info   & DECO_FLAG ) ? (unsigned short)char_I_ppO2_max_deco : (unsigned short)char_I_ppO2_max_work;
-	if( (char_O_main_status & DECO_MODE_MASK) == DECO_MODE_CCR )
-	{
+		// add some margin on ppO2 max to compensate for surface pressures > 1.000 mbar
-		overlay unsigned int max_dil;
+		int_ppO2_max += ppO2_MARGIN_ON_MAX;
-		//  The upper diluent ppO2 threshold is ppO2_GAP_TO_SETPOINT below the setpoint...
+		// get biggest of char_I_ppO2_max_work / char_I_ppO2_max_deco
-		// (the condition protects from negative numbers which would cause a wrap-around in unsigned integers)
+		int_ppO2_max_max = ( char_I_ppO2_max_deco > char_I_ppO2_max_work ) ? char_I_ppO2_max_deco : char_I_ppO2_max_work;
-		max_dil = (char_I_const_ppO2 > ppO2_GAP_TO_SETPOINT) ? (unsigned int)(char_I_const_ppO2 - ppO2_GAP_TO_SETPOINT) : 0;
+#ifdef _ccr_pscr
-		// ...but never above int_ppO2_max.
+		// default value for the upper diluent ppO2 warning threshold is the normal upper warning threshold
-		if( max_dil < int_ppO2_max ) int_ppO2_max_dil = max_dil;
+		int_ppO2_max_dil = int_ppO2_max;
-		// We do not need to guard int_ppO2_max_dil against becoming lower than char_I_ppO2_min because the check
+		// when in CCR mode, the upper diluent warning threshold gets adjust according to the current setpoint
-		// against char_I_ppO2_min is done first and will then raise a low warning and inhibit further checks.
+		if( (main_status & MODE_MASK) == MODE_CCR )
-	}
+		{
+			overlay unsigned short max_dil;
-	// 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;
+			//  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)
-	// check for safe range of breathed gas
+			max_dil = (char_I_const_ppO2 > ppO2_GAP_TO_SETPOINT) ? (unsigned short)(char_I_const_ppO2 - ppO2_GAP_TO_SETPOINT) : 0;
-	     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;
+			// ...but never above int_ppO2_max.
-	else if ( char_O_deco_info    &                DECO_FLAG        ) ; // no attention generated in deco mode
+			if( max_dil < int_ppO2_max ) int_ppO2_max_dil = max_dil;
-	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;
+			// 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 diluent
+		}
-	     if ( int_O_pure_ppO2     <= (unsigned int)char_I_ppO2_min  ) int_O_pure_ppO2     |= INT_FLAG_WARNING + INT_FLAG_LOW;
+#endif
-	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 breathed gas
+		if      ( int_O_breathed_ppO2 <=                 int_ppO2_min         ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_LOW;
-	// check for safe range of calculated pSCR loop gas
+		else if ( int_O_breathed_ppO2 >=                 int_ppO2_max_max     ) int_O_breathed_ppO2 |= INT_FLAG_WARNING + INT_FLAG_HIGH;
-	     if ( int_O_pSCR_ppO2     <=               int_ppO2_min     ) int_O_pSCR_ppO2     |= INT_FLAG_WARNING + INT_FLAG_LOW;
+		else if ( deco_info           &                  DECO_FLAG            ) ; // no attention generated in deco mode
-	else if ( int_O_pSCR_ppO2     >=               int_ppO2_max     ) int_O_pSCR_ppO2     |= INT_FLAG_WARNING + INT_FLAG_HIGH;
+		else if ( main_status         &                  MODE_LOOP            ) ; // no attention generated in loop modes
+		else if ( int_O_breathed_ppO2 >= (unsigned short)char_I_ppO2_max_work ) int_O_breathed_ppO2 |= INT_FLAG_ATTENTION;
+#ifdef _ccr_pscr
+		// 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 pure diluent
+		if      ( int_O_pure_ppO2     <= (unsigned short)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;
+#endif
+	} // tasks every second / on the first section of the second
 #ifdef _rx_functions
-	//---- Process Pressure Readings (OSTC TR only) -----------------------------------------------
+	// only when TR functions are enabled
+	if( main_status & TR_FUNCTIONS )
-	// only for OSTC TR model with TR functions enabled
-	if( char_O_main_status & DECO_TR_FUNCTIONS )
+	// Tasks every second, if more than 1 invocation per second: on the second section of the second.
-	{
+#if (INVOKES_PER_SECOND > 1)
-		// pressure warnings for reading 1, but only if enabled and pressure value available
+	if(    ( sequence_timer == 1                      )
-		if( (char_I_pressure_gas[0] > 0) && !(int_IO_pressure_value[0] & INT_FLAG_NOT_AVAIL) )
+	    || ( sequence_timer == INVOKES_PER_SECOND + 1 )
-		{
+	)
-			overlay unsigned int pressure_value = int_IO_pressure_value[0] & ~INT_FLAG_OUTDATED;
+#endif
+	{
-			if( (char_I_pressure_gas[0] < 6 ) && !(int_O_pressure_need[0] & INT_FLAG_NOT_AVAIL) )
+		calc_TR_functions();
+	}
+#endif // _rx_functions
+	//
+	//---- End of Computations for the real Tissues -----------------------------------------------
+	//
+	//=============================================================================================
+	//
+	//---- Begin of Computations for Ascent and Decompression (simulated Tissues) -----------------
+	//
+	// Dispatcher: select what to do based on the current calculation phase
+	do
+	{
+#ifdef _profiling
+		profiling_phase = next_planning_phase;
+#endif
+		switch( next_planning_phase )
+		{
+		//
+		//---- once-per-dive Initialization of the Deco Engine ------------------------------------
+		//
+		case PHASE_10_DIVE_INIT:
+		// initialize all output variables to defaults
+		init_output_vars();
+		// safeguard input parameters that are constant during the course of the dive
+		if( char_I_deco_distance >  20 ) char_I_deco_distance =  20;
+		if( char_I_ascent_speed  <   5 ) char_I_ascent_speed  =   5;
+		if( char_I_ascent_speed  >  10 ) char_I_ascent_speed  =  10;
+		// convert input parameters to float numbers
+		float_deco_distance = 0.01 * char_I_deco_distance;
+		float_ascent_speed  = 1.00 * char_I_ascent_speed;
+		// initialize values that will be recalculated later on periodically
+		deco_warnings            = 0;		// reset all deco warnings
+		deco_info                = 0;		// reset all deco infos
+		IBCD_tissue_vector       = 0;		// reset tissue IBCD vector
+		NDL_tissue_start_norm    = 0;		// initialize the tissue to start with when calculating normal      NDL time
+		NDL_tissue_start_alt     = 0;		// initialize the tissue to start with when calculating alternative NDL time
+		// enforce initialization of GF data on first cyclic initialization
+		GF_high_last             = 0;
+		GF_low_last              = 0;
+#ifdef _cave_mode
+		char_I_backtrack_time    = 0;		//clear backtracking time (index to char_I_backtrack_depth)
+		char_I_backtrack_depth   = 0;		//prime first entry with a depth of 0 meter
+#endif
+#ifdef _profiling
+		int_O_profiling_overrun_max = 0;
+		char_O_profiling_runs_norm  = 0;
+		char_O_profiling_runs_alt   = 0;
+#endif
+		// the next calculation phase will do the cyclic initialization of the deco engine if a
+		// normal or alternative plan shall be calculated, else the calculation cycle is done.
+		if( deco_status & PLAN_MASK ) next_planning_phase = PHASE_11_CYCLIC_INIT;
+		else                          next_planning_phase = PHASE_00_DONE;
+		break;
+		//
+		//---- once-per-cycle Initialization of the Deco Engine------------------------------------
+		//
+		case PHASE_11_CYCLIC_INIT:
+		// target the simulated tissues (flag bit 7 = 0)
+		tissue_increment = 0;
+		// 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] = real_pres_tissue_N2[i];
+			sim_pres_tissue_He[i] = real_pres_tissue_He[i];
+		}
+		// initialize GF parameters if using GF model
+		if( char_I_deco_model != 0 )
+		{
+			// update GF parameters (GFs may have been switched between GF and aGF)
+			if( (char_I_GF_High_percentage != GF_high_last) || (char_I_GF_Low_percentage != GF_low_last) )
 			{
-				// not a dil and need available: warning & attention by need
+				// store new values in integer format
-				     if( pressure_value <= int_O_pressure_need[0])
+				GF_high_last = char_I_GF_High_percentage;
-				         int_IO_pressure_value[0] |= INT_FLAG_WARNING;
+				GF_low_last  = char_I_GF_Low_percentage;
-				else if( pressure_value <= int_O_pressure_need[0] + int_O_pressure_need[0] / 2 )
-				         int_IO_pressure_value[0] |= INT_FLAG_ATTENTION;
+				// store new values in float format
+				GF_high  = 0.01 * char_I_GF_High_percentage;
+				GF_low   = 0.01 * char_I_GF_Low_percentage;
+				// reset low depth references and slopes
+				GF_low_depth_norm = 0;
+				GF_low_depth_alt  = 0;
+				GF_slope_norm     = 0.0;
+				GF_slope_alt      = 0.0;
+			}
+			// retrieve GF parameters for current calculation cycle
+			if( deco_status & CALC_NORM )
+			{
+				GF_low_depth = GF_low_depth_norm;
+				GF_slope     = GF_slope_norm;
 			}
 			else
 			{
-				// a dil or need not available: warning & attention by fixed thresholds
+				GF_low_depth = GF_low_depth_alt;
-				if     ( pressure_value <= PRESSURE_LIMIT_WARNING   ) int_IO_pressure_value[0] |= INT_FLAG_WARNING;
+				GF_slope     = GF_slope_alt;
-				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
+		// initialize the simulated CNS value with the current CNS value of the real tissues
-		if( (char_I_pressure_gas[1] > 0) && !(int_IO_pressure_value[1] & INT_FLAG_NOT_AVAIL) )
+		CNS_fraction_sim = CNS_fraction_real;
-		{
-			overlay unsigned int pressure_value = int_IO_pressure_value[1] & ~INT_FLAG_OUTDATED;
+		// initialize the simulated depth with the current depth (in absolute pressure)
+		sim_pres_respiration = real_pres_respiration;
-			if( (char_I_pressure_gas[1] < 6 ) && !(int_O_pressure_need[1] & INT_FLAG_NOT_AVAIL) )
+		// compute the depth in meters where we are now
+		float_depth_real = (sim_pres_respiration - pres_surface) * BAR_TO_METER;
+		// convert to integer and round up to next full meter
+		char_depth_real = (unsigned char)(float_depth_real + 0.99);
+		// initialize depth for deco ascent calculation
+		char_depth_sim = char_depth_real;
+		// Lookup the gas that is currently breathed with the real tissues and set it as
+		// the gas to be used with the simulated tissues, too. 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
+		// can be kept until a gas switch is done. Thus, if a call to gas_find_better() has
+		// found a better gas and initiated a switch, gas_set_ratios() needs to be called again.
+		gas_set_ratios();
+		// compute ppO2, ppN2 and ppHe for current depth from sim_pres_respiration
+		calc_alveolar_pressures();
+		// initialize the no decompression limit (NDL) time to 240 minutes
+		NDL_time = 240;
+		// retrieve the tissue that had the shortest NDL time during last calculation
+		NDL_tissue_start = ( deco_status & CALC_NORM ) ? NDL_tissue_start_norm : NDL_tissue_start_alt;
+		// start calculating NDL time with the tissue that had the shortest NDL last time
+		NDL_tissue      = NDL_tissue_start;
+		NDL_tissue_lead = NDL_tissue_start;
+		// initialization for calculating the initial ascent
+		// start with 1 minute ascent steps when calculating the initial ascent
+		fast = 1;
+		// initialization for calc_gas_needs_ascent()
+		gas_needs_next_phase = GAS_NEEDS_INIT;
+		// initialization for convert_gas_needs_to_press()
+		gas_needs_gas_index  = 0;
+#ifdef _profiling
+		profiling_runs = 0;
+#endif
+		// The next calculation phase will
+		// - calculate the bottom segment if extended bottom time is configured (fTTS),
+		// - proceed with calculating the NDL time else.
+		if   ( deco_status & DELAYED_ASCENT ) next_planning_phase = PHASE_20_EXTENDED_BOTTOM_TIME;
+		else                                  next_planning_phase = PHASE_30_NDL_TIME;
+		break;
+		//
+		//---- extended Bottom Time ---------------------------------------------------------------
+		//
+		case PHASE_20_EXTENDED_BOTTOM_TIME:
+		// program interval on simulated tissues (flag bit 7 = 0)
+		tissue_increment = char_I_extra_time;
+		// calculate ppO2, ppN2 and ppHe
+		calc_alveolar_pressures();
+		// update the tissues
+		calc_tissues();
+		// update the CNS value
+		calc_CNS();
+		// the next calculation phase will calculate the NDL time
+		next_planning_phase = PHASE_30_NDL_TIME;
+		break;
+		//
+		//---- NDL Time ---------------------------------------------------------------------------
+		//
+		case PHASE_30_NDL_TIME:
+		// Calculate the remaining no decompression limit (NDL) time for the tissue NDL_tissue.
+		// NDL_time will be updated if the NDL time found is shorter than the current NDL_time.
+		//
+		// In the initialization phase of the calculation cycle:
+		// - NDL_time      had been initialized to 240 (minutes),
+		// - NDL_tissue    had been initialized to the tissue with
+		//                 the shortest NDL time in the last cycle.
+		//
+		calc_NDL_time_tissue();
+		// advance to next tissue, wrapping around after last tissue
+		NDL_tissue = (NDL_tissue + 1) & (NUM_COMP - 1);
+		// did we run out of NDL time or did we have probed all tissues?
+		if( (NDL_time == 0) || (NDL_tissue == NDL_tissue_start) )
+		{
+			// YES
+			// set the tissue with the shortest NDL time found as
+			// the one to start with in the next calculation cycle
+			if( deco_status & CALC_NORM ) NDL_tissue_start_norm = NDL_tissue_lead;
+			else                          NDL_tissue_start_alt  = NDL_tissue_lead;
+			// done with calculating NDL time, set next calculation phase:
+			// - calculate return and ascent in cave mode if configured, else
+			// - proceed with gathering the results if within NDL time, or
+			// - proceed with the initial ascent    if beyond NDL time.
+#ifdef _cave_mode
+			if   ( main_status & CAVE_MODE ) next_planning_phase = PHASE_40_CAVE_ASCENT;
+			else
+#endif
+			if   ( NDL_time                ) next_planning_phase = PHASE_70_RESULTS;
+			else                             next_planning_phase = PHASE_60_DECO_ASCENT;
+		}
+		break;
+#ifdef _cave_mode
+		//
+		//---- Cave Mode Return/Ascent ------------------------------------------------------------
+		//
+		case PHASE_40_CAVE_ASCENT:
+		// TODO
+		// the next calculation phase will gather all results
+		next_planning_phase = PHASE_70_RESULTS;
+		break;
+#endif
+		//
+		//---- Open Water Ascent with Deco Stops --------------------------------------------------
+		//
+		case PHASE_60_DECO_ASCENT:
+		// program 1 minute interval on simulated tissues
+		tissue_increment = 1;
+		// ascent to the next stop depth or the depth that is reachable within one minute of ascent
+		// and decide if a stop is required (return value = 1/true) or not (return value = 0/false)
+		if( find_next_stop() )
+		{
+			//---- stop required --------------------
+			// check if there is a better gas to switch to
+			if( gas_find_better() )
 			{
-				// not a dil and need available: warning & attention by need
+				// set the new calculation ratios for N2, He and O2
-				     if( pressure_value <= int_O_pressure_need[1])
+				gas_set_ratios();
-				         int_IO_pressure_value[1] |= INT_FLAG_WARNING;
-				else if( pressure_value <= int_O_pressure_need[1] + int_O_pressure_need[1] / 2 )
+				// doing extended stops?
-				         int_IO_pressure_value[1] |= INT_FLAG_ATTENTION;
+				if( main_status & EXTENDED_STOPS )
+				{
+					// YES - set char_depth_sim to the gas change depth
+					char_depth_sim = sim_gas_current_depth;
+					//     - adjust absolute pressure down to the change depth
+					sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface;
+				}
+				// prime the deco stop with the gas change time
+				update_deco_table(char_I_gas_change_time);
+			}
+			// add one minute to an existing stop or add a new stop at char_depth_sim,
+			// or abort stops calculation if the deco table is full
+			if( !update_deco_table(1) ) next_planning_phase = PHASE_70_RESULTS;
+		}
+		else
+		{
+			//---- no stop required -----------------
+			// check if there is a better gas to switch to, but only:
+			//
+			//     if extended stops are activated,
+			// OR  if in bailout mode.
+			//
+			// Attention: do not use a && formula over both 'if' terms, the extended stops / bailout
+			//            condition must be checked before a call to gas_find_better() is made!
+			//
+			if( (main_status & EXTENDED_STOPS) || (deco_status & BAILOUT_MODE) )
+			if( gas_find_better() )
+			{
+				// set the new calculation values for N2, He and O2
+				gas_set_ratios();
+				// stop duration is the gas change time, a change time of 0 minutes
+				// will set a tissue calculation interval of 2 seconds
+				tissue_increment += char_I_gas_change_time;
+				// set char_depth_sim to the gas change depth, but not deeper than
+				// the depth we came from.
+				// (char_depth_last holds the depth from before the ascent step)
+				char_depth_sim = (sim_gas_current_depth < char_depth_last) ? sim_gas_current_depth : char_depth_last;
+				// adjust sim_pres_respiration to the adjusted value of char_depth_sim
+				sim_pres_respiration = char_depth_sim * METER_TO_BAR + pres_surface;
+				// create a stop for the gas change in the stops table
+				update_deco_table(char_I_gas_change_time);
+			}
+		}
+		//---- one minute has passed by now, update the tissues ----------------
+		// compute current ppO2, ppN2 and ppHe
+		calc_alveolar_pressures();
+		// update the tissues
+		calc_tissues();
+		// update the CNS value
+		calc_CNS();
+		// finish stops calculation if the surface is reached
+		if( char_depth_sim == 0 ) next_planning_phase = PHASE_70_RESULTS;
+		break;
+		///
+		//--- Results - Initialization ------------------------------------------------------------
+		//
+		case PHASE_70_RESULTS:
+		// The current depth is needed by calc_ascenttime(), find_NDL_gas_changes() and
+		// calc_gas_needs_ascent(). As we don't want it to be calculated multiple times,
+		// it is done here on stockpile.
+		char_depth_bottom = (unsigned char)((real_pres_respiration - pres_surface) * BAR_TO_METER + 0.5);
+		// The next calculation phase will
+		// - publish the stops table if in normal plan mode,
+		// - proceed with remaining results dependent on if within NDL, or
+		// - in deco
+		if      ( deco_status & CALC_NORM ) next_planning_phase = PHASE_71_RESULTS_STOPS_TABLE;
+		else if ( NDL_time                ) next_planning_phase = PHASE_72_RESULTS_NDL;
+		else                                next_planning_phase = PHASE_73_RESULTS_DECO;
+		break;
+		///
+		//--- Publish Stops Table -----------------------------------------------------------------
+		//
+		case PHASE_71_RESULTS_STOPS_TABLE:
+		// 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_deco_depth[0] == 0 )	// simulated ascent reveals no required stops
+		if( int_O_ceiling        >  0 )	// real tissues have a ceiling
+		{
+			// set a pro forma stop at the configured last stop depth
+			char_O_deco_depth[0] = char_I_depth_last_deco;
+			// set a stop time of 0 minutes, this will be displayed as "..'"
+			char_O_deco_time[0]  = 0;
+		}
+		// update deco info vector
+		if( char_O_deco_depth[0] ) deco_info |=  DECO_STOPS;		// set flag for deco stops found
+		else                       deco_info &= ~DECO_STOPS;		// clear flag for deco stops found
+		// The next calculation phase will publish the main results dependent on being
+		// - within NDL,
+		// - in deco.
+		if   ( NDL_time ) next_planning_phase = PHASE_72_RESULTS_NDL;
+		else              next_planning_phase = PHASE_73_RESULTS_DECO;
+		break;
+		///
+		//--- Results - within NDL ----------------------------------------------------------------
+		//
+		case PHASE_72_RESULTS_NDL:
+		// results to publish depend on normal or alternative plan
+		if( deco_status & CALC_NORM )
+		{
+			// output the NDL time
+			char_O_NDL_norm = NDL_time;
+			// clear the normal ascent time
+			int_O_TTS_norm  = 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_CNS_norm  = int_O_CNS_current;
+		}
+		else
+		{
+			// output the NDL time
+			char_O_NDL_alt = NDL_time;
+			// clear the alternative ascent time
+			int_O_TTS_alt  = 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_CNS_alt  = int_O_CNS_current;
+		}
+		// The next calculation phase will
+		// - finish the calculation cycle if no gas needs calculation configured, else
+		// - find gas switches when in bailout mode (we are in NDL), or
+		// - calculate the gas needs along the ascent
+		if      ( !(main_status & CALC_VOLUME ) ) next_planning_phase = PHASE_90_FINISH;
+		else if (  (deco_status & BAILOUT_MODE) ) next_planning_phase = PHASE_80_GAS_NEEDS_SWITCHES;
+		else                                      next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT;
+		break;
+		///
+		//--- Results - in Deco -------------------------------------------------------------------
+		//
+		case PHASE_73_RESULTS_DECO:
+		// calculate the ascent time
+		calc_ascenttime();
+		// convert the CNS value to integer
+		convert_sim_CNS_for_display();
+		// results to publish depend on normal or alternative plan
+		if( deco_status & CALC_NORM )
+		{
+			// clear the normal NDL time
+			char_O_NDL_norm = 0;
+			// export the ascent time
+			int_O_TTS_norm  = ascent_time;
+			// export the integer CNS value
+			int_O_CNS_norm  = int_sim_CNS_fraction;
+		}
+		else
+		{
+			// clear the alternative NDL time
+			char_O_NDL_alt  = 0;
+			// export the ascent time
+			int_O_TTS_alt   = ascent_time;
+			// export the integer CNS value
+			int_O_CNS_alt   = int_sim_CNS_fraction;
+		}
+		// The next calculation phase will
+		// - finish the calculation cycle if no gas needs calculation configured, else
+		// - calculate the gas needs along the ascent
+		if      ( !(main_status & CALC_VOLUME ) ) next_planning_phase = PHASE_90_FINISH;
+		else                                      next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT;
+		break;
+		//
+		//--- Gas Needs - Switches ----------------------------------------------------------------
+		//
+		case PHASE_80_GAS_NEEDS_SWITCHES:
+		// When in bailout mode and within NDL, find the gas switches along the ascent and put
+		// them into the stops table. The stops table can be "polluted" by now because the table
+		// has already been published in "clean" state before.
+		find_NDL_gas_changes();
+		// the next calculation phase will calculate the gas needs along the ascent
+		next_planning_phase = PHASE_81_GAS_NEEDS_ASCENT;
+		break;
+		//
+		//--- Gas Needs - calculate Ascent Needs using Data from Stop Table -----------------------
+		//
+		case PHASE_81_GAS_NEEDS_ASCENT:
+		// calculate the gas needs along the ascent
+		calc_gas_needs_ascent();
+		// if calculation has finished, advance to next calculation phase
+		if( gas_needs_next_phase == GAS_NEEDS_DONE ) next_planning_phase = PHASE_82_GAS_NEEDS_PRESSURES;
+		break;
+		//
+		//--- Gas Needs - convert Volumes to Pressures --------------------------------------------
+		//
+		case PHASE_82_GAS_NEEDS_PRESSURES:
+		// convert required volume of the gas pointed to by gas_needs_gas_index
+		// into the respective pressure and set the flags
+		convert_gas_needs_to_press();
+		// increment index to address next gas
+		gas_needs_gas_index++;
+		// if all gases have been converted, advance to next calculation phase
+		if( gas_needs_gas_index == NUM_GAS ) next_planning_phase = PHASE_90_FINISH;
+		break;
+		//
+		//--- finish Calculation Cycle ------------------------------------------------------------
+		//
+		case PHASE_90_FINISH:
+		// Check if deco obligation is steady state or decreasing.
+		// This works only when an alternative plan is enabled and if it is not a bailout plan,
+		// thus BAILOUT_MODE must not be set while doing the alternative plan.
+		if( (deco_status & CALC_ALT) && !(deco_status & BAILOUT_MODE) )
+		{
+			if   ( int_O_TTS_alt <= int_O_TTS_norm ) deco_info |=  DECO_ZONE;
+			else                                     deco_info &= ~DECO_ZONE;
+		}
+		// export updated deco infos and warnings
+		char_O_deco_info     = deco_info;
+		char_O_deco_warnings = deco_warnings;
+		// restore command flag to indicate that deco calculation cycle has finished
+		char_O_deco_status   = deco_status;
+		// signal end of deco calculation
+		next_planning_phase = PHASE_00_DONE;
+		break;
+		} // switch
+		// read timer 5, result will be stored in tmr5_value (in 1/32 ms) and tmr5_overflow
+		read_tmr5();
+	} // sequence calculation phases while not timed out and calculation cycle is not finished
+	while( (tmr5_overflow == 0) && ( next_planning_phase != PHASE_00_DONE ) );
+	// report where we are in terms of depth reached, used in deco calculator to show deco calculation progress
+	char_O_depth_sim = char_depth_sim;
+#ifdef _profiling
+	//---- Performance Measurement -------------------------------------------
+	// convert timer 5 readout into ms
+	profiling_runtime = tmr5_value / 32;
+	// actual runtime longer than target runtime?
+	if( tmr5_overflow )
+	{
+		// YES - report excess
+		int_O_profiling_overrun = profiling_runtime;
+		//     - excess > max we had so far?
+		if( int_O_profiling_overrun > int_O_profiling_overrun_max )
+		{
+			// YES - update max
+			int_O_profiling_overrun_max    = int_O_profiling_overrun;
+			//     - store the causing phase
+			char_O_profiling_overrun_phase = profiling_phase;
+		}
+	}
+	else
+	{
+		// NO - calculate unused budget and flag it to be under-run time
+		int_O_profiling_overrun = (2048 - profiling_runtime) | 0x8000;
+	}
+	// increment number of runs in current cycle
+	profiling_runs += 1;
+	// planning cycle completed?
+	if( next_planning_phase == PHASE_00_DONE )
+	{
+		// YES - export number of runs it took
+		if( deco_status & COMPLETED_NORM ) char_O_profiling_runs_norm = profiling_runs;
+		else                               char_O_profiling_runs_alt  = profiling_runs;
+	}
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+// calc_hauptroutine_data_input
+//
+// Set all C-code dive parameters from their ASM-code values.
+//
+void calc_hauptroutine_data_input(void)
+{
+	overlay float IG_ratio;
+	// safeguard and convert the surface pressure (mbar -> bar) (*)
+	if( int_I_pres_surface     < 500 ) pres_surface          = 0.500;
+	else                               pres_surface          = 0.001 * int_I_pres_surface;
+	// safeguard and convert the current real pressure
+	if( int_I_pres_respiration < 500 ) real_pres_respiration = 0.500;
+	else                               real_pres_respiration = 0.001 * int_I_pres_respiration;
+	// safeguard further parameters to protect the tissue-flag and the stop table
+	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;
+	// calculate partial pressure of N2 in respired air at surface pressure
+	calc_N2_equilibrium();
+	// get, safeguard and convert the saturation and desaturation factors
+	get_saturation_factors();
+#ifdef _ccr_pscr
+	// compute a factor that will be used later on for pSCR ppO2 drop calculation (*)
+	float_pSCR_factor = 0.01 * char_I_PSCR_drop * char_I_PSCR_lungratio;
+#endif
+#ifdef _helium
+	// get the currently breathed gas ratios
+	real_O2_ratio = 0.01 * char_I_O2_ratio;
+	real_He_ratio = 0.01 * char_I_He_ratio;
+	// calculate the inert gas ratio (local helper variable)
+	IG_ratio = 1.00 - real_O2_ratio;
+	// calculate the N2 ratio
+	real_N2_ratio  = IG_ratio - real_He_ratio;
+#else
+	// get the currently breathed O2 ratio
+	real_O2_ratio = 0.01 * char_I_O2_ratio;
+	// set the He ratio to zero
+	real_He_ratio = 0.0;
+	// calculate the N2 / inert gas ratio
+	real_N2_ratio = IG_ratio = 1.00 - real_O2_ratio;
+#endif	// _helium
+#ifdef _ccr_pscr
+	// calculate ppO2 drop in pSCR loop for real tissues
+	real_pSCR_drop = IG_ratio * float_pSCR_factor;
+#endif
+}
+//////////////////////////////////////////////////////////////////////////////
+// Find gas changes on an NDL ascent
+//
+// This function is used for finding the gas changes in an OC bailout ascent
+// that is within NDL.
+//
+// Input:     char_depth_bottom       depth at which the ascent starts, in meters
+//
+// Output:    gas change stops put into stops table
+//
+// Destroyed: char_depth_sim
+//            sim_gas_current_num     number of current gas
+//            sim_gas_current_depth   change depth of current gas
+//
+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( char_depth_sim = char_depth_bottom; char_depth_sim >= 3; )
+	{
+		// memorize the depth we came from
+		old_depth_limit = char_depth_sim;
+		// ascent - initially in steps of 10 m, then slowing down to 1 m steps to not miss a O2 gas
+		if   ( char_depth_sim > 10 ) char_depth_sim -= 10;
+		else                         char_depth_sim -=  1;
+		// check if there is a better gas to switch to
+		if( gas_find_better() )
+		{
+			// adjust char_depth_sim to the gas change depth, but not deeper than the depth we came from
+			char_depth_sim = (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()
+}
+//////////////////////////////////////////////////////////////////////////////
+// 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: real_pres_tissue_N2[]      tissue N2 pressures (in real tissues context)
+//           real_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_pres_N2[]    tissue N2 pressures scaled for display purpose (in real tissues context)
+//           char_O_tissue_pres_He[]    tissue He pressures scaled for display purpose (in real tissues context)
+//           char_O_tissue_pressure[]   combined tissue pressures scaled for display purpose (in real tissue context)
+//
+static void calc_tissues()
+{
+	overlay unsigned char	period;
+	overlay float			temp_tissue_N2;
+#ifdef _helium
+	overlay float			temp_tissue_He;
+#endif
+	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								// last but not lease, do 1 to 9 minutes
+		{
+			read_Buhlmann_times(1);			// NO  - program coefficients for 1 minute periods
+			period = 1;						//     - set period length (in cycles) to one
+		}
+		do
+		{
+			//---- N2 --------------------------------------------------------
+			temp_tissue = (tissue_increment & TISSUE_SELECTOR) ? real_pres_tissue_N2[ci] : sim_pres_tissue_N2[ci];
+			temp_tissue = (ppN2 - temp_tissue) * var_N2_e;
+			apply_saturation_factors();
+			if( tissue_increment & TISSUE_SELECTOR )
+			{
+				temp_tissue_N2           = temp_tissue;
+				real_pres_tissue_N2[ci] += temp_tissue;
 			}
 			else
 			{
-				// a dil or need not available: warning & attention by fixed thresholds
+				sim_pres_tissue_N2[ci]  += temp_tissue;
-				     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;
 			}
-		}
+#ifdef _helium
-		//--- SAC Calculation ---------------------------------------------------------------------
+			//---- He --------------------------------------------------------
-		//
-		// char_I_SAC_mode =0: disabled
+			temp_tissue = (tissue_increment & TISSUE_SELECTOR) ? real_pres_tissue_He[ci] : sim_pres_tissue_He[ci];
-		//                 =1: SAC from 1st reading
-		//                 =2: SAC from 2nd reading
+			temp_tissue = (ppHe - temp_tissue) * var_He_e;
-		//                 =3: SAC from higher one of both pressure drops (independent double mode)
-		//                 =4: SAC (O2 usage) from 2nd reading without real_pres_respiration term
+			apply_saturation_factors();
-		// set SAC rate to not available by default
+			if( tissue_increment & TISSUE_SELECTOR )
-		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
+				temp_tissue_He           = temp_tissue;
-				reading1_press = int_IO_pressure_value[0] & 0x0FFF;			// in 0.1 bar
+				real_pres_tissue_He[ci] += temp_tissue;
-				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 ------------------------------------
+				sim_pres_tissue_He[ci]  += temp_tissue;
-				// 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
+#endif
-		else
-		{
+			//---- decrement loop counter and adjust step size ---------------
-			//---- 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
 		}
 		while( i );
 		// have the computations been done for the "real" tissues?
-		if( tissue_increment & TISSUE_FLAG )
+		if( tissue_increment & TISSUE_SELECTOR )
 		{
+#ifdef _helium
 			// 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
+				// tag tissue as not experiencing mentionable IBCD
-				IBCD_tissue_vector &= ~(1 << ci);		// tag tissue as not experiencing mentionable IBCD
+				IBCD_tissue_vector &= ~(1 << ci);
 			}
 			else if ( temp_tissue > +HYST )				// check if the tissue in on-gassing
 			{
-				deco_tissue_vector &= ~(1 << ci);		// tag tissue as not being in decompression
+				// check for counter diffusion
+				if(    ((temp_tissue_N2 > 0.0) && (temp_tissue_He < 0.0))
-				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
+					// tag tissue as experiencing mentionable IBCD
+					IBCD_tissue_vector |= (1 << ci);
 				}
 			}
+#endif
-			// keep the saturating / desaturating flags from last invocation
-			char_O_tissue_N2_saturation[ci] &= 128;
+			// For N2 tissue pressure display purpose:
-			char_O_tissue_He_saturation[ci] &= 128;
+			// basically keep the on-gassing / off-gassing flag from last invocation, but flip
-			// flip the flags applying a hysteresis of HYST (actual value: see #define of HYST)
+			// it in case the rate exceeds a set hysteresis (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
+			char_O_tissue_pres_N2[ci]  &= 128;
-			else if( temp_tissue_N2 < -HYST ) char_O_tissue_N2_saturation[ci] =   0; // clear flag (-> tissue pressure is decreasing)
+			if      ( temp_tissue_N2 > +HYST ) char_O_tissue_pres_N2[ci]  = 128; // set flag for tissue pressure is increasing
+			else if ( temp_tissue_N2 < -HYST ) char_O_tissue_pres_N2[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)
+			// scale N2 tissue pressure such that the surface steady-state tissue loading
+			// of [0.7902 * (1013 hPa - ppWater)] bar will give a 8, which aligns with
+			// the 2nd scale line.
-			// For N2 tissue display purpose:
+			temp_tissue_N2 = (8 / (0.7902 * (1.013 - ppWater))) * real_pres_tissue_N2[ci];
-			// 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
+			// limit to 127 to protect the uppermost bit which holds the sat/desat flag
-			// gives then a 10. If N2 is completely washed out of the tissue, result will be 0.
+			if (temp_tissue_N2 > 127) temp_tissue_N2 = 127;
-			// This scaling is adapted to the capabilities of the tissue graphics in the custom views.
-			temp_tissue = (pres_tissue_N2[ci] / N2_equilibrium) * 10;
+			// convert to integer and combine with sat/desat flag
+			char_O_tissue_pres_N2[ci] += (unsigned char)temp_tissue_N2;
-			// limit to 127 to leave space for sat/desat flag
+#ifdef _helium
+			// For He tissue pressure display purpose:
+			// basically keep the on-gassing / off-gassing flag from last invocation, but flip
+			// it in case the rate exceeds a set hysteresis (actual value: see #define of HYST)
+			char_O_tissue_pres_He[ci]  &= 128;
+			if      ( temp_tissue_He > +HYST ) char_O_tissue_pres_He[ci]  = 128; // set flag for tissue pressure is increasing
+			else if ( temp_tissue_He < -HYST ) char_O_tissue_pres_He[ci]  =   0; // clear flag (-> tissue pressure is decreasing)
+			// scale He tissue pressure alike it is done for N2.
+			// With no He in a tissue, the result will be 0.
+			temp_tissue_He = (8 / (0.7902 * (1.013 - ppWater))) * real_pres_tissue_He[ci];
+			// limit to 127 to protect the uppermost bit which holds the sat/desat flag
+			if (temp_tissue_He > 127) temp_tissue_He = 127;
+			// convert to integer and combine with sat/desat flag
+			char_O_tissue_pres_He[ci] += (unsigned char)temp_tissue_He;
+			// For combined tissue pressure display purpose:
+			// basically keep the on-gassing / off-gassing flag from last invocation, but flip
+			// it in case the rate exceeds a set hysteresis (actual value: see #define of HYST)
+			char_O_tissue_pressure[ci] &= 128;
+			if      ( temp_tissue    > +HYST ) char_O_tissue_pressure[ci] = 128; // set flag for tissue pressure is increasing
+			else if ( temp_tissue    < -HYST ) char_O_tissue_pressure[ci] =   0; // clear flag (-> tissue pressure is decreasing)
+			// add the two scaled pressures.
+			temp_tissue = temp_tissue_N2 + temp_tissue_He;
+			// limit to 127 to protect the uppermost bit which holds the sat/desat flag
 			if (temp_tissue > 127) temp_tissue = 127;
-			// export as integer
+			// convert to integer and combine with sat/desat flag
-			char_O_tissue_N2_saturation[ci] += (unsigned char)temp_tissue;
+			char_O_tissue_pressure[ci] += (unsigned char)temp_tissue;
+#else
-			// For H2 tissue display purpose:
-			// Scale tissue press so that saturation in 120m on TMX 10/70 gives a value of approx. 70.
+			// He tissue pressure is zero
-			// With no He in a tissue, result will be 0.
+			char_O_tissue_pres_He[ci] = 0;
-			// This scaling is adapted to the capabilities of the tissue graphics in the custom views.
-			temp_tissue = pres_tissue_He[ci] * 7.7;
+			// combined tissue pressure equals N2 tissue pressure
+			char_O_tissue_pressure[ci] = char_O_tissue_pres_N2[ci];
-			// limit to 127 to leave space for sat/desat flag
-			if (temp_tissue > 127) temp_tissue = 127;
+#endif
-			// export as integer
-			char_O_tissue_He_saturation[ci] += (unsigned char)temp_tissue;
 		} //if
 	} // for
 }
 //////////////////////////////////////////////////////////////////////////////
 // calc_limit
 //
-// Input:  GF_parameter             gradient factor to be used, negative values activate surface mode
+// Input:    GF_parameter             gradient factor to be used, negative values activate surface mode
-//         tissue_increment         selector for context: real or simulated tissues
+//           tissue_increment         selector for context: real or simulated tissues
-//         sim_pres_tissue_N2/_He   tissue pressures (used in simulated tissues context)
+//           sim_pres_tissue_N2/_He   tissue pressures (used in simulated tissues context)
-//         pres_tissue_N2/_He       tissue pressures (used in real      tissues context)
+//           real_pres_tissue_N2/_He  tissue pressures (used in real      tissues context)
 //
-// Output: lead_supersat            highest supersaturation found among all tissues, 1.0 = 100%
+// Output:   lead_supersat            highest supersaturation found among all tissues, 1.0 = 100%
-//         lead_tissue              number of the leading tissue (0-15)
+//           lead_tissue              number of the leading tissue (0-15)
-//         ceiling                  ceiling in bar relative pressure
+//           ceiling                  ceiling in bar relative pressure
 //
-// Modified:
+// Modified: deco_warnings            for IBCD, micro bubbles and outside warning (only in real tissues context)
-//         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;
+	overlay float         pres_respiration_min_total = 0.0;
+	overlay unsigned char surface_mode               = 0;		// 0: off, 1: on
-	// set leading tissue number to not yet computed
-	lead_number = 0;
+	// check mode
+	if( GF_parameter < 0 )
+	{
+		// activate surface mode
+		surface_mode = 1;
+		// normalize parameter
+		GF_parameter = -GF_parameter;
+	}
+	// set leading tissue number to tissue 1 (it has the index 0)
+	lead_tissue   = 0;
 	// initialize leading tissue supersaturation value to null
-	lead_supersat  = 0.0;
+	lead_supersat = 0.0;
-	// check context
+	// next code section is relevant only when invoked on the real tissues
-	if( tissue_increment & TISSUE_FLAG )
+	if( tissue_increment & TISSUE_SELECTOR )
 	{
-		// clear IBCD, micro bubbles and outside warning flags (locked warnings will be preserved)
+		// clear IBCD, micro-bubbles 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 );
+		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;
+		overlay float pres_respiration_min_tissue;
+		// get the coefficients for tissue ci
+		read_Buhlmann_coefficients();
+#ifdef _helium
 		// get the tissue pressures
-		if( tissue_increment & TISSUE_FLAG )
+		// adopt_Buhlmann_coefficients needs calc_pres_tissue_N2/He when compiled for helium
+		if( tissue_increment & TISSUE_SELECTOR )
 		{
 			// context is real tissues
-			calc_pres_tissue_N2 = pres_tissue_N2[ci];
+			calc_pres_tissue_N2 = real_pres_tissue_N2[ci];
-			calc_pres_tissue_He = pres_tissue_He[ci];
+			calc_pres_tissue_He = real_pres_tissue_He[ci];
 		}
 		else
 		{
 			// context is simulated tissues
 			calc_pres_tissue_N2 = sim_pres_tissue_N2[ci];
 		}
 		// overall tissue pressure
 		pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He;
-		// get the coefficients for tissue ci
+#else
-		read_Buhlmann_coefficients();
+		// get the tissue pressure
+		pres_tissue = ( tissue_increment & TISSUE_SELECTOR ) ? real_pres_tissue_N2[ci] : sim_pres_tissue_N2[ci];
+#endif
 		// adopt a and b coefficients to current N2/He ratio inside the tissue
 		adopt_Buhlmann_coefficients();
 		// next calculations are only relevant when invoked on the real tissues
-		if( tissue_increment & TISSUE_FLAG )
+		if( tissue_increment & TISSUE_SELECTOR )
 		{
 			overlay float pres_tissue_max;
 			overlay float supersat;
 			overlay float baseline_threshold;
 			// check if tissue is in supersaturation
 			if( pres_tissue > real_pres_respiration )
 			{
 				// calculate maximum allowed tissue pressure at current ambient pressure
-				pres_tissue_max = real_pres_respiration / var_N2_b + var_N2_a;
+				pres_tissue_max = real_pres_respiration / var_b + var_a;
 				// calculate current supersaturation value (1.0 = 100%) of this tissue according to straight Buhlmann
 				supersat =    ( pres_tissue     - real_pres_respiration )
 				            / ( pres_tissue_max - real_pres_respiration );
+				// calculate supersaturation value for display purpose: 1.35 = 135% = 86 pixel
+				if( supersat <= 1.35 ) char_O_tissue_saturation[ci] = (unsigned char)(supersat * 64);
+				else                   char_O_tissue_saturation[ci] = 86;
 				// 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);
+					deco_warnings |= (DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock);
 				// outside warning: supersaturation > baseline threshold + additional 5% margin
-				if( supersat > baseline_threshold + 0.05 )
+				if( supersat > (baseline_threshold + 0.05) )
-					char_O_deco_warnings |= (DECO_WARNING_OUTSIDE  + DECO_WARNING_OUTSIDE_lock );
+					deco_warnings |= (DECO_WARNING_OUTSIDE  + DECO_WARNING_OUTSIDE_lock );
 			}
-		}
+			else
+			{
+				// supersaturation is defined as zero while tissue pressure <= ambient pressure
+				supersat                     = 0.0;
+				char_O_tissue_saturation[ci] = 0;
+			}
+			// next only when in surface mode
+			if( surface_mode )
+			{
+				// tag tissue whether it is beyond the M-line limit or not
+				if( supersat > 1.0 )
+				{
+					char_O_tissue_pres_N2[ci]  |=  128;
+#ifdef _helium
+					char_O_tissue_pres_He[ci]  |=  128;
+#endif
+					char_O_tissue_pressure[ci] |=  128;
+				}
+				else
+				{
+					char_O_tissue_pres_N2[ci]  &= ~128;
+#ifdef _helium
+					char_O_tissue_pres_He[ci]  &= ~128;
+#endif
+					char_O_tissue_pressure[ci] &= ~128;
+				}
+			}
+		} // real tissues
 		// calculate the minimum ambient pressure that the tissue can withstand
 		if( char_I_deco_model == 0 )
 		{
 			// straight Buhlmann
-			pres_min = (pres_tissue - var_N2_a) * var_N2_b;
+			pres_respiration_min_tissue = (pres_tissue - var_a) * var_b;
 		}
 		else
 		{
 			// Buhlmann with Eric Baker's varying gradient factor correction
 			// note: this equation [1] is the inverse of equation [2]
-			pres_min =   ( pres_tissue        - (var_N2_a     * GF_parameter) )
+			pres_respiration_min_tissue =   ( pres_tissue        - (var_a        * GF_parameter) )
-			           / ( 1.0 - GF_parameter + (GF_parameter / var_N2_b      ) );
+			                              / ( 1.0 - GF_parameter + (GF_parameter / var_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 )
+		if( pres_respiration_min_tissue > pres_respiration_min_total )
 		{
-			lead_tissue_limit = pres_min;
+			pres_respiration_min_total = pres_respiration_min_tissue;
-			lead_number       = ci;
+			lead_tissue                = ci;
 		}
 	} // for
 	// compute ceiling for the real tissues in bar relative pressure
-	ceiling = lead_tissue_limit - pres_surface;
+	ceiling = pres_respiration_min_total - pres_surface;
+#ifdef _helium
-	// next in real tissue context only
+	// IBCD is checked for real tissues only
-	if( tissue_increment & TISSUE_FLAG )
+	if( tissue_increment & TISSUE_SELECTOR )
 	{
 		// check if the leading tissue is in IBCD condition
-		if(    (IBCD_tissue_vector & (1 << lead_number))
+		if(    (IBCD_tissue_vector & (1 << lead_tissue))
-		    && ((pres_tissue_N2[lead_number] + pres_tissue_He[lead_number]) > real_pres_respiration) )
+		    && ((real_pres_tissue_N2[lead_tissue] + real_pres_tissue_He[lead_tissue]) > real_pres_respiration) )
 		{
-			// leading tissue is in IBCD condition and in super-saturation, so issue a warning
+			// 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);
+			deco_warnings |= (DECO_WARNING_IBCD + DECO_WARNING_IBCD_lock);
 		}
 	}
-}
+#endif
-//////////////////////////////////////////////////////////////////////////////
-// calc_NDL_time
+}
-//
-// calculation of the remaining bottom time (NDL: no decompression limit)
+//////////////////////////////////////////////////////////////////////////////
+// calc_NDL_time_tissue
+//
+// calculation of the remaining no decompression limit (NDL) time for a tissue
 //
 // 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.
+//       invert. So we have to solve the problem with a search approach.
 //
-// Input:  ppN2
+// Input:    NDL_tissue       tissue for which to calculate remaining NDL time
-//         ppHe
+//           GF_high          gradient factor used when GF factors are enabled
-//
+//           ppN2, ppHe       partial pressures of N2 and He breathed
-// Output: NDL_time
+//
-//
+// Modified: NDL_time         shortest NDL time found so far
-static void calc_NDL_time(void)
+//           NDL_tissue_lead  leading tissue, i.e. tissue with the shortest NDL
-{
+//
-	overlay unsigned char new_NDL_lead_tissue = 0;
+static void calc_NDL_time_tissue(void)
-	overlay unsigned char i;
+{
+	overlay unsigned char NDL_time_tissue	=  0;	// NDL time of this tissue, starting with  0 minutes
+	overlay unsigned char step_size			= 10;	// step size in searching,  starting with 10 minutes
-	// initialize NDL_time to 240 minutes
+	overlay float         pres_limit;				// max. tissue pressure allowed
-	NDL_time = 240;
+#ifdef _helium
-	for( i = 0; i < NUM_COMP; i++ )
+	overlay float         last_pres_tissue_N2;		// last tissue pressure for N2
-	{
+	overlay float         last_pres_tissue_He;		// last tissue pressure for He
-		overlay unsigned char period		= 10;		// start with iterations of 10 minutes
+#else
-		overlay unsigned char NDL_tissue;				// loop variable
+	overlay float         last_pres_tissue;			// last tissue pressure
-		overlay float         GF_factor;				// gradient factor to be applied
+#endif
-		overlay float         next_pres_tissue;			// auxiliary variable to cache a calculation result
+	// set the compartment index ci for reading the Buhlmann increments and coefficients
-		// select gradient factor to use
+	ci = NDL_tissue;
-		GF_factor = (char_I_deco_model != 0) ? GF_high : 1.0;
+	// read the tissue increments for a step size of 10 minutes
-		// the fastest way to find out if already being beyond NDL is to start with
+	read_Buhlmann_times(2);
-		// 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);
+	// read Buhlmann a and b coefficients for tissue ci
+	read_Buhlmann_coefficients();
-		// wrap around after the 16th tissue
-		if( ci >= NUM_COMP ) ci -= NUM_COMP;
+#ifdef _helium
-		// read the loading factors for 10 minute iterations
+	// get the current simulated tissue pressures
-		read_Buhlmann_times(2);
+	calc_pres_tissue_N2 = last_pres_tissue_N2 = sim_pres_tissue_N2[ci];
+	calc_pres_tissue_He = last_pres_tissue_He = sim_pres_tissue_He[ci];
-		// get the tissue pressures for N2 and He
-		calc_pres_tissue_N2 = sim_pres_tissue_N2[ci];
+#else
-		calc_pres_tissue_He = sim_pres_tissue_He[ci];
+	// get the current simulated tissue pressure
-		// calculate the total pressure tissue
+	pres_tissue = last_pres_tissue = sim_pres_tissue_N2[ci];
+	// set the a and b coefficients
+	adopt_Buhlmann_coefficients();
+#endif
+	// simulate an increasing bottom time and check when the NDL is hit
+	for(;;)
+	{
+#ifdef _helium
+		// calculate the total tissue pressure
 		pres_tissue = calc_pres_tissue_N2 + calc_pres_tissue_He;
-		// Simulate an increasing bottom time and check when we hit the NDL.
+		// adopt a and b coefficients to current N2/He ratio inside the tissue
-		// It is not needed to simulate for longer than the already found NDL.
+		adopt_Buhlmann_coefficients();
-		for( NDL_tissue = 0; NDL_tissue < NDL_time; )
-		{
+#endif
-			overlay float pres_limit;
-			overlay float delta_pres_tissue_N2;
+		// compute the maximum tissue pressure allowed to be exposed to an
-			overlay float delta_pres_tissue_He;
+		// ambient pressure equaling the surface pressure
+		if( char_I_deco_model != 0 )
+		{
-			// read Buhlmann a and b coefficients for tissue ci, they need to be re-read on each
+			// GF model enabled, this equation [2] is the inverse of equation [1]
-			// iteration because adopt_Buhlmann_coefficients() twiddles with the N2 coefficients
+			pres_limit = (1.0 - GF_high + GF_high / var_b) * pres_surface + GF_high * var_a;
-			read_Buhlmann_coefficients();
+		}
+		else
-			// adopt a and b coefficients to current N2/He ratio inside the tissue
+		{
-			adopt_Buhlmann_coefficients();
+			// straight Buhlmann
+			pres_limit = pres_surface / var_b + var_a;
-			// 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;
+		// is the tissue pressure higher than the maximum tissue pressure allowed?
+		if( pres_tissue > pres_limit)
-			// check if this tissue is already beyond the NDL
+		{
-			if( pres_tissue > pres_limit)
+			// YES - tissue is outside NDL
+			// was the tissue outside NDL right from the start?
+			if( NDL_time_tissue == 0 )
 			{
-				// beyond NDL - finish the outer loop, ...
+				// YES - search can be aborted
-				i = NUM_COMP;
+				// at least one tissue is outside NDL, so overall NDL time is zero
-				// ... and finish the inner loop
+				NDL_time = 0;
+				// store the number of this tissue as being the leading one
+				NDL_tissue_lead = NDL_tissue;
+				// done
 				break;
 			}
-			// compute tissue pressure deltas for 10 or 1 minute of time ahead
+			// when code execution passes here, the tissue has become
-			delta_pres_tissue_N2 = (ppN2 - calc_pres_tissue_N2) * var_N2_e;
+			// being outside NDL after doing one or more search steps
-			delta_pres_tissue_He = (ppHe - calc_pres_tissue_He) * var_He_e;
+			// still searching with a step size of 10 minutes?
-			// apply safety factors to the pressure deltas
+			if( step_size == 10 )
-			// 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
+				// YES - retry with smaller step size
-				calc_pres_tissue_N2 += delta_pres_tissue_N2;
-				calc_pres_tissue_He += delta_pres_tissue_He;
+				// go back to last NDL time
+				NDL_time_tissue -= 10;
-				// update the overall tissue pressure
-				pres_tissue = next_pres_tissue;
+#ifdef _helium
-				// increment the NDL
+				// go back to last pressures
-				NDL_tissue += period;
+				calc_pres_tissue_N2 = last_pres_tissue_N2;
+				calc_pres_tissue_He = last_pres_tissue_He;
-				// do next iteration
+#else
+				// go back to last pressure
+				pres_tissue = last_pres_tissue;
+#endif
+				// reduce step size to 1 minute
+				step_size = 1;
+				// read the tissue increments for a step size of 1 minute
+				read_Buhlmann_times(1);
+				// redo search from last pressure & time within NDL with smaller step size
 				continue;
 			}
+			else
-			// 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
+				// NO - already tried with a step size of 1 minute
-				period = 1;
+				// go back to last NDL time that was within NDL
-				// read the loading factors for 1 minute periods
+				NDL_time_tissue -= 1;
-				read_Buhlmann_times(1);
+				// is the NDL time of this tissue shorter than the overall NDL time found so far?
-				// do next iteration
+				if( NDL_time_tissue < NDL_time )
-				continue;
+				{
+					// YES - set this tissue's NDL time as the new overall NDL time
+					NDL_time = NDL_time_tissue;
+					//     - store the number of this tissue as being the leading one
+					NDL_tissue_lead = NDL_tissue;
+				}
+				// done
+				break;
 			}
+		}
-			// less than a full minute of NDL time left, so finish the inner loop
+		else
-			break;
+		{
+			// NO - tissue is still within NDL
-		} // inner for-loop simulating increasing bottom time
+			// The search can be terminated when the NDL time of this tissue
-		// is the current NDL shorter than the shortest so far?
+			// exceeds the overall NDL time, thus when a shorter NDL time has
-		if ( NDL_tissue < NDL_time )
+			// already been found with another tissue.
-		{
+			if( NDL_time_tissue >= NDL_time ) break;
-			// keep the current's tissue NDL as the new shortest NDL
-			NDL_time = NDL_tissue;
+#ifdef _helium
-			// store the causing tissue
+			// back-up current tissue pressures
-			new_NDL_lead_tissue = ci;
+			last_pres_tissue_N2 = calc_pres_tissue_N2;
-		}
+			last_pres_tissue_He = calc_pres_tissue_He;
-		// If NDL is > 0 the outer loop will continues with the next tissue.
+#else
-		// If NDL found to be overrun, outer loop will be terminated by means of the i = NUM_COMP statement.
+			// back-up current tissue pressure
-	} // outer for-loop iterating over all tissues
+			last_pres_tissue    = pres_tissue;
-	// store the NDL dominating tissue for to start with in the next NDL calculation
+#endif
-	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;
+			// step forward NDL time of current tissue
+			NDL_time_tissue += step_size;
+#ifdef _helium
+			// step forward tissue pressure - N2
+			temp_tissue          = (ppN2 - calc_pres_tissue_N2) * var_N2_e;		// pressure delta breathed - tissue
+			apply_saturation_factors();											// apply safety factor
+			calc_pres_tissue_N2 += temp_tissue;									// add pressure delta to tissue
+			// step forward tissue pressure - He
+			temp_tissue          = (ppHe - calc_pres_tissue_He) * var_He_e;		// pressure delta breathed - tissue
+			apply_saturation_factors();											// apply safety factor
+			calc_pres_tissue_He += temp_tissue;									// add pressure delta to tissue
+#else
+			// step forward tissue pressure
+			temp_tissue          = (ppN2 - pres_tissue        ) * var_N2_e;		// pressure delta breathed - tissue
+			apply_saturation_factors();											// apply safety factor
+			pres_tissue         += temp_tissue;									// add pressure delta to tissue
+#endif
+		}
+	}
 }
 //////////////////////////////////////////////////////////////////////////////
 // calc_ascenttime
 //
-// Sum up ascent from bottom to surface at float_ascent_speed, slowing down to
+// Sum up ascent from bottom to surface at char_I_ascent_speed, slowing down
-// 1 minute per meter for the final ascent when in deco, and all stop times.
+// 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
+//         char_depth_bottom
 //         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
+		// YES - stops / in deco
 		// check if already at last stop depth or shallower
-		if( char_bottom_depth <= char_I_depth_last_deco)
+		if( char_depth_bottom <= char_I_depth_last_deco)
 		{
-			// YES
+			// YES - final ascent part only
-			ascent = 0;
+			ascent_time = char_depth_bottom;
-			final  = char_bottom_depth;
 		}
 		else
 		{
-			// NO
+			// NO  - ascent part from bottom to last stop
-			ascent = char_bottom_depth - char_I_depth_last_deco;
+			ascent_time = (char_depth_bottom - char_I_depth_last_deco) / char_I_ascent_speed + 1;
-			final  = char_I_depth_last_deco;
-		}
+			//     - ascent part from last stop to surface at 1 meter per minute
+			ascent_time += char_I_depth_last_deco;
+		}
+		// add all stop times
+		for( i=0; i < NUM_STOPS && internal_deco_depth[i]; i++ )
+			ascent_time += internal_deco_time[i];
+		// 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( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) ascent_time |= INT_FLAG_INVALID;
 	}
 	else
 	{
-		// no stops / within NDL
+		// NO - no stops / within NDL
-		ascent = char_bottom_depth;
+		ascent_time = char_depth_bottom / char_I_ascent_speed + 1;
-		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
 //
+// Modified: internal_deco_time[]    stop durations
+//           internal_deco_depth[]   stop depths
+//           internal_deco_gas[]     gases used at stops
 //
 static void clear_deco_table(void)
 {
-	overlay unsigned char x;
+	for( i = 0; i < NUM_STOPS; ++i )
+	{
-	for( x = 0; x < NUM_STOPS; ++x )
+		internal_deco_time [i] = 0;
-	{
+		internal_deco_depth[i] = 0;
-		internal_deco_time [x] = 0;
+		internal_deco_gas[i]   = 0;
-		internal_deco_depth[x] = 0;
-		internal_deco_gas[x]   = 0;
 	}
 	// clear stop table overflow warning
-	char_O_deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW;
+	deco_warnings &= ~DECO_WARNING_STOPTABLE_OVERFLOW;
 }
 //////////////////////////////////////////////////////////////////////////////
 // update_deco_table
 //
-// Add time to a stop at sim_depth_limit
+// Add time to a stop at char_depth_sim
 //
 // 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
+// Input:   char_depth_sim         stop's depth, in meters
-//          sim_gas_current       : gas used at stop, as index 1..5 or 0 for gas 6
+//          sim_gas_current_num    gas used at stop, as index 1..5 or 0 for gas 6
-//          time_increment        : number of minutes to add to the stop
+//          time_increment         number of minutes to add to the stop
 //
-// Updated: internal_deco_depth[] : depth    (in meters)  of each stop
+// Updated: internal_deco_depth[]  depth    (in meters)  of each stop
-//          internal_deco_time [] : time     (in minutes) of each stop
+//          internal_deco_time []  time     (in minutes) of each stop
-//          internal_deco_gas  [] : gas used (index 1-5)  at 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
+	assert( char_depth_sim > 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]) )
+		if( internal_deco_depth[x] && (char_depth_sim > internal_deco_depth[x]) )
-			sim_depth_limit = internal_deco_depth[x];
+			char_depth_sim = internal_deco_depth[x];
 		// Is there already a stop entry for our current depth?
-		if( internal_deco_depth[x] == sim_depth_limit )
+		if( internal_deco_depth[x] == char_depth_sim )
 		{
 			// 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) )
 			{
 		// 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_depth[x] = char_depth_sim;		// ... depth, and
-			internal_deco_gas[x]   = sim_gas_current;		// ... gas
+			internal_deco_gas[x]   = sim_gas_current_num;	// ... 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;
+	deco_warnings |= DECO_WARNING_STOPTABLE_OVERFLOW;
 	// return with status 'failed'.
 	return 0;
 }
 //////////////////////////////////////////////////////////////////////////////
-// calc_desaturation_time
+// calc_desaturation_time_helper
 //
 // Helper function
 //
+// Input:  pres_actual      current tissue pressure
+//         pres_target      target  tissue pressure
+//         var_ht           half-time of the tissue
+//         desat_factor     desaturation factor
+//
+// Output: int_time         time needed by tissue to reach target pressure
+//
 static void calc_desaturation_time_helper(void)
 {
-	if( pres_actual > pres_target )		// check if actual pressure is higher then target pressure
+	// check if actual pressure is higher then target pressure
-	{									// YES - compute remaining time
+	if( pres_actual > pres_target )
+	{
+		// YES - compute remaining time
 		overlay float pres_ratio;
+		// compute pressure ratio to archive
 		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 );
+		int_time = (unsigned short)( (var_ht * log(pres_ratio) / desat_factor) + 0.9 );
 	}
 	else
-	{									// NO  - desaturation state reached, no remaining time
+	{
+		// NO  - desaturation state reached, no remaining time
 		int_time = 0;
 	}
 }
 /////////////////////////////////////////////////////////////////////////////
 // calc_desaturation_time
 //
-// Inputs:  int_I_pres_surface, ppWater, char_I_desaturation_multiplier
+// Calculates the time needed for the tissues to equilibrate with
-// Outputs: int_O_desaturation_time, int_O_nofly_time
+// surface pressure and the no-fly / no-altitude time.
 //
-// Calculate the time needed for the tissues to equilibrate with surface pressure
+// Input:   int_I_pres_surface
+//          char_I_desaturation_multiplier
+//
+// Output:  int_O_desaturation_time
+//          int_O_nofly_time
 //
 void calc_desaturation_time(void)
 {
+	overlay float P_ambient_altitude;
 	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)
+	// safeguard and convert surface pressure
-	if( int_I_pres_surface < 500) int_I_pres_surface = 500;
+	if( int_I_pres_surface < 500) pres_surface = 0.5;
+	else                          pres_surface = 0.001 * int_I_pres_surface;
-	// fraction of inert gases in respired air
-	real_N2_ratio  = 0.7902;
+	// calculate partial pressure of N2 in respired air at surface pressure
-	real_He_ratio  = 0.0;
+	calc_N2_equilibrium();
-	// surface pressure in bar
+	// get, safeguard and convert the saturation and desaturation factors
-	pres_surface   = 0.001    * int_I_pres_surface;
+	get_saturation_factors();
-	// partial pressure of N2 in respired air
+	// pre-computed term for later use: 10 [Min] * 0.6931 [=log(2)] * 1 [Desat Factor] * ...
-	N2_equilibrium = real_N2_ratio * (pres_surface - ppWater);
+	desat_factor = (6.931 * SURFACE_DESAT_FACTOR) * float_desaturation_multiplier;
-	// 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;
+	// 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;
+	}
+	// loop over all compartments in order slowest to fastest
 	for( ci = NUM_COMP; ci > 0; )
 	{
-		overlay float        pres_tissue_max;
+		overlay float          pres_tissue_max;
-		overlay float        P_ambient_altitude;
+		overlay unsigned short nofly_last = ~0;
-		overlay signed char  search_direction;
+		overlay unsigned short nofly_N2   =  0;
-		overlay unsigned int nofly_N2   =  0;
-		overlay unsigned int nofly_He   =  0;
+#ifdef _helium
-		overlay unsigned int nofly_last = ~0;
+		overlay signed char    search_direction;
+		overlay unsigned short nofly_He   =  0;
+#endif
+		// decrement compartment index
 		ci -= 1;
+		// get the Buhlmann halftimes and coefficients
 		read_Buhlmann_ht();
 		read_Buhlmann_coefficients();
-		// get selected target altitude
-		switch( char_I_altitude_wait )
+		//
-		{
+		// Desaturation time
-			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;
+		// calculate desaturation time for N2 in tissue,
-			default: P_ambient_altitude = P_ambient_fly;	break;
+		// desaturated state is defined as residual tissue pressure <= 1.05 x ppN2 respired
-		}
+		// current tissue pressure above equilibrium pressure
+		pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium;
+		// target pressure above equilibrium pressure
+		pres_target = 0.05 * N2_equilibrium;
+		// half-time of the current tissue
+		var_ht = var_N2_ht;
+		// calculate desaturation time
+		calc_desaturation_time_helper();
+		// store desaturation time if it is longer than longest found so far
+		if( int_time > int_O_desaturation_time) int_O_desaturation_time = int_time;
+#ifdef _helium
+		// calculate desaturation time for He in the tissue,
+		// desaturated state is defined as residual tissue pressure <= 0.05 x ppN2 respired
+		// actual tissue pressure above equilibrium: equilibrium for He is 0 bar
+		pres_actual = real_pres_tissue_He[ci];
+		// target pressure above equilibrium pressure: use same target pressure as for N2
+		pres_target = 0.05 * N2_equilibrium;
+		// half-time of the current tissue
+		var_ht      = var_He_ht;
+		// calculate desaturation time
+		calc_desaturation_time_helper();
+		// store desaturation time if it is longer than longest found so far
+		if( int_time > int_O_desaturation_time) int_O_desaturation_time = int_time;
+#endif
+		//
+		// no-fly time
+		//
 		// 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
+		// adjust target pressure by GF-high in case the GF model is in use, but not
-		if( char_I_deco_model != 0 )
+		// for the no-fly time as it's target pressure is hard to reach anyhow
-			pres_tissue_max = P_ambient_altitude +
+		if( char_I_deco_model && char_I_altitude_wait )
-			                  0.01 * char_I_GF_High_percentage * (pres_tissue_max - P_ambient_altitude);
+		    pres_tissue_max = P_ambient_altitude +
+		                      0.01 * char_I_GF_High_percentage * (pres_tissue_max - P_ambient_altitude);
-		//
-		// Desaturation time
+#ifdef _helium
-		//
+		//---- Variant with Helium -------------------------------------------
-		// N2: actual amount of tissue pressure above equilibrium.
-		pres_actual = pres_tissue_N2[ci] - N2_equilibrium;
+		// initialize split_N2_He in case there was a hard reboot / memory clear
-		// 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.
+			// current tissue pressure above equilibrium
+			pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium;
+			// target pressure above equilibrium pressure, weighted by N2/He split
 			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
+			// half-time of the current tissue
+			var_ht = var_N2_ht;
+			// check if desaturation to target pressure is possible at all
+			if( pres_target < 0.0 )
 			{
-				int_O_nofly_time = 288;					// NO  - set no-fly time to 288 * 10 min = 48 h
+				// NO  - set no-fly time to 288 * 10 min = 48 h
-				break;									// done for this compartment
+				int_O_nofly_time = 288;
+				break;
 			}
 			else
 			{
+				// YES - calculate desaturation time
 				calc_desaturation_time_helper();
+				// store time found
 				nofly_N2 = int_time;
 			}
-			// He: actual amount of tissue pressure above equilibrium - equilibrium for He is 0 bar.
+			// calculate no-fly time for He in the tissue,
-			pres_actual = pres_tissue_He[ci];
+			// flying is permitted when the He pressure fits into the assigned fraction
-			// He: half-time of the current tissue
+			// current tissue pressure above equilibrium: equilibrium for He is 0 bar
+			pres_actual = real_pres_tissue_He[ci];
+			// target pressure above equilibrium pressure, weighted by N2/He split
+			pres_target = ((100 - split_N2_He[ci]) * 0.01) * (pres_tissue_max - N2_equilibrium);
+			// half-time of the current tissue
 			var_ht      = var_He_ht;
-			// Calculate no-fly time for He in the tissue.
+			// calculate desaturation time
-			// 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();
+			// store time found
 			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,
+			// limit. The optimum split between the two gases can not be computed by a single formula,
 			// 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.
 			{
 				// 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
+					// 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.
+					// 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;
+					// done
 					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
+				// increase the N2 fraction of the split
 				split_N2_He[ci]  +=  1;
+				// set search direction towards more N2
 				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
+					// 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.
+					// 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;
+					// done
 					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
+				// decrease the N2 fraction of the split
 				split_N2_He[ci]  -=  1;
+				// set search direction towards less N2
 				search_direction  = -1;
 			}
 		} // for(;;)
+#else
+		//---- Variant without Helium ----------------------------------------
+		// current tissue pressure above equilibrium
+		pres_actual = real_pres_tissue_N2[ci] - N2_equilibrium;
+		// target pressure above equilibrium pressure
+		pres_target = pres_tissue_max - N2_equilibrium;
+		// half-time of the current tissue
+		var_ht = var_N2_ht;
+		// check if desaturation to target pressure is possible at all
+		if( pres_target < 0.0 )
+		{
+			// NO  - set no-fly time to 288 * 10 min = 48 h
+			int_O_nofly_time = 288;
+		}
+		else
+		{
+			// YES - calculate desaturation time
+			calc_desaturation_time_helper();
+			//     - extend desaturation time if this tissue needs
+			//       more time than already found to be needed
+			if( int_time > int_O_nofly_time ) int_O_nofly_time = int_time;
+		}
+#endif
 	} // for(compartments)
-	// Rescale int_O_desaturation_time and int_O_nofly_time to full minutes for display purpose
+	// 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
+	// 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.
+	// 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%.
+	// Clear the micro bubbles 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 )
+	if( int_O_lead_supersat < 100 )
-		char_O_deco_warnings &= ~DECO_WARNING_MBUBBLES;
+		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_warnings &= ~(   DECO_WARNING_IBCD     + DECO_WARNING_IBCD_lock
-	                               + DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock
+	                        + DECO_WARNING_MBUBBLES + DECO_WARNING_MBUBBLES_lock
-	                               + DECO_WARNING_OUTSIDE  + DECO_WARNING_OUTSIDE_lock
+	                        + DECO_WARNING_OUTSIDE  + DECO_WARNING_OUTSIDE_lock
-	                               + DECO_ATTENTION_OUTSIDE                             );
+	                        + 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
+// Input:    int_I_pres_surface     surface pressure in mbar
-//           time_interval      : time interval in minutes, must be limited to 254 at max
+//           time_interval          time interval in minutes, must be limited to 254 at max
 //
-// Modified: tissue pressures   : N2 and He pressures of the tissues
+// Modified: tissue pressures       N2 and He pressures of the tissues
-//           CNS_fraction       : current CNS value
+//           CNS_fraction_real      current real CNS value
-//           ceiling            : minimum allowed depth in mbar relative pressure
+//           ceiling                minimum allowed depth in mbar relative pressure
-//           lead_supersat      : supersaturation of the leading tissue
+//           lead_supersat          supersaturation of the leading tissue (float)
-//           int_O_gradient_factor : current GF factor
+//           int_O_lead_supersat    supersaturation of the leading tissue (integer)
 //
 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)
+	// safeguard and convert surface pressure
-	if( int_I_pres_surface < 500) int_I_pres_surface = 500;		// min. surface pressure = 500 mbar
+	if( int_I_pres_surface < 500) pres_surface = 0.500;
+	else                          pres_surface = 0.001 * int_I_pres_surface;
-	// setup input data for deco routines
-	real_pres_respiration = pres_surface = 0.001 * int_I_pres_surface;
+	// set breathed pressure to surface pressure
+	real_pres_respiration = pres_surface;
-	real_N2_ratio  = 0.7902;											// according to Buhlmann
-	N2_equilibrium = real_N2_ratio * (pres_surface          - ppWater);	// used for N2 tissue graphics scaling
+	// calculate partial pressure of N2 in respired air at surface pressure
-	ppN2           = real_N2_ratio * (real_pres_respiration - ppWater);
+	calc_N2_equilibrium();
-	ppHe           = 0.0;
+	// calculate partial pressures (0.7902 is fraction of N2 in atmosphere as of Buhlmann)
-	float_desaturation_multiplier = 0.01 * char_I_desaturation_multiplier * SURFACE_DESAT_FACTOR;
+	ppN2 = N2_equilibrium;
-	float_saturation_multiplier   = 0.01 * char_I_saturation_multiplier;
+	ppHe = 0.0;
+	// get, safeguard and convert the saturation and desaturation factors
+	get_saturation_factors();
+	// adjust desaturation factor to surface mode
+	float_desaturation_multiplier *= SURFACE_DESAT_FACTOR;
 	// Calculate the tissues:
 	// Because calc_tissues() can calculate for 127 minutes at max,
 	// the tissue updating may need to be done in two chunks.
 	// 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;
+		tissue_increment = TISSUE_SELECTOR | 127;
 		calc_tissues();
-		// determine the remaining part
+		// determine the remaining time
 		time -= 127;
 	}
-	// program the remaining part (or full part if not exceeding 127 minutes)
+	// program the remaining time (or full time if not exceeding 127 minutes) on the real tissues
-	tissue_increment = TISSUE_FLAG | time;
+	tissue_increment = TISSUE_SELECTOR | time;
 	// update the N2 and He pressures in the tissues
 	calc_tissues();
 	while( time )
 	{
 		if( time > 9 )
 		{
-			CNS_fraction *= 0.925874712;	// Half-time = 90min -> 10 min: (1/2)^(1/9)
+			CNS_fraction_real *= 0.925874712;	// half-time = 90 min -> 10 min: (1/2)^(1/9)
-			time         -= 10;				// fast speed looping
+			time              -= 10;			// fast speed looping
 		}
 		else
 		{
-			CNS_fraction *= 0.992327946;	// Half-time = 90min ->  1 min: (1/2)^(1/90)
+			CNS_fraction_real *= 0.992327946;	// half-time = 90 min ->  1 min: (1/2)^(1/90)
-			time         -= 1;				// slow speed looping
+			time              -= 1;				// slow speed looping
 		}
 	}
-	// compute integer copy of CNS value
+	// convert the CNS value to integer
-	convert_CNS_for_display();
+	convert_cur_CNS_for_display();
-	// calculate GF value (for a GF high of 100%)
+	// calculate the supersaturation of the leading tissue, the
-	calc_limit(1.0);
+	// negative argument puts calc_limit() into surface mode
+	// Attention: do not pass char_I_GF_High_percentage as an argument
-	// compute integer copy of GF value
+	//            here because it is not configured outside dive mode
-	convert_GF_for_display();
+	calc_limit(-1.0);
+	// convert the saturation value of the leading tissue to integer
+	convert_sat_for_display();
 }
 //////////////////////////////////////////////////////////////////////////////
 // calc_CNS
 //
-// Input:    char_ppO2        : current ppO2 [decibars]
+// Input:    char_ppO2          current ppO2 [in 0.1 bars]
-//           tissue_increment : time increment and tissue selector
+//           tissue_increment   time increment and tissue selector
 //
-// Modified:     CNS_fraction   accumulated CNS (real      tissue context)
+// Modified: CNS_fraction_real  accumulated CNS (real      tissue context)
-//           sim_CNS_fraction : accumulated CNS (simulated tissue context)
+//           CNS_fraction_sim   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 );
+	// calculate CNS increment for 2 seconds interval
+	if( char_ppO2 > 160 )
-	// 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;
+		// step-wise CNS increment
-	else                               time_factor =                                          1.0;
+		// calculate index for increment look-up
-	//------------------------------------------------------------------------
+		cns_i = (char_ppO2 - 161) / 5;	// integer division
-	// No CNS increase below 0.5 bar ppO2
-	     if (char_ppO2 <  50) CNS_fraction_inc = 0.0;
+		// read coefficient (increment)
-	//------------------------------------------------------------------------
+		read_CNS_c_coefficient();
-	// Below (and including) 1.60 bar
-	else if (char_ppO2 <  61) CNS_fraction_inc = time_factor/(-533.07 * char_ppO2 + 54000.0);
+		// re-scale coefficient from storage format in [1/100000] to productive value
-	else if (char_ppO2 <  71) CNS_fraction_inc = time_factor/(-444.22 * char_ppO2 + 48600.0);
+		CNS_fraction_inc = (float)var_cns_c / 100000.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 > 50 )
-	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);
+		// range wise CNS increment approximation
-	else if (char_ppO2 < 167) CNS_fraction_inc = time_factor/(-222.11 * char_ppO2 + 37350.0);
-	//------------------------------------------------------------------------
+		// calculate index for approximation coefficients look-up
-	// Arieli et all.(2002): Modeling pulmonary and CNS O2 toxicity:
+		cns_i = (char_ppO2 - 51) / 10;	// integer division
-	// J Appl Physiol 92: 248--256, 2002, doi:10.1152/japplphysiol.00434.2001
-	// Formula (A1) based on value for 1.55 and c=20
+		// read coefficients
-	// example calculation: Sqrt((1.7/1.55)^20)*0.000404
+		read_CNS_ab_coefficient();
-	else if (char_ppO2 < 172) CNS_fraction_inc = time_factor * 0.00102;
-	else if (char_ppO2 < 177) CNS_fraction_inc = time_factor * 0.00136;
+		// calculate the CNS increment
-	else if (char_ppO2 < 182) CNS_fraction_inc = time_factor * 0.00180;
+		CNS_fraction_inc = 1.0 / (var_cns_a * char_ppO2 + var_cns_b );
-	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
-	else if (char_ppO2 < 198) CNS_fraction_inc = time_factor * 0.00401;
+	{	// no increment up to 0.5 bar ppO2
-	else if (char_ppO2 < 203) CNS_fraction_inc = time_factor * 0.00517;
+		CNS_fraction_inc = 0.0;
-	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
+	// apply a time factor in case of minute-based interval (factor = N * 30.0)
+	if( tissue_increment & TIME_MASK )
+	{
+		CNS_fraction_inc *= (float)(tissue_increment & TIME_MASK) * 30.0;
+	}
 	// update the CNS accumulator
-	if( tissue_increment & TISSUE_FLAG )     CNS_fraction += CNS_fraction_inc;	// real tissues
+	if   ( tissue_increment & TISSUE_SELECTOR ) CNS_fraction_real += CNS_fraction_inc;	// real tissues
-	else                                 sim_CNS_fraction += CNS_fraction_inc;	// simulated tissues
+	else                                        CNS_fraction_sim  += CNS_fraction_inc;	// simulated tissues
 }
 //////////////////////////////////////////////////////////////////////////////
-// gas_volumes
+// calc_due_by_depth_time_sac       (Helper Function saving Code Space)
 //
-// calculates volumes and required tank fill pressures for each gas.
+// Calculates the gas volume required for a given depth, time and usage (SAC)
-//
+// rate. It uses a fixed surface pressure of 1.0 bar to deliver stable results
-// Input:	char_bottom_depth		depth of the bottom segment
+// when used through the deco calculator.
-//			char_I_bottom_time		duration of the bottom segment
+//
-//			char_I_extra_time		extra bottom time for fTTS / delayed ascent
+// Input:  gas_needs_float_depth   depth     in meters
-//			float_ascent_speed		ascent speed, in meters/minute
+//         gas_needs_float_time    time      in minutes
-//			internal_deco_depth[]	depth of the stops
+//         gas_needs_stop_usage    gas usage in liters per minute at surface pressure
-//			internal_deco_time[]	duration of the stops
+//
-//			internal_deco_gas[]		gas breathed at the stops
+// Output: gas_needs_volume_due    required gas volume in liters
-//			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
+static void calc_due_by_depth_time_sac(void)
-//			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
+	gas_needs_volume_due = (gas_needs_float_depth * METER_TO_BAR + 1.0) * gas_needs_float_time * gas_needs_stop_usage;
-//			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
+// calc_gas_needs_ascent
-//											  2^14: pres_need >= press_fill * GAS_NEEDS_ATTENTION_THRESHOLD
+//
-//											  2^11: pres_need == 0
+// calculates the gas needs along the ascent
-//											  2^10: pres_need is invalid
+//
-//
+// Input:  char_depth_bottom         depth of the bottom segment
-static void gas_volumes_helper_1(void)
+//         char_I_bottom_time        duration of the bottom segment
-{
+//         char_I_extra_time         extra bottom time for fTTS / delayed ascent
-	// Calculate the gas volume needed at a given depth, time and usage (SAC rate).
+//         float_ascent_speed        ascent speed, in meters/minute
-	// We use 1.0 for the surface pressure to have stable results when used through
+//         internal_deco_depth[]     depth of the stops
-	// the deco calculator (simulation mode).
+//         internal_deco_time[]      duration of the stops
-	volume = (float_depth * METER_TO_BAR + 1.0) * float_time * char_usage;
+//         internal_deco_gas[]       gas breathed at the stops
+//         NDL_time                  remaining NDL time, used to adjust speed of final ascent
-	return;
+//         char_I_SAC_work           gas consumption during bottom part and initial ascent, in liters/minute
-}
+//         char_I_SAC_deco           gas consumption during stops and following ascents, in liters/minute
+//         char_I_gas_avail_size[]   size of the tanks for gas 1-5, in liters
-static void gas_volume_helper_2(void)
+//         char_I_gas_avail_pres[]   fill pressure of the tanks
-{
+//
-	// Convert a gas volume in liters given as a float into an integer number
+// Output: gas_volume_need[]         amount of gas needed, in liters
-	// and computes the equivalent tank pressure in bar, including all flags.
+//
+static void calc_gas_needs_ascent(void)
-	if( volume >= 65534.5 )
+{
-	{
+	switch (gas_needs_next_phase)
-		int_volume    = 65535;
+	{
-		int_pres_need = 999 + INT_FLAG_WARNING; // 999 bar + warning flag for > pres_fill
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_INIT:
+		// set index to the first stop table entry
+		gas_needs_stop_index = 0;
+		// clear the gas volume needs
+		for( i = 0; i < NUM_GAS; ++i ) gas_volume_need[i] = 0.0;
+#ifdef _rx_functions
+		// only for OSTC TR model with TR functions enabled
+		if( main_status & 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
+		// terminate if in loop mode (CCR, pSCR) as there are no gas needs to calculate,
+		// else continue with the gas needs of the bottom segment
+		if   ( deco_status & MODE_LOOP ) gas_needs_next_phase = GAS_NEEDS_DONE;
+		else                             gas_needs_next_phase = GAS_NEEDS_BOTTOM_SEGMENT;
+		break;
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_BOTTOM_SEGMENT:
+		// sim_gas_current_num   gas used during bottom segment (0, 1-5)
+		// char_depth_bottom     depth of the bottom segment
+		// get the gas used during bottom segment
+		gas_find_current();
+		// initialize variables
+		gas_needs_stop_gas_last = gas_needs_stop_gas = sim_gas_current_num;
+		// set the usage (SAC rate) to bottom usage rate for bottom part and initial ascent
+		gas_needs_stop_usage = char_I_SAC_work;
+		// volumes are only calculated for gases 1-5, but not the manually configured one
+		if( gas_needs_stop_gas )
+		{
+			// set the bottom depth
+			gas_needs_float_depth = (float)char_depth_bottom;
+			// calculate either whole bottom time or just the fTTS/bailout extra time
+			gas_needs_float_time = ( main_status & CALCULATE_BOTTOM ) ? (float)char_I_bottom_time : (float)char_I_extra_time;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// take result
+			gas_volume_need[gas_needs_stop_gas-1] = gas_needs_volume_due;
+		}
+		// continue with initial ascent demand
+		gas_needs_next_phase = GAS_NEEDS_INITIAL_ASCENT;
+		break;
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_INITIAL_ASCENT:
+		// gas_needs_stop_gas    : gas from bottom segment
+		// char_depth_bottom     : depth of the bottom segment
+		// internal_deco_depth[0]: depth of the first stop, may be 0 if no stop exists
+		// get the data of the first stop
+		gas_needs_stop_depth = internal_deco_depth[0];
+		gas_needs_stop_time  = internal_deco_time[0];
+		// volumes are only calculated for gases 1-5, but not the manually configured one
+		if( gas_needs_stop_gas )
+		{
+			// compute distance between bottom and first stop
+			gas_needs_float_depth = (float)char_depth_bottom - (float)gas_needs_stop_depth;
+			// initial ascent exists only if ascent distance is > 0
+			if( gas_needs_float_depth > 0.0 )
+			{
+				// compute ascent time
+				gas_needs_float_time = gas_needs_float_depth / float_ascent_speed;
+				// compute average depth between bottom and first stop
+				gas_needs_float_depth = (float)char_depth_bottom - gas_needs_float_depth * 0.5;
+				// calculate gas demand
+				calc_due_by_depth_time_sac();
+				// add to overall demand
+				gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due;
+			}
+		}
+		// switch the usage (SAC rate) to deco usage rate
+		// for stops, intermediate and final ascent
+		gas_needs_stop_usage = char_I_SAC_deco;
+		// is there a (first) stop?
+		if( gas_needs_stop_depth )
+		{
+			// YES - continue with stop demand
+			gas_needs_next_phase = GAS_NEEDS_STOP;
+			break;
+		}
+		else
+		{
+			// NO - add demand of a 3 minutes safety stop at 5 meters, at least for contingency...
+			gas_needs_float_time  = 3.0;
+			gas_needs_float_depth = 5.0;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// add to overall demand
+			gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due;
+			// calculation finished
+			gas_needs_next_phase = GAS_NEEDS_DONE;
+			break;
+		}
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_STOP:
+		// correct stop depth if shallower than calculated stop depth and convert to float
+		gas_needs_float_depth = ( char_depth_bottom < gas_needs_stop_depth ) ? (float)char_depth_bottom : (float)gas_needs_stop_depth;
+		// get the gas on this stop
+		gas_needs_stop_gas = internal_deco_gas[gas_needs_stop_index];
+		// do we have a gas change?
+		if( gas_needs_stop_gas_last && (gas_needs_stop_gas != gas_needs_stop_gas_last) )
+		{
+			// YES - spend an additional char_I_gas_change_time on the old gas
+			gas_needs_float_time = (float)char_I_gas_change_time;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// add to overall demand
+			gas_volume_need[gas_needs_stop_gas_last-1] += gas_needs_volume_due;
+		}
+		// calculate demand of (new) gas for the full stop duration
+		if( gas_needs_stop_gas )
+		{
+			// get the duration of the stop
+			gas_needs_float_time = (float)gas_needs_stop_time;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// add to overall demand
+			gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due;
+		}
+		// Continue with the demand of the intermediate ascent to the next stop.
+		// If there is no further stop, it will divert by itself to final ascent.
+		gas_needs_next_phase = GAS_NEEDS_INTERMEDIATE_ASCENT;
+		break;
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_INTERMEDIATE_ASCENT:
+		// store last stop depth and last gas
+		gas_needs_stop_depth_last = gas_needs_stop_depth;
+		gas_needs_stop_gas_last   = gas_needs_stop_gas;
+		// check if end of stop table is reached
+		if( gas_needs_stop_index < NUM_STOPS-1 )
+		{
+			// NO - check if there is another stop entry
+			if( internal_deco_depth[gas_needs_stop_index+1] == 0 )
+			{
+				// NO - continue with final ascent demand
+				gas_needs_next_phase = GAS_NEEDS_FINAL_ASCENT;
+				break;
+			}
+			else
+			{
+				// YES - goto next stop entry
+				gas_needs_stop_index++;
+				// get the depth of the next stop entry
+				gas_needs_stop_depth = internal_deco_depth[gas_needs_stop_index];
+				// get the duration of the next stop
+				gas_needs_stop_time  = internal_deco_time[gas_needs_stop_index];
+			}
+		}
+		else
+		{
+			// YES - end of stop table reached
+			// We are stranded at some stop depth and do not know how many more
+			// stops there may be in front of us and how long they may be. So as
+			// as last resort to calculate at least something, we assume that the
+			// rest of the ascent will be done in deco final ascent pace, i.e. at
+			// 1 meter per minute. Because of the stop table overflow, the result
+			// will be flagged as being invalid later on.
+			//
+			gas_needs_next_phase = GAS_NEEDS_FINAL_ASCENT;
+			break;
+		}
+		// volumes are only calculated for gases 1-5, but not the manually configured one
+		if( gas_needs_stop_gas_last )
+		{
+			// compute distance between the two stops
+			gas_needs_float_depth = (float)(gas_needs_stop_depth_last - gas_needs_stop_depth);
+			// compute ascent time
+			gas_needs_float_time = gas_needs_float_depth / float_ascent_speed;
+			// compute average depth between the two stops
+			gas_needs_float_depth = (float)gas_needs_stop_depth_last - gas_needs_float_depth * 0.5;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// add to overall demand
+			gas_volume_need[gas_needs_stop_gas_last-1] += gas_needs_volume_due;
+		}
+		// continue with calculation stop demand
+		gas_needs_next_phase = GAS_NEEDS_STOP;
+		break;
+		//---------------------------------------------------------------------
+		case GAS_NEEDS_FINAL_ASCENT:
+		// gas_needs_float_depth: still holds depth of the last stop
+		// gas_needs_stop_gas   : still holds gas from last stop (0 or 1-5)
+		// volumes are only calculated for gases 1-5, but not the manually configured one
+		if( gas_needs_stop_gas )
+		{
+			// set ascent time dependent on deco status
+			if( NDL_time )
+			{
+				// within NDL - ascent with float_ascent_speed
+				//
+				// Remark: When calculating a bailout ascent, there may be stops
+				//         for gas changes although the dive is still within NDL
+				//         and final ascent thus does not need to be slowed down.
+				gas_needs_float_time = gas_needs_float_depth / float_ascent_speed;
+			}
+			else
+			{
+				// in deco - reduce ascent speed to 1 meter per minute
+				gas_needs_float_time = gas_needs_float_depth;
+			}
+			// set half-way depth
+			gas_needs_float_depth *= 0.5;
+			// calculate gas demand
+			calc_due_by_depth_time_sac();
+			// add to overall demand
+			gas_volume_need[gas_needs_stop_gas-1] += gas_needs_volume_due;
+		}
+		// calculation finished
+		gas_needs_next_phase = GAS_NEEDS_DONE;
+		break;
+	} // switch
+}
+//////////////////////////////////////////////////////////////////////////////
+// calc_TR_functions
+//
+// Process Pressure Readings (OSTC TR only)
+//
+// Input:  todo
+//
+// Output: todo
+//
+#ifdef _rx_functions
+static void calc_TR_functions(void)
+{
+	// 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 short 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 diluent 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 diluent 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 short 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 diluent 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 diluent 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_measured   = 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 = (deco_info & DECO_FLAG) ? char_I_SAC_deco : char_I_SAC_work;
+	// char_I_SAC_deco / char_I_SAC_work 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
+		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_gas_avail_size[reading1_gas-1];
+			reading2_tanksize = char_I_gas_avail_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 )
+					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 )
+					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_gas_avail_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_measured = 999 + INT_FLAG_ATTENTION;
+				}
+				else
+				{
+					// convert float to integer
+					int_O_SAC_measured = (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_measured >= max_sac_rate )
+					{
+						int_O_SAC_measured |= INT_FLAG_ATTENTION;
+					}
+				}
+			}
+			else
+			{
+				// pressure drop is out of range, so SAC will be set out of range, too
+				int_O_SAC_measured = 999 + INT_FLAG_ATTENTION;
+			}
+			// copy outdated flag from int_I_pressure_drop to int_O_SAC_measured
+			if( int_I_pressure_drop[reading_index] & INT_FLAG_OUTDATED )
+			{
+				int_O_SAC_measured |= INT_FLAG_OUTDATED;
+			}
+		}
+	}
+}
+#endif
+//////////////////////////////////////////////////////////////////////////////
+// convert_gas_needs_to_press
+//
+// Converts gas volumes into pressures and sets respective flags
+//
+// Input:  gas_needs_gas_index       index of the gas to convert (0-4)
+//         gas_volume_need[]         needed gas volume in liters
+//         char_I_gas_avail_pres[]   available gas volume in bar
+//         char_I_gas_avail_size[]   size of the tanks in liters
+//         char_I_pressure_gas[]     gas configured on reading 1/2 (TR only)
+//
+// Output: int_O_gas_need_vol[]      required gas amount in liters, including flags
+//         int_O_gas_need_pres[]     required gas amount in bar,    including flags
+//         int_O_pressure_need[]     required gas amount for reading 1/2 (TR only)
+//
+static void convert_gas_needs_to_press(void)
+{
+	// just to make the code more readable...
+	i = gas_needs_gas_index;
+	if( gas_volume_need[i] >= 65534.5 )
+	{
+		int_O_gas_need_vol[i]  = 65535;										// clip at 65535 liters
+		int_O_gas_need_pres[i] =   999 | INT_FLAG_WARNING | INT_FLAG_HIGH;	// 999 bar + warning flag + >999 flag
 	}
 	else
 	{
-		overlay unsigned short tank_pres_fill = 10.0 * (unsigned short)char_I_tank_pres_fill[gas_num];
+		overlay unsigned short int_pres_warn;
+		overlay unsigned short int_pres_attn;
-		// No distinct rounding done here because volumes are not accurate to the single liter anyhow
+		// set warning and attention thresholds
-		// convert gas volumes to integers
+		int_pres_warn = 10.0 * (unsigned short)char_I_gas_avail_pres[i];
-		int_volume    = (unsigned short)volume;
+		int_pres_attn = GAS_NEEDS_ATTENTION_THRESHOLD * int_pres_warn;
-		// compute how much pressure in the tank will be needed [in bar]  (integer-division)
+		// convert ascent gas volume need from float to integer [in liter]
-		int_pres_need = (unsigned short)(int_volume / char_I_tank_size[gas_num]);
+		int_O_gas_need_vol[i]  = (unsigned short)gas_volume_need[i];
-		// limit to 999 bar because of display constraints
+		// compute how much pressure in the tank will be needed [in bar]
-		if( int_pres_need > 999 ) int_pres_need = 999;
+		int_O_gas_need_pres[i] = (unsigned short)( gas_volume_need[i] / char_I_gas_avail_size[i] + 0.999 );
-		// set flags for fast evaluation by divemode check_for_warnings
+		// limit result to 999 bar because of display constraints
-		if     ( int_pres_need ==                                              0 ) int_pres_need |= INT_FLAG_ZERO;
+		if( int_O_gas_need_pres[i] > 999 ) int_O_gas_need_pres[i] = 999 | INT_FLAG_HIGH;
-		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;
+		// set flags for fast evaluation by dive mode
-	}
+		if      ( int_O_gas_need_pres[i] ==             0 ) int_O_gas_need_pres[i] |= INT_FLAG_ZERO;
+		else if ( int_O_gas_need_pres[i] >= int_pres_warn ) int_O_gas_need_pres[i] |= INT_FLAG_WARNING;
-	return;
+		else if ( int_O_gas_need_pres[i] >= int_pres_attn ) int_O_gas_need_pres[i] |= INT_FLAG_ATTENTION;
-}
+	}
-static void gas_volumes(void)
+	// set invalid flag if there is an overflow in the stops table
-{
+	if( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_O_gas_need_pres[i] |= INT_FLAG_INVALID;
-	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 )
+	if( main_status & TR_FUNCTIONS )
 	{
-		// invalidate pressure needs to pressure readings
+		// char_I_pressure_gas[] uses gas indexes from 1-10, loop variable i runs from 0 to 4
-		int_O_pressure_need[0] = 0 + INT_FLAG_NOT_AVAIL;
+		overlay unsigned char j = i+1;
-		int_O_pressure_need[1] = 0 + INT_FLAG_NOT_AVAIL;
-	}
+		// check if the current gas is configured on pressure reading 1 or 2
-#endif
+		if( (char_I_pressure_gas[0] == j) || (char_I_pressure_gas[1] == j) )
+		{
-	for( gas_num = 0; gas_num < NUM_GAS; ++gas_num )
+			// get a copy of the required pressure in full bar
-	{
+			overlay unsigned short int_pres_need = int_O_gas_need_pres[i];
-		volume = volumes[gas_num];
+			// strip all flags
-		// compute int_volume and int_pres_need from volume and gas_num
+			int_pres_need &= 1023;
-		gas_volume_helper_2();
+			// limit to 400 bar and multiply by 10 to get required pressure in 0.1 bar
-		// set invalid flag if there is an overflow in the stops table
+			int_pres_need = (int_pres_need > 400) ? 4000 | INT_FLAG_OUT_OF_RANGE : 10 * int_pres_need;
-		if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
-			int_pres_need |= INT_FLAG_INVALID;
+			// tag as not available if there is an overflow in the stops table
+			if( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_pres_need |= INT_FLAG_NOT_AVAIL;
-		// copy result data to ASM interface
-		int_O_ascent_volumes[gas_num]   = int_volume;
+			// copy to reading data (in both readings the same gas could be configured)
-		int_O_ascent_pres_need[gas_num] = int_pres_need;
+			if( char_I_pressure_gas[0] == j ) int_O_pressure_need[0] = int_pres_need;
+			if( char_I_pressure_gas[1] == j ) int_O_pressure_need[1] = int_pres_need;
-#ifdef _rx_functions
+		}
-		// only for OSTC TR model with TR functions enabled
+	} // TR functions
-		if( char_O_main_status & DECO_TR_FUNCTIONS )
+#endif
-		{
+}
-			// 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
+// convert the real CNS value to integer
-			if( (gas == char_I_pressure_gas[0]) || (gas == char_I_pressure_gas[1]) )
+//
-			{
+// Input  CNS_fraction_real     current CNS value as float
-				// strip all flags from int_pres_need
+//
-				int_pres_need &= 1023;
+// Output: int_O_CNS_current    current CNS value as integer including flags
+//
-				// limit to 400 bar and multiply by 10 to get result in 0.1 bar
+static void convert_cur_CNS_for_display(void)
-				int_pres_need = (int_pres_need > 400) ? (4000 | INT_FLAG_OUT_OF_RANGE) : (10 * int_pres_need);
+{
+	// convert to integer
-				// tag as not available if there is an overflow in the stops table
+	float_value = CNS_fraction_real; convert_float_to_int(); int_O_CNS_current = int_value;
-				if( char_O_deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW )
-					int_pres_need |= INT_FLAG_NOT_AVAIL;
+	// set warning & attention flags
+	if      ( int_O_CNS_current    >= CNS_WARNING_THRESHOLD   ) int_O_CNS_current |= INT_FLAG_WARNING;
-				// copy to result vars (in both readings the same gas could be configured)
+	else if ( int_O_CNS_current    >= CNS_ATTENTION_THRESHOLD ) int_O_CNS_current |= INT_FLAG_ATTENTION;
-				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
+// convert the simulated CNS value to integer
+//
-	} // for
+// Input:  CNS_fraction_sim       CNS value after predicted ascent in float
-}
+//
+// Output: int_sim_CNS_fraction   CNS value after predicted ascent in integer
-//////////////////////////////////////////////////////////////////////////////
+//                                including flags, will be routed to
+//                                int_O_{normal,alternative}_CNS_fraction
-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;
+	// convert to integer
-	else if( sim_CNS_fraction >= 9.985 ) int_sim_CNS_fraction = 999 + INT_FLAG_WARNING;
+	float_value = CNS_fraction_sim; convert_float_to_int(); int_sim_CNS_fraction = int_value;
-	else
-	{
+	// set warning & attention flags
-		// convert float to integer
+	if      ( int_sim_CNS_fraction >= CNS_WARNING_THRESHOLD   ) int_sim_CNS_fraction |= INT_FLAG_WARNING;
-		int_sim_CNS_fraction = (unsigned short)(100 * sim_CNS_fraction + 0.5);
+	else if ( int_sim_CNS_fraction >= CNS_ATTENTION_THRESHOLD ) int_sim_CNS_fraction |= INT_FLAG_ATTENTION;
-		// 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;
+	if      ( deco_warnings & DECO_WARNING_STOPTABLE_OVERFLOW ) int_sim_CNS_fraction |= INT_FLAG_INVALID;
 }
-//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
-static void convert_GF_for_display(void)
+// convert the saturation value of the leading tissue to integer
-{
+//
-	// convert supersaturation of the leading tissue to int_O_gradient_factor in % (1.0 = 100%)
+// Input     lead_supersat              saturation of the leading tissue
+//           lead_tissue                number of the     leading tissue
+//           char_I_GF_High_percentage  GF high factor
+//
+// Output:   int_O_lead_supersat        saturation of the leading tissue
+//           char_O_lead_tissue         number of the     leading tissue
+//
+// Modified: deco_warnings              deco engine warnings vector
+//
+static void convert_sat_for_display(void)
+{
+	// convert supersaturation of the leading tissue to int_O_lead_supersat in % (1.0 = 100%)
 	// limit to 255 because of constraints in ghostwriter code
-	     if( lead_supersat <= 0.000 ) int_O_gradient_factor = 0;
+	     if ( lead_supersat <= 0.000 ) int_O_lead_supersat = 0;
-	else if( lead_supersat >  2.545 ) int_O_gradient_factor = 255 + INT_FLAG_WARNING;
+	else if ( lead_supersat >  2.545 ) int_O_lead_supersat = 255;
-	else
+	else                               int_O_lead_supersat = (unsigned short)(100 * lead_supersat + 0.5);
-	{
-		int_O_gradient_factor = (unsigned int)(100 * lead_supersat + 0.5);
+	// set warning & attention flags
+	if( int_O_lead_supersat > 100 )
-		if( char_I_deco_model != 0 )
+	{
-		{
+		int_O_lead_supersat |= INT_FLAG_WARNING;			// make GF factor shown in red
-			// GF factors enabled
+		deco_warnings       |= DECO_WARNING_OUTSIDE;		// make depth     shown in red
-			if     ( int_O_gradient_factor > 99 )
+	}
-			{
+	else if(    (char_I_deco_model != 0) && (int_O_lead_supersat > char_I_GF_High_percentage)
-				int_O_gradient_factor |= INT_FLAG_WARNING;			// make GF factor shown in red
+	         || (char_I_deco_model == 0) && (int_O_lead_supersat > 99                       ) )
-			}
+	{
-			else if( int_O_gradient_factor > char_I_GF_High_percentage )
+		int_O_lead_supersat |= INT_FLAG_ATTENTION;			// make GF factor shown in yellow
-			{
+		deco_warnings       |= DECO_ATTENTION_OUTSIDE;		// make depth     shown in yellow
-				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;
+	char_O_lead_tissue = lead_tissue;
 }
-//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+// convert the ceiling value to integer
+//
+// Input:    ceiling         minimum depth permitted in float
+//
+// Output:   int_O_ceiling   minimum depth permitted in mbar
+//
+// Modified: deco_info       deco engine information vector
+//
 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;
+	if      ( ceiling <=  0.0 ) int_O_ceiling = 0;
-	else if( ceiling >  16.0 ) int_O_ceiling = 16000;
+	else if ( ceiling >  16.0 ) int_O_ceiling = 16000;
-	else                       int_O_ceiling = (short)(ceiling * 1000 + 9);
+	else                        int_O_ceiling = (unsigned short)(ceiling * 1000 + 9);
 	// set/reset ceiling flag
-	if( int_O_ceiling ) char_O_deco_info |=  DECO_CEILING;
+	if      ( int_O_ceiling   ) deco_info |=  DECO_CEILING;
-	else                char_O_deco_info &= ~DECO_CEILING;
+	else                        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!
 //
+// Input/Output: CNS_fraction_real       current real CNS value
+//               char_O_deco_warnings    deco engine warnings vector
+//               real_pres_tissue_N2[]   partial pressure of N2 in real tissues
+//               real_pres_tissue_He[]   partial pressure of He in real tissues
+//
+// Output:       int_O_CNS_current      current CNS value as integer including flags
+//
 static void push_tissues_to_vault(void)
 {
-	overlay unsigned char x;
+	// store the current CNS value and deco warnings
+	vault_CNS_fraction_real = CNS_fraction_real;
-	cns_vault_float      = CNS_fraction;
+	vault_deco_warnings     = char_O_deco_warnings;
-	deco_warnings_vault  = char_O_deco_warnings;
+	vault_deco_info         = char_O_deco_info;
-	for( x = 0; x < NUM_COMP; x++ )
+	// store the tissue pressures
-	{
+	for( i = 0; i < NUM_COMP; i++ )
-		pres_tissue_N2_vault[x] = pres_tissue_N2[x];
+	{
-		pres_tissue_He_vault[x] = pres_tissue_He[x];
+		vault_pres_tissue_N2[i] = real_pres_tissue_N2[i];
+#ifdef _helium
+		vault_pres_tissue_He[i] = real_pres_tissue_He[i];
+#else
+		vault_pres_tissue_He[i] = 0;
+#endif
 	}
 }
 static void pull_tissues_from_vault(void)
 {
-	overlay unsigned char x;
+	// restore the CNS value and deco warnings
+	CNS_fraction_real    = vault_CNS_fraction_real;
-	CNS_fraction         = cns_vault_float;
+	char_O_deco_warnings = vault_deco_warnings;
-	char_O_deco_warnings = deco_warnings_vault;
+	char_O_deco_info     = vault_deco_info;
-	convert_CNS_for_display();
+	// convert the CNS value to integer
+	convert_cur_CNS_for_display();
-	for( x = 0; x < NUM_COMP; x++ )
-	{
+	// restore the tissue pressures
-		pres_tissue_N2[x] = pres_tissue_N2_vault[x];
+	for( i = 0; i < NUM_COMP; i++ )
-		pres_tissue_He[x] = pres_tissue_He_vault[x];
+	{
-	}
+		real_pres_tissue_N2[i] = vault_pres_tissue_N2[i];
-}
+#ifdef _helium
+		real_pres_tissue_He[i] = vault_pres_tissue_He[i];
+#else
+		real_pres_tissue_He[i] = 0;
+#endif
+	}
+}
 //////////////////////////////////////////////////////////////////////////////
 //
 #ifndef CROSS_COMPILE
 void main() {}

Mercurial > public > hwos_code

comparison src/p2_deco.c @ 623:c40025d8e750