diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Defs.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Defs.cs
index 806c1c1d..e0670164 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Defs.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Defs.cs	
@@ -50,6 +50,7 @@ Date         Developer
 2025/06/21   GLS
 2025/07/16   GLS
 2025/11/16   GLS
+2026/01/02   GLS
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra Workbench
@@ -91,6 +92,16 @@ class Defs
 		public const double MPS2FPS = 3.280839895;// meters per seconds to feet per second
 
 
+		public const double LC39A_LAT = 28.6083850;// deg
+		public const double LC39A_LON = -80.6040720;// deg
+
+		public const double LC39B_LAT = 28.6272150;// deg
+		public const double LC39B_LON = -80.6208620;// deg
+
+		public const double SLC6_LAT = 34.5808470;// deg
+		public const double SLC6_LON = -120.6259500;// deg
+
+
 		public const string strKSC = "KSC";
 		public const string strVAFB = "VAFB";
 
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Mission.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Mission.cs
index 2cc24c3a..cccf8fc7 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Mission.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/Mission.cs	
@@ -70,6 +70,7 @@ Date         Developer
 2025/10/02   GLS
 2025/11/16   GLS
 2025/11/24   GLS
+2025/12/30   GLS
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra Workbench
@@ -291,10 +292,11 @@ private void LoadDefault()
 
 
 			MECO_Inc = 51.62;
-			//MECO_LAN = 0;
 			MECO_Alt = 105564;
 			MECO_Vel = 7903.449390;
 			MECO_FPA = 0.708380;
+			EF_PLANE_SW = false;
+			IYD = "0.0 0.0 0.0";
 
 
 
@@ -341,10 +343,11 @@ private void ResetMission()
 
 
 			MECO_Inc = 51.62;
-			//MECO_LAN = 0;
 			MECO_Alt = 105564;
 			MECO_Vel = 7903.449390;
 			MECO_FPA = 0.708380;
+			EF_PLANE_SW = false;
+			IYD = "0.0 0.0 0.0";
 
 
 			T0Year = 2000;
@@ -608,10 +611,19 @@ public void Load_V1( JObject jmf )
 				T0Second = dt.Second + (0.001 * dt.Millisecond);
 			}
 			MECO_Inc = (double)jmf["Legacy Launch Parameters"]["TargetInc"];
-			//MECO_LAN = (double)jmf["Legacy Launch Parameters"]["TargetLAN"];
 			MECO_Alt = (double)jmf["Legacy Launch Parameters"]["MECOAlt"];
 			MECO_Vel = (double)jmf["Legacy Launch Parameters"]["MECOVel"];
 			MECO_FPA = (double)jmf["Legacy Launch Parameters"]["MECOFPA"];
+			JToken jpsw = jmf["Legacy Launch Parameters"]["EF_PLANE_SW"];
+			if (jpsw != null)
+			{
+				EF_PLANE_SW = (bool)jpsw;
+			}
+			JToken jiyd = jmf["Legacy Launch Parameters"]["IYD"];
+			if (jiyd != null)
+			{
+				IYD = (string)jiyd;
+			}
 
 			//////// Xenon Lights ////////
 			XenonLights.Load_V1( jmf["Xenon Lights"] );
@@ -765,10 +777,11 @@ public JObject Save_V1()
 			DateTime dt = new DateTime( T0Year, T0Month, T0Day, T0Hour, T0Minute, (int)T0Second, ms );
 			joldlaunchparams["T0"] = dt.ToOADate() + 15018.0;
 			joldlaunchparams["TargetInc"] = MECO_Inc;
-			//joldlaunchparams["TargetLAN"] = MECO_LAN;
 			joldlaunchparams["MECOAlt"] = MECO_Alt;
 			joldlaunchparams["MECOVel"] = MECO_Vel;
 			joldlaunchparams["MECOFPA"] = MECO_FPA;
+			joldlaunchparams["EF_PLANE_SW"] = EF_PLANE_SW;
+			joldlaunchparams["IYD"] = IYD;
 			jroot["Legacy Launch Parameters"] = joldlaunchparams;
 
 			//////// Xenon Lights ////////
@@ -1751,6 +1764,16 @@ public bool Test( ref string str )
 		/// </summary>
 		public double MECO_FPA { get; set; }
 
+		/// <summary>
+		/// Earth–fixed plane switch
+		/// </summary>
+		public bool EF_PLANE_SW { get; set; }
+
+		/// <summary>
+		/// IYD
+		/// </summary>
+		public string IYD { get; set; }
+
 
 
 
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/OrbitTgtCalc.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/OrbitTgtCalc.cs
index 4602e9bf..8c8fa276 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/OrbitTgtCalc.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/OrbitTgtCalc.cs	
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace SSVMissionEditor
 {
@@ -18,6 +18,11 @@ class OrbitTgtCalcOptions
         public double H_OMS2;      //Height above equator of OMS-2 target (can be apogee or perigee after OMS-2 burn), nautical miles
         public double Inclination; //Inclination, radians
         public bool InsertionMode; //true = direct, false = standard insertion
+        public bool CalcIY;// flag to enable EF IY vector calculation
+        public double Pad_Latitude;// Latitude of launch pad [degrees]
+        public double Pad_Longitude;// Longitude of launch pad [degrees]
+        public double Inc_Max;// Maximum inclination allowed before "dog-leg" [degrees]
+        public double Inc_Min;// Minimum inclination allowed before "dog-leg" [degrees]
     }
 
     class OrbitTgtCalcOutput
@@ -27,6 +32,9 @@ class OrbitTgtCalcOutput
         public double TGTMECOvel; // Velocity for MECO, m/s
         public double TGTMECOfpa; //Flight path angle for MECO, degrees
         public double TGTMECOinclination; //Inclination at MECO, degrees
+        public double TGTMECOIYx;// IY.x
+        public double TGTMECOIYy;// IY.y
+        public double TGTMECOIYz;// IY.z
 
         //OMS-1 and 2
         public OMSTargetSet oms1, oms2; //PEG-4
@@ -532,6 +540,61 @@ double MECOTargetLineDI57(double v_Ins)
             return (1.59 - 0.88) / (26160 - 25945) * (v_Ins - 25945) + 0.88;
         }
 
+	VECTOR3 CalculateEFIYVector(double Incl, double Lat, double Lng, bool north, double dt_bias)
+	{
+		// Calculate insertion orbital plane (IY) in Earth-fixed coordinates, taking into account Earth rotation
+		// INPUTS:
+		// Incl = Desired inclination, radians
+		// Lat = Launch or present latitude, radians
+		// Lng = Launch or present longitude, radians
+		// north = launch heading is northerly, true = north, false = south
+		// dt_bias = Time bias for rotating Earth. Length of time before the target orbit plane is over the landing site, seconds
+
+		double bias, arg, beta, dlng, h;
+
+		const double w_E = 7.292114942213369e-05;
+
+		bias = w_E * dt_bias;
+		arg = Math.Cos(Incl) / Math.Cos(Lat);
+
+		//Limit to 1.0
+		if (Math.Abs(arg) > 1.0)
+		{
+			if (arg > 0.0)
+			{
+				beta = (Math.PI * 0.5);
+			}
+			else
+			{
+				beta = -(Math.PI * 0.5);
+			}
+		}
+		else
+		{
+			beta = Math.Asin(arg);
+		}
+		if (north == false)
+		{
+			beta = Math.PI - beta;
+		}
+		dlng = Math.Atan2(Math.Sin(Lat), Math.Cos(beta) / Math.Sin(beta));
+		if (dlng < 0)
+		{
+			dlng = dlng + (Math.PI * 2);
+		}
+		if (Math.PI - beta < 0.0)
+		{
+			dlng = Math.PI + dlng;
+		}
+		h = Lng - dlng + bias;
+		if (h < 0)
+		{
+			h = h + (Math.PI * 2);
+		}
+
+		return -_V(Math.Sin(Incl) * Math.Sin(h), -Math.Sin(Incl) * Math.Cos(h), Math.Cos(Incl));
+	}
+
         public OrbitTgtCalcOutput Calculate(OrbitTgtCalcOptions opt)
         {
             //Input: H insertion, H OMS-1, H OMS-2, insertion mode
@@ -728,6 +791,27 @@ public OrbitTgtCalcOutput Calculate(OrbitTgtCalcOptions opt)
             solution.TGTMECOvel = V_MECO;
             solution.TGTMECOfpa = fpa * Defs.DEG;
             solution.TGTMECOinclination = opt.Inclination * Defs.DEG;
+
+            if (opt.CalcIY)
+            {
+                        // if target inclination outside allowed range, calculate new dt bias
+                        double dt_bias = 300.0;
+                        if (solution.TGTMECOinclination > opt.Inc_Max)
+                        {
+                                    dt_bias += 30 * (solution.TGTMECOinclination - opt.Inc_Max);
+                                    solution.TGTMECOinclination = opt.Inc_Max;
+                        }
+                        else if (solution.TGTMECOinclination < opt.Inc_Min)
+                        {
+                                    dt_bias -= 30 * (opt.Inc_Min - solution.TGTMECOinclination);
+                                    solution.TGTMECOinclination = opt.Inc_Min;
+                        }
+                        VECTOR3 IY_EF = CalculateEFIYVector( opt.Inclination, opt.Pad_Latitude * Defs.RAD, opt.Pad_Longitude * Defs.RAD, opt.Inclination < (65.0 * Defs.RAD), dt_bias );
+                        solution.TGTMECOIYx = IY_EF.x;
+                        solution.TGTMECOIYy = IY_EF.y;
+                        solution.TGTMECOIYz = IY_EF.z;
+            }
+
             solution.TGTMECOap = apsides[0] - RADIUS_EARTH_EQUATOR;
             solution.TGTMECOpe = apsides[1] - RADIUS_EARTH_EQUATOR;
 
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_LC39.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_LC39.cs
index e27163fd..5f33c271 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_LC39.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_LC39.cs	
@@ -39,6 +39,7 @@ Date         Developer
 2025/05/10   GLS
 2025/06/21   GLS
 2025/10/02   GLS
+2026/01/02   GLS
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra Workbench
@@ -66,13 +67,6 @@ namespace SSVMissionEditor.Model
 {
 	class SSV_LC39 : OrbiterVessel
 	{
-		public const double LC39A_LAT = 28.6083850;// deg
-		public const double LC39A_LON = -80.6040720;// deg
-
-		public const double LC39B_LAT = 28.6272150;// deg
-		public const double LC39B_LON = -80.6208620;// deg
-
-
 		public SSV_LC39( Mission mission )
 		{
 			_class = "SSV_LC39";
@@ -85,16 +79,16 @@ public SSV_LC39( Mission mission )
 			statusplanet = "Earth";
 			if (mission.LaunchPad == Defs.strLC39A)
 			{
-				poslon = LC39A_LON;
-				poslat = LC39A_LAT;
+				poslon = Defs.LC39A_LON;
+				poslat = Defs.LC39A_LAT;
 				arotx = -180.0;
 				aroty = 80.604;
 				arotz = 118.608;
 			}
 			else
 			{
-				poslon = LC39B_LON;
-				poslat = LC39B_LAT;
+				poslon = Defs.LC39B_LON;
+				poslat = Defs.LC39B_LAT;
 				arotx = -180.0;
 				aroty = 80.621;
 				arotz = 118.627;
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_SLC6.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_SLC6.cs
index 501bb85e..c2f58bbb 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_SLC6.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/Model/SSV_SLC6.cs	
@@ -33,6 +33,7 @@ Date         Developer
 2025/05/10   GLS
 2025/06/21   GLS
 2025/10/02   GLS
+2026/01/02   GLS
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra Workbench
@@ -62,9 +63,6 @@ namespace SSVMissionEditor.Model
 	class SSV_SLC6 : OrbiterVessel
 	{
 
-		public const double SLC6_LAT = 34.5808470;// deg
-		public const double SLC6_LON = -120.6259500;// deg
-
 		public SSV_SLC6( Mission mission )
 		{
 			_class = "SSV_SLC6";
@@ -73,8 +71,8 @@ public SSV_SLC6( Mission mission )
 
 			statuslanded = true;
 			statusplanet = "Earth";
-			poslon = SLC6_LON;
-			poslat = SLC6_LAT;
+			poslon = Defs.SLC6_LON;
+			poslat = Defs.SLC6_LAT;
 			heading = 270.0;
 			alt = 16.0;
 
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/View/Launch.xaml b/Orbitersdk/Space Shuttle Vessel/Mission Editor/View/Launch.xaml
index e521f85b..b819c44a 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/View/Launch.xaml	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/View/Launch.xaml	
@@ -36,6 +36,8 @@ Date         Developer
 2025/06/21   GLS
 2025/10/24   GLS
 2025/11/16   GLS
+2025/12/30   GLS
+2026/01/02   GLS
 ******************************************-->
 <!--***************************************************************************
   This file is part of Space Shuttle Ultra Workbench
@@ -82,7 +84,7 @@ Date         Developer
 		<Label Margin="25,100,0,0" Visibility="{Binding Launch_PadMLP_ena, Mode=OneWay, UpdateSourceTrigger=PropertyChanged, Converter={StaticResource BoolToVis}}" HorizontalAlignment="Left" Width="100" Height="25" VerticalAlignment="Top">MLP</Label>
 		<ComboBox Name="MLP" Visibility="{Binding Launch_PadMLP_ena, Mode=OneWay, UpdateSourceTrigger=PropertyChanged, Converter={StaticResource BoolToVis}}" ItemsSource="{Binding Launch_MLP_src, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" SelectedItem="{Binding Launch_MLP, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Margin="130,100,0,0" HorizontalAlignment="Left" Width="120" Height="24" VerticalAlignment="Top"/>
 
-		<GroupBox Header="Launch Date/Time" Margin="25,150,0,0" Height="106" Width="285" VerticalAlignment="Top" HorizontalAlignment="Left">
+		<GroupBox Header="Launch Date/Time" Margin="10,150,0,0" Height="106" Width="285" VerticalAlignment="Top" HorizontalAlignment="Left">
 			<Grid Margin="2,0,4,0">
 				<Grid.ColumnDefinitions>
 					<ColumnDefinition Width="70"/>
@@ -110,7 +112,7 @@ Date         Developer
 			</Grid>
 		</GroupBox>
 
-		<GroupBox x:Name="frmAscentTarget" Header="Ascent Target" HorizontalAlignment="Left" Height="430" Margin="346,25,0,0" VerticalAlignment="Top" Width="515">
+		<GroupBox x:Name="frmAscentTarget" Header="Ascent Target" HorizontalAlignment="Left" Height="475" Margin="330,10,0,0" VerticalAlignment="Top" Width="635">
 			<Grid Margin="10,10,10,10">
 				<Label Content="Insertion Mode" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,0,0,0"/>
 				<ComboBox x:Name="cmbATInsertionMode" SelectedIndex="{Binding Launch_DI, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, Converter={StaticResource Convert_DI}}" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="85" Margin="143,0,0,0" SelectionChanged="cmbATInsertionMode_SelectionChanged">
@@ -130,28 +132,35 @@ Date         Developer
 				<Label Content="OMS-2 Target Alt (NM)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,124,0,0"/>
 				<TextBox x:Name="txtATOMS2TgtAlt" Text="{Binding Launch_OMS2TargetAltitude, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="143,124,0,0" VerticalAlignment="Top" Width="50" MaxLines="1" TextChanged="txtATOMS2TgtAlt_TextChanged"/>
 
-				<CheckBox x:Name="chkATRTHU" Content="Roll To Heads Up" IsChecked="{Binding Launch_RTHU, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="10,155,0,0" VerticalAlignment="Top"/>
-
-				<Label Content="SSME Min. Throttle (%)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,186,0,0"/>
-				<TextBox Text="{Binding Launch_SSME_KMIN, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="143,186,0,0" VerticalAlignment="Top" Width="50" MaxLines="1"/>
-
-				<Label Content="SSME Max. Throttle (%)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,217,0,0"/>
-				<TextBox Text="{Binding Launch_SSME_KMAX, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="143,217,0,0" VerticalAlignment="Top" Width="50" MaxLines="1"/>
-
-				<Label Content="SSME Abort Throttle (%)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,248,0,0"/>
-				<TextBox Text="{Binding Launch_SSME_KMAX_ABORT, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="143,248,0,0" VerticalAlignment="Top" Width="50" MaxLines="1"/>
-
-				<Label Content="SSME Sec. Throttle (%)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,279,0,0"/>
-				<TextBox Text="{Binding Launch_SSME_KMAX_SEC, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="143,279,0,0" VerticalAlignment="Top" Width="50" MaxLines="1"/>
-
-				<Button x:Name="btnATCalc" Command="{Binding Launch_CalcAscentCommand}" Content="Calculate" HorizontalAlignment="Left" Margin="63,313,0,0" VerticalAlignment="Top" Width="120" Height="30"/>
-				<Button x:Name="btnATSave" Command="{Binding Launch_AscentSaveCommand}" Content="Save" HorizontalAlignment="Left" Margin="63,348,0,0" VerticalAlignment="Top" Width="120" Height="30"/>
-
-				<TextBox x:Name="txtATresult" Text="{Binding Launch_ResultString, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="385" Margin="245,0,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="240" AllowDrop="False" VerticalScrollBarVisibility="Auto" IsReadOnly="True" IsReadOnlyCaretVisible="True"/>
+				<CheckBox x:Name="chkATRTHU" Content="Roll To Heads Up" IsChecked="{Binding Launch_RTHU, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="245,6,0,0" VerticalAlignment="Top"/>
+
+				<CheckBox x:Name="chkIY" Content="Enable IY plane targeting options" IsChecked="{Binding Launch_IY_Options, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="0,200,0,0" VerticalAlignment="Top"/>
+				<CheckBox x:Name="chkEF_PLANE_SW" Content="Earth-Fixed IY Plane" IsChecked="{Binding Launch_EF_PLANE_SW, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding Launch_IY_Options, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="0,220,0,0" VerticalAlignment="Top"/>
+				<Label Content="Target IY Plane" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="90" Margin="0,240,0,0"/>
+				<TextBox x:Name="txtIYx" Text="{Binding Launch_IYx, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding Launch_IY_Input_ena, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="90,240,0,0" VerticalAlignment="Top" Width="85" MaxLines="1"/>
+				<TextBox x:Name="txtIYy" Text="{Binding Launch_IYy, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding Launch_IY_Input_ena, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="180,240,0,0" VerticalAlignment="Top" Width="85" MaxLines="1"/>
+				<TextBox x:Name="txtIYz" Text="{Binding Launch_IYz, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" IsEnabled="{Binding Launch_IY_Input_ena, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="270,240,0,0" VerticalAlignment="Top" Width="85" MaxLines="1"/>
+
+				<Button x:Name="btnATCalc" Command="{Binding Launch_CalcAscentCommand}" Content="Calculate" HorizontalAlignment="Left" Margin="363,400,0,0" VerticalAlignment="Top" Width="115" Height="30"/>
+				<Button x:Name="btnATSave" Command="{Binding Launch_AscentSaveCommand}" Content="Save" HorizontalAlignment="Left" Margin="488,400,0,0" VerticalAlignment="Top" Width="115" Height="30"/>
+
+				<TextBox x:Name="txtATresult" Text="{Binding Launch_ResultString, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="385" Margin="363,0,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Width="240" AllowDrop="False" VerticalScrollBarVisibility="Auto" IsReadOnly="True" IsReadOnlyCaretVisible="True"/>
+				<GroupBox Header="SSME Throttle (%)" HorizontalAlignment="Left" Height="100" Margin="0,333,0,0" VerticalAlignment="Top" Width="345">
+					<Grid HorizontalAlignment="Left" Height="60" Margin="10,10,0,0" VerticalAlignment="Top" Width="315">
+						<TextBox HorizontalAlignment="Left" Height="25" Margin="5,25,0,0" TextWrapping="Wrap" Text="{Binding Launch_SSME_KMIN, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" MaxLines="1" VerticalAlignment="Top" Width="50"/>
+						<TextBox HorizontalAlignment="Left" Height="25" Margin="90,25,0,0" TextWrapping="Wrap" Text="{Binding Launch_SSME_KMAX, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" MaxLines="1" VerticalAlignment="Top" Width="50"/>
+						<TextBox HorizontalAlignment="Left" Height="25" Margin="175,25,0,0" TextWrapping="Wrap" Text="{Binding Launch_SSME_KMAX_ABORT, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" MaxLines="1" VerticalAlignment="Top" Width="50"/>
+						<TextBox HorizontalAlignment="Left" Height="25" Margin="260,25,0,0" TextWrapping="Wrap" Text="{Binding Launch_SSME_KMAX_SEC, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" MaxLines="1" VerticalAlignment="Top" Width="50"/>
+						<Label Content="Minimum" HorizontalContentAlignment="Center" HorizontalAlignment="Left" Margin="0,0,0,0" VerticalAlignment="Top" Width="65"/>
+						<Label Content="Maximum" HorizontalContentAlignment="Center" HorizontalAlignment="Left" Margin="83,0,0,0" VerticalAlignment="Top" Width="65"/>
+						<Label Content="Abort" HorizontalContentAlignment="Center" HorizontalAlignment="Left" Margin="167,0,0,0" VerticalAlignment="Top" Width="65"/>
+						<Label Content="Secondary" HorizontalContentAlignment="Center" HorizontalAlignment="Left" Margin="250,0,0,0" VerticalAlignment="Top" Width="65"/>
+					</Grid>
+				</GroupBox>
 			</Grid>
 		</GroupBox>
 
-		<GroupBox x:Name="frmLegacyMECO" Header="Legacy MECO" HorizontalAlignment="Left" Height="163" Margin="25,290,0,0" VerticalAlignment="Top" Width="300">
+		<GroupBox x:Name="frmLegacyMECO" Header="Legacy MECO" HorizontalAlignment="Left" Height="225" Margin="10,260,0,0" VerticalAlignment="Top" Width="300">
 			<Grid Margin="10,10,10,10">
 				<Label Content="Inclination (deg)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,0,0,0"/>
 				<TextBox x:Name="txtMECOInc" Text="{Binding MECO_Inc, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="148,0,0,0" VerticalAlignment="Top" Width="120" MaxLines="1"/>
@@ -164,6 +173,11 @@ Date         Developer
 
 				<Label Content="Flight Path Angle (deg)" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="140" Margin="0,93,0,0"/>
 				<TextBox x:Name="txtMECOFPA" Text="{Binding MECO_FPA, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="148,93,0,0" VerticalAlignment="Top" Width="120" MaxLines="1"/>
+
+				<CheckBox x:Name="chkMECOEF_PLANE_SW" Content="Earth-Fixed IY" IsChecked="{Binding MECO_EF_PLANE_SW, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Margin="0,130,0,0" VerticalAlignment="Top"/>
+
+				<Label Content="IY Plane" HorizontalAlignment="Left" Height="26" VerticalAlignment="Top" Width="55" Margin="0,155,0,0"/>
+				<TextBox x:Name="txtMECOIY" Text="{Binding MECO_IY, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" HorizontalAlignment="Left" Height="26" Margin="60,155,0,0" VerticalAlignment="Top" Width="208" MaxLines="1"/>
 			</Grid>
 		</GroupBox>
 	</Grid>
diff --git a/Orbitersdk/Space Shuttle Vessel/Mission Editor/ViewModel/MainWindowViewModel.cs b/Orbitersdk/Space Shuttle Vessel/Mission Editor/ViewModel/MainWindowViewModel.cs
index c7057f26..ecfb2851 100644
--- a/Orbitersdk/Space Shuttle Vessel/Mission Editor/ViewModel/MainWindowViewModel.cs	
+++ b/Orbitersdk/Space Shuttle Vessel/Mission Editor/ViewModel/MainWindowViewModel.cs	
@@ -171,6 +171,11 @@ public MainWindowViewModel( Mission mission, LandingSite landingsite )
 			Launch_OMS1MECOTargetAltitude = 160.0;
 			Launch_OMS2TargetAltitude = 160.0;
 			Launch_RTHU = true;
+			Launch_IY_Options = false;
+			Launch_EF_PLANE_SW = false;
+			Launch_IYx = 0.0;
+			Launch_IYy = 0.0;
+			Launch_IYz = 0.0;
 
 			GetSSME_KMIN();
 			GetSSME_KMAX_NOM();
@@ -1643,75 +1648,98 @@ void CalcAscentCommand()
 		{
 			Launch_ResultString = "calculating...";
 
+			double Pad_Lat = Defs.SLC6_LAT;
+			double Pad_Lon = Defs.SLC6_LON;
+			double Inc_Max = 104;
+			double Inc_Min = 70;
+			if (Launch_Site == Defs.strKSC)
+			{
+				if (Launch_Pad == Defs.strLC39A)
+				{
+					Pad_Lat = Defs.LC39A_LAT;
+					Pad_Lon = Defs.LC39A_LON;
+				}
+				else
+				{
+					Pad_Lat = Defs.LC39B_LAT;
+					Pad_Lon = Defs.LC39B_LON;
+				}
+				Inc_Max = 57;
+				Inc_Min = 28.45;
+			}
+
 			OrbitTgtCalcOptions opt = new OrbitTgtCalcOptions
 			{
 				H_Insertion = Launch_MECOAltitude * Defs.NM2KM * 1000.0,
 				H_OMS1 = Launch_OMS1MECOTargetAltitude * Defs.NM2KM * 1000.0,
 				H_OMS2 = Launch_OMS2TargetAltitude * Defs.NM2KM * 1000.0,
 				Inclination = Launch_MECOInclination * Defs.RAD,
-				InsertionMode = Launch_DI
+				InsertionMode = Launch_DI,
+				CalcIY = Launch_EF_PLANE_SW,
+				Pad_Latitude = Pad_Lat,
+				Pad_Longitude = Pad_Lon,
+				Inc_Max = Inc_Max,
+				Inc_Min = Inc_Min
 			};
 
 			OrbitTgtCalc orbittgtcalc = new OrbitTgtCalc();
 			OrbitTgtCalcOutput res = orbittgtcalc.Calculate( opt );
 
-			Launch_MECOAltitude2 = res.TGTMECOaltitude;
-			Launch_MECOVelocity = res.TGTMECOvel * Defs.MPS2FPS;
-			Launch_MECOFPA = res.TGTMECOfpa;
-			//Launch_MECOInclination = res.TGTMECOinclination;
-
-			Launch_OMS1DTIG = res.oms1.DTIG;
-			Launch_OMS1HTGT = res.oms1.HTGT * Defs.MPS2FPS;
-			Launch_OMS1THETA = res.oms1.THETA;
-			Launch_OMS1C1 = res.oms1.C1 * Defs.MPS2FPS;
-			Launch_OMS1C2 = res.oms1.C2;
-
-			Launch_OMS2DTIG = res.oms2.DTIG;
-			Launch_OMS2HTGT = res.oms2.HTGT * Defs.MPS2FPS;
-			Launch_OMS2THETA = res.oms2.THETA;
-			Launch_OMS2C1 = res.oms2.C1 * Defs.MPS2FPS;
-			Launch_OMS2C2 = res.oms2.C2;
-
-
-
-			Launch_ResultString = string.Format(">> MECO <<\n" +
-				"Inclination: {0:f2}º\n" +
-				"Altitude: {1:f0}ft ({2:f0}km)\n" +
-				"Velocity: {3:f0}fps ({4:f0}m/s)\n" +
-				"Flight Path Angle: {5:f4}º\n" +
-				"Ap/Pe: {6:f0}x{7:f0}NM ({8:f0}x{9:f0}Km)\n",
-				Launch_MECOInclination,
-				res.TGTMECOaltitude * Defs.MPS2FPS, res.TGTMECOaltitude * 0.001,
-				res.TGTMECOvel * Defs.MPS2FPS, res.TGTMECOvel,
-				res.TGTMECOfpa,
-				res.TGTMECOap / (Defs.NM2KM * 1000.0), res.TGTMECOpe / (Defs.NM2KM * 1000.0), res.TGTMECOap * 0.001, res.TGTMECOpe * 0.001 );
+			Launch_CalcMECOAltitude = res.TGTMECOaltitude;
+			Launch_CalcMECOVelocity = res.TGTMECOvel * Defs.MPS2FPS;
+			Launch_CalcMECOFPA = res.TGTMECOfpa;
+			if (Launch_IY_Options) Launch_CalcMECOInclination = res.TGTMECOinclination;
+			else Launch_CalcMECOInclination = Launch_MECOInclination;
+			if (Launch_EF_PLANE_SW)
+			{
+				Launch_CalcIYx = Math.Round( res.TGTMECOIYx, 6 );
+				Launch_CalcIYy = Math.Round( res.TGTMECOIYy, 6 );
+				Launch_CalcIYz = Math.Round( res.TGTMECOIYz, 6 );
+			}
+
+			Launch_CalcOMS1DTIG = res.oms1.DTIG;
+			Launch_CalcOMS1HTGT = res.oms1.HTGT * Defs.MPS2FPS;
+			Launch_CalcOMS1THETA = res.oms1.THETA;
+			Launch_CalcOMS1C1 = res.oms1.C1 * Defs.MPS2FPS;
+			Launch_CalcOMS1C2 = res.oms1.C2;
+
+			Launch_CalcOMS2DTIG = res.oms2.DTIG;
+			Launch_CalcOMS2HTGT = res.oms2.HTGT * Defs.MPS2FPS;
+			Launch_CalcOMS2THETA = res.oms2.THETA;
+			Launch_CalcOMS2C1 = res.oms2.C1 * Defs.MPS2FPS;
+			Launch_CalcOMS2C2 = res.oms2.C2;
 
+
+			Launch_ResultString = ">> MECO <<\n" +
+				$"Inclination: {Launch_MECOInclination:f2}º\n";
+			if (Launch_IY_Options)
+			{
+				Launch_ResultString += (Launch_EF_PLANE_SW ? $"IY Plane: {Launch_CalcIYx:f6} {Launch_CalcIYy:f6} {Launch_CalcIYz:f6}\n" : $"IY Plane: {Launch_IYx:f6} {Launch_IYy:f6} {Launch_IYz:f6}\n");
+					
+			}
+			Launch_ResultString += $"Altitude: {res.TGTMECOaltitude * Defs.MPS2FPS:f0}ft ({res.TGTMECOaltitude * 0.001:f0}km)\n" +
+				$"Velocity: {res.TGTMECOvel * Defs.MPS2FPS:f0}fps ({res.TGTMECOvel:f0}m/s)\n" +
+				$"Flight Path Angle: {res.TGTMECOfpa:f4}º\n" +
+				$"Ap/Pe: {res.TGTMECOap / (Defs.NM2KM * 1000.0):f0}x{res.TGTMECOpe / (Defs.NM2KM * 1000.0):f0}NM ({res.TGTMECOap * 0.001:f0}x{res.TGTMECOpe * 0.001:f0}Km)\n";
+
+			Launch_ResultString += "\n>> OMS-1 <<\n";
 			if (!Launch_DI)
 			{
 				// SI
-				Launch_ResultString += string.Format("\n>> OMS-1 <<\n" +
-					"TIG: {0:D2}:{1:D2}\n" +
-					"dV: {2:f1}fps ({3:f1}m/s)\n" +
-					"Ap/Pe: {4:f0}x{5:f0}NM ({6:f0}x{7:f0}Km)\n",
-					(int)res.TGTOMS1tig[0], (int)res.TGTOMS1tig[1],
-					res.TGTOMS1dv * Defs.MPS2FPS, res.TGTOMS1dv,
-					res.TGTOMS1ap / (Defs.NM2KM * 1000.0), res.TGTOMS1pe / (Defs.NM2KM * 1000.0), res.TGTOMS1ap * 0.001, res.TGTOMS1pe * 0.001 );
+				Launch_ResultString += $"TIG: {(int)res.TGTOMS1tig[0]:D2}:{(int)res.TGTOMS1tig[1]:D2}\n" +
+					$"dV: {res.TGTOMS1dv * Defs.MPS2FPS:f1}fps ({res.TGTOMS1dv:f1}m/s)\n";
 			}
 			else
 			{
 				// DI
-				Launch_ResultString += string.Format("\n>> OMS-1 <<\n(not performed)\n" +
-					"Ap/Pe: {0:f0}x{1:f0}NM ({2:f0}x{3:f0}Km)\n",
-					res.TGTOMS1ap / (Defs.NM2KM * 1000.0), res.TGTOMS1pe / (Defs.NM2KM * 1000.0), res.TGTOMS1ap * 0.001, res.TGTOMS1pe * 0.001 );
+				Launch_ResultString += "(not performed)\n";
 			}
+			Launch_ResultString += $"Ap/Pe: {res.TGTOMS1ap / (Defs.NM2KM * 1000.0):f0}x{res.TGTOMS1pe / (Defs.NM2KM * 1000.0):f0}NM ({res.TGTOMS1ap * 0.001:f0}x{res.TGTOMS1pe * 0.001:f0}Km)\n";
 
-			Launch_ResultString += string.Format("\n>> OMS-2 <<\n" +
-				"TIG: {0:D2}:{1:D2}\n" +
-				"dV: {2:f1}fps ({3:f1}m/s)\n" +
-				"Ap/Pe: {4:f0}x{5:f0}NM ({6:f0}x{7:f0}Km)\n",
-				(int)res.TGTOMS2tig[0], (int)res.TGTOMS2tig[1],
-				res.TGTOMS2dv * Defs.MPS2FPS, res.TGTOMS2dv,
-				res.TGTOMS2ap / (Defs.NM2KM * 1000.0), res.TGTOMS2pe / (Defs.NM2KM * 1000.0), res.TGTOMS2ap * 0.001, res.TGTOMS2pe * 0.001 );
+			Launch_ResultString += "\n>> OMS-2 <<\n" +
+				$"TIG: {(int)res.TGTOMS2tig[0]:D2}:{(int)res.TGTOMS2tig[1]:D2}\n" +
+				$"dV: {res.TGTOMS2dv * Defs.MPS2FPS:f1}fps ({res.TGTOMS2dv:f1}m/s)\n" +
+				$"Ap/Pe: {res.TGTOMS2ap / (Defs.NM2KM * 1000.0):f0}x{res.TGTOMS2pe / (Defs.NM2KM * 1000.0):f0}NM ({res.TGTOMS2ap * 0.001:f0}x{res.TGTOMS2pe * 0.001:f0}Km)\n";
 
 			// enable Save button
 			Launch_CalcDone = true;
@@ -1722,11 +1750,26 @@ void CalcAscentCommand()
 		public ICommand Launch_AscentSaveCommand{ get; private set; }
 		void AscentSaveCommand()
 		{
+			// save input and/or calculated params
 			// save legacy MECO target
-			MECO_Inc = Launch_MECOInclination;
-			MECO_Alt = Launch_MECOAltitude2;
-			MECO_Vel = Launch_MECOVelocity / Defs.MPS2FPS;
-			MECO_FPA = Launch_MECOFPA;
+			MECO_Inc = Launch_CalcMECOInclination;
+			MECO_Alt = Launch_CalcMECOAltitude;
+			MECO_Vel = Launch_CalcMECOVelocity / Defs.MPS2FPS;
+			MECO_FPA = Launch_CalcMECOFPA;
+
+			if (Launch_IY_Options)
+			{
+				MECO_EF_PLANE_SW = Launch_EF_PLANE_SW;
+				if (Launch_EF_PLANE_SW)
+					MECO_IY = Launch_CalcIYx.ToString() + " " + Launch_CalcIYy.ToString() + " " + Launch_CalcIYz.ToString();
+				else
+					MECO_IY = Launch_IYx.ToString() + " " + Launch_IYy.ToString() + " " + Launch_IYz.ToString();
+			}
+			else
+			{
+				MECO_EF_PLANE_SW = false;
+				MECO_IY = "0.0 0.0 0.0";
+			}
 
 			// set I-LOADs for roll to heads up and OMS-1/2 targets
 			foreach (Mission_ILOAD iload in ILOAD_List)
@@ -1740,31 +1783,31 @@ void AscentSaveCommand()
 						iload.Val = Launch_RTHU ? "0" : "180";
 						break;
 					case "DTIG_OMS":
-						iload.Val = string.Format("{0:f1} {1:f1}", Launch_OMS1DTIG, Launch_OMS2DTIG );
+						iload.Val = $"{Launch_CalcOMS1DTIG:f1} {Launch_CalcOMS2DTIG:f1}";
 						break;
 					case "HTGT_OMS":
-						iload.Val = string.Format("{0:f1} {1:f1}", Launch_OMS1HTGT, Launch_OMS2HTGT );
+						iload.Val = $"{Launch_CalcOMS1HTGT:f1} {Launch_CalcOMS2HTGT:f1}";
 						break;
 					case "THETA_OMS":
-						iload.Val = string.Format("{0:f6} {1:f6}", Launch_OMS1THETA, Launch_OMS2THETA );
+						iload.Val = $"{Launch_CalcOMS1THETA:f6} {Launch_CalcOMS2THETA:f6}";
 						break;
 					case "C1_OMS":
-						iload.Val = string.Format("{0:f0} {1:f0}", Launch_OMS1C1, Launch_OMS2C1 );
+						iload.Val = $"{Launch_CalcOMS1C1:f0} {Launch_CalcOMS2C1:f0}";
 						break;
 					case "C2_OMS":
-						iload.Val = string.Format("{0:f4} {1:f4}", Launch_OMS1C2, Launch_OMS2C2 );
+						iload.Val = $"{Launch_CalcOMS1C2:f4} {Launch_CalcOMS2C2:f4}";
 						break;
 					case "KMIN":
-						iload.Val = string.Format( "{0:d}", Launch_SSME_KMIN );
+						iload.Val = $"{Launch_SSME_KMIN}";
 						break;
 					case "KMAX_NOM":
-						iload.Val = string.Format( "{0:d}", Launch_SSME_KMAX );
+						iload.Val = $"{Launch_SSME_KMAX}";
 						break;
 					case "KMAX_ABORT":
-						iload.Val = string.Format( "{0:d}", Launch_SSME_KMAX_ABORT );
+						iload.Val = $"{Launch_SSME_KMAX_ABORT}";
 						break;
 					case "KMAX_SECONDARY":
-						iload.Val = string.Format( "{0:d}", Launch_SSME_KMAX_SEC );
+						iload.Val = $"{Launch_SSME_KMAX_SEC}";
 						break;
 					case "THROT":
 						{
@@ -1775,7 +1818,7 @@ void AscentSaveCommand()
 							{
 								THROT_3 = Convert.ToInt32( param[2] );
 							}
-							iload.Val = string.Format( "{0:d} {1:d} {2:d} {3:d}", Launch_SSME_KMAX, Launch_SSME_KMAX, THROT_3, Launch_SSME_KMAX );
+							iload.Val = $"{Launch_SSME_KMAX} {Launch_SSME_KMAX} {THROT_3} {Launch_SSME_KMAX}";
 						}
 						break;
 				}
@@ -2001,6 +2044,79 @@ public bool Launch_RTHU
 			}
 		}
 
+		/// <summary>
+		/// If true, IY options are enabled
+		/// </summary>
+		private bool launch_iy_options;
+		public bool Launch_IY_Options
+		{
+			get { return launch_iy_options; }
+			set
+			{
+				launch_iy_options = value;
+				OnPropertyChanged( "Launch_IY_Options" );
+				OnPropertyChanged( "Launch_IY_Input_ena" );
+			}
+		}
+
+		/// <summary>
+		/// EF_PLANE_SW
+		/// </summary>
+		private bool launch_ef_plane_sw;
+		public bool Launch_EF_PLANE_SW
+		{
+			get { return launch_ef_plane_sw; }
+			set
+			{
+				launch_ef_plane_sw = value;
+				OnPropertyChanged( "Launch_EF_PLANE_SW" );
+				OnPropertyChanged( "Launch_IY_Input_ena" );
+			}
+		}
+
+		/// <summary>
+		/// When Launch_EF_PLANE_SW is false, IY input is enabled
+		/// </summary>
+		public bool Launch_IY_Input_ena
+		{
+			get { return Launch_IY_Options && !Launch_EF_PLANE_SW; }
+			set {}
+		}
+
+		/// <summary>
+		/// IY
+		/// </summary>
+		private double launch_iyx;
+		public double Launch_IYx
+		{
+			get { return launch_iyx; }
+			set
+			{
+				launch_iyx = value;
+				OnPropertyChanged( "Launch_IYx" );
+			}
+		}
+		private double launch_iyy;
+		public double Launch_IYy
+		{
+			get { return launch_iyy; }
+			set
+			{
+				launch_iyy = value;
+				OnPropertyChanged( "Launch_IYy" );
+			}
+		}
+		private double launch_iyz;
+		public double Launch_IYz
+		{
+			get { return launch_iyz; }
+			set
+			{
+				launch_iyz = value;
+				OnPropertyChanged( "Launch_IYz" );
+			}
+		}
+
 		private int launch_ssme_kmin;
 		public int Launch_SSME_KMIN
 		{
@@ -2062,186 +2178,81 @@ public string Launch_ResultString
 		}
 
 		/// <summary>
-		/// MECO altitude, referenced to Orbiter Earth [m]
+		/// Calculated MECO inclination [deg]
 		/// </summary>
-		private double launch_mecoaltitude2;
-		public double Launch_MECOAltitude2
-		{
-			get { return launch_mecoaltitude2; }
-			set
-			{
-				launch_mecoaltitude2 = value;
-				OnPropertyChanged( "Launch_MECOAltitude2" );
-			}
-		}
+		public double Launch_CalcMECOInclination { get; set; }
 
 		/// <summary>
-		/// MECO velocity [fps]
+		/// Calculated MECO altitude, referenced to Orbiter Earth [m]
 		/// </summary>
-		private double launch_mecovelocity;
-		public double Launch_MECOVelocity
-		{
-			get { return launch_mecovelocity; }
-			set
-			{
-				launch_mecovelocity = value;
-				OnPropertyChanged( "Launch_MECOVelocity" );
-			}
-		}
+		public double Launch_CalcMECOAltitude { get; set; }
 
 		/// <summary>
-		/// MECO FPA [deg]
+		/// Calculated MECO velocity [fps]
 		/// </summary>
-		private double launch_mecofpa;
-		public double Launch_MECOFPA
-		{
-			get { return launch_mecofpa; }
-			set
-			{
-				launch_mecofpa = value;
-				OnPropertyChanged( "Launch_MECOFPA" );
-			}
-		}
+		public double Launch_CalcMECOVelocity { get; set; }
+
+		/// <summary>
+		/// Calculated MECO FPA [deg]
+		/// </summary>
+		public double Launch_CalcMECOFPA { get; set; }
+
+		/// <summary>
+		/// Calculated IY
+		/// </summary>
+		public double Launch_CalcIYx { get; set; }
+		public double Launch_CalcIYy { get; set; }
+		public double Launch_CalcIYz { get; set; }
 
 		/// <summary>
 		/// Time between ET separation and OMS-1 [s]
 		/// </summary>
-		private double launch_oms1dtig;
-		public double Launch_OMS1DTIG
-		{
-			get { return launch_oms1dtig; }
-			set
-			{
-				launch_oms1dtig = value;
-				OnPropertyChanged( "Launch_OMS1DTIG" );
-			}
-		}
+		public double Launch_CalcOMS1DTIG { get; set; }
 
 		/// <summary>
 		/// OMS-1 PEG-4 HTGT [ft]
 		/// </summary>
-		private double launch_oms1htgt;
-		public double Launch_OMS1HTGT
-		{
-			get { return launch_oms1htgt; }
-			set
-			{
-				launch_oms1htgt = value;
-				OnPropertyChanged( "Launch_OMS1HTGT" );
-			}
-		}
+		public double Launch_CalcOMS1HTGT { get; set; }
 
 		/// <summary>
 		/// OMS-1 PEG-4 Theta [rad]
 		/// </summary>
-		private double launch_oms1theta;
-		public double Launch_OMS1THETA
-		{
-			get { return launch_oms1theta; }
-			set
-			{
-				launch_oms1theta = value;
-				OnPropertyChanged( "Launch_OMS1THETA" );
-			}
-		}
+		public double Launch_CalcOMS1THETA { get; set; }
 
 		/// <summary>
 		/// OMS-1 PEG-4 C1 [fps]
 		/// </summary>
-		private double launch_oms1c1;
-		public double Launch_OMS1C1
-		{
-			get { return launch_oms1c1; }
-			set
-			{
-				launch_oms1c1 = value;
-				OnPropertyChanged( "Launch_OMS1C1" );
-			}
-		}
+		public double Launch_CalcOMS1C1 { get; set; }
 
 		/// <summary>
 		/// OMS-1 PEG-4 C2 [1]
 		/// </summary>
-		private double launch_oms1c2;
-		public double Launch_OMS1C2
-		{
-			get { return launch_oms1c1; }
-			set
-			{
-				launch_oms1c2 = value;
-				OnPropertyChanged( "Launch_OMS1C2" );
-			}
-		}
+		public double Launch_CalcOMS1C2 { get; set; }
 
 		/// <summary>
 		/// Time between ET separation and OMS-2 [s]
 		/// </summary>
-		private double launch_oms2dtig;
-		public double Launch_OMS2DTIG
-		{
-			get { return launch_oms2dtig; }
-			set
-			{
-				launch_oms2dtig = value;
-				OnPropertyChanged( "Launch_OMS2DTIG" );
-			}
-		}
+		public double Launch_CalcOMS2DTIG { get; set; }
 
 		/// <summary>
 		/// OMS-2 PEG-4 HTGT [ft]
 		/// </summary>
-		private double launch_oms2htgt;
-		public double Launch_OMS2HTGT
-		{
-			get { return launch_oms2htgt; }
-			set
-			{
-				launch_oms2htgt = value;
-				OnPropertyChanged( "Launch_OMS2HTGT" );
-			}
-		}
+		public double Launch_CalcOMS2HTGT { get; set; }
 
 		/// <summary>
 		/// OMS-2 PEG-4 Theta [rad]
 		/// </summary>
-		private double launch_oms2theta;
-		public double Launch_OMS2THETA
-		{
-			get { return launch_oms2theta; }
-			set
-			{
-				launch_oms2theta = value;
-				OnPropertyChanged( "Launch_OMS2THETA" );
-			}
-		}
+		public double Launch_CalcOMS2THETA { get; set; }
 
 		/// <summary>
 		/// OMS-2 PEG-4 C1 [fps]
 		/// </summary>
-		private double launch_oms2c1;
-		public double Launch_OMS2C1
-		{
-			get { return launch_oms2c1; }
-			set
-			{
-				launch_oms2c1 = value;
-				OnPropertyChanged( "Launch_OMS2C1" );
-			}
-		}
+		public double Launch_CalcOMS2C1 { get; set; }
 
 		/// <summary>
 		/// OMS-2 PEG-4 C2 [1]
 		/// </summary>
-		private double launch_oms2c2;
-		public double Launch_OMS2C2
-		{
-			get { return launch_oms2c1; }
-			set
-			{
-				launch_oms2c2 = value;
-				OnPropertyChanged( "Launch_OMS2C2" );
-			}
-		}
+		public double Launch_CalcOMS2C2 { get; set; }
 
 		/// <summary>
 		/// The date/time at the start of the simulation
@@ -2337,6 +2348,24 @@ public double MECO_FPA
 			set { mission.MECO_FPA = value; OnPropertyChanged( "MECO_FPA" ); }
 		}
 
+		/// <summary>
+		/// EF_PLANE_SW
+		/// </summary>
+		public bool MECO_EF_PLANE_SW
+		{
+			get { return mission.EF_PLANE_SW; }
+			set { mission.EF_PLANE_SW = value; OnPropertyChanged( "MECO_EF_PLANE_SW" ); }
+		}
+
+		/// <summary>
+		/// IY
+		/// </summary>
+		public string MECO_IY
+		{
+			get { return mission.IYD; }
+			set { mission.IYD = value; OnPropertyChanged( "MECO_IY" ); }
+		}
+
 
 		/// ORBIT tab
 		private string GetCurrentOrbitTargetSet()
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.cpp b/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.cpp
index 3fe6ee39..6f54a8e2 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.cpp	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.cpp	
@@ -28,6 +28,8 @@ Date         Developer
 2022/10/28   GLS
 2022/12/23   GLS
 2023/01/11   GLS
+2025/12/27   indy91
+2025/12/29   GLS
 ********************************************/
 #include "IDP.h"
 #include "../Atlantis.h"
@@ -1226,7 +1228,11 @@ namespace dps {
 
 	double IDP::GetCourseDeviationScale( void ) const
 	{
-		return pDedicatedDisplay_SOP->GetCourseDeviationScale();
+		double coursedeviation = GetCrossTrack();
+		double coursedeviationscale = 50.0;
+		if (fabs( coursedeviation ) <= 10.0) coursedeviationscale = 10.0;
+		if ((fabs( coursedeviation ) <= 1.0) && (STS()->GetMET() >= 390.0)) coursedeviationscale = 1.0;
+		return coursedeviationscale;
 	}
 
 	double IDP::GetGlideSlopeDeviation( void ) const
@@ -1244,6 +1250,16 @@ namespace dps {
 		return pDedicatedDisplay_SOP->GetGSFlag();
 	}
 
+	double IDP::GetCrossTrack(void) const
+	{
+		return pAscentDAP->GetCrossTrack();
+	}
+
+	double IDP::GetDeltaInclination(void) const
+	{
+		return pAscentDAP->GetDeltaInclination();
+	}
+
 	SimpleGPCSystem* IDP::GetGPC( void ) const
 	{
 		if (!MajorFuncPL.IsSet() && !MajorFuncGNC.IsSet()) return pGPC2;
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.h b/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.h
index b6c50ed2..3f2fdd07 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.h	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/dps/IDP.h	
@@ -46,6 +46,7 @@ Date         Developer
 2022/10/12   GLS
 2022/10/21   GLS
 2022/11/09   GLS
+2025/12/27   indy91
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra
@@ -262,6 +263,8 @@ namespace dps
 		double GetGlideSlopeDeviation( void ) const;
 		double GetGlideSlopeDeviationScale( void ) const;
 		bool GetGSFlag( void ) const;
+		double GetCrossTrack( void ) const;
+		double GetDeltaInclination( void ) const;
 	};
 }
 
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.cpp b/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.cpp
index 9057667e..0ac58ba2 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.cpp	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.cpp	
@@ -29,6 +29,9 @@ Date         Developer
 2022/11/15   GLS
 2022/12/17   GLS
 2022/12/23   GLS
+2025/12/27   indy91
+2025/12/31   indy91
+2026/01/06   indy91
 ********************************************/
 #include "AscentDAP.h"
 #include "../../../Atlantis.h"
@@ -43,7 +46,8 @@ Date         Developer
 #include "../../../mission/Mission.h"
 #include <cassert>
 #include <EngConst.h>
-
+#include "GNCUtilities.h"
+#include "StateVectorSoftware.h"
 
 namespace dps
 {
@@ -58,6 +62,741 @@ namespace dps
 	constexpr double SSME_TAILOFF_DV_91_1EO = 75;// fps
 	constexpr double SSME_TAILOFF_DV_91_2EO = 35;// fps
 
+	AscentGuidance::AscentGuidance()
+	{
+		RDMAG = 0.0;
+		VDMAG = 0.0;
+		GAMD = 0.0;
+		IYD = _V(0, 0, 0);
+
+		DVGO = _V(0, 0, 0);
+		DVS = _V(0, 0, 0);
+		IX = _V(0, 0, 0);
+		IY = _V(0, 0, 0);
+		LAM = _V(0, 0, 0);
+		LAMC = _V(0, 0, 0);
+		LAMD = _V(0, 0, 0);
+		OMEGA = _V(0, 0, 0);
+		RBIAS = _V(0, 0, 0);
+		RD = _V(0, 0, 0);
+		RGD = _V(0, 0, 0);
+		RGRAV = _V(0, 0, 0);
+		RGO = _V(0, 0, 0);
+		RP = _V(0, 0, 0);
+		RTHRUST = _V(0, 0, 0);
+		VD = _V(0, 0, 0);
+		VGD = _V(0, 0, 0);
+		VGO = _V(0, 0, 0);
+		VMISS = _V(0, 0, 0);
+		VP = _V(0, 0, 0);
+		VTHRUST = _V(0, 0, 0);
+
+		ATR = 0.0;
+		DT_LIMIT = 0.0;
+		EMISS = 0.0;
+		FT = 0.0;
+		IF_MAG_I = 0.0;
+		LA[0] = LA[1] = LA[2] = 0.0;
+		SA[0] = SA[1] = SA[2] = 0.0;
+		QA[0] = QA[1] = QA[2] = 0.0;
+		LAMDMAG = 0.0;
+		M = 0.0;
+		PHI = 0.0;
+		RMAG = 0.0;
+		TAU[0] = TAU[1] = TAU[2] = 0.0;
+		TB[0] = TB[1] = TB[2] = 0.0;
+		TFAIL = 0.0;
+		TGD = 0.0;
+		TGO = 0.0;
+		TGOA[0] = TGOA[1] = TGOA[2] = 0.0;
+		TGOP = 0.0;
+		TI = 0.0;
+		TLAM = 0.0;
+		TP = 0.0;
+		TPREV = 0.0;
+		TPRIME = 0.0;
+		VEX = 0.0;
+		VEXA[0] = VEXA[1] = VEXA[2] = 0.0;
+		VGOMAG = 0.0;
+
+		QPRIME = L = J = S = JOL = 0.0;
+
+		KPHASE = 0;
+		N = 0;
+		N_CYCLE = 0;
+
+		SALT = false;
+		SCONV = false;
+		SINIT = false;
+		SPLANE = false;
+
+		// Temporary
+		T_GMTLO = 0.0;
+	}
+
+	void AscentGuidance::Init(double t_GMTLO, double r_D, double v_D, double gamma_D, VECTOR3 IY_M50)
+	{
+		// Inputs in metric
+
+		RDMAG = r_D * MPS2FPS;
+		VDMAG = v_D * MPS2FPS;
+		GAMD = gamma_D;
+		IYD = unit(IY_M50); // TBD: Unit vector for safety, for now
+		T_GMTLO = t_GMTLO;
+
+		SINIT = true;
+		SCONV = false;
+		TFAIL = 0.0; // TBD: Implement this
+		DT_LIMIT = DTMAX;
+	}
+
+	void AscentGuidance::Cycle(VECTOR3 R, VECTOR3 V, double T, int K_CMD, int N_SSME, int N_OMS, double mass, VECTOR3 DV, VECTOR3& U_STEER)
+	{
+		// INPUTS:
+		// R = Current position vector in M50 coordinates, meters
+		// V = Current velocity vector in M50 coordinates, meters per second
+		// T = Current GMT clock time, seconds
+		// K_CMD = Commanded SSME throttle setting, percent
+		// N_SSME = Number of active SSME engines
+		// N_OMS = Number of active OMS engines
+		// mass = Current mass, kg
+		// DV = Change in accumulated velocity over the past guidance cycle, meters per second
+		// OUTPUTS:
+		// U_STEER = Desired thrust direction in M50 coordinates
+
+		// Assign to Shuttle variables
+		RGD = R * MPS2FPS;
+		VGD = V * MPS2FPS;
+		TGD = T;
+		M = mass * KG2LBM / G_2_FPS2;
+		DVS = DV * MPS2FPS;
+
+		// TBD: These are I-loads
+		double FT_SSME = 2090664.159 / LBF;
+		double VEX_SSME = 453.0 * 9.80665 * MPS2FPS;
+		double MDOT_SSME = FT_SSME / VEX_SSME;
+
+		// TBD: THRST PRM TSK
+		FT = 0.01 * (double)(K_CMD * N_SSME) * FT_SSME + (double)(N_OMS) * FT_OMS;
+		double MDOT = 0.01 * (double)(K_CMD * N_SSME) * MDOT_SSME + (double)(N_OMS)*MDOT_OMS;
+		VEX = FT / MDOT;
+
+		AscentGuidanceTask();
+
+		//Desired thrust direction
+		U_STEER = unit(LAMC - LAMD * JOL);
+	}
+
+	void AscentGuidance::UpdateVDMAG(double v)
+	{
+		// Input in m/s
+		VDMAG = v * MPS2FPS;
+	}
+
+	VECTOR3 AscentGuidance::CalculateEFIYVector(double Incl, double Lat, double Lng, bool north, double dt_bias) const
+	{
+		// Calculate insertion orbital plane (IY) in Earth-fixed coordinates, taking into account Earth rotation
+		// INPUTS:
+		// Incl = Desired inclination, radians
+		// Lat = Launch or present latitude, radians
+		// Lng = Launch or present longitude, radians
+		// north = launch heading is northerly, true = north, false = south
+		// dt_bias = Time bias for rotating Earth. Length of time before the target orbit plane is over the landing site, seconds
+
+		double bias, arg, beta, dlng, h;
+
+		const double w_E = 7.292114942213369e-05;
+
+		bias = w_E * dt_bias;
+		arg = cos(Incl) / cos(Lat);
+
+		//Limit to 1.0
+		if (abs(arg) > 1.0)
+		{
+			if (arg > 0.0)
+			{
+				beta = PI05;
+			}
+			else
+			{
+				beta = -PI05;
+			}
+		}
+		else
+		{
+			beta = asin(arg);
+		}
+		if (north == false)
+		{
+			beta = PI - beta;
+		}
+		dlng = atan2(sin(Lat), cos(beta) / sin(beta));
+		if (dlng < 0)
+		{
+			dlng = dlng + PI2;
+		}
+		if (PI - beta < 0.0)
+		{
+			dlng = PI + dlng;
+		}
+		h = Lng - dlng + bias;
+		if (h < 0)
+		{
+			h = h + PI2;
+		}
+
+		return -_V(sin(Incl) * sin(h), -sin(Incl) * cos(h), cos(Incl));
+	}
+
+	double AscentGuidance::GetTimeRemaining() const
+	{
+		return TGO;
+	}
+
+	VECTOR3 AscentGuidance::GetIYVector() const
+	{
+		return IYD;
+	}
+
+	double AscentGuidance::GetVDMAG() const
+	{
+		// Output in metric
+		return VDMAG * FPS2MS;
+	}
+
+	void AscentGuidance::AscentGuidanceTask()
+	{
+		// Estimate of acceleration based on curent mass
+		ATR = FT_FACTOR * FT / M;
+		// Cycle through PEG task
+		N_CYCLE = 0;
+		do
+		{
+			PEGTask();
+			N_CYCLE++;
+		} while (SCONV == false && N_CYCLE < N_MAX);
+	}
+
+	void AscentGuidance::PEGTask()
+	{
+		// Magnitude of the current position vector
+		PositionMagnitudeSubTask();
+		// Initialization?
+		if (SINIT == false)
+		{
+			VGOUpdateSubtask();
+		}
+		else
+		{
+			ModeIndependentInit();
+			StandardAscentModeInit();
+		}
+		TGOSubtask();
+		ThrustIntegralsSubtask();
+		ReferenceThrustVectorSubtask();
+		RangeToGoSubtask();
+		TurningRateVectorSubtask();
+		SteeringInputsUpdateSubtask();
+
+		BurnoutStateVectorPredictionSubtask();
+		DesiredOrbitPlaneCorrectionSubtask();
+
+		DesiredPositionAscentRTLSSubtask();
+		DesiredVelocitySubtask();
+
+		VGOCorrectionSubtask();
+		ConvergenceCheckSubtask();
+
+		CutoffPositionConstraintReleaseSubtask();
+	}
+
+	void AscentGuidance::PositionMagnitudeSubTask()
+	{
+		// Magnitude of the current position vector
+		RMAG = length(RGD);
+	}
+
+	void AscentGuidance::VGOUpdateSubtask()
+	{
+		// Update velocity-to-be-gained (VGO) by decrementing it by the sensed velocity change (DVS)
+		VGO = VGO - DVS;
+		// If the burn time of the current guidance phase has elapsed, incremeent the guidance phase counter KPHASE
+		// And set the current guidance phase burn time (TB) and accumulated burn time for this guidance phase (TGOA) to zero
+		if ((TB[KPHASE - 1] - (TGD - TPRIME) <= 0) && KPHASE < N)
+		{
+			TB[KPHASE - 1] = 0.0;
+			TGOA[KPHASE - 1] = 0.0;
+			KPHASE++;
+		}
+		// Save value of current time for next pass
+		TPRIME = TGD;
+	}
+
+	void AscentGuidance::ModeIndependentInit()
+	{
+		// The following parameters are required to be initialized as indicated for all guidance modes
+		double B;
+
+		KPHASE = 1;
+		RBIAS = _V(0, 0, 0);
+		PHI = 0.0;
+		TPRIME = TGD;
+		TGO = 1.0;
+		OMEGA = _V(0, 0, 0);
+		B = EARTH_MU / pow(RMAG, 3);
+		RGRAV = -RGD * 0.5 * B;
+		SINIT = false;
+		TPREV = 0.0;
+	}
+
+	void AscentGuidance::StandardAscentModeInit()
+	{
+		// Enable plane and altitude constrained flags
+		SPLANE = true;
+		SALT = true;
+		// If trajectory lofting is desired (TFAIL is not zero), then TFAIL is converted from MET to GMT and the number of thrust phases is set to 3
+		if (TFAIL != 0.0)
+		{
+			TFAIL = TFAIL + T_GMTLO;
+			N = 3;
+		}
+		else
+		{
+			N = 2;
+		}
+		// TBD: In the future, there is some AOA/ATO logic here for the IY vector
+		IY = IYD;
+		// Initialize the predicted cutoff position and velocity and VGO as follows:
+		RP = RGD;
+		VP = VGD;
+		VGO = _V(0, 0, 0);
+		// Perform the following subtasks for standard ascent:
+		DesiredOrbitPlaneCorrectionSubtask();
+		DesiredPositionAscentRTLSSubtask();
+		DesiredVelocitySubtask();
+		VGOCorrectionSubtask();
+		ConvergenceCheckSubtask();
+	}
+
+	void AscentGuidance::DesiredOrbitPlaneCorrectionSubtask()
+	{
+		// The purpose of this subtask is to constrain the position (RD) to be in a desired orbit plane whenever
+		// SPLANE = ON or to allow the position to remain in the predicted cutoff orbit plane whenever SPLANE = OFF.
+
+		if (SPLANE)
+		{
+			RD = RP - IY * dotp(RP, IY);
+		}
+		else
+		{
+			RD = RP;
+		}
+	}
+
+	void AscentGuidance::DesiredPositionAscentRTLSSubtask()
+	{
+		// The purpose of this subtask is to correct the magnitude of the burnout position vector when cutoff altitude is being controlled
+		// (SALT = ON) for the standard ascent mode and to compute a unit vector of the burnout position vector in either case.
+
+		IX = unit(RD);
+		if (SALT)
+		{
+			RD = IX * RDMAG;
+		}
+	}
+
+	void AscentGuidance::DesiredVelocitySubtask()
+	{
+		// The desired velocity vector is calculated from the following equation:
+		VD = (IX * sin(GAMD) + unit(crossp(IX, IY)) * cos(GAMD)) * VDMAG;
+		// If SPLANE = OFF, IY is recomputed as follows:
+		if (SPLANE == false)
+		{
+			IY = unit(crossp(VD, RD));
+		}
+	}
+
+	void AscentGuidance::VGOCorrectionSubtask()
+	{
+		// The purpose of this subtask is to calculate a miss in velocity, VMISS, and a delta VGO vector (DVGO), and to correct the VGO vector(VGO).
+
+		// The velocity miss vector is computed as follows:
+		VMISS = VP - VD;
+		// The delta VGO vector for all PEG modes except RTLS is computed as follows:
+		DVGO = -VMISS * RHOMAG;
+		// The VGO vector, VGO, is corrected as follows:
+		VGO = VGO + DVGO;
+	}
+
+	void AscentGuidance::ConvergenceCheckSubtask()
+	{
+		// Compute the magnitude of VGO and the convergence criterion as follows:
+		VGOMAG = length(VGO);
+		EMISS = KMISS * VGOMAG;
+		// Determine whether or not VGO is converged.
+		if (length(VMISS) > EMISS)
+		{
+			SCONV = false;
+		}
+	}
+
+	void AscentGuidance::TGOSubtask()
+	{
+		// The purpose of this subtask is to calculate the total time–to–go until the end of the maneuver TGO,
+		// and the intermediate time–to–go for each guidance phase for use in the thrust integrals.
+
+		double LREM;
+		int I;
+
+		VGOMAG = length(VGO);
+		TAU[KPHASE - 1] = VEX / ATR;
+		VEXA[KPHASE - 1] = VEX;
+
+		if (KPHASE == 1 && N == 3)
+		{
+			TB[0] = TFAIL - TGD;
+			LA[0] = -VEX * log(1.0 - TB[0] / TAU[0]);
+			TAU[1] = 0.0; //TBD: TFAIL logic
+			VEXA[1] = VEX;
+			LREM = VGOMAG - LA[0];
+		}
+		else
+		{
+			LREM = VGOMAG;
+		}
+		if (KPHASE < N)
+		{
+			I = N - 1;
+		}
+		else
+		{
+			I = N;
+		}
+		TB[N - 2] = TAU[I - 1] - VEX / AL;
+		if (TB[N - 2] <= ETB)
+		{
+			TB[N - 2] = 0.0;
+			LA[N - 2] = 0.0;
+			KPHASE = N;
+			TGOA[N - 2] = 0.0;
+		}
+		else
+		{
+			LA[N - 2] = -VEX * log(1.0 - TB[N - 2] / TAU[I - 1]);
+			if (KPHASE == N)
+			{
+				KPHASE = N - 1;
+				TAU[N - 2] = TAU[N - 1];
+			}
+		}
+		if (LREM <= LA[N - 2])
+		{
+			LA[N - 1] = 0.0;
+			TB[N - 1] = 0.0;
+			LA[N - 2] = LREM;
+			TB[N - 2] = TAU[I - 1] * (1.0 - exp(-LA[N - 2] / VEX));
+		}
+		else
+		{
+			LA[N - 1] = LREM - LA[N - 2];
+			TB[N - 1] = LA[N - 1] / AL;
+		}
+
+		for (I = KPHASE; I <= N; I++)
+		{
+			TGOA[I - 1] = 0.0;
+			for (int JJ = KPHASE; JJ <= I; JJ++)
+			{
+				TGOA[I - 1] = TGOA[I - 1] + TB[JJ - 1];
+			}
+		}
+		TGOP = TGO;
+		TGO = TGOA[N - 1];
+		TP = TGD + TGO;
+	}
+
+	void AscentGuidance::ThrustIntegralsSubtask()
+	{
+		// The purpose of this subtask is to evaluate various time integrals of	force over mass.
+
+		double Q, TGOB;
+		int I;
+
+		L = S = JOL = J = Q = 0.0;
+
+		for (I = KPHASE; I <= N; I++)
+		{
+			if (I == 1)
+			{
+				TGOB = 0.0;
+			}
+			else
+			{
+				TGOB = TGOA[I - 2];
+			}
+			if (I < N)
+			{
+				SA[I - 1] = -LA[I - 1] * (TAU[I - 1] - TB[I - 1]) + VEXA[I - 1] * TB[I - 1];
+				QA[I - 1] = SA[I - 1] * (TAU[I - 1] + TGOB) - 0.5 * VEXA[I - 1] * TB[I - 1] * TB[I - 1];
+			}
+			else
+			{
+				SA[I - 1] = 0.5 * LA[I - 1] * TB[I - 1];
+				QA[I - 1] = SA[I - 1] * (TGOB + TB[I - 1] / 3.0);
+				//TBD: Something with N_SSME == 0
+			}
+			S = S + SA[I - 1] + L * TB[I - 1];
+			Q = Q + QA[I - 1] + J * TB[I - 1];
+			L = L + LA[I - 1];
+			J = J + LA[I - 1] * TGOA[I - 1] - SA[I - 1];
+		}
+		if (L == 0) return;
+		JOL = J / L;
+		QPRIME = Q - S * JOL;
+		TLAM = TGD + JOL;
+	}
+
+	void AscentGuidance::ReferenceThrustVectorSubtask()
+	{
+		// The purpose of this subtask is to determine a reference thrust vector, LAM, for all guidance modes.
+		// This vector is a unit vector in the direction of VGO
+
+		if (VGOMAG != 0.0)
+		{
+			LAM = VGO / VGOMAG;
+		}
+		else
+		{
+			// TBD: Exit PEG?
+		}
+	}
+
+	void AscentGuidance::RangeToGoSubtask()
+	{
+		// The purpose of this subtask is to compute the position–to–be–gained vector, RGO.
+
+		VECTOR3 RGOPRIME, RGOXY, IZ;
+		double RGOX, RGOY, RGOZ;
+
+		RGRAV = RGRAV * pow(TGO / TGOP, 2);
+		RGO = RD - (RGD + VGD * TGO + RGRAV) + RBIAS;
+		RGOPRIME = crossp(OMEGA, LAM) * QPRIME + LAM * S;
+		if (SALT)
+		{
+			RGOX = dotp(RGO, IX);
+		}
+		else
+		{
+			RGOX = dotp(RGOPRIME, IX);
+		}
+		if (SPLANE)
+		{
+			RGOY = dotp(RGO, IY);
+		}
+		else
+		{
+			RGOY = dotp(RGOPRIME, IY);
+		}
+		RGOXY = IX * RGOX + IY * RGOY;
+		IZ = crossp(IX, IY);
+		RGOZ = (S - dotp(LAM, RGOXY)) / dotp(LAM, IZ);
+		RGO = RGOXY + IZ * RGOZ;
+	}
+
+	void AscentGuidance::TurningRateVectorSubtask()
+	{
+		// The purpose of this subtask is the calculation of thrust turning rate, LAMD, from RGO and previously calculated integrals.
+
+		double EL_LIMIT, DTA_LIMIT, LAMDMAX;
+
+		LAMD = (RGO - LAM * S) / QPRIME;
+		LAMDMAG = length(LAMD);
+
+		EL_LIMIT = sqrt(1.0 / pow(dotp(LAM, IX), 2) - 1.0) / JOL;
+
+		DTA_LIMIT = (0.5 + PHI) / JOL;
+		if (LAMDMAG > PHIDOT_MAX || LAMDMAG > DTA_LIMIT)
+		{
+			SCONV = false;
+		}
+		else
+		{
+			SCONV = true;
+		}
+		/*if (LAMDMAG > EL_LIMIT)
+		{
+			S_LOW_TW = true;
+		}
+		else
+		{
+			S_LOW_TW = false;
+		}*/
+		LAMDMAX = min(PHIDOT_MAX, min(DTA_LIMIT, EL_LIMIT));
+
+		if (LAMDMAG > LAMDMAX)
+		{
+			LAMDMAG = LAMDMAX;
+			LAMD = unit(LAMD) * LAMDMAG;
+			RGO = LAM * S + LAMD * QPRIME;
+		}
+		PHI = JOL * LAMDMAG;
+	}
+
+	void AscentGuidance::SteeringInputsUpdateSubtask()
+	{
+		// The purpose of this subtask is to provide new steering inputs to the G/C steering interface principal function.
+
+		//TBD: More output to do for other modes
+		LAMC = LAM;
+		TPREV = TP;
+	}
+
+	void AscentGuidance::BurnoutStateVectorPredictionSubtask()
+	{
+		// The purpose of this sub–task is to calculate the first integral of thrust and first and second time integrals of gravity
+		// as required in the prediction of the burnout state vector.
+
+		VECTOR3 R_INIT, V_INIT, R_FINAL, V_FINAL, VGRAV;
+		double DT_MAX;
+
+		int JJ;
+
+		RTHRUST = _V(0, 0, 0);
+		VTHRUST = _V(0, 0, 0);
+		TI = -JOL;
+		IF_MAG_I = sqrt(1.0 + LAMDMAG * LAMDMAG * TI * TI);
+		if (LA[N - 1] != 0.0)
+		{
+			JJ = N;
+		}
+		else
+		{
+			JJ = N - 1;
+		}
+		for (int I = KPHASE; I <= JJ; I++)
+		{
+			ThrustTimeIntegralsLogic(I);
+		}
+		RBIAS = RGO - RTHRUST;
+		R_INIT = RGD - RTHRUST * 0.1 - VTHRUST * TGO / 30.0;
+		V_INIT = VGD + RTHRUST * 1.2 / TGO - VTHRUST * 0.1;
+		DT_MAX = midval(DT_LIMIT, DTMIN, TGO / NSEG);
+		ASC_PREC_PRED(R_INIT, V_INIT, TGD, TP, 0, 0, DT_MAX, R_FINAL, V_FINAL);
+		VGRAV = V_FINAL - V_INIT;
+		RGRAV = R_FINAL - R_INIT - V_INIT * TGO;
+		RP = RGD + VGD * TGO + RGRAV + RTHRUST;
+		VP = VGD + VGRAV + VTHRUST;
+	}
+
+	void AscentGuidance::ThrustTimeIntegralsLogic(int I)
+	{
+		double TF, IF_MAG_F;
+
+		TF = TI + TB[I - 1];
+		IF_MAG_F = sqrt(1.0 + LAMDMAG * LAMDMAG * TF * TF);
+		RTHRUST = RTHRUST + VTHRUST * TB[I - 1];
+		if (LAMDMAG * TB[I - 1] < 0.09)
+		{
+			double TFMEANSQ = abs(TF * TF + TI * TF + TI * TI) / 3.0;
+			double SMA_GAIN = 1.0 / sqrt(1.0 + TFMEANSQ * LAMDMAG * LAMDMAG);
+			RTHRUST = RTHRUST + (LAM * SA[I - 1] + LAMD * (QA[I - 1] - SA[I - 1] * JOL)) * SMA_GAIN;
+			VTHRUST = VTHRUST + (LAM * LA[I - 1] + LAMD * (LA[I - 1] * TGOA[I - 1] - SA[I - 1] - LA[I - 1] * JOL)) * SMA_GAIN;
+		}
+		else
+		{
+			double A, B, C, Y[5], M[3];
+
+			if (I == N)
+			{
+				A = AL;
+				B = C = 0.0;
+			}
+			else
+			{
+				C = 60.0 * (0.5 * pow(TB[I - 1], 2) * LA[I - 1] + 3.0 * TI * SA[I - 1] - 3.0 * (QA[I - 1] - SA[I - 1] * JOL)) / pow(TB[I - 1], 5);
+				B = 12.0 * (0.5 * TB[I - 1] * LA[I - 1] - SA[I - 1]) / pow(TB[I - 1], 3) - C * (TF + TI);
+				A = LA[I - 1] / TB[I - 1] - 0.5 * B * (TF + TI) - C * (pow(TB[I - 1], 2) / 3.0 + TI * TF);
+			}
+			Y[0] = log(abs((TF * LAMDMAG + IF_MAG_F) / (TI * LAMDMAG + IF_MAG_I))) / LAMDMAG;
+			Y[1] = (TF * TF - TI * TI) / (IF_MAG_I + IF_MAG_F);
+			for (int X = 1; X <= 3; X++)
+			{
+				Y[X + 1] = (IF_MAG_F * pow(TF, X) - IF_MAG_I * pow(TI, X) - (double)X * Y[X - 1]) / (LAMDMAG * LAMDMAG * (double)(X + 1));
+				M[X - 1] = A * Y[X - 1] + B * Y[X] + C * Y[X + 1];
+			}
+			RTHRUST = RTHRUST + LAM * (TF * M[0] - M[1]) + LAMD * (TF * M[1] - M[2]);
+			VTHRUST = VTHRUST + LAM * M[0] + LAMD * M[1];
+		}
+		TI = TF;
+		IF_MAG_I = IF_MAG_F;
+	}
+
+	void AscentGuidance::CutoffPositionConstraintReleaseSubtask()
+	{
+		// For reasons of flight control stability near cutoff, there is a guidance requirement to release position constraints at a fixed input TGO(DTRD).
+		// Therefore, if either altitude (SALT = ON) or the orbital plane (SPLANE = ON) is being constrained and
+		// if TGO is less than DTRD and VGO is converged (SCONV = ON), the position constraints are released.
+		// If VGO is unconverged when TGO first becomes less than DTRD and remains unconverged on subsequent cycles, the position constraints will be released
+		// when TGO becomes less than DTRD–6 and the PEG initialization discrete (SINIT) is OFF.
+
+		if ((SALT || SPLANE) && ((SCONV && TGO < DTRD) || (TGO < DTRD - 6.0 && SINIT == false)))
+		{
+			OMEGA = crossp(LAM, LAMD);
+			SALT = false;
+			SPLANE = false;
+		}
+	}
+
+	void AscentGuidance::CENTRAL(VECTOR3 R, VECTOR3& ACCEL, double& R_INV) const
+	{
+		// Calculate spherical acceleration term
+
+		R_INV = 1.0 / length(R);
+		ACCEL = -R * EARTH_MU * pow(R_INV, 3);
+	}
+
+	void AscentGuidance::ASC_PREC_PRED(VECTOR3 R_INIT, VECTOR3 V_INIT, double T_INIT, double T_FINAL, int GMD_PRED, int GMO_PRED, double DT_MAX, VECTOR3& R_FINAL, VECTOR3& V_FINAL) const
+	{
+		// Predict final state vector from initial state vector
+		// TBD: Only spherical gravity model for now
+
+		VECTOR3 G_PREVIOUS, G_FINAL;
+		double STEP_SIZE, T, R_INV;
+		int NUMBER_STEPS;
+
+		R_FINAL = R_INIT;
+		V_FINAL = V_INIT;
+
+		NUMBER_STEPS = (int)max(round(abs(T_FINAL - T_INIT) / DT_MAX), 1.0);
+		STEP_SIZE = (T_FINAL - T_INIT) / (double)(NUMBER_STEPS);
+		T = T_INIT;
+
+		if (GMD_PRED == 0)
+		{
+			CENTRAL(R_FINAL, G_PREVIOUS, R_INV);
+		}
+		else
+		{
+			//TBD
+		}
+		for (int I = 0; I < NUMBER_STEPS; I++)
+		{
+			T = T + STEP_SIZE;
+			R_FINAL = R_FINAL + (V_FINAL + G_PREVIOUS * 0.5 * STEP_SIZE) * STEP_SIZE;
+			if (GMD_PRED == 0)
+			{
+				CENTRAL(R_FINAL, G_FINAL, R_INV);
+			}
+			else
+			{
+				//TBD
+			}
+			V_FINAL = V_FINAL + (G_PREVIOUS + G_FINAL) * 0.5 * STEP_SIZE;
+			R_FINAL = R_FINAL + (G_FINAL - G_PREVIOUS) / 6.0 * STEP_SIZE * STEP_SIZE;
+			G_PREVIOUS = G_FINAL;
+		}
+	}
+
 
 AscentDAP::AscentDAP(SimpleGPCSystem* _gpc)
 : SimpleGPCSoftware(_gpc, "AscentDAP"),
@@ -101,10 +840,13 @@ AscentDAP::AscentDAP(SimpleGPCSystem* _gpc)
 	EOVI[0] = 0;
 	EOVI[1] = 0;
 
-	dogleg = false;
-
 	AutoFCS = true;
 
+	VS = VSP = DVS = _V(0, 0, 0);
+
+	XTRK = 0.0;
+	MEDS_D_INCL = 0.0;
+
 	// I-LOADs init
 	KMAX_NOM = 104;
 	KMAX_ABORT = 104;
@@ -156,6 +898,10 @@ void AscentDAP::Realize()
 	assert( (pRHC_SOP != NULL) && "AscentDAP::Realize.pRHC_SOP" );
 	pSBTC_SOP = dynamic_cast<SBTC_SOP*> (FindSoftware( "SBTC_SOP" ));
 	assert( (pSBTC_SOP != NULL) && "AscentDAP::Realize.pSBTC_SOP" );
+	pGNCUtilities = dynamic_cast<GNCUtilities*>(FindSoftware("GNCUtilities"));
+	assert((pGNCUtilities != NULL) && "OMSBurnSoftware::Realize.pGNCUtilities");
+	pStateVectorSoftware = dynamic_cast<StateVectorSoftware*>(FindSoftware("StateVectorSoftware"));
+	assert((pStateVectorSoftware != NULL) && "OMSBurnSoftware::Realize.pStateVectorSoftware");
 }
 
 void AscentDAP::ReadILOADs( const std::map<std::string,std::string>& ILOADs )
@@ -229,7 +975,7 @@ void AscentDAP::OnPreStep( double simt, double simdt, double mjd )
 			else
 			{
 				// CSS
-				// TODO when RHCs in detent, hold attitude when rates fall below 3º/s
+				// TODO when RHCs in detent, hold attitude when rates fall below 3º/s
 				degReqdRates = _V( range( -12, pRHC_SOP->GetPitchCommand() * 0.5, 12 ), -range( -6, pRHC_SOP->GetYawCommand() * 0.5, 6 ), range( -12, pRHC_SOP->GetRollCommand() * 0.5, 12 ) );
 			}
 
@@ -249,7 +995,7 @@ void AscentDAP::OnPreStep( double simt, double simdt, double mjd )
 				else
 				{
 					// CSS
-					// TODO when RHCs in detent, hold attitude when rates fall below 3º/s
+					// TODO when RHCs in detent, hold attitude when rates fall below 3º/s
 					degReqdRates = _V( range( -12, pRHC_SOP->GetPitchCommand() * 0.5, 12 ), -range( -6, pRHC_SOP->GetYawCommand() * 0.5, 6 ), range( -12, pRHC_SOP->GetRollCommand() * 0.5, 12 ) );
 				}
 
@@ -392,12 +1138,13 @@ void AscentDAP::FirstStageGuidance( double dt )
 	STS()->CalcSSMEThrustAngles(0, ThrAngleP, ThrAngleY);
 	FirstStageThrottle( dt );
 	FirstStageRateCommand();
+	AscentUPP();
 	return;
 }
 
 void AscentDAP::SecondStageGuidance( double dt )
 {
-	Navigate();// update speed post MECO
+	Navigate(dt);// update speed post MECO
 
 	if (ReadCOMPOOL_IS( SCP_MECO_CMD ) == 0)
 	{
@@ -409,74 +1156,88 @@ void AscentDAP::SecondStageGuidance( double dt )
 		}
 		SecondStageRateCommand();
 		SecondStageThrottle( dt );
+		AscentUPP();
 	}
 	return;
 }
 
 void AscentDAP::InitializeAutopilot()
 {
+	VECTOR3 IYD;
+	double TgtAlt, TgtInc, TgtFPA, TgtSpd, EarthRadius;
+	bool EF_PLANE_SW;
+
 	mission::Mission* pMission = STS()->GetMissionData();
-	TgtInc=pMission->GetMECOInc()*DEG;
-	TgtFPA=pMission->GetMECOFPA()*DEG;
+	TgtInc=pMission->GetMECOInc();
+	TgtFPA=pMission->GetMECOFPA();
 	TgtAlt=pMission->GetMECOAlt();
 	TgtSpd=pMission->GetMECOVel() - (SSMETailoffDV[2] / MPS2FPS);
+	IYD = pMission->GetIYD();
+	EF_PLANE_SW = pMission->GetEFPLANESW();
+
+	// FIRST STAGE GUIDANCE
 
 	hEarth = STS()->GetSurfaceRef();
 	//calculate heading
 	double latitude, longitude;
 	STS()->GetEquPos(longitude, latitude, EarthRadius);
-	if(abs(cos(TgtInc*RAD))>abs(cos(latitude))) {
+	if(abs(cos(TgtInc))>abs(cos(latitude))) {
 		radTargetHeading=PI05;
-		//TgtInc = latitude*DEG;
-		dogleg = true;
+		//TgtInc = latitude;
 	}
 	else {
 		// there are two possible launch headings: going north and going south
 		// for TgtInc < 65 deg (KSC launches) we want northerly heading; max. inclination of KSC launch was 62 degrees (with dog-leg)
 		// for TgtInc > 65 deg (VAFB) we want southerly heading
-		double InHeading = asin(cos(TgtInc*RAD)/cos(latitude));
+		double InHeading = asin(cos(TgtInc)/cos(latitude));
 		double xVel, yVel;
-		xVel = TgtSpd*cos(TgtFPA*RAD)*sin(InHeading)-464.581*cos(latitude);
-		yVel = TgtSpd*cos(TgtFPA*RAD)*cos(InHeading);
+		xVel = TgtSpd*cos(TgtFPA)*sin(InHeading)-464.581*cos(latitude);
+		yVel = TgtSpd*cos(TgtFPA)*cos(InHeading);
 		radTargetHeading=atan2(xVel, yVel); // northerly heading
-		if(TgtInc > 65.0) radTargetHeading = PI - radTargetHeading; // if heading is negative, this is retrograde inclination; use southerly heading
+		if(TgtInc > 65.0*RAD) radTargetHeading = PI - radTargetHeading; // if heading is negative, this is retrograde inclination; use southerly heading
 	}
 
-	mu=GGRAV*oapiGetMass(hEarth);
-	SidDay = oapiGetPlanetPeriod(hEarth);
-	//calculate apogee/perigee
-	EarthRadius = oapiGetSize(hEarth);
-	TgtRad = TgtAlt+EarthRadius;
-	double C = (2*mu)/(TgtRad*TgtSpd*TgtSpd);
-	double det = C*C + (4*(1-C)*pow(cos(TgtFPA*RAD), 2));
-	double root1 = (-C-sqrt(det))/(2*(1-C));
-	double root2 = (-C+sqrt(det))/(2*(1-C));
-	if(root1>root2) {
-		TAp=root1*TgtRad;
-		TPe=root2*TgtRad;
+	// SECOND STAGE GUIDANCE
+
+	VECTOR3 IY_M50;
+	double PRED_GMT_LO;
+
+	// Get GMT of liftoff. TBD: Is PRED_GMT_LO set in RSLS?
+	PRED_GMT_LO = ReadClock();
+
+	// Is an IY vector available from the mission data?
+	if (length(IYD) != 0.0)
+	{
+		// Yes
+		if (EF_PLANE_SW)
+		{
+			// Convert to M50 coordinates
+			IY_M50 = mul(pGNCUtilities->EARTH_FIXED_TO_M50_COORD(PRED_GMT_LO), IYD);
+		}
+		else
+		{
+			// Use vector as-is
+			// TBD: NODE_SLOPE etc.
+			IY_M50 = IYD;
+		}
 	}
-	else {
-		TAp=root2*TgtRad;
-		TPe=root1*TgtRad;
-	}
-	//calclate Ecc
-	TEcc= (2*TAp)/(TPe+TAp) - 1.0;
-	//TPe-=Radius;
-	//TAp-=Radius;
-	//calculate TrA
-	double h = TgtRad*TgtSpd*sin((90+TgtFPA)*RAD);
-	TTrA=asin((h*TgtSpd*sin(TgtFPA*RAD))/(mu*TEcc)); //angle in Rad
-	//Calculate orbit parameters for this ta
-	//aOrbit=TPe/(1-TEcc);
-	//p=aOrbit*(1-TEcc*TEcc);
-
-	//PEG
-	STS()->GetRelativePos(hEarth,rh0);
-	rh0=rh0*(1/length(rh0));
-	A=0.0;
-	//B=0.0;
-	C=0.0;
-	//D=0.0;
+	else
+	{
+		// No
+		// Calculate IY vector in Earth-fixed coordinates
+		VECTOR3 IY_EF = guid.CalculateEFIYVector(TgtInc, latitude, longitude, TgtInc < 65.0 * RAD, 300.0);
+		// Convert to M50 coordinates
+		IY_M50 = mul(pGNCUtilities->EARTH_FIXED_TO_M50_COORD(PRED_GMT_LO), IY_EF);
+	}
+
+	// Calculate target radius
+	EarthRadius = oapiGetSize(hEarth);
+	double TgtRad = TgtAlt + EarthRadius;
+
+	// Initialize ascent guidance
+	guid.Init(PRED_GMT_LO, TgtRad, TgtSpd, TgtFPA, IY_M50);
+
+	// sprintf_s(oapiDebugString(), 128, "PRED_GMT_LO %lf TgtInc %lf EF_PLANE_SW %d IYD %lf %lf %lf IY_M50 %lf %lf %lf", PRED_GMT_LO, TgtInc*DEG, EF_PLANE_SW, IYD.x, IYD.y, IYD.z, IY_M50.x, IY_M50.y, IY_M50.z);
 }
 
 double AscentDAP::GetCurrentHeading() const
@@ -739,7 +1500,7 @@ void AscentDAP::FirstStageThrottle( double dt )
 			WriteCOMPOOL_IS( SCP_K_CMD, ReadCOMPOOL_IS( SCP_KMAX ) );// throttle to mission power level
 
 			// update MECO targets
-			if (NSSME > 0) TgtSpd = STS()->GetMissionData()->GetMECOVel() - (SSMETailoffDV[NSSME - 1] / MPS2FPS);
+			if (NSSME > 0) guid.UpdateVDMAG(STS()->GetMissionData()->GetMECOVel() - (SSMETailoffDV[NSSME - 1] / MPS2FPS));
 		}
 	}
 
@@ -800,7 +1561,7 @@ void AscentDAP::SecondStageThrottle( double dt )
 			WriteCOMPOOL_IS( SCP_K_CMD, ReadCOMPOOL_IS( SCP_KMAX ) );// throttle to mission power level
 
 			// update MECO targets
-			if (NSSME > 0) TgtSpd = STS()->GetMissionData()->GetMECOVel() - (SSMETailoffDV[NSSME - 1] / MPS2FPS);
+			if (NSSME > 0) guid.UpdateVDMAG(STS()->GetMissionData()->GetMECOVel() - (SSMETailoffDV[NSSME - 1] / MPS2FPS));
 		}
 	}
 
@@ -814,7 +1575,7 @@ void AscentDAP::SecondStageThrottle( double dt )
 	if ((STS()->GetMass() * KG2LBM * LBS2SL) < MASS_LOW_LEVEL) pSSME_Operations->SetLowLevelSensorArmFlag();
 
 	// check for MECO
-	if ((inertialVelocity >= TgtSpd) && (pSBTC_SOP->GetManThrottle() == false))
+	if ((inertialVelocity >= guid.GetVDMAG()) && (pSBTC_SOP->GetManThrottle() == false))
 	{
 		//reached target speed
 		WriteCOMPOOL_IS( SCP_MECO_CMD, 1 );
@@ -858,150 +1619,76 @@ void AscentDAP::SecondStageThrottle( double dt )
 
 void AscentDAP::MajorCycle()
 {
-	radTargetHeading = CalculateAzimuth();
-	Estimate();
-	Guide();
-}
+	VECTOR3 pos, vel, U_STEER;
+
+	PFG_INP_TSK();
+
+	// Get state vector in M50 coordinates
+	STS()->GetRelativePos(STS()->GetSurfaceRef(), pos);
+	STS()->GetRelativeVel(STS()->GetSurfaceRef(), vel);
+
+	pos = ConvertBetweenLHAndRHFrames(pos);
+	vel = ConvertBetweenLHAndRHFrames(vel);
+
+	pos = mul(M_J2000_to_M50, pos);
+	vel = mul(M_J2000_to_M50, vel);
+
+	// Call guidance function
+	guid.Cycle(pos, vel, ReadClock(), ReadCOMPOOL_IS(SCP_K_CMD), NSSME, 0, STS()->GetMass(), DVS, U_STEER);
+
+	// Convert to old steering system
+	MATRIX3 M_EF_M50;
+	VECTOR3 u_up, R_EF, u_EF;
+	double radPitch, radHeading;
+
+	// Get Earth-fixed to M50 rotation matrix
+	M_EF_M50 = pGNCUtilities->EARTH_FIXED_TO_M50_COORD(ReadClock());
+	// Calculate unit vector of present position (in M50 coordinates)
+	u_up = unit(pos);
+	// Present position vector in Earth-fixed coordinates
+	R_EF = unit(tmul(M_EF_M50, pos));
+	// Desired thrust direction in Earth-fixed coordinates
+	u_EF = unit(tmul(M_EF_M50, U_STEER));
+	// Required pitch angle in radians
+	radPitch = PI05 - acos(dotp(U_STEER, u_up));
+	// Required heading angle in radians
+	radHeading = atan2(R_EF.x * u_EF.y - R_EF.y * u_EF.x, u_EF.z - R_EF.z * dotp(R_EF, u_EF));
+	if (radHeading < 0.0)
+	{
+		radHeading += PI2;
+	}
 
-double AscentDAP::CalculateAzimuth()
-{
-	double true_azimuth=0;
-	double latitude, longitude;
-	double azimuth/*,equator_v/*,target_radius*/;
-	double tgt_orbit_v[2],lnch_v[2],current_vel[2]; //vectors
-	VECTOR3 vel, horizonvel;
-	double temp;
-
-	STS()->GetEquPos(longitude, latitude, temp);
-	STS()->GetRelativeVel(hEarth, vel);
-	MATRIX3 rot;
-	STS()->GetRotationMatrix(rot);
-	vel = tmul(rot, vel);
-	STS()->HorizonRot(vel, horizonvel);
-	current_vel[1] = horizonvel.data[0]; //East
-	current_vel[0] = horizonvel.data[2];  // North
-
-	if (latitude > (TgtInc * RAD)) azimuth = PI05;
-	else azimuth = asin(range(-1, cos(TgtInc*RAD)/cos(latitude), 1));  // this equ doesn't take rotation into accout
-	//equator_v=EarthRadius*(PI2/SidDay);   //equator velocity
-	if ((dogleg == true) && (latitude < (TgtInc * RAD))) tgt_orbit_v[0]=-TgtSpd*cos(TgtFPA*RAD)*cos(azimuth);
-	else tgt_orbit_v[0]=TgtSpd*cos(TgtFPA*RAD)*cos(azimuth) * sign( 65 - TgtInc ); // northern velocity
-	tgt_orbit_v[1]=TgtSpd*cos(TgtFPA*RAD)*sin(azimuth); // eastern velocity
-	//lnch_v[0]= abs(tgt_orbit_v[0]) - abs(current_vel[0]); // taking current velocity into accout for CC (North); assume both values have same sign
-	//lnch_v[1]= abs(tgt_orbit_v[1]) - abs(current_vel[1]); // taking current velocity into accout for CC (East); assume both values have same sign
-	lnch_v[0]= fabs( tgt_orbit_v[0] - current_vel[0] );
-	lnch_v[1]= fabs( tgt_orbit_v[1] - current_vel[1] );
-
-	//if (lnch_v[0]==0) lnch_v[0]=0.01; //div by zero protection
-	/*if(lnch_v[0]==0.0) { //div by zero protection
-		if(lnch_v[1]>0) true_azimuth=PI05;
-		else true_azimuth=-PI05;
-	}*/
-	//else true_azimuth = atan(lnch_v[1]/lnch_v[0]); // tan(azimuth) = eastern_vel / northern_vel
-	true_azimuth = atan2(lnch_v[1], lnch_v[0]); // tan(azimuth) = eastern_vel / northern_vel
-	if ((current_vel[0] < 0.0) && (TgtInc > 65)) true_azimuth = PI + true_azimuth;
-	if ((tgt_orbit_v[1] > 0.0) && (TgtInc > 65)) true_azimuth = PI2 - true_azimuth;
-	//if(current_vel[0] < 0.0) true_azimuth = PI - true_azimuth; // we are heading south, so need to use southerly heading
-	//if(current_vel[1] < 0.0) true_azimuth = PI2 - true_azimuth; // retrograde inclination
-
-	if ((dogleg == true) && (latitude < (TgtInc * RAD))) true_azimuth = PI - true_azimuth;
-
-	return true_azimuth;
+	//sprintf_s(oapiDebugString(), 128, "Heading %lf deg, Pitch %lf deg", radHeading * DEG, radPitch * DEG);
+
+	// Use outputs
+	target_pitch = radPitch * DEG;
+	radTargetHeading = radHeading;
+	timeRemaining = guid.GetTimeRemaining();
+
+	// From old Guide()
+	CmdPDot = (target_pitch - ThrAngleP * cos(STS()->GetBank()) - STS()->GetPitch() * DEG) / (2 * ASCENT_MAJOR_CYCLE);
 }
 
-void AscentDAP::Navigate()
+void AscentDAP::Navigate(double dt)
 {
-	VECTOR3 rv, vv, hv;
+	VECTOR3 rv, vv;
 	STS()->GetRelativePos(STS()->GetSurfaceRef(),rv);
 	STS()->GetRelativeVel(STS()->GetSurfaceRef(),vv);
-	radius=length(rv);
 	inertialVelocity=length(vv);
-	hv=crossp(rv,vv);
-	h=length(hv);
-	rh=rv*(1/radius);
-	hh=hv*(1/h);
-	thetah=crossp(hh,rh);
-	vr=dotp(vv,rh);
-	vtheta=dotp(vv,thetah);
-	omega=vtheta/radius;
-	//w=x/(radius*radius);
-	//last_target_pitch=target_pitch;
-	//last_target_yaw=target_yaw;
-	//last_target_roll=target_roll;
-	//oapiGetFocusPitch(&pitch);
 
 	double F=STS()->CalcNetSSMEThrust();
 	double m=STS()->GetMass();
-	Isp=STS()->GetSSMEISP();
 	thrustAcceleration=F/m;
-	tau=Isp/thrustAcceleration;
-	//theta=acos(dotp(rh0,rh));
-	//phi=acos(dotp(rh,rmh));
-	//VECTOR3 rhxrmh=crossp(rh,rmh);
-	//if(rhxrmh.y>0)phi=PI2-phi;
-}
 
-void AscentDAP::Estimate()
-{
-	double rbar=(radius+TgtRad)/2;
-	/*double num=mu/(rbar*rbar)-omega*omega*radius;
-	double fr=A+num/a0;
-	double fdotr=B+(num/a(T)-fr)/T;
-	double fh=0; //No yaw guidance yet
-	double fdoth=0;
-	double ftheta=1-fr*fr/2-fh*fh/2;  //Small number approximation to hypot
-	double fdottheta=-(fr*fdotr+fh*fdoth);
-	double fdotdottheta=-(fdotr*fdotr+fdoth*fdoth)/2;*/
-
-	//Estimate true anomaly at cutoff
-	//double d3=h*vr/(radius*radius*radius);
-	//double d4=(h*(TgtSpd*sin(TgtFPA*RAD))/(TgtRad*TgtRad*TgtRad)-d3)/T;
-	//double simdtheta=(h/(radius*radius))*T+(ftheta*c0(T)+fdottheta*cn(T,1)+fdotdottheta*cn(T,2))/rbar-d3*T*T-d4*T*T*T/3.0;
-	//thetaT=theta+simdtheta;
-	double p=(TPe/(1-TEcc))*(1-TEcc*TEcc);
-	//Estimate time of cutoff
-	double hT=sqrt(mu*p);
-	double deltah=hT-h;
-	double deltav=deltah/rbar;
-	timeRemaining=tau*(1-exp(-deltav/Isp));
-	if(timeRemaining>1000) timeRemaining=1000;
-	//Any comparison with NaN is false, so
-	//invert these tests so it's true if NaN
-	if(!(tau>timeRemaining) || !(0<timeRemaining)) timeRemaining=tau-10;
-	//  if(!(tau>T)|!(0<T))T=T2;
-	//metCutoff=timeRemaining + met;
-}
-
-void AscentDAP::Guide()
-{
-	//Calculate pitch steering coefficients
-	double a=b0(timeRemaining);
-	double b=bn(timeRemaining,1);
-	double c=c0(timeRemaining);
-	double d=cn(timeRemaining,1);
-	double y1=TgtSpd*sin(TgtFPA*RAD)-vr;
-	double y2=TgtRad-vr*timeRemaining-radius;
-	double D=a*d-b*c;
-	A=(d*y1-b*y2)/D;
-	//B=(a*y2-c*y1)/D;
-
-	//VECTOR3 ang_vel;
-	C=(mu/(radius*radius)-(omega*omega*radius))/thrustAcceleration;
-	//target_roll=0;
-	//target_yaw=0;
-	//fhdotrh=A+B*(met-TLastAB)+C;
-	double fhdotrh=A+C;
-	if(fabs(fhdotrh)>1) {
-		//Commanded to do a cos(pitch) out of range
-		target_pitch = STS()->GetPitch()*DEG;
+	// TBD: Temporary code for accumulated IMU velocity
+	VECTOR3 ThrustVector;
+	if (STS()->GetThrustVector(ThrustVector)) {
+		MATRIX3 LocalToGlobal;
+		STS()->GetRotationMatrix(LocalToGlobal);
+		VECTOR3 GlobalThrust = mul(LocalToGlobal, ThrustVector);
+		GlobalThrust = mul(M_J2000_to_M50, _V(GlobalThrust.x, GlobalThrust.z, GlobalThrust.y));
+		VS += (GlobalThrust / m) * dt;
 	}
-	else {
-		target_pitch=(PI05-acos(fhdotrh))*DEG;
-	}
-
-	//target_pitch = target_pitch+ThrAngleP; //yaw angle ignored for now
-	CmdPDot=(target_pitch-ThrAngleP*cos(STS()->GetBank())-STS()->GetPitch()*DEG)/(2*ASCENT_MAJOR_CYCLE);
-	//CmdPDot=(target_pitch-ThrAngleP*cos(GetBank())-GetPitch()*DEG)/TMajorCycle;
 }
 
 void AscentDAP::AdaptiveGuidanceThrottling( void )
@@ -1042,6 +1729,36 @@ void AscentDAP::AdaptiveGuidanceThrottling( void )
 	return;
 }
 
+void AscentDAP::PFG_INP_TSK()
+{
+	// Calculate change in accumulated sensed velocity from previous value
+	DVS = VS - VSP;
+	// Save new value as previous value
+	VSP = VS;
+}
+
+void AscentDAP::AscentUPP()
+{
+	// TBD: This should be Ascent UPP code
+	VECTOR3 R_AVGG, V_AVGG, IYC, IY_XTRK, IYC_EF, IYT_EF;
+	double T_STATE, INCL_TARGET;
+
+	pStateVectorSoftware->GetCurrentStateVectorsM50(R_AVGG, V_AVGG);
+	R_AVGG *= MPS2FPS;
+	V_AVGG *= MPS2FPS;
+	IY_XTRK = guid.GetIYVector();
+	T_STATE = ReadClock();
+
+	IYC = unit(crossp(V_AVGG, R_AVGG));
+
+	XTRK = -dotp(R_AVGG, IY_XTRK) * NAUTMI_PER_FT;
+
+	IYC_EF = tmul(pGNCUtilities->EARTH_FIXED_TO_M50_COORD(T_STATE), IYC);
+	IYT_EF = tmul(pGNCUtilities->EARTH_FIXED_TO_M50_COORD(T_STATE), IY_XTRK);
+	INCL_TARGET = acos(-IYT_EF.z);
+	MEDS_D_INCL = INCL_TARGET - acos(-IYC_EF.z);
+}
+
 void AscentDAP::NullSRBNozzles( void )
 {
 	bNullSRBNozzles = true;
@@ -1072,7 +1789,7 @@ double AscentDAP::GetEOVI( int EO ) const
 
 double AscentDAP::GetTgtSpd( void ) const
 {
-	return TgtSpd;
+	return guid.GetVDMAG();
 }
 
 double AscentDAP::GetInertialVelocity( void ) const
@@ -1090,6 +1807,16 @@ double AscentDAP::GetTimeRemaining( void ) const
 	return timeRemaining;
 }
 
+double AscentDAP::GetCrossTrack(void) const
+{
+	return XTRK;
+}
+
+double AscentDAP::GetDeltaInclination(void) const
+{
+	return MEDS_D_INCL;
+}
+
 double AscentDAP::GetTargetHeading( void ) const
 {
 	return radTargetHeading;
@@ -1099,4 +1826,5 @@ bool AscentDAP::GetFCSmode( void ) const
 {
 	return AutoFCS;
 }
+
 }
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.h b/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.h
index b2f2527e..6d9b0f1a 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.h	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/dps/Software/GNC/AscentDAP.h	
@@ -43,6 +43,8 @@ Date         Developer
 2022/09/29   GLS
 2022/11/15   GLS
 2022/12/23   GLS
+2025/12/27   indy91
+2026/01/06   indy91
 ********************************************/
 #ifndef _dps_ASCENTDAP_H_
 #define _dps_ASCENTDAP_H_
@@ -61,6 +63,213 @@ class MPS_ATVC_CMD_SOP;
 class SRBSepSequence;
 class RHC_SOP;
 class SBTC_SOP;
+class GNCUtilities;
+class StateVectorSoftware;
+
+class AscentGuidance
+{
+public:
+	AscentGuidance();
+
+	void Init(double T_GMTLO, double r_D, double v_D, double gamma_D, VECTOR3 IY_M50);
+
+	void Cycle(VECTOR3 R, VECTOR3 V, double T, int K_CMD, int N_SSME, int N_OMS, double mass, VECTOR3 DV, VECTOR3& U_STEER);
+
+	// Update insertion velocity
+	void UpdateVDMAG(double v);
+
+	// Convert inclination to IY vector
+	VECTOR3 CalculateEFIYVector(double Incl, double Lat, double Lng, bool north, double dt_bias) const;
+	// Get time remaining
+	double GetTimeRemaining() const;
+	// Get IY vector
+	VECTOR3 GetIYVector() const;
+	// Get desired insertion velocity
+	double GetVDMAG() const;
+private:
+
+	void AscentGuidanceTask();
+	void PEGTask();
+	void PositionMagnitudeSubTask();
+	void VGOUpdateSubtask();
+	void ModeIndependentInit();
+	void StandardAscentModeInit();
+	void DesiredOrbitPlaneCorrectionSubtask();
+	void DesiredPositionAscentRTLSSubtask();
+	void DesiredVelocitySubtask();
+	void VGOCorrectionSubtask();
+	void ConvergenceCheckSubtask();
+	void TGOSubtask();
+	void ThrustIntegralsSubtask();
+	void ReferenceThrustVectorSubtask();
+	void RangeToGoSubtask();
+	void TurningRateVectorSubtask();
+	void SteeringInputsUpdateSubtask();
+	void BurnoutStateVectorPredictionSubtask();
+	void ThrustTimeIntegralsLogic(int I);
+	void CutoffPositionConstraintReleaseSubtask();
+
+	// TBD: Move this to navigation code
+	void CENTRAL(VECTOR3 R, VECTOR3& ACCEL, double& R_INV) const;
+	void ASC_PREC_PRED(VECTOR3 R_INIT, VECTOR3 V_INIT, double T_INIT, double T_FINAL, int GMD_PRED, int GMO_PRED, double DT_MAX, VECTOR3& R_FINAL, VECTOR3& V_FINAL) const;
+
+	// INPUTS
+	// Desired MECO radius magnitude [FT]
+	double RDMAG;
+	// Desired MECO velocity magnitude [FT/SEC]
+	double VDMAG;
+	// Desired MECO flight path angle [RAD]
+	double GAMD;
+	// Target orbital plane (negative of relative angular momentum vector) [ND]
+	VECTOR3 IYD;
+	// Time at which guidance assumes an SSME failure [SEC]
+	double TFAIL;
+
+	// Launch GMT. TBD: AVAILABLE FROM COMPOOL, TEMPORARY
+	double T_GMTLO;
+
+	// INTERNAL
+	// VGO correction [FT/SEC]
+	VECTOR3 DVGO;
+	// Change in accumulated sensed velocity from previous value [FT/SEC]
+	VECTOR3 DVS;
+	// Guidance coordinate system X–axis in M50 coordinates [ND]
+	VECTOR3 IX;
+	// Unit vector normal to desired plane [ND]
+	VECTOR3 IY;
+	// Unit vector in direction of velocity–to–go [ND]
+	VECTOR3 LAM;
+	// M50 desired thrust vector [ND]
+	VECTOR3 LAMC;
+	// Turning rate vector [1/SEC]
+	VECTOR3 LAMD;
+	// Thrust turning rate vector [1/SEC]
+	VECTOR3 OMEGA;
+	// Difference between RGOG and RTHRUST [FT]
+	VECTOR3 RBIAS;
+	// Desired thrust cutoff position vector [FT]
+	VECTOR3 RD;
+	// Guidance position vector [FT]
+	VECTOR3 RGD;
+	// Desired position change due to thrust [FT]
+	VECTOR3 RGO;
+	// Position contributation of gravity [FT]
+	VECTOR3 RGRAV;
+	// Predicted cutoff position vector [FT]
+	VECTOR3 RP;
+	// Position change due to thrust [FT]
+	VECTOR3 RTHRUST;
+	// Desired thrust cutoff velocity vector [FT]
+	VECTOR3 VD;
+	// Guidance velocity vector [FT/SEC]
+	VECTOR3 VGD;
+	// Velocity-to-be gained vector [FT/SEC]
+	VECTOR3 VGO;
+	// Cutoff velocity error [FT/SEC]
+	VECTOR3 VMISS;
+	// Predicted cutoff velocity vector [FT/SEC]
+	VECTOR3 VP;
+	// Velocity change due to thrust [FT/SEC]
+	VECTOR3 VTHRUST;
+
+	// Current acceleration [FT/SEC^2]
+	double ATR;
+	// Maximum integration step size for gravity prediction [SEC]
+	double DT_LIMIT;
+	// Maximum value of VMISS for PEG convergence [FT/SEC]
+	double EMISS;
+	// Total vehicle thrust force [LBF]
+	double FT;
+	// Magnitude of linear tangent vector at start of thrust phase [ND]
+	double IF_MAG_I;
+	// Thrust integrals for Ith thrust phase
+	double LA[3], SA[3], QA[3];
+	// Magnitude of LAMD [1/SEC]
+	double LAMDMAG;
+	// Current mass [SLUGS]
+	double M;
+	//Thrust turn angle [RAD]
+	double PHI;
+	// Magnitude of position vector [FT]
+	double RMAG;
+	// Hypothetical time until total vehicle mass is consumed [SEC]
+	double TAU[3];
+	// Burn time of Ith thrust phase [SEC]
+	double TB[3];
+	// Time of guidance state vector [SEC]
+	double TGD;
+	// Time-to-go [SEC]
+	double TGO;
+	// Time to end of Ith thrust phase [SEC]
+	double TGOA[3];
+	// Previous value of TGO [SEC]
+	double TGOP;
+	// Value of (t-JOL) at start of thrust phase [SEC]
+	double TI;
+	// Time associated with reference thrust vector [SEC]
+	double TLAM;
+	// Predicted time of thrust cutoff [SEC]
+	double TP;
+	// Previous value of TP [SEC]
+	double TPREV;
+	// Previous value of TGD [SEC]
+	double TPRIME;
+	// Equivalent exhaust velocity [FT/SEC]
+	double VEX;
+	// Average exhaust velocity [FT/SEC]
+	double VEXA[3];
+	// Magnitude of VGO vector [SEC]
+	double VGOMAG;
+	// Q–S JOL [FT-SEC]
+	double QPRIME;
+	// Total thrust integrals
+	double L, J, S, JOL;
+
+	// Current phase
+	int KPHASE;
+	// Number of guidance phases
+	int N;
+	// Cycle counter
+	int N_CYCLE;
+
+	// Cutoff altitude constrained discrete
+	bool SALT;
+	// PEG convergence discrete
+	bool SCONV;
+	// PEG init discrete
+	bool SINIT;
+	// Constrain desired plane
+	bool SPLANE;
+
+
+	// CONSTANTS
+	// Acceleration limit [FT/SEC**2]
+	const double AL = 95.5;
+	// Minimum step size, ascent precision predictor [SEC]
+	double DTMIN = 2.0;
+	// Maximum step size, ascent precision predictor [SEC]
+	double DTMAX = 1.e20;
+	// Minimum TBN-1 computation of TGO [SEC]
+	const double ETB = 5.0;
+	// Thrust scaling factor [ND]
+	const double FT_FACTOR = 0.998;
+	// OMS vacuum thrust [LBF]
+	const double FT_OMS = 6.087e3;
+	// Decimal fraction for VGO to be used for convergence criterion for VMISS [ND]
+	const double KMISS = 1e-2;
+	// OMS mass flow rate [SLUGS/SEC]
+	const double MDOT_OMS = 6.004849e-1;
+	// Maximum number of PEG iterations
+	const int N_MAX = 1;
+	// Number of integration steps for PEG gravity prediction [ND]
+	const double NSEG = 10.0;
+	// Maximum turning rate [RAD/SEC]
+	const double PHIDOT_MAX = 3.5e-2;
+	// Scalar damping factor applied to VMISS to correct V
+	const double RHOMAG = 1.0;
+	// TGO remaining when position constraints released [SEC]
+	const double DTRD = 40.0;
+};
 
 /**
  * Controls shuttle during ascent (first and second stage).
@@ -114,6 +323,8 @@ class AscentDAP : public SimpleGPCSoftware
 	double GetInertialVelocity( void ) const;
 	double GetThrustAcceleration( void ) const;
 	double GetTimeRemaining( void ) const;
+	double GetCrossTrack(void) const;
+	double GetDeltaInclination(void) const;
 
 private:
 	/**
@@ -155,40 +366,18 @@ class AscentDAP : public SimpleGPCSoftware
 	 */
 	void SecondStageThrottle( double dt );
 
-	/**
-	 * Calculates heading required to reach target inclination.
-	 * \returns heading in radians
-	 */
-	double CalculateAzimuth();
 	void MajorCycle();
-	void Navigate();
-	void Estimate();
-	void Guide();
+	void Navigate(double dt);
 
 	void AdaptiveGuidanceThrottling( void );
 
-	// utility functions required by PEG guidance
-	inline double b0(double TT) {
-		return -Isp*log(1-TT/tau);
-	}
-	inline double bn(double TT, int n) {
-		if(n==0) return b0(TT);
-		return bn(TT,n-1)*tau-Isp*pow(TT,n)/n;
-	}
-	inline double c0(double TT) {
-		return b0(TT)*TT-bn(TT,1);
-	}
-	inline double cn(double TT, int n) {
-		if(n==0) return c0(TT);
-		return cn(TT,n-1)*tau-Isp*pow(TT,n+1)/(n*(n+1));
-	}
+	// TBD: Additional guidance and navigation tasks temporarily here
+	// PFT input task
+	void PFG_INP_TSK();
+	// Ascent User Parameter Processing
+	void AscentUPP();
 
 	OBJHANDLE hEarth;
-	double mu;
-	double EarthRadius, SidDay;
-
-	// guidance parameters
-	double TgtInc, TgtFPA, TgtAlt, TgtSpd;
 
 	unsigned short KMAX_NOM;
 	unsigned short KMAX_ABORT;
@@ -235,9 +424,8 @@ class AscentDAP : public SimpleGPCSoftware
 	PIDControl SRBGimbal[2][3];
 
 	// copied from Atlantis.h
-	double radTargetHeading, TAp, TPe, TTrA, TEcc, TgtRad;
+	double radTargetHeading;
 	std::vector<double> stage1GuidanceVelTable, stage1GuidancePitchTable;
-	bool dogleg;
 
 	//bool bAutopilot, bThrottle;
 	double tSRBSep; //time(MET)
@@ -245,26 +433,12 @@ class AscentDAP : public SimpleGPCSoftware
 
 	double target_pitch; // target second stage pitch in degrees
 	double CmdPDot; // commanded second stage pitch rate in deg/sec
-	VECTOR3 rh0;
-	double radius; // distance from centre of Earth (r)
 	double inertialVelocity; // velocity relative to Earth's center (v)
-	double /*r,*/h,/*theta,*/omega/*,phi*/;
-	VECTOR3 rh,thetah,hh;
-	//VECTOR3 posMoon,velMoon,rmh;
-	double vr,vtheta/*,vh*/;
 
-	//double fh;
-	//double pitch,yaw,roll;
-
-	//double g;
 	double thrustAcceleration; // a0
-	double Isp, tau, ThrAngleP, ThrAngleY;
+	double ThrAngleP, ThrAngleY;
 	double timeRemaining; // timeRemaining - T
-	//double deltatheta,thetaT;
-	//double fr,fdotr;
-	//double d1,d2,d3,d4;
-	double A,C;
-	//double eCurrent;
+	VECTOR3 VS, VSP, DVS; // Sensed velocity change
 
 	SSME_SOP* pSSME_SOP;
 	SSME_Operations* pSSME_Operations;
@@ -272,6 +446,8 @@ class AscentDAP : public SimpleGPCSoftware
 	SRBSepSequence* pSRBSepSequence;
 	RHC_SOP* pRHC_SOP;
 	SBTC_SOP* pSBTC_SOP;
+	GNCUtilities* pGNCUtilities;
+	StateVectorSoftware* pStateVectorSoftware;
 
 	bool glimiting;// g limiting in progress
 	double dt_thrt_glim;// timer for g limiting throttle cmds
@@ -292,8 +468,15 @@ class AscentDAP : public SimpleGPCSoftware
 	double EOVI[2];
 
 	double SSMETailoffDV[3];
-};
 
+	// TBD: This code should be in the Ascent UPP
+	// Crosstrack [NM]
+	double XTRK;
+	// Delta inclination [RAD]
+	double MEDS_D_INCL;
+
+	AscentGuidance guid;
+};
 }
 
 #endif// _dps_ASCENTDAP_H_
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.cpp b/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.cpp
index 14a04ce8..d240b7a2 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.cpp	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.cpp	
@@ -53,6 +53,7 @@ Date         Developer
 2023/02/23   GLS
 2023/08/06   GLS
 2023/08/16   GLS
+2025/12/30   GLS
 ********************************************/
 #include "Mission.h"
 #include <OrbiterAPI.h>
@@ -114,6 +115,8 @@ namespace mission
 		fMECOAlt = 105564;
 		fMECOVel = 7903.449390;
 		fMECOFPA = 0.708380 * RAD;
+		EF_PLANE_SW = false;
+		IYD = _V( 0.0, 0.0, 0.0 );
 
 		// default to Atlantis
 		strOrbiter = "Atlantis";
@@ -711,6 +714,20 @@ namespace mission
 
 			tmp = cJSON_GetObjectItemCaseSensitive( legacymeco, "MECOFPA" );
 			fMECOFPA = tmp->valuedouble * RAD;
+
+			// HACK temporary until it is moved to I-Load list
+			tmp = cJSON_GetObjectItemCaseSensitive( legacymeco, "EF_PLANE_SW" );
+			if (tmp) EF_PLANE_SW = cJSON_IsTrue( tmp );
+
+			if (tmp)
+			{
+				tmp = cJSON_GetObjectItemCaseSensitive( legacymeco, "IYD" );
+				double x;
+				double y;
+				double z;
+				sscanf_s( tmp->valuestring, "%lf %lf %lf", &x, &y, &z );
+				IYD = _V( x, y, z );
+			}
 		}
 		return;
 	}
@@ -1151,6 +1168,16 @@ namespace mission
 		return fMECOFPA;
 	}
 
+	bool Mission::GetEFPLANESW( void ) const
+	{
+		return EF_PLANE_SW;
+	}
+
+	VECTOR3 Mission::GetIYD( void ) const
+	{
+		return IYD;
+	}
+
 	bool Mission::IsExternalAirlockAftPos( void ) const
 	{
 		return (bHasTAA && !bAftTAA);
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.h b/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.h
index ed6c7470..ac876199 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.h	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/mission/Mission.h	
@@ -55,6 +55,7 @@ Date         Developer
 2023/02/15   GLS
 2023/02/23   GLS
 2023/08/06   GLS
+2025/12/30   GLS
 ********************************************/
 /****************************************************************************
   This file is part of Space Shuttle Ultra
@@ -213,6 +214,8 @@ namespace mission
 		double fMECOVel;
 		double fMECOFPA;
 		double fTargetInc;
+		bool EF_PLANE_SW;
+		VECTOR3 IYD;
 
 		bool bHasExtALODSKit;
 		bool bHasODS;
@@ -285,6 +288,8 @@ namespace mission
 		virtual double GetMECOAlt( void ) const;
 		virtual double GetMECOVel( void ) const;
 		virtual double GetMECOFPA( void ) const;
+		virtual bool GetEFPLANESW( void ) const;
+		virtual VECTOR3 GetIYD( void ) const;
 
 		virtual const std::string& GetOrbiter( void ) const;
 		virtual const std::string& GetMissionFileName( void ) const;
diff --git a/Orbitersdk/Space Shuttle Vessel/OV/vc/MDU_AEPFD_Display.cpp b/Orbitersdk/Space Shuttle Vessel/OV/vc/MDU_AEPFD_Display.cpp
index 91481317..fa469ffb 100644
--- a/Orbitersdk/Space Shuttle Vessel/OV/vc/MDU_AEPFD_Display.cpp	
+++ b/Orbitersdk/Space Shuttle Vessel/OV/vc/MDU_AEPFD_Display.cpp	
@@ -15,6 +15,8 @@ Date         Developer
 2022/09/29   GLS
 2022/10/05   GLS
 2022/12/17   GLS
+2025/12/27   indy91
+2025/12/29   GLS
 ********************************************/
 #include "MDU.h"
 #include "../Atlantis.h"
@@ -96,7 +98,7 @@ namespace vc
 				AEPFD_GMETER_STATIC( hDC );
 				AEPFD_GMETER_ACCEL( hDC );
 				hsiheading = STS()->GetYaw() - GetIDP()->GetTargetHeading();
-				HSI_A( hDC, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCourseDeviation(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
+				HSI_A( hDC, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCrossTrack(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
 				AEPFD_XTRK( hDC );// TODO only NOM, TAL and ATO
 				AEPFD_dINC( hDC );
 				break;
@@ -114,7 +116,7 @@ namespace vc
 				AEPFD_GMETER_STATIC( hDC );
 				AEPFD_GMETER_ACCEL( hDC );
 				hsiheading = STS()->GetYaw() - GetIDP()->GetTargetHeading();
-				HSI_A( hDC, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCourseDeviation(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
+				HSI_A( hDC, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCrossTrack(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
 				if (0)// TODO TAL
 				{
 					AEPFD_dXTRK( hDC );
@@ -359,7 +361,7 @@ namespace vc
 				AEPFD_GMETER_STATIC( skp );
 				AEPFD_GMETER_ACCEL( skp );
 				hsiheading = STS()->GetYaw() - GetIDP()->GetTargetHeading();
-				HSI_A( skp, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCourseDeviation(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
+				HSI_A( skp, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCrossTrack(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
 				AEPFD_XTRK( skp );// TODO only NOM, TAL and ATO
 				AEPFD_dINC( skp );
 				break;
@@ -377,7 +379,7 @@ namespace vc
 				AEPFD_GMETER_STATIC( skp );
 				AEPFD_GMETER_ACCEL( skp );
 				hsiheading = STS()->GetYaw() - GetIDP()->GetTargetHeading();
-				HSI_A( skp, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCourseDeviation(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
+				HSI_A( skp, hsiheading, STS()->GetBank(), true, hsiheading * DEG, false, true, GetIDP()->GetCourseDeviationScale(), GetIDP()->GetCrossTrack(), GetIDP()->GetPrimaryBearingType(), GetIDP()->GetPrimaryBearing(), GetIDP()->GetSecondaryBearingType(), GetIDP()->GetSecondaryBearing() );
 				if (0)// TODO TAL
 				{
 					AEPFD_dXTRK( skp );
@@ -4309,7 +4311,7 @@ namespace vc
 		SetWorldTransform( hDC, &WTroll );
 
 		if (bearingon) HSI_CourseArrow( hDC );
-		HSI_CDI( hDC, CDIflag, CDIbar, CDIscale, CDIdeviation );
+		HSI_CDI( hDC, CDIflag, CDIbar, CDIscale, -CDIdeviation * sgn );
 
 		// de-rotate
 		ModifyWorldTransform( hDC, &WTroll, MWT_IDENTITY );
@@ -4418,7 +4420,7 @@ namespace vc
 		skp->SetWorldTransform2D( 1.0f, (float)(-(bearing * sgn) * RAD), &cntr );
 
 		if (bearingon) HSI_CourseArrow( skp );
-		HSI_CDI( skp, CDIflag, CDIbar, CDIscale, CDIdeviation );
+		HSI_CDI( skp, CDIflag, CDIbar, CDIscale, -CDIdeviation * sgn );
 
 		// de-rotate
 		skp->SetWorldTransform();
@@ -6078,9 +6080,11 @@ namespace vc
 		SelectObject( hDC, gdiSSVBFont_h18w9 );
 		SetTextColor( hDC, CR_WHITE );
 		SetTextAlign( hDC, TA_RIGHT );
-		double dtmp = 0;// TODO
+
+		double XTrk = GetIDP()->GetCrossTrack();
+		XTrk = midval(-99.9, XTrk, 99.9);
 		char cbuf[8];
-		sprintf_s( cbuf, 8, "%4.1f", dtmp );
+		sprintf_s( cbuf, 8, "%4.1f", XTrk);
 		TextOut( hDC, 493, 333, cbuf, strlen( cbuf ) );
 		SetTextAlign( hDC, TA_LEFT );
 		return;
@@ -6099,9 +6103,11 @@ namespace vc
 		skp->SetFont( skpSSVBFont_h18w9 );
 		skp->SetTextColor( CR_WHITE );
 		skp->SetTextAlign( oapi::Sketchpad::RIGHT );
-		double dtmp = 0;// TODO
+
+		double XTrk = GetIDP()->GetCrossTrack();
+		XTrk = midval(-99.9, XTrk, 99.9);
 		char cbuf[8];
-		sprintf_s( cbuf, 8, "%4.1f", dtmp );
+		sprintf_s( cbuf, 8, "%4.1f", XTrk);
 		skp->Text( 493, 333, cbuf, strlen( cbuf ) );
 		skp->SetTextAlign( oapi::Sketchpad::LEFT );
 		return;
@@ -6122,9 +6128,11 @@ namespace vc
 		SelectObject( hDC, gdiSSVBFont_h18w9 );
 		SetTextColor( hDC, CR_WHITE );
 		SetTextAlign( hDC, TA_RIGHT );
-		ELEMENTS el;
-		STS()->GetElements( STS()->GetGravityRef(), el, NULL, 0, FRAME_EQU );
-		sprintf_s( cbuf, 8, "%6.2f", (STS()->pMission->GetMECOInc() - el.i) * DEG );
+
+		double DInc = GetIDP()->GetDeltaInclination() * DEG;
+		DInc = midval(-99.99, DInc, 99.99);
+
+		sprintf_s( cbuf, 8, "%6.2f", DInc );
 		TextOut( hDC, 493, 376, cbuf, strlen( cbuf ) );
 		SetTextAlign( hDC, TA_LEFT );
 		return;
@@ -6145,9 +6153,11 @@ namespace vc
 		skp->SetFont( skpSSVBFont_h18w9 );
 		skp->SetTextColor( CR_WHITE );
 		skp->SetTextAlign( oapi::Sketchpad::RIGHT );
-		ELEMENTS el;
-		STS()->GetElements( STS()->GetGravityRef(), el, NULL, 0, FRAME_EQU );
-		sprintf_s( cbuf, 8, "%6.2f", (STS()->pMission->GetMECOInc() - el.i) * DEG );
+
+		double DInc = GetIDP()->GetDeltaInclination() * DEG;
+		DInc = midval(-99.99, DInc, 99.99);
+
+		sprintf_s( cbuf, 8, "%6.2f", DInc );
 		skp->Text( 493, 376, cbuf, strlen( cbuf ) );
 		skp->SetTextAlign( oapi::Sketchpad::LEFT );
 		return;