diff --git a/.gitignore b/.gitignore
index bc6004c..4048973 100644
--- a/.gitignore
+++ b/.gitignore
@@ -213,3 +213,4 @@ Projects/.DS_Store
 .fake
 *.joblib
 FullVehicleSim/simulation_output.parquet
+.vscode/settings.json
diff --git a/Data/FSLib/IntegralsAndDerivatives.py b/Data/FSLib/IntegralsAndDerivatives.py
index 31f2e18..54b9ea4 100644
--- a/Data/FSLib/IntegralsAndDerivatives.py
+++ b/Data/FSLib/IntegralsAndDerivatives.py
@@ -7,6 +7,7 @@
 from scipy.integrate import RK45
 # from scipy.integrate import solve_ivp
 import matplotlib.pyplot as plt
+from scipy.integrate import cumulative_trapezoid
 
 
 # lat = "VDM_GPS_Latitude"
@@ -67,20 +68,20 @@ def mag (a, b, c):
     # print(f"mag = {np.sqrt(a**2 + b**2 + c**2)}")
     return np.sqrt(a**2 + b**2 + c**2)
 
-def in_place_integrate (derivative, dt=0.01): #Rimann sum that returns an array of the intergral at that point. Assumes dt of 0.01
-    if len(derivative.shape) == 1:
-        width = 1
-    else:
-        width = derivative.shape[1]
-    container = derivative[0]
-    out = np.zeros((derivative.shape[0], width))
-    out[0] = container*dt
-    for i in range(1, derivative.shape[0]):
-        container += dt*derivative[i]
-        # print(f"added {0.01*derivative[i]} to {container}")
-        out[i] = container
-    # print(f"out of integral is {out}")
-    return out
+def in_place_integrate (derivative, t, initial=0): #Rimann sum that returns an array of the intergral at that point. Assumes dt of 0.01
+    # if len(derivative.shape) == 1:
+    #     width = 1
+    # else:
+    #     width = derivative.shape[1]
+    # container = derivative[0]
+    # out = np.zeros((derivative.shape[0], width))
+    # out[0] = container*dt
+    # for i in range(1, derivative.shape[0]):
+    #     container += dt*derivative[i]
+    #     # print(f"added {0.01*derivative[i]} to {container}")
+    #     out[i] = container
+    # # print(f"out of integral is {out}")
+    return cumulative_trapezoid(derivative, t, initial)
 
 def integrate_with_tCol (col, timeCol):
     if col.len() != timeCol.len():
diff --git a/Data/README_TRACTIVE_THERMAL_MODELING.md b/Data/README_TRACTIVE_THERMAL_MODELING.md
new file mode 100644
index 0000000..42dcebc
--- /dev/null
+++ b/Data/README_TRACTIVE_THERMAL_MODELING.md
@@ -0,0 +1,32 @@
+# Run Thermal Modeling
+Todo
+
+### Run Tests
+
+```bash
+python -m unittest discover -s test
+```
+
+#### Plot the curve
+```bash
+python ./TractiveBatteryThermalModelViewer.py -h
+usage: TractiveBatteryThermalModelViewer.py [-h] --path_parquet PATH_PARQUET [--column-name COLUMN_NAME] [--t-end T_END] [--initial-temp INITIAL_TEMP]
+
+View tractive battery thermal model as a function of current draw.
+
+options:
+  -h, --help            show this help message and exit
+  --path_parquet PATH_PARQUET
+                        Path to the Parquet file containing current data.
+  --column-name COLUMN_NAME
+                        Name of the current column in the Parquet file (default: SME_TEMP_BusCurrent).
+  --t-end T_END         End time in seconds for the simulation (default: 60).
+  --initial-temp INITIAL_TEMP
+                        Initial temperature in °C (default: 22).
+```
+
+Example Command :
+
+```
+python TractiveBatteryThermalModelViewer.py --path_parquet <file_name>
+```
diff --git a/Data/SensorFrequencyAnalysis/Suspension_Travel_BR.png b/Data/SensorFrequencyAnalysis/Suspension_Travel_BR.png
new file mode 100644
index 0000000..bac64b2
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/Suspension_Travel_BR.png differ
diff --git a/Data/SensorFrequencyAnalysis/apps.py b/Data/SensorFrequencyAnalysis/apps.py
new file mode 100644
index 0000000..7ba314a
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/apps.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-23.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ETC_STATUS_PEDAL_TRAVEL"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [6, 6.5, 7]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("APPS - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("APPS - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/apps_graph.png b/Data/SensorFrequencyAnalysis/apps_graph.png
new file mode 100644
index 0000000..10290e4
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/apps_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/apps_log_graph.png b/Data/SensorFrequencyAnalysis/apps_log_graph.png
new file mode 100644
index 0000000..6414f88
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/apps_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_current.py b/Data/SensorFrequencyAnalysis/battery_current.py
new file mode 100644
index 0000000..4e93018
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/battery_current.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_22.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ACC_POWER_CURRENT"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [5, 6, 7]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Battery Current - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Battery Current - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/battery_current_graph.png b/Data/SensorFrequencyAnalysis/battery_current_graph.png
new file mode 100644
index 0000000..84ce7f6
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_current_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_current_log_graph.png b/Data/SensorFrequencyAnalysis/battery_current_log_graph.png
new file mode 100644
index 0000000..10ff9a1
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_current_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_tray_temp.py b/Data/SensorFrequencyAnalysis/battery_tray_temp.py
new file mode 100644
index 0000000..3f435ac
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/battery_tray_temp.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_1.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ACC_TRAY_TEMPS_BUSBAR"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [4, 5, 6]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Battery Tray Temp - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Battery Tray Temp - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/battery_tray_temp_graph.png b/Data/SensorFrequencyAnalysis/battery_tray_temp_graph.png
new file mode 100644
index 0000000..ae334ad
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_tray_temp_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_tray_temp_log_graph.png b/Data/SensorFrequencyAnalysis/battery_tray_temp_log_graph.png
new file mode 100644
index 0000000..3f9b2c6
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_tray_temp_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_voltage.py b/Data/SensorFrequencyAnalysis/battery_voltage.py
new file mode 100644
index 0000000..5050446
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/battery_voltage.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-14.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ACC_POWER_PACK_VOLTAGE"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [4.5, 5.5, 6.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Battery Voltage - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Battery Voltage - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/battery_voltage_graph.png b/Data/SensorFrequencyAnalysis/battery_voltage_graph.png
new file mode 100644
index 0000000..3bdfbcc
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_voltage_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/battery_voltage_log_graph.png b/Data/SensorFrequencyAnalysis/battery_voltage_log_graph.png
new file mode 100644
index 0000000..b830c65
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/battery_voltage_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/brake_temp.png b/Data/SensorFrequencyAnalysis/brake_temp.png
new file mode 100644
index 0000000..23c1f69
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/brake_temp.png differ
diff --git a/Data/SensorFrequencyAnalysis/brake_temp.py b/Data/SensorFrequencyAnalysis/brake_temp.py
new file mode 100644
index 0000000..9a19361
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/brake_temp.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_1.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["IZZE_BRAKETEMP_S1_CH1"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [5.5, 6.5, 7.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Brake Temp - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Brake Temp - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/brake_temp_log_graph.png b/Data/SensorFrequencyAnalysis/brake_temp_log_graph.png
new file mode 100644
index 0000000..2d40475
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/brake_temp_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/cell_temp.py b/Data/SensorFrequencyAnalysis/cell_temp.py
new file mode 100644
index 0000000..07430a0
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/cell_temp.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_1.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ACC_SEG0_TEMPS_CELL0"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [4.5, 5.5, 6.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Cell Temp - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Cell Temp - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/cell_temp_graph.png b/Data/SensorFrequencyAnalysis/cell_temp_graph.png
new file mode 100644
index 0000000..ac7e850
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/cell_temp_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/cell_temp_log_graph.png b/Data/SensorFrequencyAnalysis/cell_temp_log_graph.png
new file mode 100644
index 0000000..9a60623
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/cell_temp_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/cell_voltage.py b/Data/SensorFrequencyAnalysis/cell_voltage.py
new file mode 100644
index 0000000..b6ca212
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/cell_voltage.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-14.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["ACC_SEG0_VOLTS_CELL0"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [1.5, 2.5, 3.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Cell Voltage - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Cell Voltage - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/cell_voltage_graph.png b/Data/SensorFrequencyAnalysis/cell_voltage_graph.png
new file mode 100644
index 0000000..6186da7
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/cell_voltage_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/cell_voltage_log_graph.png b/Data/SensorFrequencyAnalysis/cell_voltage_log_graph.png
new file mode 100644
index 0000000..ca65200
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/cell_voltage_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/graphs b/Data/SensorFrequencyAnalysis/graphs
new file mode 100644
index 0000000..7891672
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/graphs
@@ -0,0 +1,67 @@
+# Sensor Frequency Analysis Summary
+
+## Wheel Speed BR
+Magnitude cutoff of 10 corresponds to approximately 10 Hz. Suggested sampling frequency is 20 Hz.
+
+![Wheel Speed BR Graph](wheel_speed_br_graph.png)
+![Wheel Speed BR Frequency Spectrum](wheel_speed_br_log_graph.png)
+
+## Wheel Speed BL
+![Wheel Speed BL Graph](wheel_speed_bl_graph.png)
+![Wheel Speed BL Frequency Spectrum](wheel_speed_bl_log_graph.png)
+
+## Wheel Speed FL
+![Wheel Speed FL Graph](wheel_speed_fl_graph.png)
+![Wheel Speed FL Frequency Spectrum](wheel_speed_fl_log_graph.png)
+
+## Wheel Speed FR
+![Wheel Speed FR Graph](wheel_speed_fr_graph.png)
+![Wheel Speed FR Frequency Spectrum](wheel_speed_fr_log_graph.png)
+
+## Suspension Travel BR
+![Suspension Travel BR Graph](Suspension_Travel_BR.png)
+![Suspension Travel BR Frequency Spectrum](suspension_travel_br_graph.png)
+
+## Suspension Travel BL
+![Suspension Travel BL Graph](suspension_travel_bl_graph.png)
+![Suspension Travel BL Frequency Spectrum](suspension_travel_bl_log_graph.png)
+
+## Suspension Travel FR
+![Suspension Travel FR Graph](suspension_travel_fr_graph.png)
+![Suspension Travel FR Frequency Spectrum](suspension_travel_fr_log_graph.png)
+
+## Tire Temp FL
+![Tire Temp FL Graph](tire_temp_fl_graph.png)
+![Tire Temp FL Frequency Spectrum](tire_temp_fl_log_graph.png)
+
+## Tire Temp BL
+![Tire Temp BL Graph](tire_temp_bl_graph.png)
+![Tire Temp BL Frequency Spectrum](tire_temp_bl_log_graph.png)
+
+## Brake Temp
+![Brake Temp Graph](brake_temp.png)
+![Brake Temp Frequency Spectrum](brake_temp_log_graph.png)
+
+## APPS
+![APPS Graph](apps_graph.png)
+![APPS Frequency Spectrum](apps_log_graph.png)
+
+## Battery Voltage
+![Battery Voltage Graph](battery_voltage_graph.png)
+![Battery Voltage Frequency Spectrum](battery_voltage_log_graph.png)
+
+## Battery Current
+![Battery Current Graph](battery_current_graph.png)
+![Battery Current Frequency Spectrum](battery_current_log_graph.png)
+
+## Battery Tray Temp
+![Battery Tray Temp Graph](battery_tray_temp_graph.png)
+![Battery Tray Temp Frequency Spectrum](battery_tray_temp_log_graph.png)
+
+## Cell Temp
+![Cell Temp Graph](cell_temp_graph.png)
+![Cell Temp Frequency Spectrum](cell_temp_log_graph.png)
+
+## Cell Voltage
+![Cell Voltage Graph](cell_voltage_graph.png)
+![Cell Voltage Frequency Spectrum](cell_voltage_log_graph.png)
diff --git a/Data/SensorFrequencyAnalysis/image-1.png b/Data/SensorFrequencyAnalysis/image-1.png
new file mode 100644
index 0000000..aa1d6c9
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/image-1.png differ
diff --git a/Data/SensorFrequencyAnalysis/image-2.png b/Data/SensorFrequencyAnalysis/image-2.png
new file mode 100644
index 0000000..b79bec8
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/image-2.png differ
diff --git a/Data/SensorFrequencyAnalysis/image.png b/Data/SensorFrequencyAnalysis/image.png
new file mode 100644
index 0000000..21b94e8
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/image.png differ
diff --git a/Data/SensorFrequencyAnalysis/rmsTest.py b/Data/SensorFrequencyAnalysis/rmsTest.py
new file mode 100644
index 0000000..bc5e3f8
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/rmsTest.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('../fs-data/FS-3/01112026/011026-18.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+
+signal = df["TPERIPH_BR_DATA_WHEELSPEED"].to_numpy()
+signal = signal[signal > 0]
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [7,8,9,9.5,10,10.5,11,11.5,12]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+
+plt.plot(attempts, RMSs)
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed BR - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/sensor_optimal_frequency.py b/Data/SensorFrequencyAnalysis/sensor_optimal_frequency.py
new file mode 100644
index 0000000..ca3cc10
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/sensor_optimal_frequency.py
@@ -0,0 +1,127 @@
+import polars as pl
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import os
+
+DATA_DIRS = [
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026',
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01172026',
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/03162026',
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/08172025',
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025',
+    '/Users/aanyajain/Documents/GitHub/fs-data/FS-3/08102025',
+]
+OUT_DIR = 'graphs'
+os.makedirs(OUT_DIR, exist_ok=True)
+
+SENSORS = {
+    'Brake Pressure Front':  ['TMAIN_DATA_BRAKES_F'],
+    'Brake Pressure Rear':   ['TMAIN_DATA_BRAKES_R'],
+    'Suspension Travel FL':  ['TPERIPH_FL_DATA_SUSTRAVEL'],
+    'Suspension Travel FR':  ['TPERIPH_FR_DATA_SUSTRAVEL'],
+    'Suspension Travel BL':  ['TPERIPH_BL_DATA_SUSTRAVEL'],
+    'Suspension Travel BR':  ['TPERIPH_BR_DATA_SUSTRAVEL'],
+    'Tire Temp FL':          ['TPERIPH_FL_TIRETEMP_1','TPERIPH_FL_TIRETEMP_2','TPERIPH_FL_TIRETEMP_3','TPERIPH_FL_TIRETEMP_4'],
+    'Tire Temp FR':          ['TPERIPH_FR_TIRETEMP_1','TPERIPH_FR_TIRETEMP_2','TPERIPH_FR_TIRETEMP_3','TPERIPH_FR_TIRETEMP_4'],
+    'Tire Temp BL':          ['TPERIPH_BL_TIRETEMP_1','TPERIPH_BL_TIRETEMP_2','TPERIPH_BL_TIRETEMP_3','TPERIPH_BL_TIRETEMP_4'],
+    'Tire Temp BR':          ['TPERIPH_BR_TIRETEMP_1','TPERIPH_BR_TIRETEMP_2','TPERIPH_BR_TIRETEMP_3','TPERIPH_BR_TIRETEMP_4'],
+    'Brake Temp':            ['IZZE_BRAKETEMP_S1_CH1','IZZE_BRAKETEMP_S1_CH2','IZZE_BRAKETEMP_S1_CH3','IZZE_BRAKETEMP_S1_CH4'],
+    'APPS':                  ['ETC_STATUS_PEDAL_TRAVEL'],
+    'Wheel Speed FL':        ['TPERIPH_FL_DATA_WHEELSPEED'],
+    'Wheel Speed FR':        ['TPERIPH_FR_DATA_WHEELSPEED'],
+    'Wheel Speed BL':        ['TPERIPH_BL_DATA_WHEELSPEED'],
+    'Wheel Speed BR':        ['TPERIPH_BR_DATA_WHEELSPEED'],
+    'Strain Gauge FL':       ['TPERIPH_FL_DATA_STRAIN'],
+    'Strain Gauge FR':       ['TPERIPH_FR_DATA_STRAIN'],
+    'Strain Gauge BL':       ['TPERIPH_BL_DATA_STRAIN'],
+    'Strain Gauge BR':       ['TPERIPH_BR_DATA_STRAIN'],
+    'Battery Voltage':       ['ACC_POWER_PACK_VOLTAGE'],
+    'Battery Current':       ['ACC_POWER_CURRENT'],
+    'Battery Tray Temp':     ['ACC_TRAY_TEMPS_BUSBAR','ACC_TRAY_TEMPS_PACK_FUSE','ACC_TRAY_TEMPS_COWLING'],
+    'Cell Temp':             ['ACC_SEG0_TEMPS_CELL0','ACC_SEG0_TEMPS_CELL1','ACC_SEG1_TEMPS_CELL0','ACC_SEG1_TEMPS_CELL1'],
+    'Cell Voltage':          ['ACC_SEG0_VOLTS_CELL0','ACC_SEG0_VOLTS_CELL1','ACC_SEG1_VOLTS_CELL0','ACC_SEG1_VOLTS_CELL1'],
+}
+
+all_files = []
+for d in DATA_DIRS:
+    for f in sorted(os.listdir(d)):
+        if f.endswith('.parquet'):
+            all_files.append(os.path.join(d, f))
+
+print(f"Found {len(all_files)} files")
+
+best_results = {}
+
+for sensor_name, cols in SENSORS.items():
+    best_freq = 0.0
+    best_amp = 0.0
+    best_file = None
+    best_fft = None
+    best_freq_axis = None
+
+    for path in all_files:
+        try:
+            df = pl.read_parquet(path)
+            df = df.with_columns([
+                pl.col(c).cast(pl.Float64) for c in df.columns
+                if df[c].dtype in [pl.Float32, pl.Float64]
+            ])
+            valid_cols = [c for c in cols if c in df.columns]
+            if not valid_cols:
+                continue
+            time_ms = df['Time_ms'].to_numpy()
+            diffs = np.diff(time_ms)
+            diffs = diffs[diffs > 0]
+            if len(diffs) == 0:
+                continue
+            dt_ms = np.median(diffs)
+            fs_hz = 1000.0 / dt_ms
+            data = df.select(valid_cols).mean_horizontal().drop_nulls().to_numpy().astype(float)
+            if len(data) < 64:
+                continue
+            data -= np.mean(data)
+            N = len(data)
+            fft = np.abs(np.fft.rfft(data)) / N
+            freq = np.fft.rfftfreq(N, d=1.0/fs_hz)
+            fft[0] = 0
+            peak_idx = np.argmax(fft)
+            peak_freq = freq[peak_idx]
+            peak_amp = fft[peak_idx]
+            if peak_amp > best_amp:
+                best_amp = peak_amp
+                best_freq = peak_freq
+                best_file = os.path.basename(path)
+                best_fft = fft
+                best_freq_axis = freq
+        except Exception:
+            continue
+
+    if best_fft is None:
+        print(f"  SKIP {sensor_name} — no data")
+        continue
+
+    best_results[sensor_name] = {'peak_freq': best_freq, 'peak_amp': best_amp, 'file': best_file}
+
+    fig, ax = plt.subplots(figsize=(10, 4))
+    ax.plot(best_freq_axis, best_fft, linewidth=0.8)
+    ax.axvline(best_freq, color='red', linestyle='--', linewidth=1.2,
+               label=f'Peak: {best_freq:.2f} Hz')
+    ax.set_xlabel('Frequency (Hz)')
+    ax.set_ylabel('Amplitude')
+    ax.set_title(f'{sensor_name} — Highest Frequency Activity\n(from {best_file})')
+    ax.legend()
+    ax.set_xlim(0, min(max(best_freq_axis), 50))
+    plt.tight_layout()
+    fname = sensor_name.replace(' ', '_').replace('/', '_') + '.png'
+    plt.savefig(os.path.join(OUT_DIR, fname), dpi=150)
+    plt.close()
+    print(f"  {sensor_name:30s}  peak = {best_freq:.3f} Hz  ({best_file})")
+
+print("\n" + "="*65)
+print(f"{'Sensor':<30} {'Highest Freq (Hz)':>18} {'File'}")
+print("="*65)
+for name, r in sorted(best_results.items(), key=lambda x: -x[1]['peak_freq']):
+    print(f"{name:<30} {r['peak_freq']:>18.3f}  {r['file']}")
+print(f"\nGraphs saved to: {OUT_DIR}")
diff --git a/Data/SensorFrequencyAnalysis/sensor_optimal_frequency_graphs.md b/Data/SensorFrequencyAnalysis/sensor_optimal_frequency_graphs.md
new file mode 100644
index 0000000..cd89463
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/sensor_optimal_frequency_graphs.md
@@ -0,0 +1,94 @@
+## Sensor Graphs
+
+### APPS
+
+![APPS](data:image/png;base64,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)
+
+### Battery Current
+
+![Battery Current](data:image/png;base64,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)
+
+### Battery Tray Temp
+
+![Battery Tray Temp](data:image/png;base64,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)
+
+### Battery Voltage
+
+![Battery Voltage](data:image/png;base64,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)
+
+### Brake Pressure Front
+
+![Brake Pressure Front](data:image/png;base64,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)
+
+### Brake Pressure Rear
+
+![Brake Pressure Rear](data:image/png;base64,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)
+
+### Brake Temp
+
+![Brake Temp](data:image/png;base64,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)
+
+### Cell Temp
+
+![Cell Temp](data:image/png;base64,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)
+
+### Cell Voltage
+
+![Cell Voltage](data:image/png;base64,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)
+
+### Strain Gauge BL
+
+![Strain Gauge BL](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABdwAAAJYCAYAAAB4syQkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAduVJREFUeJzt3QecVNXdP/4vRUCKKIiIDcUORrBEY0HQ2GKv0SQ+ii0xVqyPxhJrTDQqtiRPYmxRo7FLNNaINWoMohEQFQUVUUFA6QLu/3UOv9n/7rILy+5sY9/v12uY2dvmzJ07d5fPPfM9LUpKSkoCAAAAAAColZa1Wx0AAAAAABC4AwAAAABAkejhDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuAAAAAABQBAJ3AAAAAAAoAoE7AAAAAAAUgcAdAAAAAACKQOAOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwCgSbr11lujRYsWsfbaazd0U6DJGzhwYP48XXjhhUXfdtpuug0bNqzo2wbqTvrMFj6/xZTOM2mb6bwDAMsigTsANDMlJSVx7733xv777x89e/aM5ZdfPjp27BjrrrtubL/99nHaaafFgw8+GF9//fUi6w4ZMiT/R3nEiBEN0vbG6umnn47jjz8++vbtG926dYvlllsuOnfuHBtuuGH88Ic/jD/+8Y8xadKkhm5mkw2BK95atmwZK6ywQvTr1y/OOOOMGD9+/BKDnWIHRo3B0ry2cePGlS6bLlZRtYceeijv23RfG4MGDar0+K14c9GQsrbeeuvSY+NPf/pTneycadOm5WM83dLjZfHzBwANqXWDPjsAUK/Sf6z322+/eO6550qntW7dOtq3bx8fffRRfPDBB/HSSy/FNddcE7fccksOjCoG7incTAFRCjsbUiHQXn311RusDe+++278z//8T7z22mul01IYnNo2Z86cPD/d0gWOU045JU466aS44oorGqy9TVW6gNGlS5fSn+fNmxdTpkyJN998M99+97vfxf333x8/+MEPGrSdTdlaa62VP08rr7xyNHcp6LvtttviiCOOyOfL2krnhHQhriqLm0fz8vbbb5f7fXLzzTfHscceWyd/C1x00UX5cfo9v+KKK1a6XPrbIJ0Xii2dZ9J203mnrj9/ANAQ9HAHgGbk8MMPz2F7q1at4vTTT89h8Ny5c+PLL7+M2bNn5/DyN7/5Te6p3dilHvrvvPNOPPPMMw3y/K+88kp897vfzeFIhw4d4swzz4zXX389vvnmmxwGz5o1K6ZOnRpDhw7Nofy3334bt99+e4O0tanbdttt47PPPiu9FY7Xu+++O7p27ZofH3bYYTFz5syGbmqTlY7N9Hk68cQTG7opy5w111yz3PFb8fbvf/+7oZtII/HnP/+5NATv1KlT/j0zatSoBmvPVlttlc8L6VZM6TyTtul3IgDLKoE7ADQT7733Xg5/k0svvTR++9vfxvrrr597XxZ6um+66aZx1lln5ZIxhxxySAO3uPH64osv4oADDshld1KYlgKz1HN9iy22yBczClKvwb322iuHCmn/77nnng3a7mVJu3bt8jGavnWRpIsczz//fEM3C6BG0sXaO+64Iz8+7rjj4sADDywXwgMATYfAHQCaibJ11/fdd98lLp9qu1esFV2olX3kkUcuUoe4slrR6fHYsWPjpz/9aayzzjrRtm3bcvWKUw/wFCakOuff+c53ctmQFKSm2vI//vGPc+++mgyaWnFAttQLPoXdqXRD2v7GG2+cv06fyr7URArXJ06cmJ/jb3/7W97ekqSvzlcWnKSe76l9J598cnzve9+LNdZYI9q0aZN7bg8YMCD+8Ic/5BIqtRnQbkmDVqb39eijj87Pnd6jdJ/e4/fff3+R97OqoCiVddlxxx1zqYDU/lVXXTUfZ//4xz+iLpUtbTRjxow6fa7mPGhqOgavvvrqvL/TNzrSZzWtc99991Vr/YLp06fHeeedFxtttFE+x6TjPF2UevXVV5fYxkcffTSHkKmMVDpOV1pppdhhhx3i97//fT4Gq3LPPffkckPdu3fP5YnShbB0sXGfffaJG2+8sfQ8UPg8pXIWSbqveJ6ry4FfK36e33jjjfjJT36SP4+p3RUHmKzN5y59KyRdeO3du3d+H1ZZZZXYY489Sr8xlM6rldX7L9Y5J5337rzzzvyc6X1JbU/n51133TX++te/5rFGKlO2Xen1X3nllfkbWemYTKW8dtppp3j88cdjSdLxls5x6623Xi6bksaESPviqKOOiieeeKJ0ubPPPjs/X58+fRa7vXTxNY2FUpsxEh5++OGYPHlyLrWS6rinkipJCuGr+h1Q1ujRo+OEE07IryP1jk/tSds69NBDc8mttM+TdByl38cF6XHZY7zscVbV+52OsTQtXXhenPT7v7D+Cy+8sNhBU6v7+Us94ws/ly2/U5n07TKDswLQIEoAgGbhb3/7W0ow8u3JJ59cqnWvvPLKku7du5e0bNkyr7/CCivkn8veCj788MPS57nzzjtLOnbsmB+3b9++pEOHDiU9e/YsXfaXv/xl6bKtWrUqWWmllUratm1bOq1FixYl1157baVtuuWWW/IyZbdXcbsDBgwoueKKK/J20m3FFVfM94Xt77jjjiXz589fqn3xzTfflHTq1Cmvv/vuu5fUVtn9lW5pf3Xu3LnctP79+5fMmjVrkXWfffbZ0mUWp7BMWr6il19+ufT1pNvyyy9f+p6l97nscZPaWtG4ceNK+vTpU+49q9j+4447rkb7Jr1/hfexKnfccUfp87z55puLzC97jC1rlua1lT3O0menqn2dtlnRjBkzSnbYYYdFPquFz9I555yz2PUL6911110l6623Xn7crl27fE4ozGvTpk3JE088UWnb07F/0EEHlTum0rFZ9rP8ve99r2TKlCmLrHvkkUcu8vkq+7xlj+uXXnopn8tS2wptrHieS8tU1xFHHFHlOaoyZT/P9913X8lyyy1X+lpTW8p+Dmrzufvyyy9LNttss9LlWrdunc+Nhe387ne/y22u7FgpxjknPX/Z4yndKrZ9n332KZk7d+4i6xbadf3115dsvfXW+XHaT4VzVuE1/PnPf660Xel8f/LJJ5d7rvR7qezxnNpS8MEHH5ROf+GFF6p8vb///e9L163sXF0du+22W97GZZddln/+9ttvS1/v/fffv9h1f/3rX5f+fi4cu126dCk3berUqXnZ/fffv2TllVcunZ4elz3G0/wlvd/33ntv6ec2vZ9VufDCC/Ny66yzTn49lf2OLliaz1/hfHP00UdX+dzpfFDYVvpbBADq07L3Pw8AoFIpVCoEB9/5zndKxowZs9R7qqoQpuLzlA23Uijy73//u3R+2ef9v//7v/wf79dff700XEn/KU8hxymnnJLbm8K94cOH1yhwTyFSChxSIDhp0qQ876uvviq54IILSttYVTBTlfQf/sK6KZiqrY8//rjkJz/5SckjjzxSLriYPn16fo2rrbZafq5TTz11kXVrG36lAKZHjx55Xq9evUr++c9/loYir732Wknfvn1zEFVV4J6C2I022ijPGzhwYMmwYcNK5syZk+dNmzat5Oqrry4NwoYMGVLUwD09Twp9unXrlpfZddddK92GwL32gfvPfvazPC99ln7zm9/kYzNJn6lCeFkIbBcXuKdjqXfv3vk4W7BgQT7W0nG24YYbln6W0/SKDjvssNJjNAVn6TOczJ49u+Thhx/O09P8/fbbr9x6KSAt2+6yn6/JkyfngD+F4hMmTKg0KE/3tVGbwD19bvbYY4+S0aNHl85/9913i/K5S4Fqmpcubv7hD3/I+7EQ4qd5KcAuXJQoduCeAu/CsdavX7+SoUOHlsycObP0dd12220lq6yySp4/ePDgKn8HpWNp9dVXL3nooYfyRdDknXfeyRdeCvsv7YuKzjrrrNK2HXXUUeV+H6Xl0/YOOeSQcuukC6tp+cMPP7zK17v55pvnZU488cSSmvjoo4/ycZp+540fP750+vnnn5+3m46FqqTfQ2UvVLzxxhul89K+TRfY02sqfG4qng8qu5C6pPc7HW+F3w3pYkNVChfY0u/csioL3Jfm83f33XeXXiz5+uuvK13muuuuy8t07dq19PMBAPVF4A4Azcixxx5brhdg6uV4/PHH59D5v//9b7keaMUI3NPyhXCuJk444YQqe7FVJ3CvKgBMDjjggDx/5513Xqo2/elPfyrdduodXtfSxYpCsFAIxooVfl1yySWlPQnfe++9RdZLgWrZnpAVg5mLL764NDQphF4VPfDAA6W9KOfNm7cUr/z/D4FTAFi2l2PquVlo05prrplDtKp6lTaXwL1iT9CKt7Lv49IE7in8K/SSTcdLZQoB2ZIC93Rx5PPPP19k/ltvvVW6zIsvvlhu3vPPP5+npxA2hZJVXbRKn4+0XNmwMYXsi7sYU5ViB+5p/y3uvSkEoWU/z1tttVWV376pzefu1VdfXezFxvSc22+/fZXHSm3PObfffnueni4YVBaIJ+kCbPr9lHpPVzxeCr+D0sWCshcjCr744ovSXs3p2y9lpXC9cCync0Z1pRC+8O2fQi/xiu0tvN50LNfERRddlNffaaedyk1P5+U0PV14rnhhqNCLu/ANpUMPPXSJv8OLFbiXvRC3zTbbVLpu+v1YWLfi75faBu7puC9cmEkXjSqTOhak+aeddlqV2wGAuqKGOwA0I6ne7/nnn5/r3aZMJNUITtNS/e5UQz3V/z3ttNPi888/L8rznXjiibmObE0VBhl98cUXa7R+qvN8xhlnVDqvUMf+rbfeWqptfvnll6WPUx3rysydOzfvy8puqZ700thyyy1zfeWZM2eWq8NfDPfee2++T4OPplrGFaW60D//+c+rXL9Qkz4dM6nGdGX222+/XB851Sb+z3/+U6N2pvrF6Zgs3NIAqQVfffVV/jndN2dl909lt7T/a6JQ+znVuT711FMrXSadU6ojjeWQjuWK0rmnUFO64uexcIylWuZpgOLKpBrnqY55Urb+dqrVnkyaNCkWLFgQDSXtv8W9N4Xa2mWdeeaZ5QZgLtbn7u677873aV+mGuYVpees7vtZE4W2p/NKqrlemTT4dKqZnmq0P/vss5Uuc9BBB+VxACpKdeC32WabSo+lVBM87es0bkAaw6O60hgD6RhLde//8pe/LDL/T3/6U75Pz5uO5aWVfhffcsst+fHhhx9ebl46L2+77bb5+K2sNnwaQyGNi5COgzTGwpJq6xdTqo+e/Otf/8rjfVRU2Fdpv1T2+6U20utNf7ckf/zjHxeZn8Z/+e9//1t63gGA+iZwB4BmpHXr1nHxxRfHhAkT8n+GjznmmDzgXBqwLvniiy/immuuiU022WSJg5FVx3bbbbfEZT744IMciqeQJQVkKfApDIiWBtRLPvnkkxo9fwptqgr8V1tttXxfNrwtlhSgVBWupdCmohQspcFR04CBqV3pQkHZgeLS+1Kb/VCZ9JwjR47Mj9PgrFWpOFBjQTqGCoPopuCjqgsMPXr0KB3MtLD80krt+3/fzCy9pYD96aefjk033TRuuumm2GqrreK9996L5qri/ql4+/DDD2u03eHDh5de+EkX6iqz7rrrVhmGl5UGgqxKVZ/Hl156qTSoreoYS7d0LFQ8xr7//e/nQZLThcX+/fvnbdR0P9RGGgR6ce9N4cJAdc6dtf3cvf766+UGua1MGog2/a4othQaFwbCToNmLu79HDNmzCJtr+2x9PLLL+f7XXbZJR8X1ZV+Jx177LHlwvWCdCH0rrvuqlWw+89//jMPSJ0+X2lQ4IoKg6cWQvnKXlP6/Zne8/qUjtH02S8M7Frx90vh4nLFiwjFkvZ3y5Yt8zmqcJ4qKLxP6XdHGjgWAOpb8f+SAgAavdSz8LDDDsu3ZM6cObkX+XXXXRdDhw7NvSLTf/xTgLk0wURFlfVmLevBBx+MH/3oR7lHeEHqlZmeM4VB6T/tU6dOzaFGTXTq1KnKeYVAaf78+Uu1zdQ7sqCqsD61f2FVhf9fVeFWCtN33nnn0t54hfVT7/JCD9fUQzf1zKzpfqhManuh128hoKrM6quvXun0Tz/9tPRxdXtPz5o1K4olHScpUE1Be+pVmoK5n/3sZzm8qmsHHHBAadBVTKkn6wMPPBCNSTr2lnSMFI6Tjz/+uNafx/RthsqOs6+//jrfluYYS2Fguhhz3HHH5V646VboBZ16xP/4xz+OffbZp157Bdf23Fnbz13h4l1Vn+vC+Sed54r1Taey55zCuT6d12tzzqjJsfTZZ5+VXgBZWuni9CWXXJLP0+miwfe+973SbwykHubpokn6plBtev3vv//+lV4g/uEPfxinnHJK7kX+3HPPlbtAWpvXVKxe7uniSQrc033BY489lt/vdDG/pvtlSdZee+3Ybbfd4h//+Efu5Z4uWifpPFEI+9PvBABoCHq4AwA5YEmh7yOPPFLamy71pn788cdrtXeqKolQKM0yaNCgHMDstNNOMWzYsByupJ7LKehJQUKh5Elj0rt379LHxSjxksp0pBAnBVw333xzTJw4MfeCT0Fn2gfpVgg7K4b4xVKTwLFsiY7Ro0cvsYd1uqX3u9hS8FYIdFL5ibT/6loKkpZUwqUmt7r4tkWxNFQoXTjOfv/731frGKtYdiOVokkXY1IYl46T1BM/fbb+9re/5bIrKbysTpBf36o6dzaWz11NlG17Ckmr0/ayIW5DHsPpHJwuzlQsYVLoSZ0uXi+//PJLvd104SFdeE5SaF32m02F20orrZQvipcN54vxmopZVmbs2LGl30YpW04mleNJ7a8rhZJn6VsGhQvShcfpd2q6OAoADUHgDgCUU/Zr8YWv9deF1AMuBV3pP+OpV30KvioGFoXee43Jd7/73dLelekCRW2kHpiFHs033HBDrqmcyilUDKmq6slatuxDIZCpqKra5qn+fCHUK9trtrISFpUp286alooplrK9O1NphrqWLg5VJyxc2lvabmOTeoMv6RhZ3HFSW4XjrDbHWDrWU0/X1Bv5o48+yj2Fzz777BxWvvDCC0UNdetabT93hZ7zi3u/0kXQsmNVFOuckwLQwvoNcc6o7bGUvimRpIs16XdXulD66quv1qon9Z133lnlfqxMqtle9gJRMT4ftdGrV6/S8keFkD1dRHj00UfrtJxMQSo7ly6ipW8ZFMYnKFwESReaUnk2AGgIAncAoJyyX2mv+J/VVC+1WD2tC+UnUn3VNCBjZQp1mRuTNFhb4aJEGqCxUJO4JlJP20LYstlmm1W6TCr1U1UgU7bnYFXlPAqBUEXpq/6pxn2yuKC3qnnp6/yFshTpgklDKlvbvqo649TM5ptvXlr7u6qSRmkchiWVk6mpQpj397//vWjbTKVmLr/88lxSJnnqqafq7DxXbLX93KVa/EkqTVLV63v++eerLLVVm3NOOnemElA1bXsxSjYV3u+lCbkL0rfA0uCf6XOQgvKyg6WmcU9qotBjPZWMSaFxVbd0ESNd/ErffvrrX/+6yGtKn8+l+XZP4RgvxnFeCNXThYhUBi7dp4s2qSxaYRyWpbE0n7900bjw+zh986BsPXeDpQLQkATuANBMpMEC33333SUud9ttty0StpWtm51MmzatKHXkk9SmysKPVK6lMBhdY3PWWWflAepSIJDq66bSDjWR9mehJMCbb765yPwUep177rlVrr/BBhuUfivg/vvvX2R+qvuegsWqHHTQQfk+1btNJQEqSr1cC3VxK1MYSDCFRmlgysWpq3Ip6dgpfEsgXSwyQF5xpZIMKQBLIeO1115b6TKXXXZZ1JVCaPb222/nsjKLk9qYAr+CsmNDVKbw2SkbPhb7PFcXavO5K5RfSj39y57ry54zLr300jo75xTez/QNp3RbmrbXVurxnALadF775S9/udTrp3N1oSf77373u9KBQmsa7KZguFCWLI1lks5fVd3SMVkoj1K2rMzBBx+c56XfFak8WXXD88IxXozjPP0OTBfnU8/2dCGl0NP90EMPzRdZltbSfv7S4MHpmxNpoPe0D5L0jbl0rAJAQxG4A0AzMXLkyNh4441jzz33jNtvv71c6Y1U2iQFN6mkydVXX52npZ6I22+/fbltFHrxpa+1V3fQu6rsuuuuOehKoUqqs1wocVDoIZfmL25gvIaUyjKkkDcFA6mXZyozc+aZZ8Z//vOfcnWKU0361JO0qhrKKUgp9OA97bTT8oCfKbAqBIypd2DquVhVr+0UZqTBbZNf/epXpT0MC+WA0iB8b731VpWv48QTT4zu3bvn0Hr33Xcv1+s1Pe8uu+yy2EFlTz/99DxgaVo/DUKZyuKULUWRApNUqzn1gOzfv38U26hRo3KoUyh9dMIJJyy2hEAqzbO4W2MNWBu6XE8KtJILLrggfvvb38aMGTPyz+m9TsdtGnsgDRpZF1Jwls5Lhfc3BWqpR33ZUD19yyRdBEttLQwKWji+UxiYguGy01P704WkdB5M0jmxsvNcKjfzzjvvRGNTm8/d1ltvXVqLPNW/Tr20CxcmUgifAvk0uGxV3zqq7Tkn1TpPPcXTeSYtm8L9suWK0kWTNBZDeq9TuZJiSr3T03k6ueKKK/JAqGlg8ILCYJupXVVJx2I6x6Tzc/odWIzBUtNxm96XJUnHcvLvf/87P3/hwnV6LUmh7WXHFkm/g1J5l3333bdcKZrU7sI3JW655ZalHjy8rLStvffeOz9OF1sKtdwL9d2X1tJ+/tLF7/T6Ct/OSAyWCkCDKwEAmoXHH388Janlbm3atCnp0qVLSYsWLcpN33zzzUsmTJiwyDaee+650mVbtWpV0qNHj5KePXvmW8GHH35Yup30eHH+93//t9zzdu7cuWS55ZbLj9dZZ52SO++8s3ReRbfcckueXva5C375y1/meQMGDKjyuZ999tkqt11d77zzTslWW21V7jW0bNky79P0Wsru17Zt25aceuqpJVOnTi23jddff72kQ4cO5Zbr1KlTfty6deuS22+/Pb/G9HN6zRV9/PHHJauttlrp+mn/rbDCCvlx2s6wYcNK56XXXNELL7xQ0rFjx9Jl2rdvX/rziiuuWHLvvfeWzps4ceIi66fj5Hvf+17pMuk1p/UKbSjc1ltvvaXev+n9K7ym7t27l7uldpbd/iGHHFLyzTffVHksVOfWt2/fkqak7GtbkrKfy8qOo8K+TtusaPr06SXbb7996frps7/SSiuVHt/nnXdeyQ477JAfX3755Yusv7jjrzrPP3fu3JJjjjmm3HuVjtHUhvR5Kzv9k08+KV3viCOOWGSddGyWnZZe14wZM8o935QpU0q6detWuszKK69cep7717/+tcR9XfH5KztH1facVJvP3eTJk/OxXvacUdgvaTs33nhjnZ5zvvrqq5K99tqrXDvT+qkNZc+Z6fxX0eLaVXG/p/uK5s+fX3LCCSdUeiwVnjuduxfnsMMOK133xBNPLKmJ2bNnl+7z008/vVrrpLavssoqeZ3BgweXm/erX/2q3Gdh+eWXz7+Hyk6r+LvnkksuKfd7Z80118z7N51Ll/aYfOSRR8rt04022mixyy/ud3RNPn9PP/106fJdu3YtmTNnzmKfHwDqmh7uANBM7Lbbbrk3XyoLkb6Gnnq7p556qTdk6s24/vrr5x50aeCx1INutdVWW2QbO+ywQ+4tl3oopl5tn3/+eR6sraYDtv3617/OvUxTb/pUpiD1tE+9EH/xi1/kHveVtaExSeVLUr3iJ598Mg+ol3qdphrHqSdhyhlTrehUtiWVH0i9ONO3Byr2BN5iiy3yV+HTvk81b1MP99SzP/388ssvL7GX4BprrJHbkHprFnospp7zqXdrKlmQeggvTvoWQ+qRmnpupv2dejqmNh511FF5/fQaCirrxZzWSXXmU13h1HM29TZMvSpTr9dUbzr1fBwyZEhpz8OaSMdFOtbK3tJ+WmeddXIP99SbNx23NSlfwJKl4+mZZ56JK6+8MjbddNNc/z8d3+nYSt/0uOSSS0q/HVAXPd3T86We2OnzkL4tko7J9E2S1FM9fdtk4MCBufd9Oo4Ln4Hk/PPPj+uuuy73+t1oo41y2YnCOunbG6lnfhqjoOI3SNJnOB2v6dhK20v1swvnuZrU/q4LtfncpcFL07686KKL8n5J3zRK+yZ9yyXVNz/++OPr9JyTvhmUSo+kkjKpd/haa62Ve9mn9qftpW83pZ7SdTFodyopk74RkPZd+mZVeu50fknHc+/evfO3OSorlVNW+v1ZUNOe1Ok5Cp+ZQs/16rS9UFYmlbMpWz7pnHPOyWXJUrmh9Ds0SfPT7/VUrqbwjayy0u/Z9PdAquufzp1pLIx0jNdksPIf/OAHpQMs16Z3e00/fzvttFMeHDkxWCoAjUGLlLo3dCMAAGicUtCZahSn8g6V1XmHFGKnEDcFfCkoq4vyQdSvFNqngDOVG6mqJFZzddJJJ+XQPg2Wmi5c0PBSObfCgMDpQo367QA0ND3cAQCoVOpNmHrJJqn3K1QmfXMjhe2ph2kazwCWVenbS4Xa/6kGPo3D9ddfX9rTXdgOQGMgcAcAaMZSKZbzzjsvD8JXKFGQysqknsopvEgDk7Zr1y5OOeWUhm4qDWT69Om5vMPjjz9ebmDZ1AM6DUJ54YUX5p8HDx6cjxVYFqWyN+k8mEL3Nddcs8aDpVJcqTRRKrGTnHHGGXYvAI1C64ZuAAAADSfV673sssvyrUWLFrl+bioRUgjfU/3sVFZCr8HmK9VLv+eee/ItSWMMFIL4ggMPPDDXkYZlTfqWT7p98cUXMXv27NJvdaRzIw0j1ZtP44+kuv+TJk3K0/baa69cSx4AGgOBOwBAM5ZCihRYpMEjU4/lyZMn5wH0Us32HXfcMfdaFrY3b2lAzFSzOg2omb4JkY6XFDymgTpT3eQ0WGYK3NMFG1jWpG91pHNj+vZGv3798oWlNBg2DSd9Cyu9J+mckwbxTe9HGrwZABoLg6YCAAAAAEARqOEOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACiC1sXYCE3bqquuGjNnzoy11lqroZsCAAAAAFAtH330UXTo0CE+++yzaCz0cCeH7fNmz46YNs3eAAAAAACahHnz5uVsszHRw52FPdtHjYqR668fMWyYPQIAAAAANHp9+vSJxkYPdwAAAAAAKAKBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4s1Dv3hHDhtkbAAAAAAA11LqmKwIAAAAAESUlJfkG1FyLFi3yrakTuAMAAADAUpo9e3Z89dVXMX369Jg/f779B0XQtm3bWGmllaJz587RsmXTLM4icAcAAACApfD111/HhAkT7DMosrlz58Znn30Wc+bMiVVXXbVJ9ngXuLPQqFERAweq4w4AAACwhJ7thbC9Y8eOuTduu3btmmxvXGgsFixYkC9mffHFFzFt2rTo0KFDrLDCCtHUCNwBAAAAoJpSGZlC2L7GGms0yR640Bi1bNkyunbtmks0TZkyJZdraoqBu0tvAAAAAFBNKQRMUs92YTsUX6dOnfL9zJkzm+TuFbgDAAAAQDWUlJSUDpCaysgAdTNwaqHETPrMNTUCdwAAAACohrLhn5rtUDdalCnTJHAHAAAAAIBmSg93AAAAAAAoAoE7AAAAAAAUgcAdAAAAAKh13e2yt1TjfsUVV4z+/fvHTTfd1CC1uAcOHJjbMm7cuDp/rtmzZ8cFF1wQG2ywQR5Qd7XVVoujjjoqJkyYUKPtTZ06NU455ZTo2bNnHkQ03Q8ePDimTZtW5TppkNFrrrkmvvOd78Tyyy8f3bp1ix/+8IcxevTopX7+wvu4OLfeemteZtCgQUu9/WVZ64ZuAI1Ez54RQ4Y0dCsAAAAAaMKOOOKI0vB37Nix8dJLL8WLL74YzzzzTPz1r3+NZdGcOXNip512ildeeSV69OgR++67bw75b7nllvj73/+ep/fq1ava25s8eXJss8028f777+f19ttvvxg5cmRce+218Y9//CP+9a9/RZcuXcqt8+2338bBBx8cDz74YL7Qseeee+bt3HffffHoo4/Gs88+G1tttVUdvHoq0sOdhTp0iOjXz94AAAAAoMZSr+d0+8tf/hIvv/xyPPHEE9G6deu4++67c/i8LLr00ktzqJ5C8nfffTfuueeeePXVV+Oqq66KSZMm5Z7uSyP1ZE9h+wEHHBBjxozJ23v77bfjpJNOyts/7bTTFlnn5ptvzmH7+uuvH++8804O2ocNGxb33ntvzJo1K37yk5/E/Pnzi/iqqYrAHQAAAACoE7vsskv8z//8T3780EMPLXN7+ZtvvokbbrghP77xxhujY8eOpfNSML7pppvGc889F//5z3+qtb2JEyfmbwK0adMmfve73+WLFQVXXnllLhNzxx13xBdffFFuvauvvjrfX3HFFdG9e/fS6QceeGDss88+OcB/+OGHa/16WTKBOwAAAABQZzbbbLN8//HHH5ebnnqBpzIoqQxLCpjXWGONOOaYY+Kjjz5aZBupdvn1118fu+22W2ld865du8buu+8eTz311FK156uvvooddtgh1x9PvcZrU18+lcxJ21t33XVLX2dZBx10UL4fOnRotbb3+OOP5/IwqfZ92eA8Sa957733zuV6HnvssdLpH374Ya7Tnuq2p1IytW1DbQwbNmyRev4Vb8t6zXc13FkoDR4xeLA67gAAAAAU1fTp00sD44LUezuF3cl3v/vdHDCn8il//vOf45FHHsm9wjfeeOPS5VPJlpNPPjnWXnvt2HDDDXP5lhTMP/nkk/mWBmatTumWzz//PIf0I0aMyIOcXnTRRaXzUt31ddZZJz+ubgj/5ptv5vvNN9+80vmF6W+99VbRtpfKx5TdXmGdTTbZJJZbbrlat6E2Vl111dI6/hWlWv6prn+rVq1iWSZwZ6FZsyJGjLA3AAAAACiaFFwXaren8iplw/PUsz2VOdliiy1Kl0+Be+rlfuSRR+blClLIngYL/d73vldu+2+88UYesPTUU0+NH/7wh+VKulSUAvVU4iaFvtddd11p4F8bhd74qXd+ZQrTx48fX2fbK3YbamOjjTbKNfwrSu9lquOfBnT93//931iWCdwBAAAAoNhS6FhJ8FhOv37lqw2kzpCpAsGSDBtW/ueBA5e8Tnqe9HwF6XnSz3VU3iOVPfnggw/iV7/6VQ7KU+/2FKInv/71r/P8P/zhD+XC9uToo4/OPdzTLYXphTItqed5ofd5WWn+CSecEJdddlk8++yzueRKZUaOHBm77rprrn2eBnRNg4hWlHqHp2B/acyYMSPft2/fvtL5HTp0KNfLvy62V+w2lJVKwNTWJ598Evvvv38etDUNALvBBhvEskzgDgAAAAB1Ub73ueeWbp1p05Z+naQ666Rtl5XC/RVXjGKrLKDt1KlT3HbbbbnOeapP/swzz+RwONVjr0wqL5MC99dee61cXfQU0qd1X3755Ty46Ny5c/P09957r9x9Zb2rUyg/e/bsePDBB2OvvfaqdLnVV1893nnnnRq97mVVVeVhkjQQa6phvzizZ8+OfffdNz777LMYMmRIvuixrBO4AwAAAECxrb12xIABi1+mbI/zJAXgS1qnMtVZp2K4np47tbGOAtqWLVvGCiusEN/5znfigAMOiJVWWilPnzx5cmmP7DRQ6uKkZcv2kk5BeaFeeWWq6sH9P//zP6W9q6sK22uqUMJmVirXXImZM2eWXnSoq+0Vuw1lVVYepuy8JQXugwYNiuHDh+dvLpxyyinRHAjcAQAAAKDYUqmWpS3XkkLwiuViqqMm65QtZVNEiwtok9TDvRASH3jggYtdtk+fPqWPU133FLandc4666xc+iUFyCnY/+Mf/xg/+9nPqhzo9Ec/+lEuI5MGSd1hhx3ywJ7FstZaa5VeEKhMYXrPnj3rbHvFbkOxXHLJJfG3v/0ttt9++zxIbnMhcAcAAAAA6sXKK68c7dq1y0H5LbfcUq0a4amH9lNPPRXdu3fPvdRbtWpVbn6qFb84F198cay22mrxm9/8Jg+wOmzYsFhllVWiGPr27ZvvUy/uyhSmFwaMrYvtFdZ5++23Y968ebkWfW3aUAwPPvhg/PKXv8wh/wMPPLDEbzMsS1o2dAMAAAAAgOahdevWMXDgwPj6669zPfbq+Oqrr3LP+B49eiwStqeAOYW7S5IGaj3jjDNi9OjROXSfNGlSFMN2220XnTt3jrFjx8aIVBe/gvvuuy/fVzWYa0W77757vhjxwgsv5AFey0o164cOHZr3wR577FE6PQ0mu/HGG+d66Y8++mit21Bbb775Zi7jk+r0P/zww9GtW7doTgTuAAAAAEC9Offcc3OofOSRR+be5hWlGu8333xzDpCT1Bs9hdqpB3fZmuFpENX//d//jXfffbdaz3vllVfGaaedFiNHjozvf//75WrEJxMmTIiNNtoo36or9dw+8cQT8+M0MGuhXnpy9dVXx1tvvRUDBgyILbbYotx6N9xwQ36ec845p9z0dFEhlcD55ptv4vjjj8+15wtSKZ10oeCwww5bpId+el2FZcoG9al3eRqAdr311suDl9a1SZMm5edJ9eRvv/320t73zYmSMiyUrjQtbV0xAAAAAFhKqab3jTfemIPqHXfcMTbZZJPYYIMNcimUcePG5Z7iqTd3Gmx1+eWXz73iU5CcgvoUXqce6l26dIlXX301Pv/88xx0p+1Vx1VXXZWD+muvvTaH7v/85z+ja9eupb3lx4wZs9Tv53nnnRdPP/10vPzyy7H++utH//79Y/z48bl9qXd3unhQUQr703NNnDhxkXlDhgyJV155Je6///4cym+55Zb5IkG64JC2n4L8io466qh47LHHcm//tE7hgsJzzz2X9+Edd9yR92Nd+8Mf/pBfe6qTn4L+dKvs/U81+ZdVerizkMAdAAAAgHpy3HHHxeuvvx5HHHFETJ8+Pf7+97/HE088kXu3/+QnP8k/p17tBb/4xS/itttuy3XIUy/3FHCn3tMpmE6B9NJIgfZJJ52Ue5/vvPPOMWXKlFq9llST/tlnn43zzz8/l1F56KGHcug8aNCgXD+9V69eS13n/rXXXsttTD3dU4ieyuqcfPLJeXq62FBR+sbAvffemy8opHr1af/997//zYPMpv289dZbR31YsGBBvv/ss8/y+1XZ7cUXX4xlWYuSqobvpdkojPicrpQBAAAAULlUR7zQA3rDDTfMISfQcJ+zPo0w13RWAAAAAACAIhC4s1AamfnWW+0NAAAAAIAaErizkMAdAAAAAKBWBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAA1dCiRYvSxwsWLLDPoA58++23lX7mmgqBOwAAAABUQwr/2rZtmx9//fXX9hnUgZkzZ+b7Nm3aNMnAvXVDNwAAAAAAmoqVVlopPvvss/jiiy9i/vz50alTpxzCN8VgEBpbz/aZM2fG559/nn9On62mSODOQu3bR/TrZ28AAAAALEbnzp1jzpw5MW3atJgyZUq+AcXVrl276Nq1a5PcrQJ3Flp77YghQ+wNAAAAgMVo2bJlrLrqqtGhQ4eYPn167pGrnjsUR5s2bXLP9hS2t2rVqknuVoE7AAAAACyFVD5mhRVWyLekpKQk34Dafa6WhdJMAncAAAAAqIVlJSgEaq9lEbbBsiCN/jtiREO3AgAAAACgyRK4s9D48RGDB9sbAAAAAAA1JHAHAAAAAIAiELgDAAAAAEARCNyXYPbs2XHBBRfEBhtsEO3atYvVVlstjjrqqJgwYcJS7+ypU6fGKaecEj179oy2bdvm+8GDB8e0adOqtf4333wTvXv3zoNwtG5tvFsAAAAAgMZE4L4Yc+bMiZ122ikuueSSmDFjRuy7776x5pprxi233BKbbbZZfPDBB9Xe0ZMnT46tttoqrrvuuhyW77ffftGpU6e49tprY+utt44pU6YscRu/+tWv4p133qn2cwIAAAAAUH8E7otx6aWXxiuvvBLbbLNNvPvuu3HPPffEq6++GldddVVMmjQp93SvrtST/f33348DDjggxowZk7f19ttvx0knnZS3fdpppy12/dGjR8fll18exx57bPXfXQAAAAAA6k2LkpKSkvp7uqYjlW9ZZZVV4quvvorhw4fnHu1l9e3bN9566614/fXXY4sttljstiZOnBhrrLFG7tn+0UcfRffu3UvnzZ07N/eaTz3cP/300/ycFaW3aIcddsjBfOrh3qVLl2jVqlXMnz+/KK+1T58+EaNGxcgBAyKGDSvKNgEAAAAA6lLONSNi5MiR0Vjo4V6Fl156KYft66677iJhe3LQQQfl+6FDhy5xJz/++OPx7bffRv/+/cuF7Umq5b733nvHggUL4rHHHqt0/f/7v/+LF198MfesX2mllarzvgIAAAAAUM8E7lV488038/3mm29e6fzC9NTLvS63lXrHn3322fH9738/DjvssCU+FwAAAAAADUPgXoVU+iVJpWAqU5g+fvz4Ot3WiSeemAdv/d3vfhd1qndv5WQAAAAAAGqhdW1WXpbNmDEj37dv377S+R06dMj306dPr7NtPfzww/HAAw/EL3/5y9hggw2iWDWNKho7dmwunQMAAAAAQM3p4d5IpfA99W5PQfs555zT0M0BAAAAAGAJ9HCvQseOHfP9rFmzKp0/c+bMfN+pU6c62dYvfvGL+OSTT+Lpp5/OA6sWQ1Wj9VbV8x0AAAAAgOoTuFdhrbXWyvcp9K5MYXrPnj3rZFtDhw6Ndu3axSWXXJJvFS1YsCAGDhyYHw8ZMiT69esXtTJqVETa3rBhtdsOAAAAAEAzJXCvQt++ffP98OHDK51fmL7pppvW2bbSYKnPPfdcldstzJs2bdoS2wAAAAAAQN1Sw70K2223XXTu3DkPKDpixIhF5t933335fu+9917iTt59992jZcuW8cILL8QXX3xRbt7cuXNzb/ZWrVrFHnvsUTp93LhxUVJSUuktScsXfi70dAcAAAAAoOEI3KvQpk2bPGhpcsIJJ5TWWU+uvvrqeOutt2LAgAGxxRZblE6/4YYbYqONNlpkkNMePXrEj370o/jmm2/i+OOPj/nz55fOO+uss2LSpElx2GGHxSqrrFLs9xcAAAAAgHqipMxinHfeeXnQ0pdffjnWX3/96N+/f4wfPz5effXV6NatW9x8883llp88eXKMGTMmJk6cuMi2Up31V155Je6///4cym+55ZZ5ENO33347bzuF+AAAAAAANF16uC9GGrT02WefjfPPPz/at28fDz30UA7cBw0alOuu9+rVq9o7euWVV47XXnstTjrppNzT/cEHH4yvvvoqTj755Dy9S5cuxXg/AQAAAABoIC1KCkXBabb69OkTMWpUjBwwIGLYsIZuDgAAAABA9XLNiFxJpLHQwx0AAAAAAIpA4A4AAAAAAEUgcGehnj3TyK72BgAAAABADQncWahDh4h+/ewNAAAAAIAaErgDAAAAAEARCNwBAAAAAKAIBO4sNG5cxODB9gYAAAAAQA0J3Flo1qyIESPsDQAAAACAGhK4AwAAAABAEQjcAQAAAACgCATuAAAAAABQBAJ3AAAAAAAoAoE7AAAAAAAUgcAdAAAAAACKQOAOAAAAAABFIHBnoW7dIgYNsjcAAAAAAGpI4M5CAncAAAAAgFoRuAMAAAAAQBEI3AEAAAAAoAgE7iw0aVLErbfaGwAAAAAANSRwZyGBOwAAAABArQjcAQAAAACgCATuAAAAAABQBAJ3AAAAAAAoAoE7AAAAAAAUgcAdAAAAAACKQOAOAAAAAABFIHAHAAAAAIAiELizUPv2Ef362RsAAAAAADUkcGehtdeOGDLE3gAAAAAAqCGBOwAAAAAAFIHAHQAAAAAAikDgzkIzZ0aMGGFvAAAAAADUkMCdhcaPjxg82N4AAAAAAKghgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwv17h0xbJi9AQAAAABQQwJ3AAAAAAAoAoE7AAAAAAAUgcAdAAAAAACKQODOQqNGRQwcaG8AAAAAANSQwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwAAAAAAFIHAnYV69owYMsTeAAAAAACoIYE7C3XoENGvn70BAAAAAFBDAncAAAAAACgCgTsAAAAAABSBwJ2Fxo2LGDzY3gAAAAAAqCGBOwvNmhUxYoS9AQAAAABQQwJ3AAAAAAAoAoE7AAAAAAAUgcAdAAAAAACKQOAOAAAAAABFIHAHAAAAAIAiELgvwezZs+OCCy6IDTbYINq1axerrbZaHHXUUTFhwoSl3tlTp06NU045JXr27Blt27bN94MHD45p06Ytsuy8efPiySefjBNPPDE22WSTaN++fSy//PKx8cYbxxlnnBGTJk1a6ucHAAAAAKDutCgpKSmpw+03aXPmzIkdd9wxXnnllejRo0f0798/xo0bF6+99lp069YtT+/Vq1e1tjV58uTYZptt4v3338/rbLnlljFy5Mh8S2H+v/71r+jSpUvp8k8//XTssssu+fHaa68dm2++eQ7h03JpW6uuumoMGzYsNtxww1q/zj59+kSMGhUjBwyIGDas1tsDAAAAAKhrOdeMyBlrY6GH+2JceumlOVRPQfm7774b99xzT7z66qtx1VVX5R7mqad7daWe7ClsP+CAA2LMmDF5W2+//XacdNJJedunnXZa+TemZcv44Q9/mJ/vww8/jPvvvz8eeeSRvI3ddtstPvvsszjyyCOjaLp1ixg0qHjbAwAAAABoZvRwr8I333wTq6yySnz11VcxfPjw2GyzzcrN79u3b7z11lvx+uuvxxZbbLHYnTxx4sRYY401onXr1vHRRx9F9+7dS+fNnTs31lxzzZgyZUp8+umn+TmXJC23+uqr58epx30qTbOsXQkCAAAAAGhquaYe7lV46aWXcti+7rrrLhK2JwcddFC+Hzp06BJ38uOPPx7ffvttLklTNmxPUi33vffeOxYsWBCPPfZYtd60VEc+lbQphO8AAAAAADQ8gXsV3nzzzXyfaqdXpjA99XKvz20laZDVNABrkmq5AwAAAADQ8ATuVUilX5JUCqYyhenjx4+v120lN954Y8yfPz++853vxDrrrBNFMWlSxK23FmdbAAAAAADNUOuGbkBjNWPGjHzfvn37Sud36NAh30+fPr1et/XGG2/kwVyT3/zmN1GTmkYVjR07NtadO3dh4G7gVAAAAACAGtHDvQn5/PPP44ADDog5c+bE4MGD4wc/+EFDNwkAAAAAgP9HD/cqdOzYMd/PmjWr0vkzZ87M9506daqXbaXe73vssUeMGzcuDj744LjqqquW+iCuarTe3PN91Kil3h4AAAAAAP8/PdyrsNZaa+X7Tz75pNL5hek9e/as822lHu377LNPDB8+PHbddde44447omVLbx0AAAAAQGMita1C3759830KuStTmL7pppvW6bbS4KiHHHJIDBs2LLbddtt44IEHok2bNkt8TgAAAAAA6pfAvQrbbbdddO7cOQ8oOmLEiEXm33ffffl+7733XuJO3n333XOP9BdeeCG++OKLcvPmzp0bQ4cOjVatWuWSMWWVlJTEkUceGY888kj069cvHn300dIBVgEAAAAAaFwE7lVIvchPPPHE/PiEE04orbOeXH311fHWW2/FgAEDYosttiidfsMNN8RGG20U55xzTrlt9ejRI370ox/FN998E8cff3zutV5w1llnxaRJk+Kwww6LVVZZpdx6aWDUVD4mbfPJJ5+MFVdcsTjvOgAAAAAARWfQ1MU477zz4umnn46XX3451l9//ejfv3+MHz8+Xn311ejWrVvcfPPN5ZafPHlyjBkzJiZOnLjItoYMGRKvvPJK3H///TlA33LLLfMgpm+//Xbedgrxy3r44Yfjuuuuy4/XXHPNOPPMMytt49lnn523BwAAAABAwxK4L0a7du3i2WefjcsvvzzuuuuueOihh6JLly4xaNCguOSSS2KNNdao9o5eeeWV47XXXosLL7wwb+fBBx+M7t27x8knnxwXXXTRIr3Xp06dWvr4qaeeqnK7qS1FCdzbt4/o16/22wEAAAAAaKZalKRC4TRrffr0yfepxz0AAAAAQFPQpxHmmmq4AwAAAABAEQjcAQAAAACgCATuLDRzZsSIEfYGAAAAAEANCdxZaPz4iMGD7Q0AAAAAgBoSuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4s1Dv3hHDhtkbAAAAAAA1JHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4sNGpUxMCB9gYAAAAAQA0J3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAImgd9ezLL7+MO+64I1577bWYPHlyfP/734+zzjorzxs5cmSMHTs2dt5552jfvn19Nw0AAAAAAJpG4H7vvffGMcccEzNmzIiSkpJo0aJFrL766qXzJ0yYEPvvv3/cdtttcdhhh9Vn0+jZM2LIEPsBAAAAAKCxl5T517/+FT/+8Y+jdevWcdVVV+Ue7il0Lyv1du/cuXM88MAD9dUsCjp0iOjXz/4AAAAAAGjsPdx/9atfRcuWLeOpp56KzTffvNJlWrVqlee9/fbb9dUsAAAAAABoWj3cX3755dhmm22qDNsLVl111Zg4cWJ9NQsAAAAAAJpW4D5r1qzo1q3bEpebOnVqvbSHCsaNixg82G4BAAAAAGjsgXsaHHXkyJGLXSbVdE/lZNZZZ536ahYFs2ZFjBhhfwAAAAAANPbAfffdd48xY8bE3XffXeUyN910U3z88cex55571lezAAAAAACgaQ2aevbZZ8ddd90Vhx9+eLzxxhux//775+kzZ87MPz/44INxxRVX5LIzp556an01CwAAAAAAiqJFSarjUk/+9a9/xYEHHhifffZZtGjRoty81IxVVlklHn744dh6663rq0lERJ8+fSJGjYqRAwZEDBtmnwAAAAAATSPXjFhiKfNlsod7ss022+SyMn/+85/jqaeeinHjxsW3334ba6yxRuyyyy7xs5/9LDp37lyfTQIAAAAAgKYXuCedOnWKwYMH5xsAAAAAACwr6m3QVAAAAAAAWJbVWQ/3jz76qFbrr7XWWkVrCwAAAAAANNnAfe21115kYNTqSuvNnz+/6G1iMbp1ixg0yC4CAAAAAGhsgfsOO+ywSOA+d+7ceOWVV/LjlVZaKXr27FnaG37KlCl5+a233jratm1bV82iKgJ3AAAAAIDGGbgPGzas3M/Tp0+PnXbaKTbZZJO48sorY7fddis3/8knn4yzzjor5s2bF0888URdNQsAAAAAAJr2oKnnn39+jB07Nv75z38uErYnu+66azz99NN5mXPPPbe+mgUAAAAAAE0rcH/ggQdyD/eVV165ymXSvLTMgw8+WF/NomDSpIhbb7U/AAAAAAAae+A+adKkag2EmpaZPHlyvbSJMgTuAAAAAABNI3Bfe+2145lnnomPP/64ymXSvLRMWhYAAAAAAJqSegvcjz766Jg5c2YMGDAgbr/99pgzZ07pvLlz58Zf/vKXPG/WrFl5WQAAAAAAaEpalJSUlNTHE3377bfxk5/8JO65555o0aJFntatW7fScjNJasrBBx8cf/3rX6Nly3q7FtDs9enTJ2LUqBg5YEDEsGHNfn8AAAAAAE0k14yIkSNHRmNRb6l2CtBTkJ5u22+/fSy33HLxxRdf5Ft6nKbdddddOZAXtgMAAAAA0NS0ru8nPOSQQ/ItDY765Zdf5mldu3aN1q3rvSkAAAAAAFA0DZZyp4C9e/fuDfX0AAAAAABQVAqlAwAAAABAU+rh3qtXr2ovmwZVHTt2bJ22hwrat4/o189uAQAAAABo7IH7uHHj6uupqIm1144YMsS+AwAAAABo7CVlvv3220pvCxYsyGH8H//4x+jRo0eceeaZeToAAAAAADQlDTZoatnyMWuttVYcc8wxseWWW8Y222wT6623Xhx77LEN3TQAAAAAAGiag6b269cvttpqq7j++usbuinNz8yZESNGNHQrAAAAAACarEYVuCcrr7xyvP/++w3djOZn/PiIwYMbuhUAAAAAAE1Wowrcp0yZEi+99FKsuOKKDd0UAAAAAABonDXcn3/++SrnzZgxI9599934/e9/H5MmTYrjjjuuvpoFAAAAAABNK3AfOHBgHiB1cUpKSmLAgAHx61//ur6aBQAAAAAATStwP/zww6sM3Nu0aRM9evTIYfuOO+5YX00CAAAAAICmF7jfeuut9fVUAAAAAACw7A6a+tFHH+VBUZdk6tSpeVkAAAAAAGhK6i1wX2eddeLMM89c4nJnnXVW9OrVq17aBAAAAAAATS5wTwOiplt1lwUAAAAAgKak3gL36po8eXIsv/zyDd2M5qd374hhwxq6FQAAAAAATVadDpr6/PPPl/v5s88+W2Rawfz582PMmDHxxBNPRJ8+faKxmD17dlx++eVx991359ryXbp0id133z0uueSSWH311ZdqW6k+/YUXXhgPPfRQ3herrrpq7L///nnaiiuuWOk6CxYsiOuuuy5uvvnmeP/996Njx46x4447xkUXXRQbb7xxkV4lAAAAAAC11aKkDuu3tGzZMlq0aJEfp6cpPK5KYZk777wzDj300Ghoc+bMyeH2K6+8Ej169Ij+/fvHuHHj4rXXXotu3brl6dWtN5967m+zzTY5NE/rbLnlljFy5Mh822CDDeJf//pXDvPL+vbbb+Oggw6KBx98MAfy3//+9/N20kWL9C2AZ599Nrbaaqtav87CBY7UFgAAAACApqBPI8w167SH++GHH14ast92222x7rrrxnbbbVfpsm3atInVVlst9t5779h8882jMbj00ktzqJ6C8ieffDL3Lk+uvvrqOP300+Ooo46KYdUswzJ48OActh9wwAFxzz33ROvWC3f9ySefHNdff32cdtppceutt5ZbJ/VqT2H7+uuvHy+88EJ07949T7///vtzEP+Tn/wkRo8eXbotAAAAAACW0R7uFXu7Dxo0KIfITcE333wTq6yySnz11VcxfPjw2GyzzcrN79u3b7z11lvx+uuvxxZbbLHYbU2cODHWWGONHIynsjSF4DyZO3durLnmmjFlypT49NNP83MW9O7dOwfqKXTfb7/9ym1z3333jUceeSTuu+++OPDAA2t/JWjUqBg5YIA67gAAAABAk9CnEfZwr7dBU1N5lKYSticvvfRSDttTr/yKYXuSepgnQ4cOXeK2Hn/88fz6U0masmF70rZt29yrP9Vqf+yxx0qnf/jhhzlsT6Vj9txzz1o9PwAAAAAAy1Dg3tS8+eab+b6q8jaF6amXe11sq7DOJptsEsstt1ytnh8AAAAAgLpXZ8W/L7744ly//YQTTsiDgaafqyutd/7550dDSqVfklQKpjKF6ePHj6+TbRXz+QEAAAAAaMKB+4UXXpiD80MOOSQH7oWfq1MyvjEE7jNmzMj37du3r3R+hw4d8v306dPrZFvFfP6KNY0qGjt2bKybwvsps+LOx0ZXe3sAAAAAAA1l8oy5sXLHts0jcL/lllvyfY8ePcr9TOM1cdrs+OPzHzR0MwAAAAAAlmjqzHnNJ3A/4ogjFvtzY9exY8d8P2vWrErnz5w5M9936tSpTrZVzOcvqGq03tzzfdSo6LfWSvHCWTtWe3sAAAAAAA3l+w8trALSLAL3pm6ttdbK95988kml8wvTe/bsWSfbKubzV1e71i1jzS6Vl7ABAAAAAGhMlmvVIhqblg3dgMaqb9+++X748OGVzi9M33TTTetkW4V13n777Zg3b16tnh8AAAAAgCbcw/2oo46q8bpp0NQ///nP0ZC222676Ny5cx5QdMSIEdGvX79y8++77758v/feey9xW7vvvnu0bNkyXnjhhfjiiy9ilVVWKZ03d+7cGDp0aLRq1Sr22GOP0unrrLNObLzxxjF69Oh49NFHY7/99qvx81dL6ik/ZEhxtgUAAAAA0Ay1KCkpKamLDaeAuTaB+4IFC6KhnXfeeXHZZZfFtttuG08++WR06LCwJtDVV18dp59+egwYMCCGDRtWuvwNN9yQb/vvv39cfvnl5bZ12GGHxZ133hkHHnhg3H333dG69cJrHaecckpcd911ucb9rbfeWm6dm266KY499thYf/3148UXXywN6h944IG8nfXWWy8H8oVt1VSu4b6YGu8AAAAAAI1Nn0aYa9ZZD/dnn302mroUuD/99NPx8ssv59C7f//+MX78+Hj11VejW7ducfPNN5dbfvLkyTFmzJiYOHHiItsaMmRIvPLKK3H//ffHRhttFFtuuWU+EFLJmLTtFOJX9i2Bxx57LB588MG8zve///38HM8991wsv/zycccdd9Q6bAcAAAAAoDjqLK1Nvb+bunbt2uULB6m3+l133RUPPfRQdOnSJQYNGhSXXHJJrLHGGtXe1sorrxyvvfZaXHjhhXk7KUTv3r17nHzyyXHRRRfFiiuuWOm3BO6999649tprc7j/97//PfeyT73b0zq9e/cu8isGAAAAAKDRlZShiX31Yty4GHnsseq4AwAAAABNQp/mVFJmcVKJljSA6Keffpp/Xm211WL77bfPA5XSQGbNihgxwu4HAAAAAGgKgft///vfXI5lxP8Ldgud69MgqUnfvn3zwKGbbrppfTYLAAAAAACaTuCeBhNNdd2nTZuWa58fdNBBsfbaa+d5aSDSNJhoCuIHDhyYe8CnQUIBAAAAAKCpqLfA/Re/+EUO288+++y4+OKLo3Xr8k99xRVXxAUXXJAHKD333HNzAA8AAAAAAE1FvQ2a2qVLl1h99dVzWZnF+c53vhMTJkyIKVOm1EezKAwuMGpUjBwwIGLYMPsEAAAAAGj0+jTCQVNb1tcTzZs3r1q12dMyaVkAAAAAAGhK6i1wTwOijh07donLpWXSsgAAAAAA0JTUW+Ce6rL/+9//jptvvrnKZW655Za8TKr3DgAAAAAATUm9DZraoUOH+PnPfx7HHnts3HrrrXHIIYdEz54987zx48fH3/72t3jxxRfzMh07doznn3++3Po77LBDfTW1eerWLWLQoIZuBQAAAABAk1Vvg6a2bNkyWrRoEYWnS4/Lqmp6wYIFC+qhlc1TYxxcAAAAAACgqeWa9dbD/fDDD68yTAcAAAAAgKau3gL3VEYGAAAAAACWVfU2aCqN3KRJ6apIQ7cCAAAAAKDJErizkMAdAAAAAKBplJRJ5s6dG3fffXc899xzMXHixPxzZVKt92eeeaY+mwYAAAAAAE0jcP/oo49i5513jrFjx0ZJSclilzW4KgAAAAAATU29Be4nn3xyvP/++7HTTjvFKaecEr169YqOHTvW19MDAAAAAMCyEbinEjHrr79+PP7449G6db1WsgEAAAAAgGVn0NQ2bdrE5ptvLmwHAAAAAGCZVG+B+7bbbptLygAAAAAAwLKo3gL3iy66KEaPHh1/+tOf6uspAQAAAACg3tRbMfVUTubJJ5+Mww47LO64447YddddY/XVV4+WLSvP/A8//PD6ahpJ+/YR/frZFwAAAAAANVSvo5c+9dRT8cUXX8S4cePixRdfrHSZkpKSaNGihcC9vq29dsSQIfX+tAAAAAAAy4p6C9yvvPLKXFambdu2sf/++0evXr2iY8eO9fX0AAAAAACwbATuv//972OFFVaIV199NTbccMP6eloAAAAAAFi2Bk397LPPYsCAAcL2xmrmzIgRIxq6FQAAAAAATVa9Be7rrrtufPvtt/X1dCyt8eMjBg+23wAAAAAAGnvgftxxx8Wzzz6bB0wFAAAAAIBlTb0F7ieccEL89Kc/jf79+8ett94aEyZMqK+nBgAAAACAZWfQ1FatWuX7kpKSOProoxe7bIsWLWL+/Pn11DIAAAAAAGhCgfuaa66Zg/QlSYF8dZYDAAAAAIBmGbgvTe12g6sCAAAAANDU1FsN9+p444034rTTTos11lijoZsCAAAAAACNs4d7VT7++OO4884744477ojRo0crKQMAAAAAQJPUIIH79OnT4957780h+/PPP59D9nRbffXV45BDDokf/ehHDdEsAAAAAABo/IH7ggUL4vHHH4+//OUvMXTo0JgzZ04O2ZM0SOqwYcOif//+BkxtKL17Rwwb1mBPDwAAAADQ1NV5Dfd///vfcfLJJ8dqq60W++yzT/ztb3+L+fPn58epl/t3v/vdvNwOO+wgbAcAAAAAoMmqsx7ul156aa7N/u6775b2ZN92223jsMMOix/+8IfRpUuXPG3IkCF11QQAAAAAAGj6gfsFF1yQe6yvuuqqcfzxx8dPfvKTWHvttevq6QAAAAAAYNktKZN6tn/22WfxxBNPxFNPPRXTpk2ry6ejNkaNihg40D4EAAAAAGhsgfurr74aJ5xwQnTt2jVefPHFOO6446JHjx5x4IEHxgMPPBDz5s2rq6cGAAAAAIBlJ3BPg6Fef/318emnn8bDDz8cBx10UC4x8+CDD8bBBx+cw/ef/exn8fnnn9dVEwAAAAAAYNkoKZO0bt069t5777jnnntyeZk//elP0b9//5g6dWp+PHbs2Lzc2WefHSNGjKjr5gAAAAAAQNMM3MtaYYUV4uijj45hw4bFuHHj4rLLLouNNtoo13q/8sorY4sttoiNN944LrnkkvpsFgAAAAAA1FqLkpR2N7Dhw4fHX/7yl7j77rtziZlUembBggUN3axmo0+fPnnQ1JEDBkQMG9bQzQEAAAAAqF6uGREjR46MZtnDvSqbb755XHPNNTFhwoR49NFH49BDD23oJgEAAAAAwFJpHY1Iy5Yt4wc/+EG+AQAAAABAU9IoergDAAAAAEBTJ3BnoZ49I4YMsTcAAAAAAGpI4M5CHTpE9OtnbwAAAAAA1JDAHQAAAAAAikDgDgAAAAAARSBwZ6Fx4yIGD7Y3AAAAAABqSODOQrNmRYwYYW8AAAAAANSQwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwt16xYxaJC9AQAAAABQQwJ3FhK4AwAAAADUisAdAAAAAACKQOAOAAAAAABFIHBnoUmTIm691d4AAAAAAKghgfsSvPTSS7HHHntEly5domPHjrHVVlvF7bffXtP9HUOHDo0BAwbECiuskG8DBw6MRx99tNJlx48fH9dff33svvvuseqqq8Zyyy0XK6+8cv75kUceiaISuAMAAAAA1IrAfTHuv//+HI4//vjjsemmm+ag+7333osjjjgizjjjjKXe2UOGDIl99tknXn755dhuu+1ip512itdeey322muvuOGGGxZZ/ic/+UmcfPLJMWzYsNhoo43iwAMPjF69esUTTzwR++67b5x22mlL3QYAAAAAAOpGi5KSkpI62naTNmXKlFhnnXXi66+/zsH7AQcckKd//vnnsf3228f7778fzz77bO6hXh1jxoyJPn36ROvWrfN622yzTZ7+7rvvxrbbbhtfffVVjB49OtZbb73SdQ499ND8XCng79SpU+n01CN+v/32i/nz5+fwfdddd63Va03tilGjYuSAARHDhtVqWwAAAAAA9SHnmhExcuTIaCz0cK/CTTfdlMP21JO8ELYn3bt3jyuuuCI/vuqqq6q9o6+99tpYsGBBHHfccaVhe7LBBhvEueeem8PztExZd999d5x44onlwvZkzz33jKOOOio//utf/1rtNgAAAAAAUHcE7lUo1FU/6KCDFpmXAu927drF008/HXPmzKn19grTUn336urbt2++//TTT6u9DgAAAAAAdUfgXoU333wz32+++eaLzGvTpk1ssskmOWxPJWGWZNq0afHRRx/lx5ttttki89dcc808GGoaJDX1qq+ODz74IN+nwVQBAAAAAGh4AvdKpNA71VRP1lhjjUp3XGF6CsmXpBC2r7TSStGhQ4daby8F+Lfffnt+nEreAAAAAADQ8Fo3dAMaoxkzZpQ+bt++faXLFILz6dOnV3t7VW1rabeX6sBPmjQpvve978X+++8fSzuIQEVjx46Ndau9FQAAAAAAmlXgnoLo0aNHL9U6qdf4VlttFY3Zb37zm7jnnnuiS5cuceedd0aLFi2Ks+F0MaBfv+JsCwAAAACgGVpmA/cPP/wwxowZs1TrzJo1K9937Nix3LQVVlhhkWVnzpyZ7zt16rTE7Ra2V9h+ZaqzvTvuuCPOOeec3Bs+DcLaq1evWBojR45cfM/3IUOWansAAAAAADSDwH3EiBE1XjcF7J07d8513D/55JPo3bv3Isuk6UnPnj2XuL211lor30+dOjUH65XVcV/S9v7+97/HkUceGcstt1w88MADuZwMAAAAAACNh0FTq9C3b998P3z48EXmzZs3L95+++1o165dbLDBBkvcySuuuGJp6P7GG28sMv/jjz+OyZMn57C9st70zz33XBx88MFRUlISd911V+y6665LfmcBAAAAAKhXAvcq7Lnnnvn+vvvuq7S3+Zw5c2LnnXfOoXttt1eYtvfeey8yLwX+++yzT8ydOzduuummOPDAA6NOpJI2tfhWAAAAAABAc9eiJHWbZhFTpkyJddZZJ77++uu4//7744ADDsjTv/jii9huu+3i/fffj2effTYGDhxYbr2NNtoo3z/zzDOx+uqrl05P9eRTrfTWrVvHsGHDSkvCvPfee7HNNtvk8jVpkNf11luv3Dr9+/ePSZMmxXXXXRcnnXRSnbxTuYb7qFExcsCAiGHDHA0AAAAAQKPX5/+NTVnV2JUNYZmt4V5bXbp0iZtvvjl++MMfxkEHHZSD9a5du8bTTz8d06ZNi9NOO22RsD0pDNSays6UteGGG8aVV16Z10sh+i677BJt2rSJJ598MmbPnp0D9bJhe3LooYfmsL1bt27xn//8JwYNGrTI86WA/+yzzy766wcAAAAAYOkI3BcjlW95/vnn49JLL41XXnklvvnmmzyA6oknnhhHHHHEUu7qiFNPPTWH6il4f+GFF/K0LbfcMs4666zYa6+9Flk+DbKapND9tttuq3SbAwYMELgDAAAAADQCSsqgpAwAAAAA0OT0aYQlZQyaCgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuAAAAAABQBAJ3FurdO2LYMHsDAAAAAKCGBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwJ2FRo2KGDjQ3gAAAAAAqCGBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuAAAAAABQBAJ3AAAAAAAoAoE7C/XsGTFkiL0BAAAAAFBDAncW6tAhol8/ewMAAAAAoIYE7gAAAAAAUAQCdwAAAAAAKAKBOwuNGxcxeLC9AQAAAABQQwJ3Fpo1K2LECHsDAAAAAKCGBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3FmoW7eIQYPsDQAAAACAGhK4s5DAHQAAAACgVgTuAAAAAABQBAJ3AAAAAAAoAoE7C02aFHHrrfYGAAAAAEANCdxZSOAOAAAAAFArAncAAAAAACgCgTsAAAAAAAjcAQAAAACgcdDDHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcWah9+4h+/ewNAAAAAIAaEriz0NprRwwZYm8AAAAAANSQwB0AAAAAAIpA4A4AAAAAAEUgcGehmTMjRoywNwAAAAAAakjgzkLjx0cMHmxvAAAAAADUkMAdAAAAAACKQOAOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwJ2FeveOGDbM3gAAAAAAqCGBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwZ6FRoyIGDrQ3AAAAAABqSOAOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNyX4KWXXoo99tgjunTpEh07doytttoqbr/99hrv8KFDh8aAAQNihRVWyLeBAwfGo48+Wu31//KXv0SLFi3y7dJLL61xOwAAAAAAKC6B+2Lcf//9ORx//PHHY9NNN43dd9893nvvvTjiiCPijDPOWOqdPWTIkNhnn33i5Zdfju222y522mmneO2112KvvfaKG264YYnrT548OU477bQctgMAAAAA0LgI3KswZcqUOOqoo2LBggVx3333xbBhw/L9O++8E+utt15cddVVeVp1jRkzJof0bdu2jeeffz7+8Y9/xEMPPRQjRoyIrl27xqmnnhrvv//+YreRlpk5c2YcdthhS/cuAwAAAABQ5wTuVbjpppvi66+/jn333TcOOOCA0undu3ePK664Ij9OoXt1XXvttTm8P+6442KbbbYpnb7BBhvEueeeG/Pnz8/LVOWpp56KO+64Iy/bq1evaj8vAAAAAAD1Q+BehUJd9YMOOmiReXvuuWe0a9cunn766ZgzZ06tt1eYluq7V2bWrFk5qN94443jzDPPrNbzAQAAAABQvwTuVXjzzTfz/eabb77IvDZt2sQmm2ySw/Z33313iTt52rRp8dFHH+XHm2222SLz11xzzVh55ZVj/PjxuVd9RRdeeGF88MEH8Yc//CE/d53o2TMVma+bbQMAAAAANAMC90qk0Purr77Kj9dYY41Kd1xhegrJl6QQtq+00krRoUOHpdpeqvF+zTXXxJFHHhk77LBD1JnUrn796m77AAAAAADLuNYN3YDGaMaMGaWP27dvX+kyheB8+vTp1d5eVduqanup5vuxxx4bnTt3jiuvvDJqq0+fPpVOHzt2bKy77rq13j4AAAAAQHO2zAbu+++/f4wePXqp1rn99ttjq622isYiDaL6+uuvx8033xxdu3Zt6OYAAAAAANAcA/cPP/wwxowZs1TrpMFJk44dO5abtsIKKyyy7MyZM/N9p06dlrjdwvYK269Mxe2l0jIXXHBBLiMzaNCgKIaRI0dW3fN93LiIwYPVcQcAAAAAqKFlNnBPtc9rKgXsqYxLquP+ySefRO/evRdZJk1PeqbBRpdgrbXWyvdTp07NwXplddwrbu/ZZ5/Ny37xxRex4447llt2XArHI+LPf/5zPP3009GvX78YUtsBT9PFgFrsMwAAAACA5m6ZDdxrq2/fvvH888/H8OHDFwnc582bF2+//Xa0a9cuNthggyVua8UVV8yhexo89Y033ojtt9++3PyPP/44Jk+enMP2ir3p33nnnXyrTAreC+E7AAAAAAANq2UDP3+jteeee+b7++67b5F5f//732POnDmx884759C9ttsrTNt7771Lp6UyMiUlJZXefvnLX+ZlLrnkkvzzsGHDavgqAQAAAAAoFoF7FY455pjc2/zhhx+OBx54oHR6KvFy1lln5cenn376IutttNFG+TZhwoRy00855ZRo1apV/OEPf4hXXnmldPp7770Xl112WbRu3TovAwAAAABA0yRwr0KXLl3i5ptvjpYtW8ZBBx0UO+20Uxx88MGx4YYbxvvvvx+nnXZaDBw4cJH10kCt6ZbKzpSV1rvyyitj7ty50b9//9hjjz1iv/32y6Vrvvzyy7j66qtjvfXWq5t3GQAAAACAOqeG+2IceOCBuY77pZdemnulf/PNN7me+4knnhhHHHHEUu/sU089NYfqKXh/4YUX8rQtt9wy95jfa6+9av4uAgAAAADQ4FqUpCLgNGt9+vSJGDUqRg4YEKEePAAAAADQVHLNiBg5cmQ0FkrKAAAAAABAEQjcWahbt4hBg+wNAAAAAIAaErizkMAdAAAAAKBWBO4AAAAAAFAEAncAAAAAACgCgTsLTZoUceut9gYAAAAAQA0J3FlI4A4AAAAAUCsCdwAAAAAAKAKBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuLNS+fUS/fvYGAAAAAEANCdxZaO21I4YMsTcAAAAAAGpI4A4AAAAAAEUgcAcAAAAAgCIQuLPQzJkRI0bYGwAAAAAANSRwZ6Hx4yMGD7Y3AAAAAABqSOAOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4M5CvXtHDBtmbwAAAAAA1JDAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4s9CoUREDB9obAAAAAAA1JHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcGehnj0jhgyxNwAAAAAAakjgzkIdOkT062dvAAAAAADUkMAdAAAAAACKQOAOAAAAAABFIHBnoXHjIgYPtjcAAAAAAGpI4M5Cs2ZFjBhhbwAAAAAA1JDAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuAAAAAABQBC1KSkpKirEhmq5OnTrFvBkzYt327SPWXruhmwMAAAAAsERjx46N5ZZbLqZPnx6NReuGbgANb/bs2VHSsqWwHVjiL7Fk3XXXtacA5wqgVvxdAThPAMUwb968mD9/fjQmAndiww03zHth5MiR9gZQpT59+jhXAEvkXAFUh3MF4DwBFPNvisZEDXcAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCJoUVJSUlKMDQEAAAAAQHOmhzsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7s3Y7Nmz44ILLogNNtgg2rVrF6uttlocddRRMWHChIZuGlCP/vOf/8Svf/3rOOCAA2KNNdaIFi1a5NuS3HrrrbHVVltFx44do0uXLrHHHnvEyy+/XC9tBurXrFmz4qGHHoqjjz46Ntxww/x3Q4cOHaJv375x8cUXx4wZM6pc17kCmperr746/02x/vrrR+fOnaNt27bRs2fPOPzww+O///1vles5V0Dz9eWXX8Yqq6yS/w+y3nrrLXZZ5wpoXgYOHFiaUVR2e/zxxxvluaJFSUlJSb09G43GnDlzYscdd4xXXnklevToEf37949x48bFa6+9Ft26dcvTe/Xq1dDNBOrBfvvtFw8//PAi0xf362Hw4MFx7bXXxvLLLx+77rprPqc888wzeZ377rsvbxNYdtx0001x7LHH5scbb7xxbLLJJvH111/nP1qnT58eG220UTz33HP5P8tlOVdA87PyyivHzJkzY9NNN43VV189Txs5cmS8++67sdxyy8UDDzwQe+21V7l1nCugeRs0aFDcfvvt+f8S6667brz//vuVLudcAc0zcH/uuefiwAMPzOF5Raeffnp85zvfaXznihS40/yce+65KUkr2WabbUqmT59eOv2qq67K0wcMGNCg7QPqz69//euS888/v+SRRx4pmThxYknbtm3zeaAqTz31VJ7ftWvXknfffbd0+ssvv1zSpk2bkhVXXLFk6tSp9dR6oD7ceuutJT/96U9LRo0aVW76p59+WrLZZpvlc8KPfvSjcvOcK6B5evHFF0tmz569yPQbb7wxnyu6d+9eMm/evNLpzhXQvD399NP53JD+zkj36667bqXLOVdA8zRgwIB8bvjwww+rtXxjOVcI3JuhuXPnlnTu3DkfgMOHD19k/qabbprnvf766w3SPqBhLSlw/8EPfpDnX3PNNYvMO/nkk/O83/72t3XcSqCxSH+8ps99OnekvzEKnCuAilKQls4Xb775pnMFUDJr1qx8Xujdu3cOxhYXuPu7ApqnAUsZuDeWc4Ua7s3QSy+9FF999VX+qtZmm222yPyDDjoo3w8dOrQBWgc09rEf/vnPf5Y7V5Tl/AHNT6rjnsydOzfXYE2cK4DKpJIySZs2bZwrgLjooovigw8+iD/84Q+l54fK+LsCqI7GdK5oXefPQKPz5ptv5vvNN9+80vmF6W+99Va9tgto/MaMGZNDtTTWQxpgtSLnD2h+0n+Uk/Qf5TQgUeJcAVT0l7/8JZ8b0mCq6eZcAc1byhuuuuqqOPLII0vHlKuKvyuAP//5z7lzT8uWLWODDTbIddjXWmutRnuuELg3Qx999FG+r+zgKzt9/Pjx9douoOmfPzp06BArrrhiTJ06NQ+k2KlTp3puIVDf0oBEye677x5t27bNj50rgCuvvDIPlpoGUB09enR+vNpqq8Vf//rXaNWqlXMFNGPffvttHHPMMfn/DVdcccUSl/d3BXDppZeW2wlnnHFGnH/++fnWGM8VSso0QzNmzMj37du3r/IATNLBB7A05w/nEGheHnvssdzbJPVuv+SSS0qnO1cATzzxRNx2221x33335bC9Z8+eOWzfYostnCugmbv++uvj3//+d74w17Vr1yUu7+8KaL522GGH/C25sWPHxqxZs3Iv9ssuuyxat24dF1xwQWnnn8Z2rhC4AwCw1N5555047LDD0gjL+T/MhVruAMnTTz+dzw+pF9nzzz+fy8gMGDAg/ycZaL5SD9Tzzjsvnw8GDRrU0M0BGrmLL744/5+jV69esfzyy+dyMr/4xS/ioYceyvMvvPDCXLu9sRG4N0MdO3bM9+nKUGXS1z4TpSCApT1/OIdA8zBhwoRcQiYFaaeddlqccsop5eY7VwAF6avbqT5z+kZM6t2evvqderY6V0DzdMIJJ8Q333yTB0qtLn9XABXtuuuuseWWW8a0adPi1VdfbXTnCjXcm6HCoAKffPJJpfML09PXPgGW5vyRfnmlX3grrbSSi3awjJoyZUr+AzeN9ZIGOvvtb3+7yDLOFUBFqfTUIYccEv/5z39i6NCh8d3vfte5Apqhv//97/lC3HHHHVdu+pw5c0ov6g8cODA/vvvuu2PVVVd1rgAqlb499/rrr8fEiRMb3f9BBO7NUOEr38OHD690fmH6pptuWq/tAhq/DTfcMA+KOGnSpPzH8Oqrr15uvvMHLNtSXcQf/OAHMWrUqDjggAPiT3/6U7Ro0WKR5ZwrgMqsvPLK+T79HeFcAc1XCryee+65Suel4L0wrxDC+7sCqEz6tm3ZuuyN6VyhpEwztN1220Xnzp3zgAMjRoxYZH4a2CjZe++9G6B1QGOWaqbttNNO+fG99967yHznD1h2zZ07N/bdd9947bXXYrfddsuDH7Zq1arSZZ0rgMoUQrR1113XuQKaqTS2Q2W3Dz/8sPT8UJi29tpr52n+rgAqSqH6Cy+8kB9vvvnmje9cUUKzdO6555akt3/bbbctmTFjRun0q666Kk8fMGBAg7YPaDht27bN54GqPPXUU3l+165dS959993S6S+//HJed8UVVyyZOnVqPbUWqA/z588v2X///fNnv3///iUzZ85c4jrOFdD8vPjiiyX/+Mc/ShYsWFBu+jfffFNy3XXXlbRs2bJk+eWXL/noo49K5zlXAMmHH36Y/85Yd911K90hzhXQ/Lz00kslDz74YP6/SMXzxXbbbZfPGfvss0+jPFe0SP/UfaxPY5O+mpXqoqWBBXr06JEHMkq1WNPP3bp1i1deeSWPAAws+x599NG45JJLSn9OvVfTr4att966dFoa4GzPPfcs/Xnw4MFx7bXXRvv27WOXXXbJAx899dRTeb101Xi//far99cB1J30eU+f+2T//fePFVZYodLlUj33QsmIxLkCmpdbb701j+2QzgNpgNSuXbvG5MmT47///W+ur9quXbu47bbb4oc//GG59ZwrgHHjxsU666yTe7i///77le4Q5wponn9XrLrqqrkXexr/IWWXaTyYlGv26dMn/vnPf8Yqq6zS6M4VAvdmbPbs2XH55ZfHXXfdFR9//HF06dIldt999xy8rbHGGg3dPKCef4ktzi233BKDBg1aZL0bbrghRo8eHW3atInvfe97OZjfdttt67jFQH278MIL46KLLlricunr4IWvfxc4V0Dzkc4BN910Uy4d88EHH+SwPf2NkM4L6SveJ598cqy33nqVrutcAc1bdQL3xLkCmo/Ro0fH9ddfnzsHp9wy1WxP9do33njjOPjgg+PnP/95LiPTGM8VAncAAAAAACgCg6YCAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwAALKUWLVos9jZw4ED7tAl5//33o02bNnHmmWeWm37hhRfm9zPdL87aa6+dlxs3blyNnn/ixImx/PLLx/HHH1+j9QEAaDxaN3QDAACgqTriiCMqnb7RRhvVe1uouXPOOScH7meddVaD7MYePXrET3/60/jd734XgwcPjg022KBB2gEAQO0J3AEAoIZuvfVW+66JGz58eNx3331x8sknR7du3RqsHSnsv+GGG+L888+Pe+65p8HaAQBA7SgpAwAANFu///3v8/3hhx/eoO1YffXVY8cdd4wHH3wwPv/88wZtCwAANSdwBwCAOjJo0KBc23vYsGHxxBNP5EB1xRVXzNOmTZtWutzjjz8ee+65Z+5h3bZt2+jVq1ecdtpp8eWXX1a63SlTpsSJJ54Yq622WrRr1y569+4d1157bZSUlORtp5rildUir6pHfqEGeWVGjx6dX8eaa66Z29a9e/c49NBDY+TIkYssm7ZfqHn+0UcfxY9//OP8mlJ98i233DKGDh1a5b5Kz3P00UfntqTnWWWVVWK77baL3/72tzF//vy8zCabbJK3P2bMmEq38fHHH0erVq1inXXWyftiSWbMmBF33313rL/++rHFFltEMaU6/kuq9V+x5nvaX/PmzfPNCQCAJkzgDgAAdeyuu+6KH/zgBzFz5sx8/93vfrc04D777LPztKeffjo23HDD2GeffaJ169ZxzTXXxNZbb71Ib+epU6fG9ttvHzfeeGMOlffdd9/cO/qMM87IZVGK6aGHHorNNtssbrvttlh55ZVz21KY/be//S222mqreP755ytdLwXJ6TW+9tpr8f3vfz9v4z//+U/st99+8eSTTy6y/L333puXufnmm6N9+/ax//775wA8BehpINMUjCc/+9nP8v1NN91U6fOm9b/99ts45phjqryAUNZzzz2Xt10Xg9zuvvvuucZ/xduBBx5Yuky6OFBWoR2PPvpo0dsDAED9UMMdAADq2J/+9Kfck/qQQw5ZJGj+zW9+k3tup1Ii6623Xp6egvTUS/ziiy+OU045Ja9b8Itf/CL3Bk+B7v33358D6qQQbhdLCs0PO+ywWG655eLvf/977LzzzuV65KfwPc1///3384CjZaWA/vTTT48rrrgiWrZc2MdnyJAhceqpp8all14au+66a+my7733Xi7nsmDBgrjzzjtzL++CtB+eeuqp3EM+SculCxRp+5dddlm5501BewrcU4h95JFHVus1vvDCC/k+XRwottTOitLrOeCAA/Lj448/Pn9roKz0zYZ0YSO9l3PmzMnfXgAAoGnRwx0AAGqouqVCUrmYimF7kkLj5K9//Wtp2F7Ybgrc+/Xrlwf0nDx5cp6eesinsDmF2GmAzULYnqQe5yeccELR3ssUkKfnu/zyy8uF7UkK+3/+85/nHuiV9cZOveB/9atflYbtSSqBs9JKK8Urr7wS33zzTen01JM/hcupV3rZsL2wH1I4n0rMJJ07d87lbCZNmhQPP/xwuWVTz/lUxibt61RqpzreeuutfJ++WbA4F1100WJLw4wfP75az5cGRE3fGkilhVIJoMqktsydOzdfVAEAoOnRwx0AAGoolQipTMeOHcv9nHqDV/TFF1/Em2++meuHpx7uFaUgN9UwHzFiRC7Hsttuu+X72bNn53B93XXXXWSdH/3oR7nHfDEUSr8UemRX1L9//7juuutyb+xUAqZiaZSKvd5TmZwUxA8fPjzXpu/Ro0eenkrplC0XsyTHHXdc7smevjVw8MEHl05PPyc//elPq/0a03uQpAsBi9O3b9988aMq6aJIujixOOlbCukCS3rf0vJpf1SmS5cu+T5dVAAAoOkRuAMAQA1VNQhpRWuttdYi0wq94FNJlSXVGy/0cP/000/zfc+ePStdruJgqbVRaF+qD1+dtpW1xhprVLpsp06d8n3qwV2QesknlV1AqEwq/7L55pvnoP7DDz/MIX6qc58GZE3Pm3rfV9dXX31Vrl1VSbXn0zcOqpIGxV1c4J4ulBx11FH5eR555JHSUL0yK6ywQr4vO6guAABNh8AdAADqWGW1uFPN8WTVVVfNvdcXp6qAvVgKbalsWlW9+AvSwK4VlS0lUxdSL/fUk/3Pf/5zrgmfyuzMmzcvh9oVByJdnFSiJpk+fXqdtfWzzz7LA9umiwxpsNnevXtX6yLAiiuuWGdtAgCg7gjcAQCgARR6gadBMqvbU75QhqWqmuFVTS+Ud5kxY8Yi89JgpSkUrqx9Y8eOjauuuiq6du0adSUNHJp6+afnWlzZlrJSrfczzjgjbrnlltzz/Kabbsoh/9FHH71Uz73KKqvk+ylTpkRdSCF76h0/YcKEXOpnr732WuI6U6dOzffdunWrkzYBAFC3DJoKAAANIAXaG220UYwaNSrefffdaq2zxRZbxPLLL59LlHzwwQeV1glfXFBf2fM8++yzuXd4Rbvssku+f/DBB6MuFQZk/eMf/1jtdTp06BCHHXZYLrFz1lln5cA+fUugstI9S6rNnowZMybqwrHHHhuvvvpqbmtqZ3W88847eZDYjTfeuE7aBABA3RK4AwBAAzn//PNz6ZYDDzwwD45aURpctDAYaGEw1v/5n//JvdJPOumkPIBqweuvvx433HBDpc+zww475Ps77rijtDZ7kmqgn3zyyZWuc/rpp+dwP/Ukf+CBByrtvZ0G//zkk0+iNgYPHpxL7qTXec8995SbV1JSEk899VS5mu9ly8ok11xzTWm4vbTSwK/Jv//97yi2K664Iv7yl7/kkjtl38PFSb3803ueBsWtrAwRAACNn5IyAADQQFJplJEjR8avfvWr3Hs9lVRJg4emoDmFr2+99VYO2cuGyZdffnk899xz8dhjj+VlU5ieypD885//jJ/97Gdx4403LvI8abnDDz88br/99vwcaZ1Zs2bFK6+8EnvssUd+XLEczXrrrRd//etfcxvTBYH0c+p1nXqXpxIpw4cPzwOFvvHGG1UOklodG2ywQS4Nk9p36KGHxsUXXxybbrpprmX+9ttv50FV0+tLvb7L+s53vhPbbrttvPzyy7kO/t57773Uz532Q9q/adDTYjvnnHPy/UorrVR6caCi3/72t7mkUEGhHXvuuWfR2wMAQP3Qwx0AABrQZZddlgP0FGqnWuoPPfRQLvOSerH//Oc/j0ceeaTc8l26dImXXnopz0vBfFr+o48+il//+tdx/fXXV/k8qZf12WefHSussEI88cQTuad7CoVTqF6VNNhnCv2PP/74aNGiRe5t/uijj8YXX3yRA+7qDAJaHSloTz30U+mVFLTff//9uWxOKhGTasinULwyO+20U74/8sgjo3Xrpe9LlLb7ox/9KN5///2i93IvDDr7+OOP50FdK7tVrKl/1113xXLLLReDBg0qalsAAKg/LUrSX+kAAMAyIQXjPXv2LFc6ZlmU/huTetynuvQpMO/Vq1eNtpNK+Wy22WZx4oknLvaCRV1LpXnS+3bQQQctUloHAICmQw93AACgyUn149Ngp6kkTk3D9iSV2Dn44IPj5ptvzj33G8qVV14ZLVu2zCV1AABougTuAABAk3HMMcfkXuBp8NhWrVrFRRddVOttprr48+bNywOdNoSJEyfGH//4x1yrf8MNN2yQNgAAUBxKygAAwDJkWS8pk15fqte+/vrr597gKXwHAIDGQuAOAAAAAABFoKQMAAAAAAAUgcAdAAAAAACKQOAOAAAAAABFIHAHAAAAAIAiELgDAAAAAEARCNwBAAAAAKAIBO4AAAAAAFAEAncAAAAAACgCgTsAAAAAABSBwB0AAAAAAIpA4A4AAAAAAEUgcAcAAAAAgCIQuAMAAAAAQBEI3AEAAAAAoAgE7gAAAAAAUAQCdwAAAAAAKAKBOwAAAAAAFIHAHQAAAAAAikDgDgAAAAAARSBwBwAAAACAIhC4AwAAAABAEQjcAQAAAACgCATuAAAAAAAQtff/AXGm3sNvLuY5AAAAAElFTkSuQmCC)
+
+### Strain Gauge BR
+
+![Strain Gauge BR](data:image/png;base64,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)
+
+### Strain Gauge FL
+
+![Strain Gauge FL](data:image/png;base64,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)
+
+### Strain Gauge FR
+
+![Strain Gauge FR](data:image/png;base64,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)
+
+### Suspension Travel BL
+
+![Suspension Travel BL](data:image/png;base64,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)
+
+### Suspension Travel BR
+
+![Suspension Travel BR](data:image/png;base64,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)
+
+### Suspension Travel FL
+
+![Suspension Travel FL](data:image/png;base64,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)
+
+### Suspension Travel FR
+
+![Suspension Travel FR](data:image/png;base64,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)
+
+### Tire Temp BL
+
+![Tire Temp BL](data:image/png;base64,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)
+
+### Tire Temp FL
+
+![Tire Temp FL](data:image/png;base64,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)
+
+### Wheel Speed BL
+
+![Wheel Speed BL](data:image/png;base64,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)
+
+### Wheel Speed BR
+
+![Wheel Speed BR](data:image/png;base64,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)
+
+### Wheel Speed FL
+
+![Wheel Speed FL](data:image/png;base64,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)
+
+### Wheel Speed FR
+
+![Wheel Speed FR](data:image/png;base64,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)
+
diff --git a/Data/SensorFrequencyAnalysis/summary.md b/Data/SensorFrequencyAnalysis/summary.md
new file mode 100644
index 0000000..5fb13ab
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/summary.md
@@ -0,0 +1,67 @@
+
+### BR Wheel Speed Sensor:
+
+Magnitude cutoff of 10 corresponds to approximately 10 Hz. Suggested sampling frequency is 20 Hz.
+
+![alt text](wheel_speed_br_graph.png)
+![alt text](wheel_speed_br_log_graph.png)
+
+## Wheel Speed BL
+![Wheel Speed BL Graph](wheel_speed_bl_graph.png)
+![Wheel Speed BL Frequency Spectrum](wheel_speed_bl_log_graph.png)
+
+## Wheel Speed FL
+![Wheel Speed FL Graph](wheel_speed_fl_graph.png)
+![Wheel Speed FL Frequency Spectrum](wheel_speed_fl_log_graph.png)
+
+## Wheel Speed FR
+![Wheel Speed FR Graph](wheel_speed_fr_graph.png)
+![Wheel Speed FR Frequency Spectrum](wheel_speed_fr_log_graph.png)
+
+## Suspension Travel BR
+![Suspension Travel BR Graph](Suspension_Travel_BR.png)
+![Suspension Travel BR Frequency Spectrum](suspension_travel_br_graph.png)
+
+## Suspension Travel BL
+![Suspension Travel BL Graph](suspension_travel_bl_graph.png)
+![Suspension Travel BL Frequency Spectrum](suspension_travel_bl_log_graph.png)
+
+## Suspension Travel FR
+![Suspension Travel FR Graph](suspension_travel_fr_graph.png)
+![Suspension Travel FR Frequency Spectrum](suspension_travel_fr_log_graph.png)
+
+## Tire Temp FL
+![Tire Temp FL Graph](tire_temp_fl_graph.png)
+![Tire Temp FL Frequency Spectrum](tire_temp_fl_log_graph.png)
+
+## Tire Temp BL
+![Tire Temp BL Graph](tire_temp_bl_graph.png)
+![Tire Temp BL Frequency Spectrum](tire_temp_bl_log_graph.png)
+
+## Brake Temp
+![Brake Temp Graph](brake_temp.png)
+![Brake Temp Frequency Spectrum](brake_temp_log_graph.png)
+
+## APPS
+![APPS Graph](apps_graph.png)
+![APPS Frequency Spectrum](apps_log_graph.png)
+
+## Battery Voltage
+![Battery Voltage Graph](battery_voltage_graph.png)
+![Battery Voltage Frequency Spectrum](battery_voltage_log_graph.png)
+
+## Battery Current
+![Battery Current Graph](battery_current_graph.png)
+![Battery Current Frequency Spectrum](battery_current_log_graph.png)
+
+## Battery Tray Temp
+![Battery Tray Temp Graph](battery_tray_temp_graph.png)
+![Battery Tray Temp Frequency Spectrum](battery_tray_temp_log_graph.png)
+
+## Cell Temp
+![Cell Temp Graph](cell_temp_graph.png)
+![Cell Temp Frequency Spectrum](cell_temp_log_graph.png)
+
+## Cell Voltage
+![Cell Voltage Graph](cell_voltage_graph.png)
+![Cell Voltage Frequency Spectrum](cell_voltage_log_graph.png)
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_bl.py b/Data/SensorFrequencyAnalysis/suspension_travel_bl.py
new file mode 100644
index 0000000..eedb918
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/suspension_travel_bl.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01172026/011726-10.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_BL_DATA_SUSTRAVEL"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [3, 4, 5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Suspension Travel BL - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Suspension Travel BL - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_bl_graph.png b/Data/SensorFrequencyAnalysis/suspension_travel_bl_graph.png
new file mode 100644
index 0000000..5d616b4
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/suspension_travel_bl_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_bl_log_graph.png b/Data/SensorFrequencyAnalysis/suspension_travel_bl_log_graph.png
new file mode 100644
index 0000000..bae9980
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/suspension_travel_bl_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_br.py b/Data/SensorFrequencyAnalysis/suspension_travel_br.py
new file mode 100644
index 0000000..48cc0b7
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/suspension_travel_br.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-22.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_BR_DATA_SUSTRAVEL"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [4.5, 5.5, 6.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Suspension Travel BR - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Suspension Travel BR - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_br_graph.png b/Data/SensorFrequencyAnalysis/suspension_travel_br_graph.png
new file mode 100644
index 0000000..99b1961
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/suspension_travel_br_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_fr.py b/Data/SensorFrequencyAnalysis/suspension_travel_fr.py
new file mode 100644
index 0000000..73446f9
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/suspension_travel_fr.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-23.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_FR_DATA_SUSTRAVEL"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [4.5, 5.5, 6.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Suspension Travel FR - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Suspension Travel FR - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_fr_graph.png b/Data/SensorFrequencyAnalysis/suspension_travel_fr_graph.png
new file mode 100644
index 0000000..d2435f0
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/suspension_travel_fr_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/suspension_travel_fr_log_graph.png b/Data/SensorFrequencyAnalysis/suspension_travel_fr_log_graph.png
new file mode 100644
index 0000000..3f5a320
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/suspension_travel_fr_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/temp.md b/Data/SensorFrequencyAnalysis/temp.md
new file mode 100644
index 0000000..caa73eb
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/temp.md
@@ -0,0 +1,2 @@
+![alt text](image-1.png)
+![alt text](image-2.png)
\ No newline at end of file
diff --git a/Data/SensorFrequencyAnalysis/temp.py b/Data/SensorFrequencyAnalysis/temp.py
new file mode 100644
index 0000000..3fe6043
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/temp.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet("../fs-data/FS-3/01112026/011026-5.parquet")
+
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+
+df["ETC_STATUS_HE1"]
+plt.plot(df["ETC_STATUS_HE1"])
+plt.show()
+
+fft = scipy.fft.fft(df["ETC_STATUS_HE1"].to_numpy())
+fft
+freqs = scipy.fft.fftfreq(len(df["ETC_STATUS_HE1"]), d=0.01)
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Frequency Spectrum")
+plt.show()
+
+attempts = [10, 10.5, 11, 11.5, 11.75, 12, 12.5]
+ffts = []
+iffts = []
+
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+plt.plot(df["ETC_STATUS_HE1"], label="Real")
+
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
\ No newline at end of file
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_bl.py b/Data/SensorFrequencyAnalysis/tire_temp_bl.py
new file mode 100644
index 0000000..d0554e9
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/tire_temp_bl.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_9.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_BL_TIRETEMP_1"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [9, 9.5, 10, 10.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Tire Temp BL - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Tire Temp BL - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_bl_graph.png b/Data/SensorFrequencyAnalysis/tire_temp_bl_graph.png
new file mode 100644
index 0000000..a9a7c9c
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/tire_temp_bl_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_bl_log_graph.png b/Data/SensorFrequencyAnalysis/tire_temp_bl_log_graph.png
new file mode 100644
index 0000000..f48cad6
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/tire_temp_bl_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_fl.py b/Data/SensorFrequencyAnalysis/tire_temp_fl.py
new file mode 100644
index 0000000..d547e92
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/tire_temp_fl.py
@@ -0,0 +1,41 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_1.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_FL_TIRETEMP_1"].to_numpy()
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [6, 7, 8]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Tire Temp FL - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Tire Temp FL - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_fl_graph.png b/Data/SensorFrequencyAnalysis/tire_temp_fl_graph.png
new file mode 100644
index 0000000..2172323
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/tire_temp_fl_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/tire_temp_fl_log_graph.png b/Data/SensorFrequencyAnalysis/tire_temp_fl_log_graph.png
new file mode 100644
index 0000000..aa0c9fd
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/tire_temp_fl_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_bl.py b/Data/SensorFrequencyAnalysis/wheel_speed_bl.py
new file mode 100644
index 0000000..d89a6cf
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/wheel_speed_bl.py
@@ -0,0 +1,42 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_21.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_BL_DATA_WHEELSPEED"].to_numpy()
+signal = signal[signal > 0]
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [8.5, 9.5, 10.5]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Wheel Speed BL - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed BL - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_bl_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_bl_graph.png
new file mode 100644
index 0000000..747d6e3
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_bl_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_bl_log_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_bl_log_graph.png
new file mode 100644
index 0000000..19ca03f
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_bl_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_br.py b/Data/SensorFrequencyAnalysis/wheel_speed_br.py
new file mode 100644
index 0000000..8531b7c
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/wheel_speed_br.py
@@ -0,0 +1,47 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-18.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_BR_DATA_WHEELSPEED"].to_numpy()
+signal = signal[signal > 0]
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [9, 10, 11]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Wheel Speed BR - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed BR - Frequency Spectrum")
+plt.show()
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed BR - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_br_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_br_graph.png
new file mode 100644
index 0000000..f547ea5
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_br_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_br_log_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_br_log_graph.png
new file mode 100644
index 0000000..7d518c0
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_br_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fl.py b/Data/SensorFrequencyAnalysis/wheel_speed_fl.py
new file mode 100644
index 0000000..7155e56
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/wheel_speed_fl.py
@@ -0,0 +1,42 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/11222025/11222025_21.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_FL_DATA_WHEELSPEED"].to_numpy()
+signal = signal[signal > 0]
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [8, 9, 10]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Wheel Speed FL - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed FL - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fl_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_fl_graph.png
new file mode 100644
index 0000000..6d035ef
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_fl_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fl_log_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_fl_log_graph.png
new file mode 100644
index 0000000..3c3515c
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_fl_log_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fr b/Data/SensorFrequencyAnalysis/wheel_speed_fr
new file mode 100644
index 0000000..38dac78
--- /dev/null
+++ b/Data/SensorFrequencyAnalysis/wheel_speed_fr
@@ -0,0 +1,42 @@
+import scipy
+import numpy as np
+import polars as pl
+import matplotlib.pyplot as plt
+
+df = pl.read_parquet('/Users/aanyajain/Documents/GitHub/fs-data/FS-3/01112026/011026-18.parquet')
+df = df.fill_null(strategy="forward").fill_null(strategy="backward")
+signal = df["TPERIPH_FR_DATA_WHEELSPEED"].to_numpy()
+signal = signal[signal > 0]
+
+fft = scipy.fft.fft(signal)
+freqs = scipy.fft.fftfreq(len(signal), d=0.01)
+
+attempts = [9, 10, 11]
+ffts = []
+iffts = []
+for i, attempt in enumerate(attempts):
+    ffts.append(fft.copy())
+    ffts[-1][np.log(np.abs(fft)) < attempt] = 0
+    ifft = scipy.fft.ifft(ffts[-1])
+    iffts.append(ifft)
+
+RMSs = [np.sqrt(np.mean((ifft.real - signal)**2)) for ifft in iffts]
+plt.plot(attempts, RMSs)
+plt.xlabel("Attempt")
+plt.ylabel("RMS")
+plt.title("Wheel Speed FR - RMS vs Attempt")
+plt.show()
+
+plt.plot(signal, label="Real")
+for ifft, attempt in zip(iffts, attempts):
+    plt.plot(ifft.real, label=f"Attempt {attempt}")
+plt.xlabel("Time")
+plt.ylabel("Amplitude")
+plt.legend()
+plt.show()
+
+plt.scatter(freqs, np.log(np.abs(fft)), s=0.25)
+plt.xlabel("Frequency (Hz)")
+plt.ylabel("Magnitude")
+plt.title("Wheel Speed FR - Frequency Spectrum")
+plt.show()
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fr_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_fr_graph.png
new file mode 100644
index 0000000..c768a1f
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_fr_graph.png differ
diff --git a/Data/SensorFrequencyAnalysis/wheel_speed_fr_log_graph.png b/Data/SensorFrequencyAnalysis/wheel_speed_fr_log_graph.png
new file mode 100644
index 0000000..710d5c8
Binary files /dev/null and b/Data/SensorFrequencyAnalysis/wheel_speed_fr_log_graph.png differ
diff --git a/Data/Simultaneous_Plot_Viewer.py b/Data/Simultaneous_Plot_Viewer.py
new file mode 100644
index 0000000..69aa2d4
--- /dev/null
+++ b/Data/Simultaneous_Plot_Viewer.py
@@ -0,0 +1,155 @@
+# read current draw from parquet file
+from fs4BatteryThermalModelingEx import thermal_ode_solve_ivp
+import argparse
+import polars as pl
+import numpy as np
+import matplotlib.pyplot as plt
+from numpy.typing import NDArray
+from typing import Tuple
+from scipy.integrate import solve_ivp
+
+def load_avg_temp_from_parquet(path: str) -> NDArray[np.float64]:
+    """
+    Load average temperature from all ACC_SEG*_TEMPS_CELL* columns in a Parquet file.
+    
+    Parameters
+    ----------
+    path : str
+        Path to the Parquet file containing temperature data.
+    
+    Returns
+    -------
+    NDArray[np.float64]
+        Array of average temperatures across all cells.
+    """
+    columns_list = [
+        "ACC_SEG0_TEMPS_CELL0", "ACC_SEG0_TEMPS_CELL1", "ACC_SEG0_TEMPS_CELL2", 
+        "ACC_SEG0_TEMPS_CELL3", "ACC_SEG0_TEMPS_CELL4", "ACC_SEG0_TEMPS_CELL5",
+        "ACC_SEG1_TEMPS_CELL0", "ACC_SEG1_TEMPS_CELL1", "ACC_SEG1_TEMPS_CELL2", 
+        "ACC_SEG1_TEMPS_CELL3", "ACC_SEG1_TEMPS_CELL4", "ACC_SEG1_TEMPS_CELL5",
+        "ACC_SEG2_TEMPS_CELL0", "ACC_SEG2_TEMPS_CELL1", "ACC_SEG2_TEMPS_CELL2", 
+        "ACC_SEG2_TEMPS_CELL3", "ACC_SEG2_TEMPS_CELL4", "ACC_SEG2_TEMPS_CELL5",
+        "ACC_SEG3_TEMPS_CELL0", "ACC_SEG3_TEMPS_CELL1", "ACC_SEG3_TEMPS_CELL2", 
+        "ACC_SEG3_TEMPS_CELL3", "ACC_SEG3_TEMPS_CELL4", "ACC_SEG3_TEMPS_CELL5",
+        "ACC_SEG4_TEMPS_CELL0", "ACC_SEG4_TEMPS_CELL1", "ACC_SEG4_TEMPS_CELL2", 
+        "ACC_SEG4_TEMPS_CELL3", "ACC_SEG4_TEMPS_CELL4", "ACC_SEG4_TEMPS_CELL5"
+    ]
+    
+    temps_df = pl.read_parquet(path, columns=columns_list)
+    # take the mean of all the columns
+    avg_temp_df = temps_df.select(pl.mean_horizontal(pl.col(columns_list)).alias("avg"))
+    return avg_temp_df["avg"].to_numpy()
+
+def run_thermal_model_from_parquet(
+    path: str,
+    current_column: str = "SME_TEMP_BusCurrent",
+    t_span: Tuple[float, float] = (0, 10),
+    initial_temp: float = 30,
+    t_eval: NDArray[np.float64] | None = None,
+):
+    """
+    Load current data from a Parquet file and run the thermal ODE model.
+    
+    Parameters
+    ----------
+    path : str
+        Path to the Parquet file containing current data.
+    current_column : str, optional
+        Name of the current column in the Parquet file (default: "SME_TEMP_BusCurrent").
+    t_span : Tuple[float, float], optional
+        Integration time span (t0, tf) in seconds (default: (0, 10)).
+    initial_temp : float, optional
+        Initial temperature in °C (default: 30).
+    t_eval : NDArray[np.float64] | None, optional
+        Times at which to evaluate the solution. If None, uses 100 points over t_span.
+    
+    Returns
+    -------
+    OdeResult
+        Solution from thermal_ode_solve_ivp containing temperature predictions.
+    """
+    df = pl.read_parquet(path)
+    current_draw = df[current_column].to_numpy()
+    
+    if t_eval is None:
+        t_eval = np.linspace(t_span[0], t_span[1], 100, dtype=np.float64)
+    
+    return thermal_ode_solve_ivp(current_draw, t_span, initial_temp, t_eval)
+
+def parse_args() -> argparse.Namespace:
+    """
+    Parse command line arguments.
+    
+    Returns
+    -------
+    argparse.Namespace
+        Parsed command line arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="Compare thermal model predictions with measured temperatures from parquet data."
+    )
+    parser.add_argument(
+        "parquet_path",
+        type=str,
+        help="Path to the Parquet file containing temperature and current data.",
+    )
+    return parser.parse_args()
+
+
+def plot_temperature_comparison(
+    solution,
+    av_temp_array: NDArray[np.float64],
+    t_span: Tuple[float, float] = (0, 10),
+) -> None:
+    """
+    Plot comparison between thermal model prediction and measured temperatures.
+    
+    Parameters
+    ----------
+    solution : OdeResult
+        Solution from thermal_ode_solve_ivp containing model predictions.
+    av_temp_array : NDArray[np.float64]
+        Array of measured average temperatures.
+    t_span : Tuple[float, float], optional
+        Time span (t0, tf) in seconds for the actual data (default: (0, 10)).
+    """
+    # Create time array for av_temp_array (assuming same time span as model)
+    t_actual = np.linspace(t_span[0], t_span[1], len(av_temp_array))
+    
+    # Plot the temperature vs time in the same plot window
+    plt.figure()  # Explicitly create a single figure
+    plt.plot(solution.t, solution.y[0], label="Model prediction", linewidth=2)
+    plt.plot(t_actual, av_temp_array, label="Measured temperature", linewidth=2, alpha=0.7)
+    plt.xlabel("Time [s]")
+    plt.ylabel("Temperature [°C]")
+    plt.title("Thermal Model Comparison")
+    plt.grid(True)
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+
+def main() -> None:
+    """
+    Main function to load data, run thermal model, and plot comparison.
+    """
+    args = parse_args()
+    parquet_path = args.parquet_path
+    
+    # Load average temperature data from parquet
+    av_temp_array = load_avg_temp_from_parquet(parquet_path)
+    
+    # Run thermal model
+    sol = run_thermal_model_from_parquet(parquet_path)
+    
+    # Check if solution was successful
+    if not sol.success:
+        raise RuntimeError(f"ODE solver failed: {sol.message}")
+    
+    # Plot the comparison
+    plot_temperature_comparison(sol, av_temp_array, t_span=(0, 10))
+
+# run the main function: python Simultaneous_Plot_Viewer.py "/Users/gautham/Documents/fs-data/FS-3/08102025/08102025Endurance1_FirstHalf.parquet"
+if __name__ == "__main__":
+    main()
+
diff --git a/Data/Suspension/suspension_forces/12-12-highspeed.csv b/Data/Suspension/suspension_forces/12-12-highspeed.csv
new file mode 100644
index 0000000..29b43b7
--- /dev/null
+++ b/Data/Suspension/suspension_forces/12-12-highspeed.csv
@@ -0,0 +1,131 @@
+0-4.3 0-4.3 X _THROW_,0-4.3 0-4.3 Y _THROW_,0-3 0-3 X,0-3 0-3 Y,0-2 0-2 X,0-2 0-2 Y,0-1 0-1 X,0-1 0-1 Y,0-0 0-0 X,0-0 0-0 Y
+0.06048157177882768,22.01424593412321,0.12896343263378945,-16.48812811506889,0.06618839351674116,-9.0803079298324,0.11612308372348412,-12.829945307544676,0.18246488642672834,8.36465133354858
+0.32584878259180455,-45.60116629161553,0.21884587500592678,42.728706081728916,0.08188215329600323,-16.67103725544507,0.13752366524065968,23.934791908073407,0.2573669217368428,-5.6050342626843985
+0.4050309342053541,-50.760728293061106,0.29160785216432367,49.72498070111891,0.10328273481317879,-25.999403414631757,0.22655008435211,-18.372092260943845,0.2723473287988657,9.256333392882595
+0.4942000238602522,-56.453775287270616,0.3532415269337893,61.63236573961014,0.17176459566814056,-29.38322251159164,0.2231259913093619,27.775883855973802,0.3943306434467663,-6.519579964565452
+0.5683887064531274,70.48516813381869,0.381490294536461,-39.16886152171884,0.1846049445784459,40.12225083136792,0.28304761955745344,-18.042855808266637,0.4302836203956213,10.381224606196298
+0.6083364586185219,-59.19741239291375,0.44569203908798766,66.59834890082423,0.2809075614057359,-37.65986111361511,0.3943306434467663,-18.95740151014769,0.4713727369085984,-7.754216662104881
+0.7324598314181401,-63.31286805137847,0.5056136673360793,-45.96698457236795,0.29160785216432367,49.51920791819569,0.43713180648111744,30.336611821240723,0.5227341325498197,11.58842493267926
+0.7367399477215751,76.33826062585737,0.5501268768918044,72.27767770950553,0.3532415269337893,53.291708938455,0.4799329695154685,-20.786492913909797,0.6511376216528729,-7.617034806822716
+0.8480229716108881,-66.87959628871454,0.5847958189496287,-47.742727476853645,0.5056136673360793,-40.35777093416419,0.5377145396118426,32.508657863208214,0.6725382031700485,13.646152761911623
+0.92506506507272,82.6486259688366,0.6211768075288272,74.41771465190718,0.5432786908063082,55.541491365082365,0.6083364586185219,-20.603583773533586,1.2246732063131778,13.783334617193788
+0.9293451813761552,-68.80014226266474,0.7096325444664862,-53.252865330686944,0.6468575053494379,-42.18686233792627,0.6511376216528729,32.98879435669576,1.2246732063131778,-9.263217070208611
+1.0384881471137506,-70.99505194717926,0.7110592499009646,78.35026116999568,0.6768183194734837,57.40716459691971,0.7024990172940943,-21.883947756167032,1.31883576498875,13.783334617193788
+1.0727290775412315,86.21535420617268,0.7966615759696668,-54.53322931332042,0.7367399477215751,57.1328008863554,0.9165048324658499,34.08624919895303,1.31883576498875,-9.263217070208611
+1.104829949816995,-71.8181430788722,0.9279184759416768,-57.36832098915167,0.9507457628933308,59.32771057086991,0.9122247161624147,-22.432675177295664,1.4129983236643229,13.783334617193788
+1.2218197954442211,89.32480959256823,0.8993843672521095,80.7280799948864,1.1133901824238648,60.42516541312716,1.0620287867826437,34.63497662008166,1.4129983236643229,-9.263217070208611
+1.2389402606579614,-73.83014362301051,1.0263611509206845,82.19135311789607,1.3017152997750099,60.97389283425579,1.079149251996384,-22.981402598424296,1.508016905600582,14.112571069870967
+1.3502232845472744,-75.29341674602017,1.0277878563551628,-59.19741239291375,1.460079603002109,62.07134767651304,1.4900404171261545,36.281158883467526,1.4814801845192846,-9.263217070208611
+1.3473698736783177,91.88553755783518,1.1305106476376054,-60.29486723517101,1.7297269301185207,63.168802518770306,1.545681929070811,36.281158883467526,1.6013234410154675,14.33206203832242
+1.4244119671401498,93.53171982122106,1.186152159582262,83.47171710052955,2.0935368159105057,64.81498478215619,1.7468473953322614,-24.07885744068156,1.6954859996910399,14.33206203832242
+1.5242813475536354,-77.85414471128712,1.2503539041337883,-61.66668578799258,2.07213623439333,-49.32031881259846,1.8067690235803529,36.82988630459616,1.7853684420631772,14.33206203832242
+1.59918338286375,97.18990262874524,1.3316761138990558,84.5691719427868,2.2818619332616503,65.91243962441344,2.123497630034551,37.92734114685342,2.388864840847528,-10.360671912465847
+1.6241507279671215,-79.13450869392057,1.3701971606299717,-63.03850434081414,2.5258285625574515,66.46116704554207,2.2005397234963833,37.92734114685342,2.4830273995231007,-10.360671912465847
+1.6783655344772996,98.83608489213113,1.5033563345146193,85.97147535233773,2.6199911212330242,67.0098944666707,2.6799127494811157,-26.27376712519606,2.577189958198673,-10.360671912465847
+1.7832283839114598,-81.42087294862318,1.4729199519124143,-64.1359591830714,2.739834377729207,-50.966501075984326,2.774075308156688,-26.27376712519606,2.654232051660505,15.429516880579655
+1.7925019692355693,101.21390371702185,1.5927632084085972,-65.50777773589297,2.812596354887604,-50.966501075984326,2.85111740161852,-26.27376712519606,2.6713525168742454,-10.360671912465847
+1.8923713496490553,-82.79269150144478,1.6698053018704293,87.31280904842994,3.048002751576535,68.65607673005658,2.885358332046001,40.07236652035624,2.7483946103360775,15.429516880579655
+1.9672733849591695,104.87208652454603,1.7126064649047805,-66.87959628871454,3.2491682178379855,69.75353157231385,2.962400425507833,40.12225083136792,2.7655150755498177,-10.360671912465847
+2.046455536572719,-84.98760118595925,1.8153292561872232,88.41026389068719,3.467454149313176,-53.16141076049885,3.664339499271191,41.76843309475382,2.84255716901165,15.429516880579655
+2.099956990365658,106.79263249849623,1.8153292561872232,-67.9770511309718,4.01530903615287,72.49716867795698,3.7371014764295882,41.76843309475382,2.8596776342253905,-10.360671912465847
+2.157738560462032,-86.08505602821651,1.935172512683406,-69.34886968379337,4.066670431794091,72.49716867795698,3.938266942691038,-27.919949388581955,2.936719727687222,15.429516880579655
+2.2090999561032536,108.1644510513178,1.9855827713683087,89.81256730023813,4.254995549145236,73.59462352021424,4.037185186148205,-27.919949388581955,2.953840192900963,-10.360671912465847
+2.2561812354410398,-87.18251087047378,2.2005397234963833,-70.72068823661493,4.314917177393328,73.59462352021424,4.126592060042183,-27.919949388581955,2.9923612396318786,15.429516880579655
+2.2747284060892587,109.07899675319885,2.2090999561032536,91.15390099633034,4.39195927085516,-54.80759302388472,4.177953455683404,-27.919949388581955,3.005201588542184,-10.360671912465847
+2.3717443756337877,110.35936073583231,2.2561812354410398,-70.72068823661493,4.486121829530733,-54.80759302388472,4.605965086026916,43.96334277926832,3.4075325210650846,-99.80324155643223
+2.3931449571509633,-88.82869313385964,2.414545538668139,92.25135583858759,4.546043457778824,-54.80759302388472,4.700127644702488,43.96334277926832,3.8697850818360764,16.52697172283692
+2.500147864736841,-89.92614797611691,2.542949027771192,-71.8181430788722,4.8370913664124116,-55.905047866141985,4.764329389254015,43.96334277926832,3.959667524208214,16.52697172283692
+2.5634935860276804,112.77376138879828,2.6345435166647033,93.45855616507056,4.931253925087984,-55.905047866141985,5.222301833721572,44.51207020039695,4.0581101991872215,16.52697172283692
+2.616322450115794,-91.33716134473337,2.5943104234124132,-71.8181430788722,4.956934622908594,75.78953320472876,5.581831603210121,-30.114859073096454,4.152272757862794,16.52697172283692
+2.6906130402397035,114.47481639429702,2.7013133309982913,93.89753810197348,4.995455669639511,-55.905047866141985,5.6759941618856935,-30.114859073096454,4.233594967628061,16.52697172283692
+2.739834377729207,-92.66978508176004,2.8767980994391307,-72.91559792112946,5.085338112011648,75.78953320472876,5.718795324920045,45.60952504265421,4.323477410000198,-11.45812675472311
+2.788342362501472,115.66372580674239,2.8981986809563063,94.99499294423073,5.265102996755923,76.33826062585737,5.770156720561266,-30.114859073096454,4.417639968675771,-11.45812675472311
+2.84255716901165,-93.7672399240173,2.970960658114703,-73.40335562879935,5.239422298935312,-56.453775287270616,5.812957883595617,45.60952504265421,4.511802527351343,-11.45812675472311
+2.8703779249839783,116.80690793409369,3.030882286362795,-73.46432534225809,5.320744508700579,76.33826062585737,5.838638581416228,-30.114859073096454,4.605965086026916,-11.45812675472311
+2.9587317543906027,-95.17825329263377,3.1036442635211916,96.09244778648798,5.513349742355159,77.43571546811464,5.877159628147144,45.60952504265421,4.700127644702488,-11.45812675472311
+2.9937879450663574,118.40736291238554,3.321930194996382,-74.56178018451533,5.57327137060325,77.43571546811464,6.189608118297906,-30.663586494225086,4.76004927295058,-11.45812675472311
+3.110777790693583,119.8706360353952,3.3287783810818787,97.35452085508383,5.684554394492563,-57.00250270839925,6.805944865992562,-31.212313915353718,5.325024625004014,17.624426565094183
+3.082243682004016,-96.51087702966043,3.3775717069410387,-74.56178018451533,6.104005792229204,79.08189773150052,7.165474635481112,-31.76104133648235,5.419187183679586,17.624426565094183
+3.187106531438176,121.05954544784056,3.3946921721547794,97.73863004987388,6.249529746545998,79.63062515262915,7.259637194156684,-31.76104133648235,5.513349742355159,17.624426565094183
+3.1806863569830237,-97.6083318719177,3.587297405809359,98.83608489213113,6.591939050820807,80.17935257375777,7.3537997528322565,-31.76104133648235,5.607512301030732,17.624426565094183
+3.2848358536999447,122.24845486028593,3.6557792666643207,-75.65923502677259,6.6261799812482876,-58.648684971785116,7.413721381080348,-31.76104133648235,5.701674859706304,17.624426565094183
+3.285549206417184,-98.84296856945713,3.7525098951219547,-76.0982169636755,6.664701027979204,80.17935257375777,7.6876488245001955,49.45061699055461,5.798405488163937,18.06340850199709
+3.401825699327171,123.71172798329559,3.7927429883742443,99.93353973438839,6.72034253992386,-58.648684971785116,7.781811383175768,49.45061699055461,5.889999977057449,18.173153986222815
+3.424652986278825,-100.35196897756083,3.81414356989142,-76.20796244790122,6.780264168171952,-58.648684971785116,8.723436969931493,-33.95595102099685,5.980738442690273,18.173153986222815
+3.456040505837349,124.44336454480043,4.011884943110123,101.0858673187585,6.891547192061265,81.27680741601503,8.817599528607065,-33.95595102099685,6.078325094408593,18.173153986222815
+3.518815544954397,-101.4494238198181,4.0735186178795875,-77.19567180593276,6.9643091692196615,81.27680741601503,8.911762087282638,-33.95595102099685,6.159647304173861,18.173153986222815
+3.544496242775008,125.7237285274339,4.109471594828443,101.57972199777427,7.079872309412409,-59.74613981404238,8.971683715530729,-33.95595102099685,6.258089979152868,-13.104309018109007
+3.6429389177540155,-102.82124237263969,4.152272757862794,-77.30541729015846,7.174034868087982,-59.74613981404238,9.177129298095615,52.74298151732637,6.3522525378284405,-13.104309018109007
+3.6429389177540155,126.82118336969116,4.20791426980745,-77.30541729015846,7.233956496336074,-59.74613981404238,9.613701161045995,53.291708938455,6.446415096504013,-13.104309018109007
+3.7585020579467634,128.46736563307704,4.417639968675771,102.67717684003152,8.072859291809355,84.02044452165816,9.703583603418133,53.291708938455,6.514896957358975,-13.104309018109007
+3.7670622905536337,-104.19306092546122,4.469001364316992,102.67717684003152,8.145621268967751,84.02044452165816,0.05582560296846009,16.401590457256447,6.908667657275005,19.27060882848005
+3.87549190357399,129.93063875608672,4.554603690385695,-78.40287213241572,8.372467433049813,85.11789936391543,0,0.8946322067594394,7.001118169429203,19.27060882848005
+3.861224849229206,-105.29051576771849,4.623085551240656,-78.40287213241572,8.372467433049813,-61.94104949855688,,,7.09699277462615,19.27060882848005
+3.9425470589944736,130.66227531759154,4.7343685751299684,103.77463168228878,8.44522941020821,85.11789936391543,,,7.169754751784547,19.27060882848005
+3.9939084546356947,-106.73092524818117,4.7857299707711904,103.77463168228878,8.868960924248286,-62.48977691968551,,,7.259637194156684,-14.201763860366242
+4.135152292649053,132.30845758097743,4.991175553336076,-79.50032697467299,8.963123482923859,-62.48977691968551,,,7.3537997528322565,-14.201763860366242
+4.1693932230765345,-108.03415287336162,5.051097181584167,104.87208652454603,9.01448487856508,-62.48977691968551,,,7.447962311507829,-14.201763860366242
+4.3405978752139385,133.4059124232347,5.086194135272335,-79.8295634273502,9.314093019805538,-63.587231761942775,,,7.516444172362791,-14.201763860366242
+4.3363177589105035,-109.13160771561888,5.145259740259739,105.37092963466297,9.356894182839888,87.31280904842994,,,7.918775104885691,20.368063670737314
+4.528922992565083,-110.50342626844048,5.1752205543837855,-80.04905439580159,9.40825557848111,-63.587231761942775,,,8.012081640300577,20.368063670737314
+4.546043457778824,134.50336726549196,5.200901252204396,105.42081394567467,9.472457323032636,-63.587231761942775,,,8.107100222236836,20.368063670737314
+4.580284388206305,-110.77778997900481,5.479108811927678,106.51826878793192,9.562339765404774,87.86153646955857,,,8.175582083091799,20.368063670737314
+4.7300884588265335,-111.87524482126202,5.5647111379963805,-81.14650923805885,9.630821626259735,87.86153646955857,,,8.2611844091605,-15.299218702623506
+4.819970901198671,136.14954952887783,5.633192998851342,-81.14650923805885,9.716423952328437,-64.1359591830714,,,8.355346967836073,-15.299218702623506
+4.901293110963938,-112.97269966351928,5.7872771857750065,107.61572363018918,9.861947906645232,88.95899131181582,,,8.449509526511646,-15.299218702623506
+5.025416483763556,137.2470043711351,5.838638581416228,107.61572363018918,9.930429767500193,88.95899131181582,,,8.543672085187218,-15.548640257681967
+5.093898344618518,-114.34451821634087,5.999570954425387,-82.24396408031612,0.01860853432282003,0.2982107355864798,,,8.63783464386279,-15.847946123752138
+5.145259740259739,-114.6188819269052,6.0697648618017235,-82.24396408031612,0.01860853432282003,-6.858846918489064,,,8.731997202538363,-15.847946123752138
+5.2351421826318765,138.34445921339235,6.099725675925769,108.71317847244643,0.09304267161410018,28.330019880715696,,,8.826159761213935,-15.847946123752138
+5.290783694576533,-115.71633676916247,6.193888234601341,109.26190589357506,0.037217068645640075,15.208747514910527,,,8.920322319889507,21.465518512994578
+5.4577082304105025,-116.81379161141967,6.454975329110884,-83.34141892257338,,,,,9.011631467696123,21.465518512994578
+5.513349742355159,139.99064147677822,6.476375910628059,110.35936073583231,,,,,9.108647437240652,21.465518512994578
+5.650313464065083,-118.18561016424127,6.5482818645257685,-83.56090989102483,,,,,9.202809995916224,21.71494006805304
+5.714515208616609,141.0880963190355,6.643300446462028,-83.89014634370199,,,,,9.296972554591797,22.01424593412321
+5.701674859706304,-118.4599738748056,6.698941958406685,-83.89014634370199,,,,,9.391135113267369,22.01424593412321
+5.851478930326532,-119.55742871706286,6.754583470351341,111.45681557808958,,,,,9.485297671942941,22.01424593412321
+5.92424090748493,142.18555116129275,7.045631378984929,112.60415473135852,,,,,9.605140928439125,-16.9454009660094
+6.028390404201851,-120.65488355932007,7.079872309412409,-84.98760118595925,,,,,9.699303487114697,-16.9454009660094
+6.245249630242563,143.83173342467862,7.135513821357066,113.10299784147546,,,,,9.79346604579027,-16.9454009660094
+6.288906816537601,-121.80721114369021,7.148354170267371,-84.98760118595925,,,,,9.857667790341797,-16.9454009660094
+6.373653119345616,-122.301065822706,7.418001497383783,114.2004526837327,,,,,0.12095547309833024,-4.473161033797226
+6.497776492145235,144.92918826693588,7.533564637576531,-86.08505602821651,,,,,-0.009304267161410022,0.2982107355864798
+6.6304600975517225,-123.39852066496326,7.606326614734928,-86.08505602821651,,,,,0.11165120593692021,6.858846918489036
+6.754583470351341,146.02664310919315,7.7004891734105,115.29790752598997,,,,,0.05582560296846009,5.069582504970157
+6.891547192061265,-124.49597550722046,7.987256965740652,116.44524667925893,,,,,0.05582560296846009,-2.6838966202783467
+7.092712658322715,147.672825372579,7.993249128565463,-87.18251087047378,,,,,,
+7.162050542438364,-125.6483030915906,8.07713940811279,116.94408978937585,,,,,,
+7.246796845246379,-126.14215777060639,8.089123733762408,-87.40200183892523,,,,,,
+7.345239520225387,148.77028021483628,8.184142315698669,-87.73123829160238,,,,,,
+7.499323707149051,-127.23961261286365,8.24406394394676,-87.73123829160238,,,,,,
+7.5917742193032485,149.86773505709354,8.359627084139508,118.04154463163312,,,,,,
+7.760410801658592,-128.33706745512086,8.612153946042179,-88.82869313385964,,,,,,
+7.935895570099432,151.5139173204794,8.642114760166224,119.13899947389037,,,,,,
+8.026848041547428,-129.5031132250192,8.689196039504012,-88.82869313385964,,,,,,
+8.111380338540272,-129.98324971850678,8.920322319889507,120.23645431614761,,,,,,
+8.188422432002103,152.61137216273667,9.018764994868516,120.78518173727625,,,,,,
+8.372467433049813,-131.08070456076405,9.08296673942004,-89.92614797611691,,,,,,
+8.440949293904774,153.70882700499394,9.15572871657844,-89.92614797611691,,,,,,
+8.633554527559355,-132.17815940302125,9.296972554591797,121.88263657953351,,,,,,
+8.783358598179584,155.35500926837983,9.545219300191034,-91.02360281837417,,,,,,
+8.980243948137598,-133.82434166640718,9.57518011431508,122.98009142179076,,,,,,
+9.03282823415123,156.45246411063707,9.639381858866606,-91.2979665289385,,,,,,
+9.245611158950576,-134.92179650866444,9.733544417542179,-91.57233023950283,,,,,,
+9.293548461549047,157.60479169500718,9.7849058131834,-91.57233023950283,,,,,,
+9.37401464805363,158.09864637402296,9.857667790341797,124.07754626404801,,,,,,
+9.506698253460117,-136.01925135092165,9.951830349017369,124.62627368517664,,,,,,
+9.6265415099563,159.19610121628023,0.28843228200371057,-34.89065606361831,,,,,,
+9.85338767403836,-137.66543361430757,0.18608534322820033,-27.137176938369805,,,,,,
+9.879068371858972,160.29355605853746,0.07443413729128014,-7.455268389662024,,,,,,
+0.23260667903525045,-40.854870775347905,0,0.2982107355864798,,,,,,
+0.13025974025974024,-27.733598409542765,0.08373840445269015,11.63021868787277,,,,,,
+0.05582560296846009,-18.190854870775354,0.15817254174397027,25.34791252485087,,,,,,
+0.027912801484230046,-12.823061630218717,0.18608534322820033,36.67992047713716,,,,,,
+0.009304267161410008,-7.455268389662024,,,,,,,,
+0.009304267161410008,8.648111332007915,,,,,,,,
+0.037217068645640075,15.208747514910527,,,,,,,,
+0.10234693877551018,30.715705765407563,,,,,,,,
+0.1674768089053803,40.854870775347905,,,,,,,,
+0.2698237476808905,52.18687872763418,,,,,,,,
+0.37217068645640067,61.13320079522862,,,,,,,,
+0.4559090909090908,65.90457256461231,,,,,,,,
diff --git a/Data/Suspension/suspension_forces/12-12-lowspeed.csv b/Data/Suspension/suspension_forces/12-12-lowspeed.csv
new file mode 100644
index 0000000..12e71a0
--- /dev/null
+++ b/Data/Suspension/suspension_forces/12-12-lowspeed.csv
@@ -0,0 +1,164 @@
+0-4.3 0-4.3 X,0-4.3 0-4.3 Y,2-4.3 2-4.3 X,2-4.3 2-4.3 Y,4-4.3 4-4.3 X,4-4.3 4-4.3 Y,6-4.3 6-4.3 X,6-4.3 6-4.3 Y,10-4.3 10-4.3 X,10-4.3 10-4.3 Y,15-4.3 15-4.3 X,15-4.3 15-4.3 Y,25-4.3 25-4.3 X,25-4.3 25-4.3 Y
+0.07656300183293896,-16.477704260832382,0.05689271385752279,5.910374521215658,0.23099308879521233,6.302322679164689,0.4956256587005004,6.020120005441385,0.41181312732698816,-3.9667190590996313,0.47167922116521127,3.166737415572527,0.6854866991588651,3.715464836701159
+0.1392085928850795,-28.556566618426302,0.21938639713269972,-7.807811007000026,0.3262901361295266,-5.612901322485527,0.486645744624767,-4.172491842022879,0.7282481947575958,-3.9667190590996313,1.000971511131723,4.812919678958394,0.7795619894760727,3.715464836701159
+0.14241570505498433,37.73656494667608,0.31346168744990743,-9.316811415103757,0.4609888472655286,-5.064173901356895,0.5614783619225459,-4.515446480228263,0.792390438155692,-3.9667190590996313,1.0617878604276958,4.812919678958394,0.852256531993915,3.715464836701159
+0.21724832235276317,45.281566987194736,0.4075369777671151,-9.453993270385922,0.5400976141231805,-5.338537611921225,0.6598298017996266,7.556556784601554,1.0951418269947057,6.129865489667111,1.352566030499065,-3.9667190590996313,0.907846476272265,-2.869264216842396
+0.20655794845308048,-37.896364598886464,0.48878381940470356,-10.368538972266975,0.7453527929970881,11.946376153630581,0.7008808375744081,-5.228792127695499,1.1515870011850304,6.45910194234429,1.3782229278583034,5.910374521215658,1.130206253385665,-2.869264216842396
+0.3120363042632831,-47.49909446863745,0.5871352592817842,18.531105207174107,0.7154197460779765,-8.356538428128658,0.7624573912365804,-5.612901322485527,1.185796197664015,-5.612901322485527,1.4466413208162727,-3.9667190590996313,1.8143901829653573,4.812919678958394
+0.4139512021069247,61.743389621053566,0.5999637079614035,-13.84381263941495,0.847980382434042,13.592558417016448,0.8223234850748035,8.65401162685879,1.3226329835799535,7.556556784601554,1.4748639079114352,6.349356458118564,1.8828085759233264,-3.9667190590996313
+0.4631269220454651,-57.19327890857656,0.6854866991588651,21.27474231281724,1.0446832621882034,16.88492294378821,0.9335033736315035,-6.710356164742791,1.463745919055765,-6.710356164742791,1.4979551155347497,-3.9667190590996313,1.908465473282565,4.812919678958394
+0.6726582504792458,73.67821103060122,0.7667335407964535,-17.54772273203318,1.083168608227061,-12.197630376029053,1.0226916358802849,9.986635363885483,1.5065074146544957,8.65401162685879,1.5449927606933533,6.45910194234429,1.9768838662405344,-3.9667190590996313
+0.7624573912365804,-65.14982651494168,0.8707865134200318,-20.611450833334686,1.241386141942365,21.27474231281724,1.116902676977171,-8.051689860834983,1.719459662736175,9.970957437567506,1.8742562768035804,7.556556784601554,2.001590508142023,4.812919678958394
+0.7368004938773419,76.42184813624436,0.8864657284728996,28.774017068241847,1.3910513765379227,-16.58744974505808,1.1473108516251573,11.397648732501949,1.7331433413277688,-7.807811007000026,1.9341223706418034,7.556556784601554,2.0666830069978688,-3.9667190590996313
+0.8821895789130265,80.81166750527339,0.9734141028569856,32.24929073538982,1.416708273897161,25.390197971281964,1.2542145906219841,12.495103574759185,1.7759048369264996,10.300193890244685,2.1137206521564726,-5.612901322485527,2.0666830069978688,4.812919678958394
+1.0104740657092188,84.37839574260947,1.0361309630684574,-25.367088483116135,1.5065074146544957,-18.233632008443976,1.2841476375410958,-9.453993270385922,1.9426746697615496,11.397648732501949,2.1735867459946956,8.65401162685879,2.4472603178265726,5.910374521215658
+1.0874447577869342,-72.28328298961384,1.098135131686617,36.91347381498315,1.5407166111334805,28.225289647113215,1.3696706287385574,13.866922127580779,2.079511455677488,-9.453993270385922,2.1735867459946956,-5.612901322485527,2.5404803782318055,6.129865489667111
+1.181520048104142,88.21948769050987,1.1729677489843957,-29.48254414158086,1.7074864439685304,31.97492702482549,1.4295367225767803,-10.551448112643186,2.0923399043571074,12.495103574759185,2.421603420467334,9.851235091139444,2.635410898460988,6.45910194234429
+1.241386141942365,-74.20382896356404,1.237109992382492,41.57765689457648,1.8657039776838342,-23.172178798601635,1.4894028164150035,15.238740680402344,2.2458061607836632,13.836437270851405,2.490021813425303,-6.710356164742791,2.695276992299211,6.45910194234429
+1.3867752269780496,92.33494334897458,1.2755953384213496,-32.363363102506156,2.1051683530367264,-27.01327074650203,1.5967816831407051,-11.953751522194125,2.2762143354316495,-10.551448112643186,2.5028502621049227,10.300193890244685,2.8321137782151493,-5.612901322485527
+1.5407166111334805,-78.52505740495198,1.3482898809391919,45.41874884247687,2.2077959424736804,43.223839157962374,1.5963065554118303,16.33619552265958,2.4002226726679687,15.238740680402344,2.5498879072635265,-6.710356164742791,2.926189068532357,-5.612901322485527
+1.8257932484583521,-82.52619485068158,1.3867752269780496,-35.792909484560084,2.297595083231015,-30.579998983838095,1.7117625935284033,17.708014075481174,2.4977188826330745,-11.868393923351874,2.7337623383380687,11.397648732501949,2.9860551623705804,-5.612901322485527
+1.8785324263634533,102.34921878457205,1.4494920871895214,48.89402250962486,2.37456577530873,46.927749250580604,1.7630763882468803,-13.295085218286317,2.532783309024034,16.33619552265958,2.8748752738138803,-7.807811007000026,3.063025854448296,7.556556784601554
+2.068108390184493,105.87021973681406,1.5150597137742419,-39.74374691668618,2.395946523108096,-32.50054495778829,1.8357709307647228,19.07983262830274,2.5584402063832727,-12.197630376029053,2.9304652180922304,-7.807811007000026,3.139996546526011,7.556556784601554
+2.103457893212777,-86.00146851782955,1.570649658052592,53.10093273827768,2.490021813425303,-34.14672722117419,1.904189323722692,-14.392540060543581,2.686724693179465,17.708014075481174,2.968950564131088,12.495103574759185,3.5077454086750954,-6.710356164742791
+2.2420051389526647,108.24803856170479,1.634791901450688,-43.475093380360875,2.537059458583907,50.63165934319885,1.9383985202016765,20.177287470560003,2.7465907870176878,-13.295085218286317,3.2229538479875486,13.702303901242175,3.533402306034334,8.65401162685879
+2.3788419248686035,109.89422082509067,1.7053483691885938,57.627933962588855,2.6974150670791475,54.19838758053493,2.0581307078781226,21.82346973394587,2.8406660773348955,19.07983262830274,3.302490229801188,14.14128583814508,3.601820698992303,-6.710356164742791
+2.4344318691469535,-89.77396953808886,1.754524089127134,-47.20643984403554,2.6995531418590843,-37.987819169074584,2.0453022591985035,-15.764358613365147,2.9432936667718494,-14.392540060543581,3.370908622759157,-9.453993270385922,3.601820698992303,8.65401162685879
+2.6696200949399724,114.00967648355538,1.8468889196203928,62.42929889746435,2.866322974694134,58.03947952843532,2.1607582973150765,23.469651997331766,2.973226713690961,20.177287470560003,3.43077471659738,-9.453993270385922,3.6616867928305266,-6.710356164742791
+2.7807999834966726,-93.95801612419467,1.8828085759233264,-51.157277276161665,2.926189068532357,-42.10327482753928,2.1671725216548863,-17.410540876751043,3.1639429840613005,-15.65461312913942,3.533402306034334,15.238740680402344,3.98667415938088,9.751466469116053
+2.9646744145712147,117.85076843145578,2.0089549879395823,-54.72400551349773,3.04164510664893,61.88057147633572,2.2762143354316495,-18.782359429572608,3.1485488456457573,21.82346973394587,3.755762083147734,-10.551448112643186,4.080749449698088,10.025830179680383
+3.028816657969311,-96.7016532298378,2.0089549879395823,67.91657310875063,3.1143396491667725,-45.670003064875374,2.3232519805902534,26.213289102974898,3.2297956872833455,-16.03872232392945,3.7771428309470996,16.33619552265958,4.157720141775803,-7.807811007000026
+3.370908622759157,-100.5427451777382,2.159332914128452,70.84311935476998,3.139996546526011,64.07548116085023,2.3417819620163702,-19.69690513145366,3.2768333324419494,22.920924576203134,3.8156281769859572,-10.551448112643186,4.161996291335677,10.300193890244685
+3.493491576808852,124.43549748499932,2.250557438072411,-58.29073375083382,3.311042528920934,-48.96236759164714,2.4330064859603286,28.042380506736976,3.418801497829736,24.128124902686096,4.018317666123941,17.54339584914257,4.248374512445113,-7.862683749112904
+3.689054150013714,-103.83510970450993,2.366013476188984,74.77566587285848,3.370908622759157,69.01402795100789,2.4615141496928166,-21.34308739483953,3.422222417477634,-17.136177166186712,4.102130197497453,-11.64890295490045,4.345870722410218,-8.356538428128658
+3.745499324204039,127.61811652754537,2.3446327283896187,-59.38818859309109,3.520573857354715,-52.80345953954753,2.5541640568233994,30.054381050875293,3.5847161007528108,25.664561681846266,4.085025599257961,17.982377786045475,4.43139371360768,-8.356538428128658
+3.935360364662403,130.1971354068499,2.4985741125450494,77.24493926793731,3.5419546051540802,72.85511989890828,2.5783955709960136,-22.806360517849185,3.6189252972317956,-18.233632008443976,4.191929338254788,-12.197630376029053,4.508364405685396,11.397648732501949
+4.043689486845855,-107.63047436731625,2.490021813425303,-61.583098277605586,3.7130005875490033,-56.370187776883625,2.654653571480417,-23.99526993029457,3.717276737108876,26.76201652410353,4.2560715816528845,19.07983262830274,4.568230499523619,11.397648732501949
+4.080749449698088,-107.67620165241033,2.6097540011017495,-63.503644251555784,3.7258290362286224,76.970575557373,2.6696200949399724,31.97492702482549,3.8395746145212466,-19.495705077039815,4.427117564047807,20.177287470560003,4.884665566954227,12.495103574759185
+4.136339393976438,131.8433176702358,2.7180831232852007,81.26894035621392,3.918255766422911,-60.1198251545959,2.7850761330565454,33.89547299877569,3.8455612239050687,27.859471366360793,4.457050610966919,-13.295085218286317,4.8932178660739725,-9.453993270385922
+4.200481637374534,-109.32238391579625,2.7465907870176878,-65.42419022550598,4.04226410365923,-62.13182569873422,2.82569955387534,-26.190179614809068,3.901151168183419,-19.879814271829844,4.658029640280954,21.82346973394587,4.94453166079245,12.495103574759185
+4.311661525931234,132.94077251249306,2.8235614790954036,83.28094090035222,4.04226410365923,83.82966832148084,2.898394096393182,35.67883711744372,4.0251595054197375,29.50565362974666,4.722171883679049,-14.392540060543581,4.974464707711561,-9.453993270385922
+4.59174932210292,-111.72306638323397,2.866322974694134,-67.34473619945618,4.174824740015295,-63.778007962120114,2.914215849764713,-27.34250719917921,4.067921001018469,-20.977269114087107,4.837627921795622,22.920924576203134,5.269519027342803,13.592558417016448
+4.6323727429217145,-111.79165731087505,2.9518459658915956,85.65875972524294,4.303109226811488,87.67076026938123,3.0031597606100724,37.46220123611178,4.132063244416565,30.603108472003925,4.992424535863028,-15.544867644913722,5.365304777483961,13.976667611806477
+4.829075622675877,135.71870508195673,3.0068250316613927,-69.42206143658598,4.508364405685396,-67.61909991002051,3.0779923779078513,-29.48254414158086,4.20903393649428,-22.07472395634437,5.017226203310291,24.0183794184604,5.449117308857472,-10.551448112643186
+4.867560968714734,-113.16347586369665,3.1421346213059476,89.17976067748496,4.628096593361842,-68.71655475227774,3.1293061726263285,39.519929065344115,4.260347731212757,31.97492702482549,5.077092297148515,-16.03872232392945,5.436288860177854,14.14128583814508
+4.995845455510926,136.50750074982915,3.239773369589716,-72.83201041074247,4.87611326783448,95.90167158631066,3.172983985987889,-30.854362694402425,4.376278897058205,-23.47702736589531,5.089920745828134,24.567106839589,5.534640300054934,-10.551448112643186
+5.038606951109657,-114.80965812708251,3.2768333324419494,-73.10637412130677,4.846180220915369,-71.4601918579209,3.255452584642584,41.57765689457648,4.388632218008949,33.346745577647056,5.256690578663184,25.664561681846266,5.774104675407826,15.238740680402344
+5.179719886585469,-115.67847654386952,3.3606458638154617,93.37752544911898,5.085644596268261,98.6453086919538,3.274695257662013,-32.22618124722399,4.499812106565649,34.44420041990432,5.333661270740899,-17.136177166186712,5.833970769246049,15.238740680402344
+5.517535701815442,139.52550156603658,3.4906408104356035,-76.67310235864286,5.149786839666357,-74.75255638469267,3.370908622759157,43.55307561063955,4.529745153484761,-24.818361061987503,5.436288860177854,26.76201652410353,5.996464452521226,-11.64890295490045
+5.688581684210365,140.89732011885815,3.4478793148368725,95.35294416518204,5.335086653927523,102.12058235910179,3.3965655201183957,-33.83316869481499,4.623209565293416,35.776824156930985,5.594506393893157,-18.233632008443976,6.088829283014484,-11.813521181239025
+5.739895478928841,-119.74820491724017,3.565473427733382,97.27349013913224,5.483326505336457,-78.59364833259306,3.496342343182101,45.601657982853084,4.679410388080319,-25.915815904244766,5.568849496533918,-99.99401775660954,6.1375773879970374,16.33619552265958
+5.98791215340148,-121.39438718062604,3.724403653041998,100.29149095533968,5.59878254345303,106.05312887719028,3.5184357825747785,-35.518545773995754,4.752104930598161,37.18783752554745,5.607334842572776,27.859471366360793,6.184615033155642,-12.197630376029053
+6.039225948119957,142.54350238224404,3.755762083147734,-80.51419430654323,5.816866171006557,-82.43474028049343,3.601820698992303,47.33929481642707,4.859008669594988,38.285292367804715,5.838246918805923,29.50565362974666,6.235928827874119,-12.197630376029053
+6.2530334261136105,143.6409572245013,3.8156281769859572,101.93767321872556,5.872456115284907,109.89422082509067,3.6274775963515418,-36.89036432681732,4.867560968714734,-27.561998167630662,5.864759046077135,-19.385959592814118,6.411250959828915,17.433650364916844
+6.235928827874119,-122.21747831231897,3.8327327752254496,-81.33728543823622,6.111920490637799,-85.63565023707713,3.717276737108876,49.25984079037728,4.982406128322754,39.61791610483138,5.953702956922496,-19.879814271829844,6.505326250146123,17.982377786045475
+6.449736305867773,-123.58929686514057,3.9524649629018955,104.68131032436871,6.21027193051488,113.46094906242675,3.691619839749638,-37.85063731379242,4.995845455510926,-28.659453009887898,6.013569050760719,30.603108472003925,6.5694684935442185,-13.295085218286317
+6.843142065376095,-124.68675170739783,4.012331056740119,-84.08092254387935,6.214548080074753,-86.27583222839382,3.814202793799333,50.906023053763164,5.115577643187373,41.028929473447846,6.162759157627401,31.944442168096145,6.637886886502188,-13.295085218286317
+7.219443226644926,147.4820491724017,4.127787094856692,106.87622000888322,6.59940154046333,-89.47674218497752,3.800234038570414,-39.30476497978327,5.149786839666357,-29.75690785214516,6.167510434916149,-20.977269114087107,6.787552121097745,19.07983262830274
+7.476012200237311,148.85386772522327,4.179100889575168,-86.00146851782955,6.7405144759391415,117.30204101032714,3.894736943843609,-40.45709256415341,5.222481382184199,42.12638431570511,6.3086233703919605,33.346745577647056,6.981879362207533,-14.392540060543581
+7.54443059319528,-127.97911623416957,4.281728479012123,108.79676598283342,7.0911587398487335,-93.33089907147621,3.9695695611413875,53.37529644884199,5.333661270740899,-31.403090115531057,6.364213314670311,-22.07472395634437,7.065501842489495,20.177287470560003
+7.7240288747099495,149.6769588569162,4.345870722410218,-87.37328707065109,7.236547824884418,120.59440553709892,3.978121860261134,-41.609420148523554,5.3564674017268885,43.589657438714795,6.436907857188153,34.44420041990432,7.0569495433697496,-14.392540060543581
+7.800999566787665,-129.35093478699116,4.4855582746994065,110.90022109715983,7.741133472949442,124.43549748499932,4.069346384205093,55.112933282415966,5.474774206216711,44.87002142134824,6.567758033720269,-23.33679702494021,7.4075938072793415,-15.489994902800845
+7.937836352703603,-129.6252984975555,4.448498311847173,-88.47074191290835,7.9292840535838565,126.0816797483852,4.091439823597771,-43.200729669796544,5.479050355776584,-32.50054495778829,6.582907820732391,35.855213788520786,7.437526854198453,21.82346973394587
+8.151643830697257,152.42059596255936,4.529745153484761,111.26603937791225,8.10033003597878,-101.0914725988668,4.197060717726636,57.161515654629525,5.5859540947734105,45.967476263605505,6.633610736942314,-23.720906219730267,7.501669097596549,-15.789300768871016
+8.151643830697257,-130.7227533398127,4.735000332358669,-91.21437901855148,8.125986933338018,127.17913459064246,4.18907857188154,-44.38963908224193,5.6158871416925225,-33.59799980004556,6.727686027259522,37.18783752554745,7.591468238353884,-16.03872232392945
+8.527944991966088,153.5180508048166,4.8632848191548605,115.10713132581265,8.262823719253957,128.2765894328997,4.281728479012123,58.588206949563954,5.7313431798090955,47.6136585269914,6.82176131757673,-24.818361061987503,7.71120042603033,22.920924576203134
+8.65622947876228,154.06677822594523,4.98729315639118,-93.95801612419467,8.530795758339337,-104.47529169582668,4.2710381051124395,-45.53282120959321,5.799761572767065,-35.24418206343145,6.851694364495842,38.285292367804715,7.963493250062841,-17.136177166186712
+8.805894713357837,-133.4938268165123,5.1241299423071185,-95.05547096645188,8.793066264678219,132.19607101238992,4.362975320649711,-46.76745790713264,5.8467992179256685,48.711113369248636,6.997083449531526,39.65711092062628,7.990100402879829,24.0183794184604
+8.912798452354664,155.4385967787668,5.183996036145341,118.94822327371304,9.006873742671873,-108.22492907353899,4.418565264928061,60.78311663407847,5.945150657802749,-36.34163690568869,7.005635748651272,-25.915815904244766,8.029060876647561,-17.136177166186712
+9.374622604820956,157.359142752717,5.256690578663184,-96.42728951927347,9.21212892154578,135.41004590757188,4.479856741952908,-48.23073103014232,5.953702956922496,49.8085682115059,7.142472534567211,41.028929473447846,8.369727458250784,25.664561681846266
+9.588430082814611,159.0053250161029,5.48760265489633,-98.89656291435227,9.314756510982734,135.95877332870052,4.502662872938898,62.24638975708814,6.103979070026607,-37.752650274305154,7.26648087180353,-27.561998167630662,8.374003607810657,-18.233632008443976
+9.673953074012072,-137.58184610392055,5.526088000935188,122.78931522161344,9.388876436687202,-111.42583903012263,4.561816275183809,-49.373913157493604,6.086263593278561,51.45475047489178,7.26648087180353,42.12638431570511,8.442422000768627,-18.233632008443976
+9.802237560808264,-137.85620981448488,5.603058693012903,123.8867700638707,9.498630942057275,-112.06602102143938,4.636648892481587,64.34984487141455,6.180338883595769,52.552205317149046,7.417215143789056,43.56679379616776,8.64340103008266,26.76201652410353
+9.836446757287248,159.55405243723152,5.697133983330111,124.43549748499932,9.738095317410169,139.25113785547228,4.696514986319811,-51.157277276161665,6.244481126993865,-39.08527401133185,7.467459901117564,-28.659453009887898,8.793066264678219,-19.33108685070124
+0.29746061167747917,53.976143141153074,5.854740638536861,-102.65926523066287,9.876357486512731,-115.26693097802303,4.7478287810382875,66.27039084536474,6.274414173912977,53.649660159406295,7.561535191434772,44.87002142134824,8.8879967849074,-19.66032330337842
+0.5298517145505096,68.29025844930418,5.855351517045415,126.63040716951383,9.99038814144268,-115.90711296933978,4.801993342130014,-52.43764125879511,6.364213314670311,-40.18272885358908,7.659886631311853,-29.75690785214516,8.925626901034283,27.859471366360793
+1.6081464318813714,96.91848906560635,5.9023891622040185,-102.73765486225267,0.11154772937905466,5.069582504970157,4.8889417165141,68.46530052987926,6.3941463615894225,55.29584242279219,7.685543528671092,45.967476263605505,8.976940695752761,-19.879814271829844
+0.009295644114921224,-0.2982107355864798,5.945150657802749,127.7278620117711,0.009295644114921224,0.2982107355864798,4.859008669594988,-53.352186960676164,6.5096023997059955,-41.55454740641068,7.852313361506141,47.6136585269914,9.293375763183368,29.50565362974666
+0.04647822057460612,15.208747514910527,6.201719631395134,129.37404427515696,0.45548656163113993,8.051689860835012,4.9488078103523225,69.56275537213651,6.48822165190663,56.39329726504944,7.920731754464111,-31.403090115531057,9.34896570746172,-20.977269114087107
+0.07436515291936976,24.75149105367791,6.227376528754372,-105.48129196789586,0.6135125115848006,10.43737574552685,4.975890090898185,-54.81546008368585,6.582296942223838,57.49075210730669,7.97632169874246,48.711113369248636,9.417384100419687,-20.977269114087107
+0.10225208526413343,28.330019880715724,6.37704176334993,130.47149911741423,1.9427896200185355,37.27634194831015,5.078517680335139,-56.187278636507415,6.650715335181807,-42.92636595923224,8.10033003597878,49.8085682115059,9.57560163413499,30.603108472003925
+,,6.381317912909803,-106.57874681015306,0.12084337349397589,-2.0874751491053587,5.129261321778967,72.41613796200538,6.706305279460157,59.136934370692586,8.108882335098526,-32.50054495778829,9.76802836432928,-22.07472395634437
+,,6.483945502346757,131.02022653854286,0.21379981464318812,-3.876739562624266,5.146936073293108,-57.01036976820038,6.7704475228582535,-44.02382080148948,8.26709986881383,51.45475047489178,9.857827505086615,31.70056331426119
+,,6.6250584378225685,-107.95056536297466,,,5.213929083064453,73.95257474116553,6.796104420217492,60.234389212949836,8.305585214852687,-33.59799980004556,9.832170607727376,-22.07472395634437
+,,6.620782288262696,131.5689539596715,,,5.2666682609695545,-58.656552031586244,6.910491420944096,-45.32704842666999,8.395384355610021,52.552205317149046,9.947626645843949,32.24929073538982
+,,6.952183879152859,-110.14547504748919,,,5.368725697131858,76.3669753941315,6.908139538686166,61.661080507884265,8.515116543286469,53.649660159406295,0.4740778498609823,2.6838966202783183
+,,6.971426552172288,133.763863644186,,,5.367870467219884,-59.93691601421972,7.045546477876754,63.34384459934539,8.562154188445072,-35.24418206343145,0.3253475440222428,-0.2982107355864798
+,,7.005635748651272,-110.41983875805346,,,5.4405650097377265,77.61075754868972,7.0569495433697496,-46.76745790713264,8.686162525681391,55.29584242279219,0.45548656163113993,-2.6838966202783183
+,,7.082606440728988,-110.96856617918212,,,5.437714243364478,-60.85146171610077,7.139621768193962,64.44129944160265,8.758857068199234,-36.34163690568869,0.6785820203892492,-2.6838966202783183
+,,7.108263338088226,134.31259106531462,,,5.553882973074363,-62.40618940929852,7.180957880606068,-47.8649127493899,8.805894713357837,56.39329726504944,,
+,,7.450355302878072,-113.16347586369665,,,5.5873794779600345,79.98857637358044,7.221581301424862,65.58448156895396,8.93417920015403,57.49075210730669,,
+,,7.634229733952615,137.05622817095775,,,5.637267889491888,-63.55851699366866,7.32207081608188,-49.23673130221147,8.970954086368938,-37.603709974284556,,
+,,8.091777736859033,-117.00456781159704,,,5.684305534650492,81.63475863696632,7.326346965641753,66.81911826649338,9.03253064003111,-37.987819169074584,,
+,,8.160196129817002,139.7998652766009,,,5.7501582378725375,-65.0949537728288,7.447504536504823,68.28239138950305,9.10094903298908,59.136934370692586,,
+,,8.215786074095353,-118.1020226538543,,,5.797623497987128,83.41812275563437,7.454631452437946,-50.60854985503303,9.216405071105653,-39.08527401133185,,
+,,8.3355182617718,140.89732011885815,,,5.844661143145732,-66.24728135719891,7.527325994955787,69.2883916615722,9.224957370225399,60.234389212949836,,
+,,8.425317402529133,-119.19947749611151,,,5.919493760443511,85.47585058486673,7.591468238353884,-51.7060046972903,9.375691642210924,61.674798693412484,,
+,,8.476631197247611,141.9947749611154,,,5.928046059563257,-67.39960894156906,7.634229733952615,70.66021021439377,9.408831801299941,-40.18272885358908,,
+,,8.703267123920885,-120.84565975949744,,,6.026397499440337,-68.71655475227774,7.728305024269822,71.75766505665102,9.515735540296768,62.97802631859298,,
+,,8.82299931159733,-121.66875089119037,,,6.0546200865354995,87.56101478515552,7.7539619216290605,-53.352186960676164,9.620928819469645,-41.44480192218495,,
+,,8.981216845312634,-123.04056944401191,,,6.15468198623653,-69.81400959453501,7.840340142738497,73.18435635158545,9.639743877533087,64.07548116085023,,
+,,9.033752397048216,144.73841206675854,,,6.171786584476022,88.7682151116385,7.873694109305507,-54.44964180293343,9.682505373131818,-41.82891111697498,,
+,,9.21854314588559,-124.4123879968335,,,6.282966473032722,89.86566995389575,7.997702446541826,-55.54709664519069,9.785132962568772,65.41681485694244,,
+,,9.297651912743241,-124.68675170739783,,,6.309098498120836,-71.21631300408595,8.036187792580684,75.59875700455142,9.862103654646488,-42.92636595923224,,
+,,9.34896570746172,-125.23547912852644,,,6.411861838337468,91.27668332251223,8.160196129817002,-57.19327890857656,9.93479819716433,66.81911826649338,,
+,,9.494354792497402,147.4820491724017,,,6.4540124554276455,-72.55764670017814,8.160196129817002,77.24493926793731,10.041701936161157,-44.02382080148948,,
+,,9.682505373131818,148.57950401465894,,,6.5395354466251066,92.60930705953889,8.254271420134211,78.34239411019456,0.33464318813716404,2.0874751491053587,,
+,,9.746647616529915,148.57950401465894,,,6.590849241343584,-73.6551015424354,8.284204467053323,-58.29073375083382,0,-0.2982107355864798,,
+,,9.887760552005727,-128.52784365529823,,,6.650715335181807,93.70676190179614,8.344070560891545,79.43984895245183,1.1154772937905466,-5.069582504970185,,
+,,9.913417449364964,149.6769588569162,,,6.735763198650393,-74.99643523852762,8.403936654729769,-59.38818859309109,0.6971733086190917,-3.876739562624266,,
+,,9.947626645843949,-128.52784365529823,,,6.783275971537872,95.11777527041262,8.468078898127864,81.0860312158377,0.2881649675625579,-2.0874751491053587,,
+,,0.13013901760889712,-7.455268389662024,,,6.890179710534699,-76.39873864807853,8.566430338004945,-61.034370856476954,,,,
+,,0.01859128822984244,-3.280318091451278,,,6.911560458334065,96.45039900743929,8.593512618550808,82.54930433884738,,,,
+,,0.01859128822984244,0.2982107355864798,,,7.018464197330892,-77.4961934903358,8.660505628322152,83.28094090035222,,,,
+,,0.13013901760889712,7.455268389662052,,,7.022740346890765,97.54785384969655,8.690438675241264,-62.13182569873422,,,,
+,,0.2881649675625579,11.63021868787277,,,7.151024833686957,98.91967240251812,8.775961666438725,84.9271231637381,,,,
+,,0.46478220574606116,15.208747514910527,,,7.171930453757447,-78.83752718642802,8.814447012477583,-63.22928054099148,,,,
+,,,,,,7.339175414321372,100.84021837646831,8.874313106315807,86.02457800599535,,,,
+,,,,,,7.32207081608188,-80.23983059597896,8.98634822478448,87.45126930092978,,,,
+,,,,,,7.399041508159596,101.38894579759695,8.976940695752761,-64.87546280437735,,,,
+,,,,,,7.454631452437946,-81.33728543823622,9.088120584309461,88.7682151116385,,,,
+,,,,,,7.5236607239044675,102.79995916621343,9.096672883429207,-65.97291764663461,,,,
+,,,,,,7.604296687033503,-82.70910399105776,9.182195874626668,89.86566995389575,,,,
+,,,,,,7.651334332192107,104.13258290324008,9.241451089956337,-67.30554138366128,,,,
+,,,,,,7.758238071188933,-84.08092254387935,9.294230993095342,91.29236124883018,,,,
+,,,,,,7.773917286241802,105.41294688587355,9.37889875438083,-68.71655475227774,,,,
+,,,,,,7.891409586053553,106.64105111411381,9.400279502180195,92.60930705953889,,,,
+,,,,,,7.9083784335133664,-85.48322595343029,9.49007864293753,93.70676190179614,,,,
+,,,,,,8.040463942140557,-86.58939075475308,9.507183241177023,-69.81400959453501,,,,
+,,,,,,8.019083194341192,107.97367485114047,9.602113761406203,95.13345319673057,,,,
+,,,,,,8.14675680262883,109.30629858816715,9.648296176652833,-71.18582814735657,,,,
+,,,,,,8.190129176736114,-87.92201449177975,9.708162270491057,96.45039900743929,,,,
+,,,,,,8.259158448202637,110.4821430620142,9.789409112128645,-72.55764670017814,,,,
+,,,,,,8.34454568862042,-89.32431790133069,9.802237560808264,97.54785384969655,,,,
+,,,,,,8.386832056490276,111.81476679904087,9.909996529717064,98.97454514463098,,,,
+,,,,,,8.48945964592723,-90.66565159742288,9.917693598924837,-73.6551015424354,,,,
+,,,,,,8.514505664777916,113.14739053606755,0.8644949026876736,4.473161033797197,,,,
+,,,,,,8.622020282283295,-91.76310643968014,0.6413994439295643,5.069582504970157,,,,
+,,,,,,8.64340103008266,114.55840390468401,0.41830398517145506,3.280318091451278,,,,
+,,,,,,8.771210389149978,-93.10444013577234,0,-0.2982107355864798,,,,
+,,,,,,8.75458091863936,115.65585874694128,,,,,,
+,,,,,,8.882254526927,116.98848248396794,,,,,,
+,,,,,,8.92135075147441,-94.50674354532327,,,,,,
+,,,,,,9.011149892231746,118.39949585258441,,,,,,
+,,,,,,9.053911387830476,-95.60419838758054,,,,,,
+,,,,,,9.122329780788446,119.49695069484167,,,,,,
+,,,,,,9.208327899714783,-97.00650179713148,,,,,,
+,,,,,,9.250003389076083,120.82957443186834,,,,,,
+,,,,,,9.357518006581465,-98.34783549322367,,,,,,
+,,,,,,9.37889875438083,122.2405878004848,,,,,,
+,,,,,,9.49007864293753,123.33804264274207,,,,,,
+,,,,,,9.49007864293753,-99.44529033548093,,,,,,
+,,,,,,9.622639279293596,124.70986119556363,,,,,,
+,,,,,,9.649721559839458,-100.90856345849062,,,,,,
+,,,,,,9.746647616529915,126.0816797483852,,,,,,
+,,,,,,9.789409112128645,-102.18892744112406,,,,,,
+,,,,,,9.862103654646488,127.17913459064246,,,,,,
+,,,,,,9.917693598924837,-103.28638228338133,,,,,,
+,,,,,,9.979697767542998,128.41377128818186,,,,,,
+,,,,,,10.041701936161157,-104.38383712563859,,,,,,
+,,,,,,0.3718257645968489,4.473161033797197,,,,,,
+,,,,,,0.17661723818350322,2.6838966202783183,,,,,,
+,,,,,,0.009295644114921224,-0.8946322067594394,,,,,,
+,,,,,,0.12084337349397589,-3.876739562624266,,,,,,
+,,,,,,0.35323447636700644,-4.473161033797226,,,,,,
diff --git a/Data/Suspension/suspension_forces/damping_forces.py b/Data/Suspension/suspension_forces/damping_forces.py
new file mode 100644
index 0000000..7ab8f1b
--- /dev/null
+++ b/Data/Suspension/suspension_forces/damping_forces.py
@@ -0,0 +1,155 @@
+import polars as pl
+import matplotlib.pyplot as plt
+from scipy import interpolate
+import numpy as np
+
+flparams = (5,3,2,1.5)
+frparams = (5,3.33,1,3.33)
+blparams = (7,3,3,3)
+brparams = (7,2.66,3.33,3)
+
+#Make the interpolationerator
+highspeed_curves = pl.read_csv('data/12-12-highspeed.csv')
+lowspeed_curves = pl.read_csv('data/12-12-lowspeed.csv')
+
+nasty_curves = pl.concat([highspeed_curves, lowspeed_curves], how="horizontal")
+
+curves = pl.DataFrame()
+
+settings = {"0-4.3 0-4.3": (0,4.3,0,4.3),
+            "0-3 0-3": (0,3,0,3),
+            "0-2 0-2": (0,2,0,2),
+            "0-1 0-1": (0,1,0,1),
+            "0-0 0-0": (0,0,0,0),
+            "2-4.3 2-4.3": (2,4.3,2,4.3),
+            "4-4.3 4-4.3": (4,4.3,4,4.3),
+            "6-4.3 6-4.3": (6,4.3,6,4.3),
+            "10-4.3 10-4.3": (10,4.3,10,4.3),
+            "15-4.3 15-4.3": (15,4.3,15,4.3),
+            "25-4.3 25-4.3": (25,4.3,25,4.3)}
+
+for key in settings.keys():
+    tdf = nasty_curves.with_columns(
+            (pl.col(key + " X").alias('velocity')),
+            (pl.col(key + " Y").alias('force')))
+            #(pl.lit(float(settings[key][0])).alias('lsc')),
+            #(pl.lit(float(settings[key][1])).alias('hsc')),
+            #(pl.lit(float(settings[key][2])).alias('lsr')),
+            #(pl.lit(float(settings[key][3])).alias('hsr')))
+
+    #print(tdf["velocity", "force", "lsc", "hsc", "lsr", "hsr"])
+    tdf = tdf.drop_nulls() 
+    tdf = tdf.sort('velocity')
+
+    tdf = tdf.with_columns(
+        pl.when(pl.col("force") < 0)
+          .then(-pl.col("velocity").abs())  # make velocity negative
+          .otherwise(pl.col("velocity").abs())  # keep positive otherwise
+          .alias("velocity")
+    )
+
+    v_new = np.arange(0, 10.0 + 1e-9, 0.05)
+    f_new = np.interp(v_new, tdf['velocity'], tdf['force'])
+
+    tdf = pl.DataFrame({'velocity': v_new, 'force': f_new})
+
+    tdf = tdf.with_columns(
+            (pl.lit(float(settings[key][0])).alias('lsc')),
+            (pl.lit(float(settings[key][1])).alias('hsc')),
+            (pl.lit(float(settings[key][2])).alias('lsr')),
+            (pl.lit(float(settings[key][3])).alias('hsr')))
+
+
+    curves = pl.concat([curves, tdf["velocity", "force", "lsc", "hsc", "lsr", "hsr"]], how="vertical")
+#curves = curves.sort(["velocity"])
+interperator = interpolate.NearestNDInterpolator(curves["velocity", "lsc", "hsc", "lsr", "hsr"], curves["force"])
+
+
+# Source file generated with c++ decoder program using 100ms cache and forward fill, from fs3norcal.log
+all_data = pl.read_parquet('data/fs3norcal_100ms.parquet')
+
+
+rc = all_data[['Time_ms', 
+              'TPERIPH_BL_DATA_SUSTRAVEL', 
+              'TPERIPH_BR_DATA_SUSTRAVEL', 
+              'TPERIPH_FR_DATA_SUSTRAVEL', 
+              'TPERIPH_FL_DATA_SUSTRAVEL']]
+
+rd = (rc.filter(pl.col('Time_ms')>40000)).filter(pl.col('Time_ms')<95000)
+
+rd = rd.with_columns(
+    pl.col("TPERIPH_BL_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_BL_DATA_SUSTRAVEL"),
+    pl.col("TPERIPH_BR_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_BR_DATA_SUSTRAVEL"),
+    pl.col("TPERIPH_FL_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_FL_DATA_SUSTRAVEL"),
+    pl.col("TPERIPH_FR_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_FR_DATA_SUSTRAVEL")
+)
+
+# Function to produce force values
+def suspensionForce(position, velocity, params):
+    lsc = params[0]
+    hsc = params[1]
+    lsr = params[2]
+    hsr = params[3]
+
+    
+    try:
+      pos_in = position/25.4
+      force_lb = pos_in * 200
+      velocity = velocity / 25.4 # convert from mm/s to in/s
+      force_lb += interperator(np.array([velocity, lsc, hsc, lsr, hsr]))
+      print(interperator(np.array([velocity, lsc, hsc, lsr, hsr])))
+    except:
+      print("oopsie")
+      return None
+    return force_lb
+
+rd = rd.with_columns(
+        (pl.col('TPERIPH_BL_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('BL_SUSVELOCITY'), #mm/s
+        (pl.col('TPERIPH_BR_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('BR_SUSVELOCITY'),
+        (pl.col('TPERIPH_FL_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('FL_SUSVELOCITY'),
+        (pl.col('TPERIPH_FR_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('FR_SUSVELOCITY'))
+
+rd = rd.with_columns([
+    pl.struct(["TPERIPH_BL_DATA_SUSTRAVEL", "BL_SUSVELOCITY"])
+      .map_elements(
+          lambda row: suspensionForce(row["TPERIPH_BL_DATA_SUSTRAVEL"], row["BL_SUSVELOCITY"], blparams),
+          return_dtype=pl.Float64
+      )
+      .alias("BL_SUSFORCE"),
+
+    pl.struct(["TPERIPH_BR_DATA_SUSTRAVEL", "BR_SUSVELOCITY"])
+      .map_elements(
+          lambda row: suspensionForce(row["TPERIPH_BR_DATA_SUSTRAVEL"], row["BR_SUSVELOCITY"], brparams),
+          return_dtype=pl.Float64
+      )
+      .alias("BR_SUSFORCE"),
+
+    pl.struct(["TPERIPH_FL_DATA_SUSTRAVEL", "FL_SUSVELOCITY"])
+      .map_elements(
+          lambda row: suspensionForce(row["TPERIPH_FL_DATA_SUSTRAVEL"], row["FL_SUSVELOCITY"], flparams),
+          return_dtype=pl.Float64
+      )
+      .alias("FL_SUSFORCE"),
+
+    pl.struct(["TPERIPH_FR_DATA_SUSTRAVEL", "FR_SUSVELOCITY"])
+      .map_elements(
+          lambda row: suspensionForce(row["TPERIPH_FR_DATA_SUSTRAVEL"], row["FR_SUSVELOCITY"], frparams),
+          return_dtype=pl.Float64
+      )
+      .alias("FR_SUSFORCE"),
+])
+
+plt.plot(rd['Time_ms'], rd['TPERIPH_BL_DATA_SUSTRAVEL'], label='BL Suspension Travel')
+plt.plot(rd['Time_ms'], rd['BL_SUSFORCE'], label='BL Suspension Force')
+plt.plot(rd['Time_ms'], rd['BR_SUSFORCE'], label='BR Suspension Force')
+plt.plot(rd['Time_ms'], rd['FL_SUSFORCE'], label='FL Suspension Force')
+plt.plot(rd['Time_ms'], rd['FR_SUSFORCE'], label='FR Suspension Force')
+plt.plot(rd['Time_ms'], rd['BL_SUSVELOCITY'], label='BL Suspension Velocity')
+
+plt.title('BL Suspension Travel and Velocity vs Time')
+plt.xlabel('Time (ms)')
+plt.ylabel('Value')
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+plt.show()
diff --git a/Data/Suspension/suspension_forces/data/01112026/downforce_vs_time.png b/Data/Suspension/suspension_forces/data/01112026/downforce_vs_time.png
new file mode 100644
index 0000000..958ad3d
Binary files /dev/null and b/Data/Suspension/suspension_forces/data/01112026/downforce_vs_time.png differ
diff --git a/Data/Suspension/suspension_forces/data/01112026/validation.png b/Data/Suspension/suspension_forces/data/01112026/validation.png
new file mode 100644
index 0000000..614c7c2
Binary files /dev/null and b/Data/Suspension/suspension_forces/data/01112026/validation.png differ
diff --git a/Data/Suspension/suspension_forces/data/03162026/downforce_vs_time.png b/Data/Suspension/suspension_forces/data/03162026/downforce_vs_time.png
new file mode 100644
index 0000000..9f6583f
Binary files /dev/null and b/Data/Suspension/suspension_forces/data/03162026/downforce_vs_time.png differ
diff --git a/Data/Suspension/suspension_forces/downforce_from_suspension.py b/Data/Suspension/suspension_forces/downforce_from_suspension.py
new file mode 100644
index 0000000..a21ba85
--- /dev/null
+++ b/Data/Suspension/suspension_forces/downforce_from_suspension.py
@@ -0,0 +1,338 @@
+import polars as pl
+import matplotlib.pyplot as plt
+import numpy as np
+from pathlib import Path
+
+# need to fill in real values before running
+
+DATA_DIR = Path("data")
+PARQUET_FILE = Path("../fs-data/FS-3/01112026/011026-1.parquet")
+
+# Time window to analyze (milliseconds)
+TIME_MIN_MS = 40_000
+TIME_MAX_MS = 95_000
+
+# Baseline window — must be a period where the car is STATIONARY
+# (used to zero out the spring deflection at rest)
+BASELINE_START_MS = 40_000
+BASELINE_END_MS   = 45_000
+
+# Smoothing — rolling mean window (samples)
+ROLLING_WINDOW = 5
+
+# Spring rates
+# Units: lb/in  (wheel rate, not spring rate)
+# need to replace with real values 
+SPRING_RATES_LB_PER_IN = {
+    "FL": 200.0,
+    "FR": 200.0,
+    "BL": 200.0,
+    "BR": 200.0,
+}
+
+
+TRAVEL_COLS = {
+    "FL": "TPERIPH_FL_DATA_SUSTRAVEL",
+    "FR": "TPERIPH_FR_DATA_SUSTRAVEL",
+    "BL": "TPERIPH_BL_DATA_SUSTRAVEL",
+    "BR": "TPERIPH_BR_DATA_SUSTRAVEL",
+}
+
+# True: larger sensor value means more compression (spring more loaded)
+# False: larger sensor value means more extension  (spring less loaded)
+COMPRESSION_IS_POSITIVE = True
+
+
+# Wheel travel / spring travel.  Typical FSAE range: 0.6 – 0.9.
+# At MR=1.0 this has no effect, so safe to leave until we get have real values.
+MOTION_RATIOS = {
+    "FL": 1.0,
+    "FR": 1.0,
+    "BL": 1.0,
+    "BR": 1.0,
+}
+
+
+
+def validate_inputs():
+    if not PARQUET_FILE.exists():
+        raise FileNotFoundError(f"Parquet file not found: {PARQUET_FILE}")
+    if BASELINE_END_MS <= BASELINE_START_MS:
+        raise ValueError("BASELINE_END_MS must be greater than BASELINE_START_MS")
+    if TIME_MAX_MS <= TIME_MIN_MS:
+        raise ValueError("TIME_MAX_MS must be greater than TIME_MIN_MS")
+    if not (TIME_MIN_MS <= BASELINE_START_MS and BASELINE_END_MS <= TIME_MAX_MS):
+        raise ValueError("Baseline window must fall inside the analysis time window")
+
+
+
+def load_and_filter_data() -> pl.DataFrame:
+    needed_cols = ["Time_ms"] + list(TRAVEL_COLS.values())
+    df = pl.read_parquet(PARQUET_FILE).select(needed_cols)
+    df = df.filter(
+        (pl.col("Time_ms") >= TIME_MIN_MS) &
+        (pl.col("Time_ms") <= TIME_MAX_MS)
+    )
+    if df.height == 0:
+        raise ValueError("No data found in selected time window")
+    return df
+
+
+
+def smooth_travel_signals(df: pl.DataFrame) -> pl.DataFrame:
+    """Apply a rolling mean to remove high-frequency sensor noise."""
+    return df.with_columns([
+        pl.col(col).rolling_mean(window_size=ROLLING_WINDOW).alias(col)
+        for col in TRAVEL_COLS.values()
+    ]).drop_nulls()
+
+
+def compute_baseline(df: pl.DataFrame) -> dict:
+    """
+    Median suspension travel in the baseline window.
+    This represents the static ride height — the reference for zero aero load.
+    The baseline window MUST be a period where the car is stationary and settled.
+    """
+    baseline_df = df.filter(
+        (pl.col("Time_ms") >= BASELINE_START_MS) &
+        (pl.col("Time_ms") <= BASELINE_END_MS)
+    )
+    if baseline_df.height == 0:
+        raise ValueError(
+            "Baseline window has no rows. "
+            "Check BASELINE_START_MS / BASELINE_END_MS."
+        )
+    return {
+        corner: float(baseline_df[TRAVEL_COLS[corner]].median()) #type: ignore
+        for corner in ["FL", "FR", "BL", "BR"]
+    }
+
+
+def add_relative_travel(df: pl.DataFrame, baseline: dict) -> pl.DataFrame:
+    """
+    Subtract the static baseline from each corner's travel signal.
+    Result is the ADDITIONAL compression beyond the static ride height.
+    Positive = more compressed than baseline (more load).
+    Negative = more extended than baseline (less load / aero lift).
+    """
+    exprs = []
+    for corner in ["FL", "FR", "BL", "BR"]:
+        travel_col = TRAVEL_COLS[corner]
+        rel_col    = f"{corner}_REL_MM"
+        if COMPRESSION_IS_POSITIVE:
+            expr = (pl.col(travel_col) - baseline[corner]).alias(rel_col)
+        else:
+            expr = (baseline[corner] - pl.col(travel_col)).alias(rel_col)
+        exprs.append(expr)
+    return df.with_columns(exprs)
+
+
+
+def add_corner_loads(df: pl.DataFrame) -> pl.DataFrame:
+    """
+    Convert relative wheel travel to an apparent additional load at each corner.
+
+    Formula per corner:
+        spring_displacement_in = (wheel_travel_mm / 25.4) / motion_ratio
+        apparent_load_lb       = spring_rate_lb_per_in × spring_displacement_in
+
+    Notes:
+    - Dividing by motion ratio is correct: a MR < 1 means the spring moves
+      LESS than the wheel, so the spring displacement is smaller.
+    - This gives the ADDITIONAL load vs. static, not absolute corner weight.
+    - With placeholder spring rates the magnitudes are not meaningful —
+      only the shape of the curves is valid.
+    """
+    load_exprs = []
+    force_cols = []
+
+    for corner in ["FL", "FR", "BL", "BR"]:
+        rel_col  = f"{corner}_REL_MM"
+        load_col = f"{corner}_APPARENT_LOAD_LB"
+        k  = SPRING_RATES_LB_PER_IN[corner]
+        mr = MOTION_RATIOS[corner]
+
+        # mm → in, then divide by MR to get spring displacement, then × spring rate
+        load_exprs.append(
+            ((pl.col(rel_col) / 25.4) / mr * k).alias(load_col)
+        )
+        force_cols.append(load_col)
+
+    df = df.with_columns(load_exprs)
+
+    # Axle and total sums
+    df = df.with_columns([
+        (pl.col("FL_APPARENT_LOAD_LB") + pl.col("FR_APPARENT_LOAD_LB"))
+            .alias("FRONT_APPARENT_LOAD_LB"),
+        (pl.col("BL_APPARENT_LOAD_LB") + pl.col("BR_APPARENT_LOAD_LB"))
+            .alias("REAR_APPARENT_LOAD_LB"),
+        sum(pl.col(c) for c in force_cols)
+            .alias("TOTAL_APPARENT_DOWNFORCE_LB"),
+    ])
+
+    # Also keep SI units
+    df = df.with_columns([
+        (pl.col("TOTAL_APPARENT_DOWNFORCE_LB") * 4.44822)
+            .alias("TOTAL_APPARENT_DOWNFORCE_N")
+    ])
+
+    return df
+
+
+
+# OUTPUT
+
+def save_summary(df: pl.DataFrame):
+    vals = [df["TOTAL_APPARENT_DOWNFORCE_LB"].mean(), df["TOTAL_APPARENT_DOWNFORCE_LB"].max(), df["TOTAL_APPARENT_DOWNFORCE_LB"].min(), df["TOTAL_APPARENT_DOWNFORCE_N"].mean(), df["FRONT_APPARENT_LOAD_LB"].mean(), df["REAR_APPARENT_LOAD_LB"].mean()]
+    valsNew = []
+    for i, val in enumerate(vals):
+        if val is None:
+            print(f"Warning: Value is None for index {i}. Setting to 0.0")
+            valsNew.append(0.0)
+        try: 
+            valsNew.append(float(val)) #type: ignore
+        except (ValueError):
+            print(f"Warning: Could not convert value to float: {val}. Setting to 0.0")
+            valsNew.append(0.0)
+    summary = pl.DataFrame({
+        "metric": [
+            "mean_total_apparent_downforce_lb",
+            "max_total_apparent_downforce_lb",
+            "min_total_apparent_downforce_lb",
+            "mean_total_apparent_downforce_N",
+            "mean_front_apparent_load_lb",
+            "mean_rear_apparent_load_lb",
+        ],
+        "value": [
+            float(valsNew[0]),
+            float(valsNew[1]),
+            float(valsNew[2]),
+            float(valsNew[3]),
+            float(valsNew[4]),
+            float(valsNew[5]),
+        ],
+    })
+    summary.write_csv(DATA_DIR / "downforce_summary.csv")
+
+
+def make_plots(df: pl.DataFrame):
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    time_s = df["Time_ms"].to_numpy() / 1000.0
+
+    def _save(name: str):
+        plt.grid(True, linewidth=0.5, alpha=0.6)
+        plt.tight_layout()
+        plt.savefig(DATA_DIR / name, dpi=200)
+        plt.close()
+
+    # 1. Raw travel
+    plt.figure(figsize=(12, 5))
+    for corner in ["FL", "FR", "BL", "BR"]:
+        plt.plot(time_s, df[TRAVEL_COLS[corner]].to_numpy(), label=corner)
+    plt.xlabel("Time [s]")
+    plt.ylabel("Suspension travel [mm]")
+    plt.title("Suspension travel vs time")
+    plt.legend()
+    _save("suspension_travel_vs_time.png")
+
+    # 2. Relative compression
+    plt.figure(figsize=(12, 5))
+    for corner in ["FL", "FR", "BL", "BR"]:
+        plt.plot(time_s, df[f"{corner}_REL_MM"].to_numpy(), label=f"{corner} rel")
+    plt.axhline(0, color="k", linewidth=0.8, linestyle="--", label="baseline")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Additional compression vs baseline [mm]")
+    plt.title("Relative suspension compression vs time")
+    plt.legend()
+    _save("relative_compression_vs_time.png")
+
+    # 3. Corner apparent additional loads
+    plt.figure(figsize=(12, 5))
+    for corner in ["FL", "FR", "BL", "BR"]:
+        plt.plot(time_s, df[f"{corner}_APPARENT_LOAD_LB"].to_numpy(), label=corner)
+    plt.axhline(0, color="k", linewidth=0.8, linestyle="--")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Apparent additional load [lb]")
+    plt.title("Corner apparent additional loads vs time\n"
+              "(delta from static — NOT absolute corner weight)")
+    plt.legend()
+    _save("corner_apparent_loads_vs_time.png")
+
+    # 4. Total apparent downforce (both units)
+    fig, ax1 = plt.subplots(figsize=(12, 5))
+    ax2 = ax1.twinx()
+    lb_data = df["TOTAL_APPARENT_DOWNFORCE_LB"].to_numpy()
+    ax1.plot(time_s, lb_data, color="tab:blue", label="Total [lb]")
+    ax2.plot(time_s, lb_data * 4.44822, color="tab:orange", alpha=0.0)  # hidden, just for scale
+    ax1.set_xlabel("Time [s]")
+    ax1.set_ylabel("Apparent additional downforce [lb]", color="tab:blue")
+    ax2.set_ylabel("Apparent additional downforce [N]", color="tab:orange")
+    ax2.tick_params(axis="y", labelcolor="tab:orange")
+    # sync axes
+    ax2.set_ylim(ax1.get_ylim()[0] * 4.44822, ax1.get_ylim()[1] * 4.44822)
+    ax1.axhline(0, color="k", linewidth=0.8, linestyle="--")
+    ax1.set_title("Estimated total apparent downforce vs time\n"
+                  "(requires real spring rates for valid magnitude)")
+    ax1.grid(True, linewidth=0.5, alpha=0.6)
+    plt.tight_layout()
+    plt.savefig(DATA_DIR / "estimated_downforce_vs_time.png", dpi=200)
+    plt.close()
+
+    # 5. Front vs rear
+    plt.figure(figsize=(12, 5))
+    plt.plot(time_s, df["FRONT_APPARENT_LOAD_LB"].to_numpy(), label="Front axle")
+    plt.plot(time_s, df["REAR_APPARENT_LOAD_LB"].to_numpy(),  label="Rear axle")
+    plt.axhline(0, color="k", linewidth=0.8, linestyle="--")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Apparent additional load [lb]")
+    plt.title("Front vs rear apparent additional load")
+    plt.legend()
+    _save("front_vs_rear_apparent_load.png")
+
+
+
+def main():
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    validate_inputs()
+
+    df = load_and_filter_data()
+    print(f"Loaded {df.height} rows ({TIME_MIN_MS/1000:.1f}s – {TIME_MAX_MS/1000:.1f}s)")
+
+    df = smooth_travel_signals(df)
+
+    baseline = compute_baseline(df)
+    print("\nBaseline suspension travel (static ride height) [mm]:")
+    for corner, val in baseline.items():
+        print(f"  {corner}: {val:.3f}")
+
+    df = add_relative_travel(df, baseline)
+    df = add_corner_loads(df)
+
+    # Print sanity-check summary
+    print("\nApparent additional downforce summary:")
+    print(f"  Mean  : {df['TOTAL_APPARENT_DOWNFORCE_LB'].mean():.1f} lb  "
+          f"({df['TOTAL_APPARENT_DOWNFORCE_N'].mean():.1f} N)")
+    print(f"  Max   : {df['TOTAL_APPARENT_DOWNFORCE_LB'].max():.1f} lb")
+    print(f"  Min   : {df['TOTAL_APPARENT_DOWNFORCE_LB'].min():.1f} lb")
+    print("\n  NOTE: Magnitudes are placeholder until real spring rates are entered.")
+
+    df.write_csv(DATA_DIR / "downforce_estimate_output.csv")
+    save_summary(df)
+    make_plots(df)
+
+    print("\nSaved outputs:")
+    for f in [
+        "downforce_estimate_output.csv",
+        "downforce_summary.csv",
+        "suspension_travel_vs_time.png",
+        "relative_compression_vs_time.png",
+        "corner_apparent_loads_vs_time.png",
+        "estimated_downforce_vs_time.png",
+        "front_vs_rear_apparent_load.png",
+    ]:
+        print(f"  {DATA_DIR / f}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Data/Suspension/suspension_forces/suspension_downforce.py b/Data/Suspension/suspension_forces/suspension_downforce.py
new file mode 100644
index 0000000..ad956f7
--- /dev/null
+++ b/Data/Suspension/suspension_forces/suspension_downforce.py
@@ -0,0 +1,208 @@
+import pandas as pd
+import polars as pl
+from scipy import interpolate
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+damper_params = {
+    "FL": (5, 3, 2,1.5),
+    "FR": (5,3.33, 1,3.33),
+    "BL": (7,3,3,3),
+    "BR": (7,2.66, 3.33, 3),
+}
+
+
+preload_lb = {
+    "FL": 0.0,
+    "FR": 0.0,
+    "BL": 0.0,
+    "BR": 0.0,
+}
+
+## spring_rate = 200  # lbs per in
+
+##luca's code basically imported
+highspeed_curves = pl.read_csv('12-12-highspeed.csv')
+lowspeed_curves = pl.read_csv('12-12-lowspeed.csv')
+nasty_curves = pl.concat([highspeed_curves, lowspeed_curves], how="horizontal")
+
+settings = {"0-4.3 0-4.3": (0,4.3,0,4.3),
+            "0-3 0-3": (0,3,0,3),
+            "0-2 0-2": (0,2,0,2),
+            "0-1 0-1": (0,1,0,1),
+            "0-0 0-0": (0,0,0,0),
+            "2-4.3 2-4.3": (2,4.3,2,4.3),
+            "4-4.3 4-4.3": (4,4.3,4,4.3),
+            "6-4.3 6-4.3": (6,4.3,6,4.3),
+            "10-4.3 10-4.3": (10,4.3,10,4.3),
+            "15-4.3 15-4.3": (15,4.3,15,4.3),
+            "25-4.3 25-4.3": (25,4.3,25,4.3)}
+
+curves = pl.DataFrame()
+for key in settings.keys():
+    tdf = nasty_curves.with_columns(
+            (pl.col(key + " X").alias('velocity')),
+            (pl.col(key + " Y").alias('force')))
+
+    tdf = tdf.drop_nulls()
+    tdf = tdf.sort('velocity')
+
+    tdf = tdf.with_columns(
+        pl.when(pl.col("force") < 0)
+          .then(-pl.col("velocity").abs())
+          .otherwise(pl.col("velocity").abs())
+          .alias("velocity")
+    )
+
+    v_new = np.arange(0, 10.0 + 1e-9, 0.05)
+    f_new = np.interp(v_new, tdf['velocity'], tdf['force'])
+
+    tdf = pl.DataFrame({'velocity': v_new, 'force': f_new})
+
+    tdf = tdf.with_columns(
+            (pl.lit(float(settings[key][0])).alias('lsc')),
+            (pl.lit(float(settings[key][1])).alias('hsc')),
+            (pl.lit(float(settings[key][2])).alias('lsr')),
+            (pl.lit(float(settings[key][3])).alias('hsr')))
+
+    curves = pl.concat([curves, tdf["velocity", "force", "lsc", "hsc", "lsr", "hsr"]], how="vertical")
+
+interperator = interpolate.NearestNDInterpolator(curves["velocity", "lsc", "hsc", "lsr", "hsr"], curves["force"])
+
+
+def suspensionForce(position, velocity, params, preload):
+    lsc = params[0]
+    hsc = params[1]
+    lsr = params[2]
+    hsr = params[3]
+
+    try:
+      pos_in = position/25.4
+      force_lb = pos_in * 200
+      velocity = velocity / 25.4
+      interp_result = interperator(np.array([velocity, lsc, hsc, lsr, hsr]))
+      force_lb += interp_result.item() if hasattr(interp_result, 'item') else float(interp_result)
+      force_lb += preload
+    except:
+      return None
+    return force_lb
+
+##changed ver of my code
+files = ["../fs-data/FS-3/03162026/2_steeper_regen_curve.parquet"]
+window = (10_000, 35_000)
+out_root = "data"
+
+def run(path):
+    run_id = path.split("/")[-2]
+    out = out_root + "/" + run_id
+    os.makedirs(out, exist_ok=True)
+    print("processing", run_id)
+
+    all_data = pl.read_parquet(path)
+    rd = all_data[['Time_ms',
+                   'TPERIPH_BL_DATA_SUSTRAVEL',
+                   'TPERIPH_BR_DATA_SUSTRAVEL',
+                   'TPERIPH_FR_DATA_SUSTRAVEL',
+                   'TPERIPH_FL_DATA_SUSTRAVEL']]
+
+    rd = rd.filter(pl.col('Time_ms') > window[0]).filter(pl.col('Time_ms') < window[1])
+
+    rd = rd.with_columns([
+        pl.col("TPERIPH_BL_DATA_SUSTRAVEL").forward_fill(),
+        pl.col("TPERIPH_BR_DATA_SUSTRAVEL").forward_fill(),
+        pl.col("TPERIPH_FL_DATA_SUSTRAVEL").forward_fill(),
+        pl.col("TPERIPH_FR_DATA_SUSTRAVEL").forward_fill(),
+    ]).drop_nulls()
+
+    rd = rd.with_columns(
+        pl.col("TPERIPH_BL_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_BL_DATA_SUSTRAVEL"),
+        pl.col("TPERIPH_BR_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_BR_DATA_SUSTRAVEL"),
+        pl.col("TPERIPH_FL_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_FL_DATA_SUSTRAVEL"),
+        pl.col("TPERIPH_FR_DATA_SUSTRAVEL").rolling_mean(window_size=5).alias("TPERIPH_FR_DATA_SUSTRAVEL")
+    )
+
+    rd = rd.with_columns(
+        (pl.col('TPERIPH_BL_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('BL_SUSVELOCITY'),
+        (pl.col('TPERIPH_BR_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('BR_SUSVELOCITY'),
+        (pl.col('TPERIPH_FL_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('FL_SUSVELOCITY'),
+        (pl.col('TPERIPH_FR_DATA_SUSTRAVEL').diff() / (pl.col('Time_ms').diff()/1000)).alias('FR_SUSVELOCITY'))
+
+    bl_p = damper_params["BL"]
+    br_p = damper_params["BR"]
+    fl_p = damper_params["FL"]
+    fr_p = damper_params["FR"]
+    bl_pre = preload_lb["BL"]
+    br_pre = preload_lb["BR"]
+    fl_pre = preload_lb["FL"]
+    fr_pre = preload_lb["FR"]
+
+    rd = rd.with_columns([
+        pl.struct(["TPERIPH_BL_DATA_SUSTRAVEL", "BL_SUSVELOCITY"])
+          .map_elements(
+              lambda row: suspensionForce(row["TPERIPH_BL_DATA_SUSTRAVEL"], row["BL_SUSVELOCITY"], bl_p, bl_pre),
+              return_dtype=pl.Float64
+          )
+          .alias("BL_SUSFORCE"),
+
+        pl.struct(["TPERIPH_BR_DATA_SUSTRAVEL", "BR_SUSVELOCITY"])
+          .map_elements(
+              lambda row: suspensionForce(row["TPERIPH_BR_DATA_SUSTRAVEL"], row["BR_SUSVELOCITY"], br_p, br_pre),
+              return_dtype=pl.Float64
+          )
+          .alias("BR_SUSFORCE"),
+
+        pl.struct(["TPERIPH_FL_DATA_SUSTRAVEL", "FL_SUSVELOCITY"])
+          .map_elements(
+              lambda row: suspensionForce(row["TPERIPH_FL_DATA_SUSTRAVEL"], row["FL_SUSVELOCITY"], fl_p, fl_pre),
+              return_dtype=pl.Float64
+          )
+          .alias("FL_SUSFORCE"),
+
+        pl.struct(["TPERIPH_FR_DATA_SUSTRAVEL", "FR_SUSVELOCITY"])
+          .map_elements(
+              lambda row: suspensionForce(row["TPERIPH_FR_DATA_SUSTRAVEL"], row["FR_SUSVELOCITY"], fr_p, fr_pre),
+              return_dtype=pl.Float64
+          )
+          .alias("FR_SUSFORCE"),
+    ])
+
+    df = rd.to_pandas().dropna(subset=["FL_SUSFORCE", "FR_SUSFORCE", "BL_SUSFORCE", "BR_SUSFORCE"])
+
+    df["FRONT_LB"] = df["FL_SUSFORCE"] + df["FR_SUSFORCE"]
+    df["REAR_LB"]  = df["BL_SUSFORCE"] + df["BR_SUSFORCE"]
+    df["TOTAL_LB"] = df["FRONT_LB"] + df["REAR_LB"]
+
+    m  = df["TOTAL_LB"].mean()
+    mx = df["TOTAL_LB"].max()
+    mn = df["TOTAL_LB"].min()
+    print("TOTAL lb mean:", round(m, 1), "max:", round(mx, 1), "min:", round(mn, 1))
+    print("preload offset applied:", round(sum(preload_lb.values()), 1), "lb total")
+
+    parked = df[(df["Time_ms"] >= 160_000) & (df["Time_ms"] <= 180_000)]
+    if len(parked) > 0:
+        print("parked total:", round(parked["TOTAL_LB"].mean(), 1), "lb (should ≈ vehicle weight)")
+
+    t = df["Time_ms"] / 1000
+    plt.figure(figsize=(12, 5))
+    plt.plot(t, df["TOTAL_LB"], label="Total")
+    plt.plot(t, df["FRONT_LB"], label="Front", alpha=0.7)
+    plt.plot(t, df["REAR_LB"], label="Rear", alpha=0.7)
+    plt.xlabel("Time [s]")
+    plt.ylabel("Load [lb]")
+    plt.title(run_id + " - vertical load (spring + damper + preload)")
+    plt.legend()
+    plt.grid()
+    plt.savefig(out + "/load_vs_time.png", dpi=150)
+    plt.close()
+    return {"run": run_id, "mean": m, "max": mx, "min": mn}
+
+results = []
+for f in files:
+    r = run(f)
+    if r:
+        results.append(r)
+
+print("\nsummary:")
+for r in results:
+    print(r["run"], "mean:", round(r["mean"], 1))
diff --git a/Data/Suspension/suspension_forces/validate_downforce.py b/Data/Suspension/suspension_forces/validate_downforce.py
new file mode 100644
index 0000000..51213e9
--- /dev/null
+++ b/Data/Suspension/suspension_forces/validate_downforce.py
@@ -0,0 +1,62 @@
+import polars as pl
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+PATH = "../fs-data/FS-3/01112026/011026-1.parquet"
+OUT = Path("data/01112026")
+OUT.mkdir(parents=True, exist_ok=True)
+
+window   = (40_000, 95_000)
+baseline = (40_000, 45_000)
+spring_rate = 200.0
+
+cols = [
+    "Time_ms",
+    "TPERIPH_FR_DATA_SUSTRAVEL",
+    "TPERIPH_BR_DATA_SUSTRAVEL",
+    "VDM_X_AXIS_ACCELERATION",
+    "ETC_STATUS_BRAKE_SENSE_VOLTAGE",
+    "ETC_STATUS_PEDAL_TRAVEL",
+]
+
+df = pl.read_parquet(PATH).select(cols).filter(
+    (pl.col("Time_ms") >= window[0]) & (pl.col("Time_ms") <= window[1])
+)
+df = df.with_columns([pl.col(c).forward_fill() for c in cols if c != "Time_ms"]).drop_nulls()
+
+base = df.filter((pl.col("Time_ms") >= baseline[0]) & (pl.col("Time_ms") <= baseline[1]))
+fr_base = float(base["TPERIPH_FR_DATA_SUSTRAVEL"].median()) #type: ignore 
+br_base = float(base["TPERIPH_BR_DATA_SUSTRAVEL"].median()) #type: ignore
+df = df.with_columns([
+    ((pl.col("TPERIPH_FR_DATA_SUSTRAVEL") - fr_base) / 25.4 * spring_rate * 2).alias("FRONT_LB"),
+    ((pl.col("TPERIPH_BR_DATA_SUSTRAVEL") - br_base) / 25.4 * spring_rate * 2).alias("REAR_LB"),
+])
+df = df.with_columns((pl.col("FRONT_LB") + pl.col("REAR_LB")).alias("TOTAL_LB"))
+
+t = df["Time_ms"].to_numpy() / 1000
+fig, axes = plt.subplots(4, 1, figsize=(14, 9), sharex=True)
+
+axes[0].plot(t, df["TOTAL_LB"].to_numpy(), color="black")
+axes[0].axhline(0, color="k", lw=0.5, ls="--")
+axes[0].set_ylabel("Load [lb]")
+axes[0].grid(alpha=0.3)
+
+axes[1].plot(t, df["VDM_X_AXIS_ACCELERATION"].to_numpy(), color="tab:red")
+axes[1].axhline(0, color="k", lw=0.5, ls="--")
+axes[1].set_ylabel("Lon accel [g]")
+axes[1].grid(alpha=0.3)
+
+axes[2].plot(t, df["ETC_STATUS_BRAKE_SENSE_VOLTAGE"].to_numpy(), color="tab:red")
+axes[2].set_ylabel("Brake [V]")
+axes[2].grid(alpha=0.3)
+
+axes[3].plot(t, df["ETC_STATUS_PEDAL_TRAVEL"].to_numpy(), color="tab:green")
+axes[3].set_ylabel("Throttle")
+axes[3].set_xlabel("Time [s]")
+axes[3].grid(alpha=0.3)
+
+plt.tight_layout()
+plt.savefig(OUT / "validation.png", dpi=150)
+plt.close()
+
+print(f"saved: {OUT / 'validation.png'}")
\ No newline at end of file
diff --git a/Data/TractiveBatteryThermalModelViewer.py b/Data/TractiveBatteryThermalModelViewer.py
new file mode 100644
index 0000000..ba776f8
--- /dev/null
+++ b/Data/TractiveBatteryThermalModelViewer.py
@@ -0,0 +1,116 @@
+# TractiveBatteryThermalModelViewer.py
+
+import argparse
+import matplotlib.pyplot as plt
+import numpy as np
+from numpy.typing import NDArray
+import polars as pl
+
+from fs4BatteryThermalModelingEx import thermal_ode_solve_ivp
+
+def load_current_from_parquet(path: str, column: str) -> NDArray[np.float64]:
+    """
+    Load a single current column from a Parquet file as a NumPy array.
+    """
+    # df = pl.read_parquet(path, columns=[column])
+    # df = pl.read_parquet(path, columns=["ACC_SEG0_TEMPS_CELL0", "ACC_SEG0_TEMPS_CELL1"])
+    # # take the average of 64 Columns and create a dataframe with the average value
+    # avg_df = df.select(
+    # pl.mean_horizontal("ACC_SEG0_TEMPS_CELL0", "ACC_SEG0_TEMPS_CELL1").alias("avg")
+    # )
+    csv_df = pl.read_csv("../Docs/Columns.csv").select("Column Name")  # or columns=["c1"] to only read c1
+
+    filtered_df = csv_df.filter(
+    # pl.col("Column Name").str.contains("ACC_SEG0_TEMPS", literal=True)
+    pl.col("Column Name").str.contains(r"ACC_SEG\d+_TEMPS_")  # \d+ = one or more
+    )
+
+    acc_seg_temps_list: list[str] = filtered_df["Column Name"].to_list()
+    cleaned_acc_seg_temps_list = [s.strip("'") for s in acc_seg_temps_list]
+    parquet_df = pl.read_parquet(path, columns= cleaned_acc_seg_temps_list)
+    # take the average of 64 Columns and create a dataframe with the average value
+    avg_df = parquet_df.select(
+    pl.mean_horizontal(pl.col(cleaned_acc_seg_temps_list)).alias("avg")
+    )
+    return avg_df["avg"].to_numpy()
+
+
+def run_thermal_model(
+    current_draw: NDArray[np.float64],
+    t_end: float,
+    initial_temp: float,
+):
+    """
+    Run the thermal ODE solver over [0, t_end] for the given current profile.
+    """
+    t_span = (0.0, t_end)
+    t_eval = np.linspace(t_span[0], t_span[1], len(current_draw), dtype=np.float64)
+    return thermal_ode_solve_ivp(
+        current_draw=current_draw,
+        t_span=t_span,
+        initial_temp=initial_temp,
+        t_eval=t_eval,
+    )
+
+
+def plot_temperature(solution) -> None:
+    """
+    Plot temperature vs time from a solve_ivp solution.
+    """
+    t = solution.t
+    T = solution.y[0]
+
+    plt.figure()
+    plt.plot(t, T, label="Cell temperature")
+    plt.xlabel("Time [s]")
+    plt.ylabel("Temperature [°C]")
+    plt.title("Tractive Battery Thermal Model")
+    plt.grid(True)
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="View tractive battery thermal model as a function of current draw."
+    )
+    parser.add_argument(
+        "--path_parquet",
+        required=True,
+        help="Path to the Parquet file containing current data.",
+    )
+    parser.add_argument(
+        "--column-name",
+        default="SME_TEMP_BusCurrent",
+        help="Name of the current column in the Parquet file "
+             "(default: SME_TEMP_BusCurrent).",
+    )
+    parser.add_argument(
+        "--t-end",
+        type=float,
+        default=60.0,
+        help="End time in seconds for the simulation (default: 60).",
+    )
+    parser.add_argument(
+        "--initial-temp",
+        type=float,
+        default=22.0,
+        help="Initial temperature in °C (default: 22).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    current = load_current_from_parquet(args.path_parquet, args.column_name)
+
+    solution = run_thermal_model(current, args.t_end, args.initial_temp)
+
+    if not solution.success:
+        raise RuntimeError(f"ODE solver failed: {solution.message}")
+
+    plot_temperature(solution)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Data/blueMaxDragAnalysis.py b/Data/blueMaxDragAnalysis.py
new file mode 100644
index 0000000..73bd242
--- /dev/null
+++ b/Data/blueMaxDragAnalysis.py
@@ -0,0 +1,135 @@
+import polars as pl
+import matplotlib.pyplot as plt
+import numpy as np
+from FSLib.IntegralsAndDerivatives import *
+from FSLib.fftTools import *
+from FSLib.AnalysisFunctions import *
+from scipy.optimize import curve_fit
+
+dbcPath = "../fs-3/CANbus.dbc"
+
+# lv = "GLV"
+# v = "Violation"
+V = "ACC_POWER_PACK_VOLTAGE"
+I = "SME_TEMP_BusCurrent"
+E = "Energy"
+P = "Power"
+t = "Time"
+
+smeFaultCode = "SME_TEMP_FaultCode"
+smeFaultLevel = "SME_TEMP_FaultLevel"
+smeContactor = "SME_TRQSPD_contactor_closed"
+busV = "SME_TEMP_DC_Bus_V"
+busC = "SME_TEMP_BusCurrent"
+bmsFault = "ACC_STATUS_BMS_FAULT"
+imdFault = "ACC_STATUS_IMD_FAULT"
+pchOn = "ACC_STATUS_PRECHARGING"
+pchDone = "ACC_STATUS_PRECHARGE_DONE"
+accShutdown = "ACC_STATUS_SHUTDOWN_STATE" 
+glv = "ACC_STATUS_GLV_VOLTAGE"
+
+vdmValid = "VDM_GPS_VALID1"
+# time = ""
+brakeF = "TMAIN_DATA_BRAKES_F"
+brakeR = "TMAIN_DATA_BRAKES_R"
+frT = "TELEM_FR_SUSTRAVEL"
+flT = "TELEM_FL_SUSTRAVEL"
+brT = "TELEM_BR_SUSTRAVEL"
+blT = "TELEM_BL_SUSTRAVEL"
+lat = "VDM_GPS_Latitude"
+long = "VDM_GPS_Longitude"
+course = "VDM_GPS_TRUE_COURSE"
+xA = "xA"
+yA = "yA"
+zA = "zA"
+vA = "vA"
+xA_uncorrected = "VDM_X_AXIS_ACCELERATION"
+yA_uncorrected = "VDM_Y_AXIS_ACCELERATION"
+zA_uncorrected = "VDM_Z_AXIS_ACCELERATION"
+vA_uncorrected = "vA_uncorrected"
+xG = "VDM_X_AXIS_YAW_RATE"
+yG = "VDM_Y_AXIS_YAW_RATE"
+zG = "VDM_Z_AXIS_YAW_RATE"
+rpm = "SME_TRQSPD_Speed"
+speed = "VDM_GPS_SPEED"
+tsC = "ACC_POWER_CURRENT"
+xA_mps = "IMU_XAxis_Acceleration_mps"
+yA_mps = "IMU_YAxis_Acceleration_mps"
+zA_mps = "IMU_ZAxis_Acceleration_mps"
+speed_mps = "VMD_GPS_Speed_mps"
+index = "index"
+heFL = "TPERIPH_FL_DATA_WHEELSPEED"
+heFR = "TPERIPH_FR_DATA_WHEELSPEED"
+heBL = "TPERIPH_BL_DATA_WHEELSPEED"
+heBR = "TPERIPH_BR_DATA_WHEELSPEED"
+
+dfa = readValid("../fs-data/FS-3/08102025/08102025RollingResistanceTestP1.parquet")
+dfb = readValid("../fs-data/FS-3/08102025/08102025RollingResistanceTestP2.parquet")
+dfc = readValid("../fs-data/FS-3/08102025/08102025RollingResistanceTestP3.parquet")
+dfd = readValid("../fs-data/FS-3/08102025/08102025RollingResistanceTestP4.parquet")
+dfa.insert_column(0, timeCol(dfa))
+dfb.insert_column(0, timeCol(dfb))
+dfc.insert_column(0, timeCol(dfc))
+dfd.insert_column(0, timeCol(dfd))
+
+
+dragTrainingDFs = [
+    dfa.filter(pl.col(t) > 117).filter(pl.col(t) < 149),
+    dfa.filter(pl.col(t) > 177).filter(pl.col(t) < 197),
+    dfb.filter(pl.col(t) > 25).filter(pl.col(t) < 41),
+    dfb.filter(pl.col(t) > 54).filter(pl.col(t) < 72),
+    dfb.filter(pl.col(t) > 99.5).filter(pl.col(t) < 114.2),
+    dfc.filter(pl.col(t) > 9.985).filter(pl.col(t) < 17),
+    dfc.filter(pl.col(t) > 112).filter(pl.col(t) < 133)
+]
+
+dragTrainingdf = pl.concat([dfa.with_columns(pl.col(t) - pl.col(t).min()) for dfa in dragTrainingDFs])
+
+
+def resistanceCurveFun (x, coeffRollingResistance, dragCoeff):
+    carMass = 221.4# kg
+    carNormalForce = 9.805*carMass # N
+    airDensity = 1.23 # kg / m^3
+    def drag(speed):
+        return 0.5*airDensity*dragCoeff*(speed**2) #add frontal area
+    
+    outList = []
+
+    dfs = []
+    pos = 1
+    while (True):
+        try:
+            ind = x["Time"].to_list().index(0, pos)
+            dfs.append(x[pos-1:ind])
+            pos = ind+1
+            continue
+        except:
+            dfs.append(x[pos-1:])
+            break
+
+    for df in dfs:
+        arr = np.zeros(df.height)
+        time_s = df[t] - df[t].min() # s
+        speed = (df[rpm]*12/41*0.2*2*np.pi/60)# m/s
+        arr[0] = speed[0]
+        for i in range(1, df.height):
+            dt = time_s[i] - time_s[i-1]
+            force = carNormalForce*coeffRollingResistance + drag(arr[i-1])
+            accel = force/(carMass + 22.68)
+            arr[i] = arr[i-1] - (dt * accel)
+        outList.append(arr)
+        #print(np.concatenate(outList))
+    return np.concatenate(outList)
+
+if dragTrainingDFs:
+    # Use the concatenated dataframe
+    times = dragTrainingdf[t].to_numpy()
+    speeds = dragTrainingdf[rpm].to_numpy() * 12/41*0.2*2*np.pi/60
+
+    popt, pcov = curve_fit(resistanceCurveFun, dragTrainingdf, speeds, p0=[0.01, 0.3])
+
+    coeffRollingResistance, dragCoeff = popt
+    print("Rolling Resistance Coefficient:", coeffRollingResistance)
+    print("Drag Coefficient * Frontal Area:", dragCoeff)
+else:
+    print("No data loaded for drag training. Please populate dragTrainingDFs with dataframes.")
diff --git a/Data/fs4BatteryThermalModelingEx.py b/Data/fs4BatteryThermalModelingEx.py
new file mode 100644
index 0000000..cab52a5
--- /dev/null
+++ b/Data/fs4BatteryThermalModelingEx.py
@@ -0,0 +1,104 @@
+import numpy as np
+from numpy.typing import NDArray
+from scipy.integrate import solve_ivp
+from typing import Tuple
+
+
+THERMAL_COEFFICIENT: float = 12.6316 / (49.9 * 1000.0)
+"""
+Effective thermal coefficient relating I² to temperature rate of change.
+
+Units
+-----
+(°C / s) / A²
+"""
+
+
+def thermal_ode(
+    t: float,
+    T: float,
+    current_draw: NDArray[np.float64],
+    total_time: float,
+) -> float:
+    """
+    Compute dT/dt for a single cell using a sampled current profile.
+
+    The model assumes Joule heating only:
+
+        dT/dt = THERMAL_COEFFICIENT * I(t)²
+
+    where I(t) is obtained by indexing into ``current_draw``, which is
+    assumed to be uniformly sampled over the time interval
+    ``[0, total_time]``.
+
+    Parameters
+    ----------
+    t : float
+        Current time (seconds) at which the derivative is evaluated.
+    T : float
+        Current cell temperature (degrees Celsius). Currently unused,
+        but included for compatibility with ``scipy.integrate.solve_ivp``.
+    current_draw : NDArray[np.float64]
+        1D array of current samples (amperes), uniformly spaced in time.
+    total_time : float
+        Total duration (seconds) covered by ``current_draw``. Used to map
+        the continuous time ``t`` to an index in ``current_draw``.
+
+    Returns
+    -------
+    float
+        Instantaneous temperature time derivative ``dT/dt`` in
+        degrees Celsius per second.
+    """
+    idx = int(t * len(current_draw) / total_time)
+    idx = min(max(idx, 0), len(current_draw) - 1)
+    I_t = current_draw[idx]
+    return float(THERMAL_COEFFICIENT * (I_t ** 2))
+
+
+def thermal_ode_solve_ivp(
+    current_draw: NDArray[np.float64],
+    t_span: Tuple[float, float],
+    initial_temp: float,
+    t_eval: NDArray[np.float64] | None = None,
+):
+    """
+    Integrate the thermal ODE over a time interval using ``solve_ivp``.
+
+    This solves
+
+        dT/dt = THERMAL_COEFFICIENT * I(t)²
+
+    where ``I(t)`` is obtained from the discrete array ``current_draw``,
+    assumed to be uniformly sampled over the interval ``t_span``.
+
+    Parameters
+    ----------
+    current_draw : NDArray[np.float64]
+        1D array of current samples (amperes) over the driving cycle.
+    t_span : tuple of float
+        Integration interval ``(t0, tf)`` in seconds.
+    initial_temp : float
+        Initial temperature at ``t0`` in degrees Celsius.
+    t_eval : NDArray[np.float64], optional
+        1D array of times at which to store the computed solution.
+        If ``None``, the solver chooses its own time steps.
+
+    Returns
+    -------
+    OdeResult
+        The object returned by ``scipy.integrate.solve_ivp``, containing
+        at least ``t`` (times) and ``y`` (temperatures).
+    """
+    total_time = t_span[1] - t_span[0]
+
+    sol = solve_ivp(
+        fun=lambda t, T: thermal_ode(t, T, current_draw, total_time),
+        t_span=t_span,
+        y0=[initial_temp],
+        t_eval=t_eval,
+        method="RK45",
+        rtol=1e-6,
+        atol=1e-8,
+    )
+    return sol
diff --git a/Data/speed-drag comparison b/Data/speed-drag comparison
new file mode 100644
index 0000000..dc21684
--- /dev/null
+++ b/Data/speed-drag comparison	
@@ -0,0 +1,40 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from FSLib.IntegralsAndDerivatives import *
+from FSLib.fftTools import *
+from FSLib.AnalysisFunctions import *
+
+df = readValid("/Users/purnima/Desktop/Sims-Data-bluemax-drag-analysis/Data/speed_drag_parquet_file.parquet")
+
+speed_channel = "VDM_GPS_SPEED"
+drag_coefficient = 1.0858790012112278  
+air_density = 1.225 
+
+dt = 0.01 #can be adjusted accordingly
+time = np.arange(df.height) * dt
+
+speed_vals = df[speed_channel].to_numpy()
+speed_vals = speed_vals * 0.44704
+drag_vals = 0.5 * air_density * drag_coefficient * speed_vals**2
+speed_drag = speed_vals * drag_vals
+
+plt.figure(figsize=(12, 6))
+
+ax1 = plt.subplot(1, 2, 1)
+ax1.plot(time, speed_vals, label="Speed", color='blue')
+ax1.set_xlabel("Time (s)")
+ax1.set_ylabel("Speed (m/s)")
+ax1.set_title("Speed vs Time")
+ax1.legend()
+ax1.grid(True)
+
+ax2 = plt.subplot(1, 2, 2)
+ax2.plot(time, speed_drag, label="Speed × Drag Force", color='red')
+ax2.set_xlabel("Time (s)")
+ax2.set_ylabel("Speed × Drag Force (m/s × N)")
+ax2.set_title("Speed × Drag Force vs Time")
+ax2.legend()
+ax2.grid(True)
+
+plt.tight_layout()
+plt.show()
diff --git a/Data/test/test_IT_ThermalIntegrationParquet.py b/Data/test/test_IT_ThermalIntegrationParquet.py
new file mode 100644
index 0000000..14208cf
--- /dev/null
+++ b/Data/test/test_IT_ThermalIntegrationParquet.py
@@ -0,0 +1,58 @@
+import unittest
+import pathlib
+import numpy as np
+import polars as pl
+from numpy.testing import assert_array_almost_equal
+from numpy.typing import NDArray
+
+from fs4BatteryThermalModelingEx import (
+    THERMAL_COEFFICIENT,
+    thermal_ode_solve_ivp,
+)
+
+HERE = pathlib.Path(__file__).parent
+PARQUET_PATH = HERE / "testdata" / "parquet" / "08102025Endurance1_FirstHalf.parquet"
+COLUMN_NAME = "SME_TEMP_BusCurrent"
+
+
+class TestThermalIntegrationParquet(unittest.TestCase):
+    def setUp(self) -> None:
+        # read only the needed column
+        df = pl.read_parquet(PARQUET_PATH, columns=["SME_TEMP_BusCurrent"])
+        self.current_draw: NDArray[np.float64] = df[
+            "SME_TEMP_BusCurrent"
+        ].to_numpy()
+
+        # basic time grid: assume data covers 0–60s
+        self.t_span = (0.0, 60.0)
+        n_points = len(self.current_draw)
+        self.t_eval = np.linspace(
+            self.t_span[0], self.t_span[1], n_points, dtype=np.float64
+        )
+        self.initial_temp = 25.0
+
+    def test_integration_runs_and_temperature_increases_on_average(self) -> None:
+        sol = thermal_ode_solve_ivp(
+            current_draw=self.current_draw,
+            t_span=self.t_span,
+            initial_temp=self.initial_temp,
+            t_eval=self.t_eval,
+        )
+
+        # 1) solver succeeded
+        self.assertTrue(sol.success, msg=sol.message)
+
+        temps = sol.y[0]
+
+        # 2) length matches t_eval / current array
+        self.assertEqual(temps.shape, self.t_eval.shape)
+
+        # 3) on average, temperature should not drop far below initial
+        self.assertGreaterEqual(temps.mean(), self.initial_temp - 1.0)
+
+        # 4) first value equals initial temperature
+        self.assertAlmostEqual(temps[0], self.initial_temp, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Data/test/test_UT_fs4BatteryThermalModeling.py b/Data/test/test_UT_fs4BatteryThermalModeling.py
new file mode 100644
index 0000000..43b0e6d
--- /dev/null
+++ b/Data/test/test_UT_fs4BatteryThermalModeling.py
@@ -0,0 +1,72 @@
+import unittest
+import numpy as np
+from numpy.typing import NDArray
+from numpy.testing import assert_array_almost_equal
+
+from fs4BatteryThermalModelingEx import (
+    THERMAL_COEFFICIENT,
+    thermal_ode_solve_ivp,
+)
+
+class TestThermal_ode_solve_ivp(unittest.TestCase):
+    def setUp(self) -> None:
+        self.t_span = (0.0, 10.0)
+        self.n_points = 1000
+        self.t_eval: NDArray[np.float64] = np.linspace(
+            self.t_span[0], self.t_span[1], self.n_points, dtype=np.float64
+        )
+        self.initial_temp: float = 25.0
+
+    def test_constant_current_matches_analytic(self) -> None:
+        """
+        For constant I, dT/dt = k * I^2 -> T(t) = T0 + k * I^2 * t
+        """
+        I_const = 5.0
+        current_draw = np.full(self.n_points, I_const, dtype=np.float64)
+
+        sol = thermal_ode_solve_ivp(
+            current_draw=current_draw,
+            t_span=self.t_span,
+            initial_temp=self.initial_temp,
+            t_eval=self.t_eval,
+        )
+
+        self.assertTrue(sol.success, msg=sol.message)
+        temps = sol.y[0]
+
+        expected = self.initial_temp + THERMAL_COEFFICIENT * (I_const ** 2) * self.t_eval
+        assert_array_almost_equal(temps, expected, decimal=4)
+
+    def test_zero_current_results_in_constant_temperature(self) -> None:
+        zero_current = np.zeros(self.n_points, dtype=np.float64)
+
+        sol = thermal_ode_solve_ivp(
+            current_draw=zero_current,
+            t_span=self.t_span,
+            initial_temp=self.initial_temp,
+            t_eval=self.t_eval,
+        )
+
+        self.assertTrue(sol.success, msg=sol.message)
+        temps = sol.y[0]
+        expected = np.full_like(temps, self.initial_temp)
+        assert_array_almost_equal(temps, expected, decimal=8)
+
+    def test_extreme_currents_no_nan_or_inf(self) -> None:
+        extreme_currents = np.linspace(0.0, 1e3, self.n_points, dtype=np.float64)
+
+        sol = thermal_ode_solve_ivp(
+            current_draw=extreme_currents,
+            t_span=self.t_span,
+            initial_temp=self.initial_temp,
+            t_eval=self.t_eval,
+        )
+
+        self.assertTrue(sol.success, msg=sol.message)
+        temps = sol.y[0]
+        self.assertFalse(np.isnan(temps).any())
+        self.assertFalse(np.isinf(temps).any())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Data/test/testdata/parquet/08102025Endurance1_FirstHalf.parquet b/Data/test/testdata/parquet/08102025Endurance1_FirstHalf.parquet
new file mode 100644
index 0000000..7a175e0
Binary files /dev/null and b/Data/test/testdata/parquet/08102025Endurance1_FirstHalf.parquet differ
diff --git a/Docs/Columns.csv b/Docs/Columns.csv
index c53aecf..8ae0467 100644
--- a/Docs/Columns.csv
+++ b/Docs/Columns.csv
@@ -1,210 +1,210 @@
 Column Name,Description
-'ACC_POWER_CURRENT',"Current as measured by the accumulator current sensor (A)"
-'ACC_POWER_PACK_VOLTAGE',"Voltage as measured by the accumulator BMS (V)"
-'ACC_POWER_SOC',"SOC as estimated by the accumulator firmware (% charge)"
-'ACC_SEG0_TEMPS_CELL0',"Accumulator Segment 0 Cell 0 Temperature"
-'ACC_SEG0_TEMPS_CELL1',"Accumulator Segment 0 Cell 1 Temperature"
-'ACC_SEG0_TEMPS_CELL2',"Accumulator Segment 0 Cell 2 Temperature"
-'ACC_SEG0_TEMPS_CELL3',"Accumulator Segment 0 Cell 3 Temperature"
-'ACC_SEG0_TEMPS_CELL4',"Accumulator Segment 0 Cell 4 Temperature"
-'ACC_SEG0_TEMPS_CELL5',"Accumulator Segment 0 Cell 5 Temperature"
-'ACC_SEG0_VOLTS_CELL0',"Accumulator Segment 0 Cell 0 Voltage"
-'ACC_SEG0_VOLTS_CELL1',"Accumulator Segment 0 Cell 1 Voltage"
-'ACC_SEG0_VOLTS_CELL2',"Accumulator Segment 0 Cell 2 Voltage"
-'ACC_SEG0_VOLTS_CELL3',"Accumulator Segment 0 Cell 3 Voltage"
-'ACC_SEG0_VOLTS_CELL4',"Accumulator Segment 0 Cell 4 Voltage"
-'ACC_SEG0_VOLTS_CELL5',"Accumulator Segment 0 Cell 5 Voltage"
-'ACC_SEG1_TEMPS_CELL0',"Accumulator Segment 1 Cell 0 Temperature"
-'ACC_SEG1_TEMPS_CELL1',"Accumulator Segment 1 Cell 1 Temperature"
-'ACC_SEG1_TEMPS_CELL2',"Accumulator Segment 1 Cell 2 Temperature"
-'ACC_SEG1_TEMPS_CELL3',"Accumulator Segment 1 Cell 3 Temperature"
-'ACC_SEG1_TEMPS_CELL4',"Accumulator Segment 1 Cell 4 Temperature"
-'ACC_SEG1_TEMPS_CELL5',"Accumulator Segment 1 Cell 5 Temperature"
-'ACC_SEG1_VOLTS_CELL0',"Accumulator Segment 1 Cell 0 Voltage"
-'ACC_SEG1_VOLTS_CELL1',"Accumulator Segment 1 Cell 1 Voltage"
-'ACC_SEG1_VOLTS_CELL2',"Accumulator Segment 1 Cell 2 Voltage"
-'ACC_SEG1_VOLTS_CELL3',"Accumulator Segment 1 Cell 3 Voltage"
-'ACC_SEG1_VOLTS_CELL4',"Accumulator Segment 1 Cell 4 Voltage"
-'ACC_SEG1_VOLTS_CELL5',"Accumulator Segment 1 Cell 5 Voltage"
-'ACC_SEG2_TEMPS_CELL0',"Accumulator Segment 2 Cell 0 Temperature"
-'ACC_SEG2_TEMPS_CELL1',"Accumulator Segment 2 Cell 1 Temperature"
-'ACC_SEG2_TEMPS_CELL2',"Accumulator Segment 2 Cell 2 Temperature"
-'ACC_SEG2_TEMPS_CELL3',"Accumulator Segment 2 Cell 3 Temperature"
-'ACC_SEG2_TEMPS_CELL4',"Accumulator Segment 2 Cell 4 Temperature"
-'ACC_SEG2_TEMPS_CELL5',"Accumulator Segment 2 Cell 5 Temperature"
-'ACC_SEG2_VOLTS_CELL0',"Accumulator Segment 2 Cell 0 Voltage"
-'ACC_SEG2_VOLTS_CELL1',"Accumulator Segment 2 Cell 1 Voltage"
-'ACC_SEG2_VOLTS_CELL2',"Accumulator Segment 2 Cell 2 Voltage"
-'ACC_SEG2_VOLTS_CELL3',"Accumulator Segment 2 Cell 3 Voltage"
-'ACC_SEG2_VOLTS_CELL4',"Accumulator Segment 2 Cell 4 Voltage"
-'ACC_SEG2_VOLTS_CELL5',"Accumulator Segment 2 Cell 5 Voltage"
-'ACC_SEG3_TEMPS_CELL0',"Accumulator Segment 3 Cell 0 Temperature"
-'ACC_SEG3_TEMPS_CELL1',"Accumulator Segment 3 Cell 1 Temperature"
-'ACC_SEG3_TEMPS_CELL2',"Accumulator Segment 3 Cell 2 Temperature"
-'ACC_SEG3_TEMPS_CELL3',"Accumulator Segment 3 Cell 3 Temperature"
-'ACC_SEG3_TEMPS_CELL4',"Accumulator Segment 3 Cell 4 Temperature"
-'ACC_SEG3_TEMPS_CELL5',"Accumulator Segment 3 Cell 5 Temperature"
-'ACC_SEG3_VOLTS_CELL0',"Accumulator Segment 3 Cell 0 Voltage"
-'ACC_SEG3_VOLTS_CELL1',"Accumulator Segment 3 Cell 1 Voltage"
-'ACC_SEG3_VOLTS_CELL2',"Accumulator Segment 3 Cell 2 Voltage"
-'ACC_SEG3_VOLTS_CELL3',"Accumulator Segment 3 Cell 3 Voltage"
-'ACC_SEG3_VOLTS_CELL4',"Accumulator Segment 3 Cell 4 Voltage"
-'ACC_SEG3_VOLTS_CELL5',"Accumulator Segment 3 Cell 5 Voltage"
-'ACC_SEG4_TEMPS_CELL0',"Accumulator Segment 4 Cell 0 Temperature"
-'ACC_SEG4_TEMPS_CELL1',"Accumulator Segment 4 Cell 1 Temperature"
-'ACC_SEG4_TEMPS_CELL2',"Accumulator Segment 4 Cell 2 Temperature"
-'ACC_SEG4_TEMPS_CELL3',"Accumulator Segment 4 Cell 3 Temperature"
-'ACC_SEG4_TEMPS_CELL4',"Accumulator Segment 4 Cell 4 Temperature"
-'ACC_SEG4_TEMPS_CELL5',"Accumulator Segment 4 Cell 5 Temperature"
-'ACC_SEG4_VOLTS_CELL0',"Accumulator Segment 4 Cell 0 Voltage"
-'ACC_SEG4_VOLTS_CELL1',"Accumulator Segment 4 Cell 1 Voltage"
-'ACC_SEG4_VOLTS_CELL2',"Accumulator Segment 4 Cell 2 Voltage"
-'ACC_SEG4_VOLTS_CELL3',"Accumulator Segment 4 Cell 3 Voltage"
-'ACC_SEG4_VOLTS_CELL4',"Accumulator Segment 4 Cell 4 Voltage"
-'ACC_SEG4_VOLTS_CELL5',"Accumulator Segment 4 Cell 5 Voltage"
-'ACC_STATUS_BALANCING',"Accumulator Status Balancing (1 = yes, 0 = no)"
-'ACC_STATUS_BMS_FAULT',"Accumulator Status BMS Fault (1 = yes, 0 = no)"
-'ACC_STATUS_CELL_FAULT_INDEX',"Accumulator Status Cell Fault Index (Internal usage)"
-'ACC_STATUS_CELL_TOO_HIGH',"Accumulator Status Cell Too High (1 = yes, 0 = no)"
-'ACC_STATUS_CELL_TOO_LOW',"Accumulator Status Cell Too Low (1 = yes, 0 = no)"
-'ACC_STATUS_CHARGING',"Accumulator Status Charging (1 = yes, 0 = no)"
-'ACC_STATUS_GLV_VOLTAGE',"Accumulator Status GLV Voltage (V"
-'ACC_STATUS_IMD_FAULT',"Accumulator Status IMD Fault (1 = yes, 0 = no)"
-'ACC_STATUS_PRECHARGE_DONE',"Accumulator Status Precharge Done (1 = yes, 0 = no)"
-'ACC_STATUS_PRECHARGING',"Accumulator Status Precharging (1 = yes, 0 = no)"
-'ACC_STATUS_SHUTDOWN_STATE',"Unknown"
-'ACC_STATUS_TEMP_TOO_HIGH',"Temperature in the accumulator is too high (1 = yes, 0 = no)"
-'ACC_STATUS_TEMP_TOO_HIGH_CRG',"Temperature in the accumulator is too high, while charging (1 = yes, 0 = no)"
-'ACC_STATUS_TEMP_TOO_LOW',"Temperature in the accumulator is too low (1 = yes, 0 = no)"
-'ETC_STATUS_BRAKELIGHT',"Whether or not the brakelight is turned on (1 = yes, 0 = no)"
-'ETC_STATUS_BRAKE_SENSE_VOLTAGE',"Voltage from the brake sensor scaled down (5->3.3)(V)"
-'ETC_STATUS_HE1',"Voltage reading from Hall Effect Sensor 1 (mV)"
-'ETC_STATUS_HE2',"Voltage reading from Hall Effect Sensor 2 (mV)"
-'ETC_STATUS_IMPLAUSIBILITY',"If there is an implausability (error) for throttle control (1 = yes, 0 = no)"
-'ETC_STATUS_PEDAL_TRAVEL',"Calculated pedal travel (0-100%)"
-'ETC_STATUS_REVERSE',"Whether in reverse mode (1 = yes, 0 = no)"
-'ETC_STATUS_RTD',"Whether ready to drive or not (1 = yes, 0 = no)"
-'ETC_STATUS_RTDS',"Signal for ready to drive sound"
-'ETC_STATUS_RTD_BUTTON',"Whether the button on the dash is presse to initialize ready to drive (1 = yes, 0 = no)"
-'ETC_STATUS_TS_ACTIVE',"Whether or not the ETC has enabled the tractive system yet (RTD sequence completed) (1 = yes, 0 = no)"
-'PDB_POWER_A_CURRENT_ACC',"Unused"
-'PDB_POWER_A_CURRENT_BPS',"Unused"
-'PDB_POWER_A_CURRENT_BSPD',"Unused"
-'PDB_POWER_A_CURRENT_ETC',"Unused"
-'PDB_POWER_A_CURRENT_SHUTDOWN',"Unused"
-'PDB_POWER_A_CURRENT_TRACTIVE',"Unused"
-'PDB_POWER_A_GLV_VOLTAGE',"Unused"
-'PDB_POWER_B_CURRENT_DASH',"Unused"
-'PDB_POWER_B_CURRENT_EXTRA_1',"Unused"
-'PDB_POWER_B_CURRENT_EXTRA_2',"Unused"
-'PDB_POWER_B_CURRENT_PDB',"Unused"
-'PDB_POWER_B_CURRENT_RTML',"Unused"
-'PDB_POWER_B_CURRENT_TELEMETRY',"Unused"
-'SME_CURRLIM_ChargeCurrentLim',"Current limit set by ETC board for the motor controller charge"
-'SME_CURRLIM_DischargeCurrentLim',"Current limit set by the ETC for the motor controller discharge"
-'SME_TEMP_BusCurrent',"Current measured by the motor controller in its 3 phases converted back to effective DC current (A)"
-'SME_TEMP_ControllerTemperature',"Temperature of the motor controller (°C)"
-'SME_TEMP_DC_Bus_V',"Voltage of the DC bus (V)"
-'SME_TEMP_FaultCode',"Fault code of the motor controller"
-'SME_TEMP_FaultLevel',"Fault level of the motor controller (1-4 with 4 being the lowest severity)"
-'SME_TEMP_MotorTemperature',"Temperature of the motor (°C)"
-'SME_THROTL_Forward',"Whether to move forward or not (1 = yes, 0 = no)"
-'SME_THROTL_MBB_Alive',"Signal regularly sent by ETC to maintain active state"
-'SME_THROTL_MaxSpeed',"Unknown"
-'SME_THROTL_PowerReady',"Unknown"
-'SME_THROTL_Reverse',"Whether to move in reverse or not (1 = yes, 0 = no)"
-'SME_THROTL_TorqueDemand',"Torque demand sent by ETC to motor controller (0-32000 corresponds to 0-180Nm)"
-'SME_TRQSPD_Controller_Overtermp',"Whether the motor controller is overheated (1 = yes, 0 = no)"
-'SME_TRQSPD_Forward',"Unknown"
-'SME_TRQSPD_Hydraulic',"Unknown"
-'SME_TRQSPD_Key_switch_overvolt',"Unknown"
-'SME_TRQSPD_Key_switch_undervolt',"Unknown"
-'SME_TRQSPD_MotorFlags',"Unknown"
-'SME_TRQSPD_Park_Brake',"Unknown"
-'SME_TRQSPD_Pedal_Brake',"Unknown"
-'SME_TRQSPD_Powering_Enabled',"Unknown"
-'SME_TRQSPD_Powering_Ready',"Unknown"
-'SME_TRQSPD_Precharging',"Unknown"
-'SME_TRQSPD_Reverse',"Unknown"
-'SME_TRQSPD_Running',"Unknown"
-'SME_TRQSPD_SOC_Low_Hydraulic',"Unknown"
-'SME_TRQSPD_SOC_Low_Traction',"Unknown"
-'SME_TRQSPD_Speed',"RPM of the motor (RPM)"
-'SME_TRQSPD_Torque',"Unsure? Potentially % of max torque or maybe % of desired torque actually achieved. (0-100)"
-'SME_TRQSPD_Traction',"Unknown"
-'SME_TRQSPD_contactor_closed',"Unknown"
-'TPERIPH_BL_DATA_SIDE_TIRE_TEMP',"Back left side tire temp. Not implemented."
-'TPERIPH_BL_DATA_STRAIN',"Back left strain gauge value. Not implemented."
-'TPERIPH_BL_DATA_SUSTRAVEL',"Back left suspension travel. (mm)"
-'TPERIPH_BL_DATA_WHEELSPEED',"Back left wheel speed. Currently (0-32767 but goal is to make it RPM)"
-'TPERIPH_BL_TIRETEMP_1',"Back left lateral tire temp channel 1 (°C)"
-'TPERIPH_BL_TIRETEMP_2',"Back left lateral tire temp channel 2 (°C)"
-'TPERIPH_BL_TIRETEMP_3',"Back left lateral tire temp channel 3 (°C)"
-'TPERIPH_BL_TIRETEMP_4',"Back left lateral tire temp channel 4 (°C)"
-'TPERIPH_BL_TIRETEMP_5',"Back left lateral tire temp channel 5 (°C)"
-'TPERIPH_BL_TIRETEMP_6',"Back left lateral tire temp channel 6 (°C)"
-'TPERIPH_BL_TIRETEMP_7',"Back left lateral tire temp channel 7 (°C)"
-'TPERIPH_BL_TIRETEMP_8',"Back left lateral tire temp channel 8 (°C)"
-'TPERIPH_BR_DATA_SIDE_TIRE_TEMP',"Back right side tire temp. Not implemented."
-'TPERIPH_BR_DATA_STRAIN',"Back right strain gauge value. Not implemented."
-'TPERIPH_BR_DATA_SUSTRAVEL',"Back right suspension travel. (mm)"
-'TPERIPH_BR_DATA_WHEELSPEED',"Back right wheel speed. Currently (0-32767 but goal is to make it RPM)"
-'TPERIPH_FL_DATA_SIDE_TIRE_TEMP',"Front left side tire temp. Not implemented."
-'TPERIPH_FL_DATA_STRAIN',"Front left strain gauge value. Not implemented."
-'TPERIPH_FL_DATA_SUSTRAVEL',"Front left suspension travel. (mm)"
-'TPERIPH_FL_DATA_WHEELSPEED',"Front left wheel speed. Currently (0-32767 but goal is to make it RPM)"
-'TPERIPH_FL_TIRETEMP_1',"Front left lateral tire temp channel 1 (°C)"
-'TPERIPH_FL_TIRETEMP_2',"Front left lateral tire temp channel 2 (°C)"
-'TPERIPH_FL_TIRETEMP_3',"Front left lateral tire temp channel 3 (°C)"
-'TPERIPH_FL_TIRETEMP_4',"Front left lateral tire temp channel 4 (°C)"
-'TPERIPH_FL_TIRETEMP_5',"Front left lateral tire temp channel 5 (°C)"
-'TPERIPH_FL_TIRETEMP_6',"Front left lateral tire temp channel 6 (°C)"
-'TPERIPH_FL_TIRETEMP_7',"Front left lateral tire temp channel 7 (°C)"
-'TPERIPH_FL_TIRETEMP_8',"Front left lateral tire temp channel 8 (°C)"
-'TPERIPH_FR_DATA_SIDE_TIRE_TEMP',"Front right side tire temp. Not implemented."
-'TPERIPH_FR_DATA_STRAIN',"Front right strain gauge value. Not implemented."
-'TPERIPH_FR_DATA_SUSTRAVEL',"Front right suspension travel. (mm)"
-'TPERIPH_FR_DATA_WHEELSPEED',"Front right wheel speed. Currently (0-32767 but goal is to make it RPM)"
-'VDM_GPS_ALTITUDE',"GPS altitude (m)"
-'VDM_GPS_Latitude',"GPS latitude (°)"
-'VDM_GPS_Longitude',"GPS longitude (°)"
-'VDM_GPS_SATELLITES_IN_USE',"GPS satellites in use"
-'VDM_GPS_SPEED',"GPS speed (mph)"
-'VDM_GPS_TRUE_COURSE',"GPS true course (°)"
-'VDM_GPS_VALID1',"GPS validity 1"
-'VDM_GPS_VALID2',"GPS validity 2"
-'VDM_UTC_DATE_DAY',"UTC date day"
-'VDM_UTC_DATE_MONTH',"UTC date month"
-'VDM_UTC_DATE_YEAR',"UTC date year"
-'VDM_UTC_TIME_HOURS',"UTC time hours"
-'VDM_UTC_TIME_MINUTES',"UTC time minutes"
-'VDM_UTC_TIME_SECONDS',"UTC time seconds"
-'VDM_X_AXIS_ACCELERATION',"X axis acceleration (Gs)"
-'VDM_X_AXIS_YAW_RATE',"X axis yaw rate (°/s)"
-'VDM_Y_AXIS_ACCELERATION',"Y axis acceleration (Gs)"
-'VDM_Y_AXIS_YAW_RATE',"Y axis yaw rate (°/s)"
-'VDM_Z_AXIS_ACCELERATION',"Z axis acceleration (Gs)"
-'VDM_Z_AXIS_YAW_RATE',"Z axis yaw rate (°/s)"
-'timestamp',"ms since start"
-'IZZE_BRAKETEMP_S1_CH1","Brake Temp Channel 1 (°C)"
-'IZZE_BRAKETEMP_S1_CH2","Brake Temp CChannel 2 (°C)"
-'IZZE_BRAKETEMP_S1_CH3","Brake Temp CChannel 3 (°C)"
-'IZZE_BRAKETEMP_S1_CH4","Brake Temp Channel 4 (°C)"
-'IZZE_BRAKETEMP_S1_CH5","Brake Temp Channel 5 (°C)"
-'IZZE_BRAKETEMP_S1_CH6","Brake Temp Channel 6 (°C)"
-'IZZE_BRAKETEMP_S1_CH7","Brake Temp CChannel 7 (°C)"
-'IZZE_BRAKETEMP_S1_CH8","Brake Temp CChannel 8 (°C)"
-'IZZE_BRAKETEMP_S1_CH9","Brake Temp Channel 9 (°C)"
-'IZZE_BRAKETEMP_S1_CH10","Brake Temp Channel 10 (°C)"
-'IZZE_BRAKETEMP_S1_CH11","Brake Temp Channel 11 (°C)"
-'IZZE_BRAKETEMP_S1_CH12","Brake Temp Channel 12 (°C)"
-'IZZE_BRAKETEMP_S1_CH13","Brake Temp Channel 13 (°C)"
-'IZZE_BRAKETEMP_S1_CH14","Brake Temp Channel 14 (°C)"
-'IZZE_BRAKETEMP_S1_CH15","Brake Temp Channel 15 (°C)"
-'IZZE_BRAKETEMP_S1_CH16","Brake Temp Channel 16 (°C)"
+"ACC_POWER_CURRENT","Current as measured by the accumulator current sensor (A)"
+"ACC_POWER_PACK_VOLTAGE","Voltage as measured by the accumulator BMS (V)"
+"ACC_POWER_SOC","SOC as estimated by the accumulator firmware (% charge)"
+"ACC_SEG0_TEMPS_CELL0","Accumulator Segment 0 Cell 0 Temperature"
+"ACC_SEG0_TEMPS_CELL1","Accumulator Segment 0 Cell 1 Temperature"
+"ACC_SEG0_TEMPS_CELL2","Accumulator Segment 0 Cell 2 Temperature"
+"ACC_SEG0_TEMPS_CELL3","Accumulator Segment 0 Cell 3 Temperature"
+"ACC_SEG0_TEMPS_CELL4","Accumulator Segment 0 Cell 4 Temperature"
+"ACC_SEG0_TEMPS_CELL5","Accumulator Segment 0 Cell 5 Temperature"
+"ACC_SEG0_VOLTS_CELL0","Accumulator Segment 0 Cell 0 Voltage"
+"ACC_SEG0_VOLTS_CELL1","Accumulator Segment 0 Cell 1 Voltage"
+"ACC_SEG0_VOLTS_CELL2","Accumulator Segment 0 Cell 2 Voltage"
+"ACC_SEG0_VOLTS_CELL3","Accumulator Segment 0 Cell 3 Voltage"
+"ACC_SEG0_VOLTS_CELL4","Accumulator Segment 0 Cell 4 Voltage"
+"ACC_SEG0_VOLTS_CELL5","Accumulator Segment 0 Cell 5 Voltage"
+"ACC_SEG1_TEMPS_CELL0","Accumulator Segment 1 Cell 0 Temperature"
+"ACC_SEG1_TEMPS_CELL1","Accumulator Segment 1 Cell 1 Temperature"
+"ACC_SEG1_TEMPS_CELL2","Accumulator Segment 1 Cell 2 Temperature"
+"ACC_SEG1_TEMPS_CELL3","Accumulator Segment 1 Cell 3 Temperature"
+"ACC_SEG1_TEMPS_CELL4","Accumulator Segment 1 Cell 4 Temperature"
+"ACC_SEG1_TEMPS_CELL5","Accumulator Segment 1 Cell 5 Temperature"
+"ACC_SEG1_VOLTS_CELL0","Accumulator Segment 1 Cell 0 Voltage"
+"ACC_SEG1_VOLTS_CELL1","Accumulator Segment 1 Cell 1 Voltage"
+"ACC_SEG1_VOLTS_CELL2","Accumulator Segment 1 Cell 2 Voltage"
+"ACC_SEG1_VOLTS_CELL3","Accumulator Segment 1 Cell 3 Voltage"
+"ACC_SEG1_VOLTS_CELL4","Accumulator Segment 1 Cell 4 Voltage"
+"ACC_SEG1_VOLTS_CELL5","Accumulator Segment 1 Cell 5 Voltage"
+"ACC_SEG2_TEMPS_CELL0","Accumulator Segment 2 Cell 0 Temperature"
+"ACC_SEG2_TEMPS_CELL1","Accumulator Segment 2 Cell 1 Temperature"
+"ACC_SEG2_TEMPS_CELL2","Accumulator Segment 2 Cell 2 Temperature"
+"ACC_SEG2_TEMPS_CELL3","Accumulator Segment 2 Cell 3 Temperature"
+"ACC_SEG2_TEMPS_CELL4","Accumulator Segment 2 Cell 4 Temperature"
+"ACC_SEG2_TEMPS_CELL5","Accumulator Segment 2 Cell 5 Temperature"
+"ACC_SEG2_VOLTS_CELL0","Accumulator Segment 2 Cell 0 Voltage"
+"ACC_SEG2_VOLTS_CELL1","Accumulator Segment 2 Cell 1 Voltage"
+"ACC_SEG2_VOLTS_CELL2","Accumulator Segment 2 Cell 2 Voltage"
+"ACC_SEG2_VOLTS_CELL3","Accumulator Segment 2 Cell 3 Voltage"
+"ACC_SEG2_VOLTS_CELL4","Accumulator Segment 2 Cell 4 Voltage"
+"ACC_SEG2_VOLTS_CELL5","Accumulator Segment 2 Cell 5 Voltage"
+"ACC_SEG3_TEMPS_CELL0","Accumulator Segment 3 Cell 0 Temperature"
+"ACC_SEG3_TEMPS_CELL1","Accumulator Segment 3 Cell 1 Temperature"
+"ACC_SEG3_TEMPS_CELL2","Accumulator Segment 3 Cell 2 Temperature"
+"ACC_SEG3_TEMPS_CELL3","Accumulator Segment 3 Cell 3 Temperature"
+"ACC_SEG3_TEMPS_CELL4","Accumulator Segment 3 Cell 4 Temperature"
+"ACC_SEG3_TEMPS_CELL5","Accumulator Segment 3 Cell 5 Temperature"
+"ACC_SEG3_VOLTS_CELL0","Accumulator Segment 3 Cell 0 Voltage"
+"ACC_SEG3_VOLTS_CELL1","Accumulator Segment 3 Cell 1 Voltage"
+"ACC_SEG3_VOLTS_CELL2","Accumulator Segment 3 Cell 2 Voltage"
+"ACC_SEG3_VOLTS_CELL3","Accumulator Segment 3 Cell 3 Voltage"
+"ACC_SEG3_VOLTS_CELL4","Accumulator Segment 3 Cell 4 Voltage"
+"ACC_SEG3_VOLTS_CELL5","Accumulator Segment 3 Cell 5 Voltage"
+"ACC_SEG4_TEMPS_CELL0","Accumulator Segment 4 Cell 0 Temperature"
+"ACC_SEG4_TEMPS_CELL1","Accumulator Segment 4 Cell 1 Temperature"
+"ACC_SEG4_TEMPS_CELL2","Accumulator Segment 4 Cell 2 Temperature"
+"ACC_SEG4_TEMPS_CELL3","Accumulator Segment 4 Cell 3 Temperature"
+"ACC_SEG4_TEMPS_CELL4","Accumulator Segment 4 Cell 4 Temperature"
+"ACC_SEG4_TEMPS_CELL5","Accumulator Segment 4 Cell 5 Temperature"
+"ACC_SEG4_VOLTS_CELL0","Accumulator Segment 4 Cell 0 Voltage"
+"ACC_SEG4_VOLTS_CELL1","Accumulator Segment 4 Cell 1 Voltage"
+"ACC_SEG4_VOLTS_CELL2","Accumulator Segment 4 Cell 2 Voltage"
+"ACC_SEG4_VOLTS_CELL3","Accumulator Segment 4 Cell 3 Voltage"
+"ACC_SEG4_VOLTS_CELL4","Accumulator Segment 4 Cell 4 Voltage"
+"ACC_SEG4_VOLTS_CELL5","Accumulator Segment 4 Cell 5 Voltage"
+"ACC_STATUS_BALANCING","Accumulator Status Balancing (1 = yes, 0 = no)"
+"ACC_STATUS_BMS_FAULT","Accumulator Status BMS Fault (1 = yes, 0 = no)"
+"ACC_STATUS_CELL_FAULT_INDEX","Accumulator Status Cell Fault Index (Internal usage)"
+"ACC_STATUS_CELL_TOO_HIGH","Accumulator Status Cell Too High (1 = yes, 0 = no)"
+"ACC_STATUS_CELL_TOO_LOW","Accumulator Status Cell Too Low (1 = yes, 0 = no)"
+"ACC_STATUS_CHARGING","Accumulator Status Charging (1 = yes, 0 = no)"
+"ACC_STATUS_GLV_VOLTAGE","Accumulator Status GLV Voltage (V"
+"ACC_STATUS_IMD_FAULT","Accumulator Status IMD Fault (1 = yes, 0 = no)"
+"ACC_STATUS_PRECHARGE_DONE","Accumulator Status Precharge Done (1 = yes, 0 = no)"
+"ACC_STATUS_PRECHARGING","Accumulator Status Precharging (1 = yes, 0 = no)"
+"ACC_STATUS_SHUTDOWN_STATE","Unknown"
+"ACC_STATUS_TEMP_TOO_HIGH","Temperature in the accumulator is too high (1 = yes, 0 = no)"
+"ACC_STATUS_TEMP_TOO_HIGH_CRG","Temperature in the accumulator is too high, while charging (1 = yes, 0 = no)"
+"ACC_STATUS_TEMP_TOO_LOW","Temperature in the accumulator is too low (1 = yes, 0 = no)"
+"ETC_STATUS_BRAKELIGHT","Whether or not the brakelight is turned on (1 = yes, 0 = no)"
+"ETC_STATUS_BRAKE_SENSE_VOLTAGE","Voltage from the brake sensor scaled down (5->3.3)(V)"
+"ETC_STATUS_HE1","Voltage reading from Hall Effect Sensor 1 (mV)"
+"ETC_STATUS_HE2","Voltage reading from Hall Effect Sensor 2 (mV)"
+"ETC_STATUS_IMPLAUSIBILITY","If there is an implausability (error) for throttle control (1 = yes, 0 = no)"
+"ETC_STATUS_PEDAL_TRAVEL","Calculated pedal travel (0-100%)"
+"ETC_STATUS_REVERSE","Whether in reverse mode (1 = yes, 0 = no)"
+"ETC_STATUS_RTD","Whether ready to drive or not (1 = yes, 0 = no)"
+"ETC_STATUS_RTDS","Signal for ready to drive sound"
+"ETC_STATUS_RTD_BUTTON","Whether the button on the dash is presse to initialize ready to drive (1 = yes, 0 = no)"
+"ETC_STATUS_TS_ACTIVE","Whether or not the ETC has enabled the tractive system yet (RTD sequence completed) (1 = yes, 0 = no)"
+"PDB_POWER_A_CURRENT_ACC","Unused"
+"PDB_POWER_A_CURRENT_BPS","Unused"
+"PDB_POWER_A_CURRENT_BSPD","Unused"
+"PDB_POWER_A_CURRENT_ETC","Unused"
+"PDB_POWER_A_CURRENT_SHUTDOWN","Unused"
+"PDB_POWER_A_CURRENT_TRACTIVE","Unused"
+"PDB_POWER_A_GLV_VOLTAGE","Unused"
+"PDB_POWER_B_CURRENT_DASH","Unused"
+"PDB_POWER_B_CURRENT_EXTRA_1","Unused"
+"PDB_POWER_B_CURRENT_EXTRA_2","Unused"
+"PDB_POWER_B_CURRENT_PDB","Unused"
+"PDB_POWER_B_CURRENT_RTML","Unused"
+"PDB_POWER_B_CURRENT_TELEMETRY","Unused"
+"SME_CURRLIM_ChargeCurrentLim","Current limit set by ETC board for the motor controller charge"
+"SME_CURRLIM_DischargeCurrentLim","Current limit set by the ETC for the motor controller discharge"
+"SME_TEMP_BusCurrent","Current measured by the motor controller in its 3 phases converted back to effective DC current (A)"
+"SME_TEMP_ControllerTemperature","Temperature of the motor controller (°C)"
+"SME_TEMP_DC_Bus_V","Voltage of the DC bus (V)"
+"SME_TEMP_FaultCode","Fault code of the motor controller"
+"SME_TEMP_FaultLevel","Fault level of the motor controller (1-4 with 4 being the lowest severity)"
+"SME_TEMP_MotorTemperature","Temperature of the motor (°C)"
+"SME_THROTL_Forward","Whether to move forward or not (1 = yes, 0 = no)"
+"SME_THROTL_MBB_Alive","Signal regularly sent by ETC to maintain active state"
+"SME_THROTL_MaxSpeed","Unknown"
+"SME_THROTL_PowerReady","Unknown"
+"SME_THROTL_Reverse","Whether to move in reverse or not (1 = yes, 0 = no)"
+"SME_THROTL_TorqueDemand","Torque demand sent by ETC to motor controller (0-32000 corresponds to 0-180Nm)"
+"SME_TRQSPD_Controller_Overtermp","Whether the motor controller is overheated (1 = yes, 0 = no)"
+"SME_TRQSPD_Forward","Unknown"
+"SME_TRQSPD_Hydraulic","Unknown"
+"SME_TRQSPD_Key_switch_overvolt","Unknown"
+"SME_TRQSPD_Key_switch_undervolt","Unknown"
+"SME_TRQSPD_MotorFlags","Unknown"
+"SME_TRQSPD_Park_Brake","Unknown"
+"SME_TRQSPD_Pedal_Brake","Unknown"
+"SME_TRQSPD_Powering_Enabled","Unknown"
+"SME_TRQSPD_Powering_Ready","Unknown"
+"SME_TRQSPD_Precharging","Unknown"
+"SME_TRQSPD_Reverse","Unknown"
+"SME_TRQSPD_Running","Unknown"
+"SME_TRQSPD_SOC_Low_Hydraulic","Unknown"
+"SME_TRQSPD_SOC_Low_Traction","Unknown"
+"SME_TRQSPD_Speed","RPM of the motor (RPM)"
+"SME_TRQSPD_Torque","Unsure? Potentially % of max torque or maybe % of desired torque actually achieved. (0-100)"
+"SME_TRQSPD_Traction","Unknown"
+"SME_TRQSPD_contactor_closed","Unknown"
+"TPERIPH_BL_DATA_SIDE_TIRE_TEMP","Back left side tire temp. Not implemented."
+"TPERIPH_BL_DATA_STRAIN","Back left strain gauge value. Not implemented."
+"TPERIPH_BL_DATA_SUSTRAVEL","Back left suspension travel. (mm)"
+"TPERIPH_BL_DATA_WHEELSPEED","Back left wheel speed. Currently (0-32767 but goal is to make it RPM)"
+"TPERIPH_BL_TIRETEMP_1","Back left lateral tire temp channel 1 (°C)"
+"TPERIPH_BL_TIRETEMP_2","Back left lateral tire temp channel 2 (°C)"
+"TPERIPH_BL_TIRETEMP_3","Back left lateral tire temp channel 3 (°C)"
+"TPERIPH_BL_TIRETEMP_4","Back left lateral tire temp channel 4 (°C)"
+"TPERIPH_BL_TIRETEMP_5","Back left lateral tire temp channel 5 (°C)"
+"TPERIPH_BL_TIRETEMP_6","Back left lateral tire temp channel 6 (°C)"
+"TPERIPH_BL_TIRETEMP_7","Back left lateral tire temp channel 7 (°C)"
+"TPERIPH_BL_TIRETEMP_8","Back left lateral tire temp channel 8 (°C)"
+"TPERIPH_BR_DATA_SIDE_TIRE_TEMP","Back right side tire temp. Not implemented."
+"TPERIPH_BR_DATA_STRAIN","Back right strain gauge value. Not implemented."
+"TPERIPH_BR_DATA_SUSTRAVEL","Back right suspension travel. (mm)"
+"TPERIPH_BR_DATA_WHEELSPEED","Back right wheel speed. Currently (0-32767 but goal is to make it RPM)"
+"TPERIPH_FL_DATA_SIDE_TIRE_TEMP","Front left side tire temp. Not implemented."
+"TPERIPH_FL_DATA_STRAIN","Front left strain gauge value. Not implemented."
+"TPERIPH_FL_DATA_SUSTRAVEL","Front left suspension travel. (mm)"
+"TPERIPH_FL_DATA_WHEELSPEED","Front left wheel speed. Currently (0-32767 but goal is to make it RPM)"
+"TPERIPH_FL_TIRETEMP_1","Front left lateral tire temp channel 1 (°C)"
+"TPERIPH_FL_TIRETEMP_2","Front left lateral tire temp channel 2 (°C)"
+"TPERIPH_FL_TIRETEMP_3","Front left lateral tire temp channel 3 (°C)"
+"TPERIPH_FL_TIRETEMP_4","Front left lateral tire temp channel 4 (°C)"
+"TPERIPH_FL_TIRETEMP_5","Front left lateral tire temp channel 5 (°C)"
+"TPERIPH_FL_TIRETEMP_6","Front left lateral tire temp channel 6 (°C)"
+"TPERIPH_FL_TIRETEMP_7","Front left lateral tire temp channel 7 (°C)"
+"TPERIPH_FL_TIRETEMP_8","Front left lateral tire temp channel 8 (°C)"
+"TPERIPH_FR_DATA_SIDE_TIRE_TEMP","Front right side tire temp. Not implemented."
+"TPERIPH_FR_DATA_STRAIN","Front right strain gauge value. Not implemented."
+"TPERIPH_FR_DATA_SUSTRAVEL","Front right suspension travel. (mm)"
+"TPERIPH_FR_DATA_WHEELSPEED","Front right wheel speed. Currently (0-32767 but goal is to make it RPM)"
+"VDM_GPS_ALTITUDE","GPS altitude (m)"
+"VDM_GPS_Latitude","GPS latitude (°)"
+"VDM_GPS_Longitude","GPS longitude (°)"
+"VDM_GPS_SATELLITES_IN_USE","GPS satellites in use"
+"VDM_GPS_SPEED","GPS speed (mph)"
+"VDM_GPS_TRUE_COURSE","GPS true course (°)"
+"VDM_GPS_VALID1","GPS validity 1"
+"VDM_GPS_VALID2","GPS validity 2"
+"VDM_UTC_DATE_DAY","UTC date day"
+"VDM_UTC_DATE_MONTH","UTC date month"
+"VDM_UTC_DATE_YEAR","UTC date year"
+"VDM_UTC_TIME_HOURS","UTC time hours"
+"VDM_UTC_TIME_MINUTES","UTC time minutes"
+"VDM_UTC_TIME_SECONDS","UTC time seconds"
+"VDM_X_AXIS_ACCELERATION","X axis acceleration (Gs)"
+"VDM_X_AXIS_YAW_RATE","X axis yaw rate (°/s)"
+"VDM_Y_AXIS_ACCELERATION","Y axis acceleration (Gs)"
+"VDM_Y_AXIS_YAW_RATE","Y axis yaw rate (°/s)"
+"VDM_Z_AXIS_ACCELERATION","Z axis acceleration (Gs)"
+"VDM_Z_AXIS_YAW_RATE","Z axis yaw rate (°/s)"
+"timestamp","ms since start"
+"IZZE_BRAKETEMP_S1_CH1","Brake Temp Channel 1 (°C)"
+"IZZE_BRAKETEMP_S1_CH2","Brake Temp CChannel 2 (°C)"
+"IZZE_BRAKETEMP_S1_CH3","Brake Temp CChannel 3 (°C)"
+"IZZE_BRAKETEMP_S1_CH4","Brake Temp Channel 4 (°C)"
+"IZZE_BRAKETEMP_S1_CH5","Brake Temp Channel 5 (°C)"
+"IZZE_BRAKETEMP_S1_CH6","Brake Temp Channel 6 (°C)"
+"IZZE_BRAKETEMP_S1_CH7","Brake Temp CChannel 7 (°C)"
+"IZZE_BRAKETEMP_S1_CH8","Brake Temp CChannel 8 (°C)"
+"IZZE_BRAKETEMP_S1_CH9","Brake Temp Channel 9 (°C)"
+"IZZE_BRAKETEMP_S1_CH10","Brake Temp Channel 10 (°C)"
+"IZZE_BRAKETEMP_S1_CH11","Brake Temp Channel 11 (°C)"
+"IZZE_BRAKETEMP_S1_CH12","Brake Temp Channel 12 (°C)"
+"IZZE_BRAKETEMP_S1_CH13","Brake Temp Channel 13 (°C)"
+"IZZE_BRAKETEMP_S1_CH14","Brake Temp Channel 14 (°C)"
+"IZZE_BRAKETEMP_S1_CH15","Brake Temp Channel 15 (°C)"
+"IZZE_BRAKETEMP_S1_CH16","Brake Temp Channel 16 (°C)"
 "IZZE_BRAKETEMP_S1_STEMP", "Brake Sensor Temperature (°C)"
-'ACC_TRAY_TEMPS_BOLTED_CONNECTION', "Temperature at the bolted connection of the accumulator tray (°C)"
-'ACC_TRAY_TEMPS_BUSBAR', "Temperature at the busbar of the accumulator tray (°C)"
-'ACC_TRAY_TEMPS_PACK_FUSE', "Temperature at the pack fuse of the accumulator tray (°C)"
-'ACC_TRAY_TEMPS_COWLING', "Temperature at the cowling of the accumulator tray (°C)"
-'ACC_TRAY_TEMPS_INTAKE', "Temperature at the intake of the accumulator tray (°C)"
\ No newline at end of file
+"ACC_TRAY_TEMPS_BOLTED_CONNECTION", "Temperature at the bolted connection of the accumulator tray (°C)"
+"ACC_TRAY_TEMPS_BUSBAR", "Temperature at the busbar of the accumulator tray (°C)"
+"ACC_TRAY_TEMPS_PACK_FUSE", "Temperature at the pack fuse of the accumulator tray (°C)"
+"ACC_TRAY_TEMPS_COWLING", "Temperature at the cowling of the accumulator tray (°C)"
+"ACC_TRAY_TEMPS_INTAKE", "Temperature at the intake of the accumulator tray (°C)"
diff --git a/Docs/Testing Plan Documentation/drag_test.md b/Docs/Testing Plan Documentation/drag_test.md
new file mode 100644
index 0000000..8ee9245
--- /dev/null
+++ b/Docs/Testing Plan Documentation/drag_test.md	
@@ -0,0 +1,7 @@
+## Drag Test
+1) Accelerate the car to three different given speeds (45 mph, 55 mph, 65 mph)
+2) Release the accelerator and let the car roll ("neutral gear")
+3) Wait for the car to stop
+
+If the car is allowed to coast, we can measure the change in speed over time and attribute linear losses to rolling resistance and quadratic losses to drag.
+If you fit an equation ax + bx^2 to your estimated force on the car, a is your rolling resistance coefficient and b is the product of all the coefficients in drag (air density, cross sectional area, and drag coeff.)
\ No newline at end of file
diff --git a/FullVehicleSim/Electrical/powertrain.py b/FullVehicleSim/Electrical/powertrain.py
index 4487971..ec80c30 100644
--- a/FullVehicleSim/Electrical/powertrain.py
+++ b/FullVehicleSim/Electrical/powertrain.py
@@ -1,7 +1,9 @@
 import numpy as np
+from numpy.typing import NDArray
 from paramLoader import *
 
-def calcMaxMotorTorque(worldArray:np.ndarray, step:int, resistiveForces:float, maxPower:float, maxTractionTorqueAtWheel:float):
+def calcMaxMotorTorque(worldArray:NDArray[np.float64], step:int, resistiveForces:np.float64, maxPower:np.float64, maxTractionTorqueAtWheel:np.float64) \
+    -> np.float64:
         '''
         Motor Torque at the wheel
         
@@ -17,28 +19,33 @@ def calcMaxMotorTorque(worldArray:np.ndarray, step:int, resistiveForces:float, m
         torque = min(Parameters["maxTorque"], maxPowerTorque, 2*maxTractionTorqueAtWheel/Parameters["gearRatio"])
         return torque
 
-def calcCurrent(power:float, voltage:float) -> float:
+def calcCurrent(power:np.float64, voltage:np.float64) \
+    -> np.float64:
         if (power / voltage) > Parameters["tractiveIMax"]:
             return Parameters["tractiveIMax"]
         return power / voltage
 
-def calcMaxWheelTorque(maxMotorTorque):
+def calcMaxWheelTorque(maxMotorTorque:np.float64) \
+    -> np.float64:
         '''
         maxMotorTorque * gear ratio
         '''
         return maxMotorTorque * Parameters["gearRatio"]
 
-def calcMotorForce(motorTorque:float) -> float:
+def calcMotorForce(motorTorque:np.float64) \
+    -> np.float64:
         return (motorTorque * Parameters["gearRatio"] / Parameters["wheelRadius"])
 
-def calcMaxPower(voltage:float) -> float:
+def calcMaxPower(voltage:np.float64) \
+    -> np.float64:
         return Parameters["tractiveIMax"] * voltage
 
 
-def calcVoltage(worldArray:np.ndarray, step:int) -> float:
+def calcVoltage(worldArray:NDArray[np.float64], step:int) \
+    -> np.float64:
 
-    F = Parameters["FaradaysConstant"]
-    R = Parameters["GasConstant"]
+    F = Parameters["faradaysConstant"]
+    R = Parameters["gasConstant"]
     
     V0 = Magic["cellModel_V0"]
     C1 = Magic["cellModel_C1"]
diff --git a/FullVehicleSim/Mech/aero.py b/FullVehicleSim/Mech/aero.py
index 6b5ecbc..f13b580 100644
--- a/FullVehicleSim/Mech/aero.py
+++ b/FullVehicleSim/Mech/aero.py
@@ -1,8 +1,10 @@
 import numpy as np
+from numpy.typing import NDArray
 from paramLoader import *
 
-def calcDrag(worldArray:np.ndarray, step:int) -> float:
+def calcDrag(worldArray:NDArray[np.float64], step:int) -> np.float64:
     return  0.5 * Parameters["airDensity"] * Parameters["dragCoeffAreaCombo"] * worldArray[step-1, varSpeed]**2
 
-def calcDownForce(worldArray:np.ndarray, step:int) -> np.ndarray:
-    return np.asarray([0,0,0,0], dtype=float)
+#TODO: Implement downforce model. Could be lookup table based or physics based.
+def calcDownForce(worldArray:NDArray[np.float64], step:int) -> NDArray[np.float64]:
+    return np.asarray([0,0,0,0], dtype=np.float64)
diff --git a/FullVehicleSim/Mech/braking.py b/FullVehicleSim/Mech/braking.py
index 0f2dea0..f0f39a0 100644
--- a/FullVehicleSim/Mech/braking.py
+++ b/FullVehicleSim/Mech/braking.py
@@ -1,26 +1,28 @@
 from Mech import brakepadFrictionModel
 from paramLoader import *
 import numpy as np
+from numpy.typing import NDArray
 import polars as pl
 # Docs:
 # https://docs.google.com/document/d/1oGsGDnY0DEKWpE3S6481A9yZ0F9qUEwWkSXJwTSz4E4/edit?tab=t.2rmbsj26c7w
 # The goal of these functions are to calculate the net force on the brakes, applied reverse to heading
 
+brakeThermalTransferDataPath = "Mech/brakeThermalTransfer.csv"
 try:
-    brakeConvectionData = pl.read_csv("Mech/brakeThermalTransfer.csv")
+    brakeConvectionData = pl.read_csv(brakeThermalTransferDataPath)
 except Exception as e:
-    print("Error loading brake thermal transfer data from Mech/brakeThermalTransfer.csv:", e)
+    print(f"Error loading brake thermal transfer data from {brakeThermalTransferDataPath}:", e)
     raise e
 brakeAirSpeedData, brakeCoeffData = brakeConvectionData["airSpeed"].to_numpy(), brakeConvectionData["coeff"].to_numpy()
 
-def brakeTransferCoeff(speed:float) -> float:
+def brakeTransferCoeff(speed:np.float64) -> np.float64:
     # Interpolate the heat transfer coefficient based on air speed
     return np.interp(speed, brakeAirSpeedData, brakeCoeffData) #type: ignore Function says it returns an array but it just returns a scalar
 
-def brakePSI_toNewtons(psi:float) -> float:
+def brakePSI_toNewtons(psi:np.float64) -> np.float64:
     return psi * Parameters["brakeCaliperArea"] * 2 * 4.448222 # lb force to Newtons, 2 for 2 sides of a caliper per disc
 
-def calcBrakeForce(worldArray:np.ndarray, step:int) -> tuple[float,float]:
+def calcBrakeForce(worldArray:NDArray[np.float64], step:int) -> tuple[np.float64,np.float64]:
     """
     Calculate the brake force.
 
@@ -30,46 +32,56 @@ def calcBrakeForce(worldArray:np.ndarray, step:int) -> tuple[float,float]:
     :param step: Current step index
     :return: Brake Force
     """
-    frontBrakePSI = worldArray[step, varBrakePressureFront]
-    rearBrakePSI = worldArray[step, varBrakePressureRear]
-    frontBrakeForce = brakePSI_toNewtons(frontBrakePSI)
-    rearBrakeForce = brakePSI_toNewtons(rearBrakePSI)
+    frontBrakePSI:np.float64 = worldArray[step, varBrakePressureFront]
+    rearBrakePSI:np.float64 = worldArray[step, varBrakePressureRear]
+    frontBrakeCaliperForce:np.float64 = brakePSI_toNewtons(frontBrakePSI)
+    rearBrakeCaliperForce:np.float64 = brakePSI_toNewtons(rearBrakePSI)
 
     # Calculate Brake Force
     # Factor of 2 for 2 brakes on front and 2 on rear
-    frontBrakeForce:float = brakepadFrictionModel.calcFrictionCoeff(worldArray[step-1, varFrontBrakeTemperature]) * frontBrakeForce * 2 * Parameters["brakeDiscRadius"] / Parameters["wheelRadius"]
-    rearBrakeForce:float = brakepadFrictionModel.calcFrictionCoeff(worldArray[step-1, varRearBrakeTemperature]) * rearBrakeForce * 2 * Parameters["brakeDiscRadius"] / Parameters["wheelRadius"]
+    frontBrakeForce:np.float64 = brakepadFrictionModel.calcFrictionCoeff(worldArray[step-1, varFrontBrakeTemperature]) * frontBrakeCaliperForce * 2 * Parameters["brakeDiscRadius"] / Parameters["wheelRadius"]
+    rearBrakeForce:np.float64 = brakepadFrictionModel.calcFrictionCoeff(worldArray[step-1, varRearBrakeTemperature]) * rearBrakeCaliperForce * 2 * Parameters["brakeDiscRadius"] / Parameters["wheelRadius"]
     return frontBrakeForce, rearBrakeForce
 
-def calcBrakeCooling(worldArray:np.ndarray, step:int) -> tuple[float,float]:
+def calcBrakeCooling(worldArray:NDArray[np.float64], step:int) -> tuple[np.float64,np.float64]:
     """
-    Calculate the cooled brake temperature.
+    Calculate the change in brake temperature due to convective cooling. Uses data from step-1.
+    This currently neglects conduction to nearby bits of metal like the inner rotor/hub, the brake lines, etc.
     
-    :param prevWorld: World State
+    :param worldArray: World Array
+    :param step: Current Step
     :return: Change in Temperature
     """
-    speed = worldArray[step-1, varSpeed]
-    heatTransferCoeff = brakeTransferCoeff(speed)
-    brakeThermalMass = Parameters["4130SpecificHeatCapacity"] * Parameters["brakeRotorMass"]
-    brakeCoolingArea = Parameters["brakeRotorArea"]
-    frontBrakeCoolingEnergy = heatTransferCoeff * brakeCoolingArea *(worldArray[step-1, varFrontBrakeTemperature] - Parameters["ambientTemperature"])
-    frontBrakeCooling = frontBrakeCoolingEnergy / brakeThermalMass / Parameters["stepsPerSecond"]
+    speed:np.float64 = worldArray[step-1, varSpeed]
+    heatTransferCoeff:np.float64 = brakeTransferCoeff(speed)
+    brakeThermalMass:np.float64 = Parameters["4130SpecificHeatCapacity"] * Parameters["brakeRotorMass"]
+    brakeCoolingArea:np.float64 = Parameters["brakeRotorArea"]
+    frontBrakeCoolingEnergy:np.float64 = heatTransferCoeff * brakeCoolingArea *(worldArray[step-1, varFrontBrakeTemperature] - Parameters["ambientTemperature"])
+    frontBrakeCooling:np.float64 = frontBrakeCoolingEnergy / brakeThermalMass / Parameters["stepsPerSecond"]
     
-    rearBrakeCoolingEnergy = heatTransferCoeff * brakeCoolingArea *(worldArray[step-1, varRearBrakeTemperature] - Parameters["ambientTemperature"])
-    rearBrakeCooling = rearBrakeCoolingEnergy / brakeThermalMass / Parameters["stepsPerSecond"]
+    rearBrakeCoolingEnergy:np.float64 = heatTransferCoeff * brakeCoolingArea *(worldArray[step-1, varRearBrakeTemperature] - Parameters["ambientTemperature"])
+    rearBrakeCooling:np.float64 = rearBrakeCoolingEnergy / brakeThermalMass / Parameters["stepsPerSecond"]
 
     return frontBrakeCooling, rearBrakeCooling
     #q = (initTemperature - parameters["ambientTemperature"]) * parameters["brakeMass"] * parameters["brakeSpecificHeatCapacity"]
     #change = (q * parameters["brakepadThickness"])/(initTemperature * parameters["brakeThermalConductivity"] * parameters["brakeSurfaceArea"]
     #return initTemperature - change
 
-def calcBrakeHeating(worldArray:np.ndarray, step:int) -> tuple[float,float]:
+def calcBrakeHeating(worldArray:NDArray[np.float64], step:int) -> tuple[float,float]:
+    """
+    Calculate the change in brake temperature due to brake force heating. Uses data from step-1.
+    
+    :param worldArray: World Array
+    :param step: Current Step
+    :return: Change in Temperature
+    """
     # Calculate Brake Force
     frontBrakeForce, rearBrakeForce = calcBrakeForce(worldArray, step)
     # Guess energy increase based on kinetic energy decrease of the vehicle.
-    # Assumption is 100% of kinetic energy lost goes into brake heating.
-    speedChange = (frontBrakeForce + rearBrakeForce) / Parameters["Mass"] / Parameters["stepsPerSecond"] # momentum impulse
-    energyChange = 0.5 * Parameters["Mass"] * (worldArray[step-1, varSpeed]**2 - ((worldArray[step-1, varSpeed] - speedChange)**2))
+    # Assumption is 100% of kinetic energy lost by the change in speed due to braking goes into brake heating. 
+    # In reality, some of it is also going to heating the brake fluid although that is largely conductive. 
+    speedChange = (frontBrakeForce + rearBrakeForce) / Parameters["mass"] / Parameters["stepsPerSecond"] # momentum impulse
+    energyChange = 0.5 * Parameters["mass"] * (worldArray[step-1, varSpeed]**2 - ((worldArray[step-1, varSpeed] - speedChange)**2))
     tempChange = energyChange/(Parameters["brakeMass"] * Parameters["brakeSpecificHeatCapacity"])
 
     # While this doesn't seem physically intuitive, it is based on the idea that the front and rear brakes share heat based on their contribution to total braking force.
@@ -89,8 +101,8 @@ def calcBrakeHeating(worldArray:np.ndarray, step:int) -> tuple[float,float]:
 #     # Calculate Brake Force
 #     brakeForce = calcBrakeForce(prevWorld)
 #     # Guess energy increase
-#     speedChange = brakeForce / Parameters["Mass"] / Parameters["stepsPerSecond"] # momentum impulse
-#     energyChange = 0.5 * Parameters["Mass"] * (prevWorld.speed - (prevWorld.speed - speedChange))
+#     speedChange = brakeForce / Parameters["mass"] / Parameters["stepsPerSecond"] # momentum impulse
+#     energyChange = 0.5 * Parameters["mass"] * (prevWorld.speed - (prevWorld.speed - speedChange))
 #     # Guess temperature increase
 #     brakeTemperature = prevWorld.brakeTemperature + energyChange/(Parameters["brakeMass"] * Parameters["brakeSpecificHeatCapacity"])
 #     return brakeTemperature
diff --git a/FullVehicleSim/Mech/general.py b/FullVehicleSim/Mech/general.py
index 5bad33b..a50ecb4 100644
--- a/FullVehicleSim/Mech/general.py
+++ b/FullVehicleSim/Mech/general.py
@@ -1,19 +1,20 @@
-from Mech.traction import calcCorneringStiffness
+import numpy as np
 from paramLoader import *
+from numpy.typing import NDArray
+from Mech.traction import calcCorneringStiffness
 from Mech.braking import calcBrakeForce
 from Mech.aero import calcDrag
 from Mech.steering import calcSlipAngle, calcYawRate
 from Mech.tireLoad import calcLoadTransfer
-import numpy as np
 
-def calcResistiveForces(worldArray:np.ndarray, step:int):
+def calcResistiveForces(worldArray:NDArray[np.float64], step:int) -> np.float64:
         if worldArray[step-1, varSpeed] <= 1e-5: # Floating point error
-            return 0
+            return np.float64(0)
         else:
             frontBrakeForce, rearBrakeForce = calcBrakeForce(worldArray, step)
             return -1 * (calcDrag(worldArray, step) + frontBrakeForce + rearBrakeForce)
         
-def calculateYawRate(worldArray:np.ndarray, step:int, initAcceleration:float, initYawRate:float, timeSinceLastSteer:float):
+def calculateYawRate(worldArray:NDArray[np.float64], step:int, initAcceleration:np.float64, initYawRate:np.float64, timeSinceLastSteer:np.float64) -> np.float64:
         """Calculate the yaw rate of the vehicle at the current state.
         This function computes the yaw rate by calculating tire loads, slip angles,
         cornering stiffness, and then applying the vehicle dynamics equations.
@@ -35,5 +36,5 @@ def calculateYawRate(worldArray:np.ndarray, step:int, initAcceleration:float, in
         slipAngle = calcSlipAngle(worldArray, step)
         slipRatio = 0.15
         corneringStiffness = calcCorneringStiffness(tireLoad, slipAngle, slipRatio, worldArray[step-1, varSpeed], 80, 40, Parameters, Magic) # Works but unused
-        res = calcYawRate(initYawRate, worldArray[step-1, varSpeed], worldArray[step, varSteerAngle], timeSinceLastSteer, corneringStiffness[0], corneringStiffness[1])
+        res:np.float64 = calcYawRate(initYawRate, worldArray[step-1, varSpeed], worldArray[step, varSteerAngle], timeSinceLastSteer, corneringStiffness[0], corneringStiffness[1])
         return res
diff --git a/FullVehicleSim/Mech/steering.py b/FullVehicleSim/Mech/steering.py
index 4c06198..e705df1 100644
--- a/FullVehicleSim/Mech/steering.py
+++ b/FullVehicleSim/Mech/steering.py
@@ -1,8 +1,9 @@
 # Steering model
 import numpy as np
+from numpy.typing import NDArray
 from paramLoader import *
 
-def calcSlipAngle(worldArray:np.ndarray, step:int) -> tuple[float,float]:
+def calcSlipAngle(worldArray:NDArray[np.float64], step:int) -> tuple[np.float64,np.float64]:
     """
     Calculate Slip Angle Based on yawRate, Velocity, and Steering Angle.
     
@@ -18,7 +19,7 @@ def calcSlipAngle(worldArray:np.ndarray, step:int) -> tuple[float,float]:
     speed = worldArray[step-1, varSpeed]
     yawRate = worldArray[step-1, varYawRate]
     if yawRate == 0 or speed == 0: # WRONG. RELAXATION LENGTH. PROJECT
-        return (0, 0)
+        return (np.float64(0), np.float64(0))
     else:
         bodySlip = np.arctan(worldArray[step-1, varVelY]/worldArray[step-1, varVelX])
 
@@ -41,7 +42,7 @@ def calcVirtualSlipAngle():
     Fy = 0
 
     # l = Parameters["wheelBase"]
-    # m = Parameters["Mass"]
+    # m = Parameters["mass"]
     # epsilon_i = Parameters["rollSteerCoefficient"]
     # tau_i = Parameters["rollCamberSteerCoefficient"]
     # hPrime = Parameters["CoG-distanceToRollAxis"]
@@ -71,7 +72,7 @@ def calcVirtualSlipAngle():
     #
     # return (Fy / CF) * (1 + term1Num/Term1Denom + term2Num/term2Denom + term3)
 
-def calcYawRate(currYawRate, speed, stepSteerInput, timeSinceLastSteer, frontCorneringStiffnessDeg_, rearCorneringStiffnessDeg_):
+def calcYawRate(currYawRate, speed, stepSteerInput, timeSinceLastSteer, frontCorneringStiffnessDeg_, rearCorneringStiffnessDeg_) -> np.float64:
     # This model is based on Performance Vehicle Dynamics
     # It is a pretty meh model which uses euler's method to approximate transient behavior
     # Ideally we would use something a bit better like rk4 but i couldn't get that to work
@@ -84,13 +85,13 @@ def calcYawRate(currYawRate, speed, stepSteerInput, timeSinceLastSteer, frontCor
     rearCorneringStiffnessDeg = -140 # Guess because this system isn't valid at high slip angle and when corrnering stiffness is dynamic
     #speed = 30 # Arbitrary because speed maybe doesn't work
     if speed == 0 or stepSteerInput == 0:
-        return 0
+        return np.float64(0)
 
     CF = frontCorneringStiffnessDeg * 180 / np.pi
     CR = rearCorneringStiffnessDeg * 180 / np.pi
     a = Parameters['a']
     b = Parameters["wheelBase"] - a
-    m = Parameters["Mass"]
+    m = Parameters["mass"]
     I = Parameters["polarMoment"]
     Y_beta = CF + CR
     Y_delta = -CF
@@ -101,7 +102,7 @@ def calcYawRate(currYawRate, speed, stepSteerInput, timeSinceLastSteer, frontCor
     c = -(NR_v / speed + (I * Y_beta) / (m * speed))
     k = N_beta + (Y_beta * NR_v - N_beta * YR_v) / (m * speed**2)
     C2 = (Y_delta * N_beta - Y_beta * N_delta) / (m * speed)
-    r_inf = (C2 * stepSteerInput) / k
+    r_inf:np.float64 = (C2 * stepSteerInput) / k
     r_dot_0 = N_delta * stepSteerInput / I
     omega_n = np.sqrt(abs(k / I))
     Cc = 2 * I * omega_n
diff --git a/FullVehicleSim/Mech/tireLoad.py b/FullVehicleSim/Mech/tireLoad.py
index 5eeb645..6ba871c 100644
--- a/FullVehicleSim/Mech/tireLoad.py
+++ b/FullVehicleSim/Mech/tireLoad.py
@@ -1,12 +1,12 @@
 from paramLoader import *
 
-def calcLoadTransfer(accelerationX, accelerationY, yawVelocity:float) -> tuple[float, float, float, float]:
+def calcLoadTransfer(accelerationX, accelerationY, yawVelocity:np.float64) -> tuple[np.float64, np.float64, np.float64, np.float64]:
     # TODO: add weight transfer for torsional compliancy
     #frontAxleLoad = params["Mass"] * 9.81 * (params["wheelBase"] - params["frontWeightDist"])/params["wheelBase"] - params["CoG-height"]/params["wheelBase"] * params["Mass"] * accelerationX
     #rearAxleLoad = params["Mass"] * 9.81 * (params["wheelBase"] - params["frontWeightDist"])/params["wheelBase"] - params["CoG-height"]/params["wheelBase"] * params["Mass"] * accelerationX
     #res = [params["Mass"]*9.8/4, params["Mass"]*9.8/4,params["Mass"]*9.8/4,params["Mass"]*9.8/4] # FL, FR, BL, BR
-    frontAxleLoad:float = Parameters["Mass"] * 9.81 * (Parameters["wheelBase"] - Parameters["a"])/Parameters["wheelBase"] - Parameters["CoG-height"]/Parameters["wheelBase"] * Parameters["Mass"] * accelerationX
-    rearAxleLoad:float = Parameters["Mass"] * 9.81 * (Parameters["wheelBase"] - Parameters["a"])/Parameters["wheelBase"] + Parameters["CoG-height"]/Parameters["wheelBase"] * Parameters["Mass"] * accelerationX
+    frontAxleLoad:np.float64 = Parameters["mass"] * 9.81 * (Parameters["wheelBase"] - Parameters["a"])/Parameters["wheelBase"] - Parameters["CoG-height"]/Parameters["wheelBase"] * Parameters["mass"] * accelerationX
+    rearAxleLoad:np.float64 = Parameters["mass"] * 9.81 * (Parameters["wheelBase"] - Parameters["a"])/Parameters["wheelBase"] + Parameters["CoG-height"]/Parameters["wheelBase"] * Parameters["mass"] * accelerationX
 
     return (frontAxleLoad/2, frontAxleLoad/2, rearAxleLoad/2, rearAxleLoad/2) # FL, FR, BL, BR
 
diff --git a/FullVehicleSim/Mech/traction.py b/FullVehicleSim/Mech/traction.py
index 1f88042..06b53d3 100644
--- a/FullVehicleSim/Mech/traction.py
+++ b/FullVehicleSim/Mech/traction.py
@@ -1,33 +1,33 @@
-from Mech import tireState as tire
+import numpy as np
+from numpy.typing import NDArray
 from paramLoader import Parameters, Magic
+from Mech import tireState as tire
 from Mech.tireLoad import calcLoadTransfer
 from Mech.steering import calcSlipAngle
-import numpy as np
 
-def calcTraction(tireLoad:tuple[float,float,float,float], slipAngle:tuple[float,float], slipRatio:float, speed, surfaceTemperature, tirePressure):
+def calcTraction(tireLoad:tuple[np.float64,np.float64,np.float64,np.float64], slipAngle:tuple[np.float64,np.float64], 
+                 slipRatio:np.float64, speed:np.float64, surfaceTemperature:np.float64, tirePressure:np.float64) -> NDArray[np.float64]:
     frontLeft = tire.Tire(tireLoad[0] , 0.15, slipAngle[0], speed, 80, 40)
     frontRight = tire.Tire(tireLoad[1] , 0.15, slipAngle[0], speed, 80, 40)
     backLeft = tire.Tire(tireLoad[2] , 0.15, slipAngle[1], speed, 80, 40)
     backRight = tire.Tire(tireLoad[3] , 0.15, slipAngle[1], speed, 80, 40)
-    return [(frontLeft.getLongForce(), frontLeft.getLateralForce() * 0.6),
-        (frontRight.getLongForce() * 0.6, frontRight.getLateralForce() * 0.6),
-        (backLeft.getLongForce() * 0.6, backLeft.getLateralForce() * 0.6),
-        (backRight.getLongForce() * 0.6, backRight.getLateralForce() * 0.6)]
-
-def calcCorneringStiffness(tireLoad:tuple[float,float,float,float], slipAngle:tuple[float,float], slipRatio, speed, surfaceTemperature, tirePressure):
+    return np.array([[frontLeft.getLongForce(), frontLeft.getLateralForce() * 0.6],
+        [frontRight.getLongForce() * 0.6, frontRight.getLateralForce() * 0.6],
+        [backLeft.getLongForce() * 0.6, backLeft.getLateralForce() * 0.6],
+        [backRight.getLongForce() * 0.6, backRight.getLateralForce() * 0.6]])
+def calcCorneringStiffness(tireLoad:tuple[np.float64,np.float64,np.float64,np.float64], slipAngle:tuple[np.float64,np.float64], 
+                           slipRatio:np.float64, speed:np.float64, surfaceTemperature:np.float64, tirePressure:np.float64) -> tuple[np.float64, np.float64]:
     """
     Calculate the cornering stiffness of the vehicle at the current state using a Daniel's patented sketchy derivatives 
     
-    :param tireLoad: Description
-    :type tireLoad: tuple[float, float, float, float]
-    :param slipAngle: Description
-    :type slipAngle: tuple[float, float]
-    :param slipRatio: Description
-    :param speed: Description
-    :param surfaceTemperature: Description
-    :param tirePressure: Description
+    :param tireLoad: Loads on each tire
+    :param slipAngle: Slip Angles (LR? FB?)
+    :param slipRatio: Vehicle slip ratio
+    :param speed: Vehicle Speed
+    :param surfaceTemperature: Tire surface temperature simplified such that all tires have the same pressure.
+    :param tirePressure: Tire pressure simplified such that all tires have the same pressure.
     """
-    delta = 0.1
+    delta = 1 / Parameters["stepsPerSecond"]
     less = calcTraction(tireLoad, tuple(x - delta for x in slipAngle), slipRatio, speed, surfaceTemperature, tirePressure) # type: ignore
     more = calcTraction(tireLoad, tuple(x + delta for x in slipAngle), slipRatio, speed, surfaceTemperature, tirePressure) # type: ignore
 
@@ -36,37 +36,37 @@ def calcCorneringStiffness(tireLoad:tuple[float,float,float,float], slipAngle:tu
 
     return (front, rear)
 
-def maxTraction(initAcceleration:float, heading:np.ndarray, initYawRate:float, velocity:np.ndarray, steerAngle:float, speed:float):
-        """Calculate the maximum traction available for the vehicle at the current state.
-        This function computes the total traction magnitude by calculating tire loads,
-        slip angles, and individual tire tractions, then combining them into a resultant
-        traction vector.
-        heading : np.ndarray
-            Unit heading vector of the vehicle [x, y] components.
-            Initial yaw rate of the vehicle before this time step, in rad/s.
-            The velocity vector of the vehicle, in m/s.
-            The steering angle of the vehicle, in radians.
-            The speed of the vehicle, in m/s.
-        Returns
-        -------
-        np.float32
-            The magnitude of the maximum available traction force, in Newtons.
-        Notes
-        -----
-        Yaw velocity is currently set to 0 in tire load calculations.
-        Slip ratio is fixed at 0.15.
-        """
-        tireLoad = calcLoadTransfer(Parameters, initAcceleration * heading[0], initAcceleration * heading[1], initYawRate) # yaw velocity is currently set to 0
+def maxTraction(initAcceleration:np.float64, heading:np.ndarray, initYawRate:np.float64, velocity:NDArray[np.float64], steerAngle:np.float64, speed:np.float64):
+    """Calculate the maximum traction available for the vehicle at the current state.
+    This function computes the total traction magnitude by calculating tire loads,
+    slip angles, and individual tire tractions, then combining them into a resultant
+    traction vector.
+    heading : np.ndarray
+        Unit heading vector of the vehicle [x, y] components.
+        Initial yaw rate of the vehicle before this time step, in rad/s.
+        The velocity vector of the vehicle, in m/s.
+        The steering angle of the vehicle, in radians.
+        The speed of the vehicle, in m/s.
+    Returns
+    -------
+    np.float64
+        The magnitude of the maximum available traction force, in Newtons.
+    Notes
+    -----
+    Yaw velocity is currently set to 0 in tire load calculations.
+    Slip ratio is fixed at 0.15.
+    """
+    tireLoad = calcLoadTransfer(Parameters, initAcceleration * heading[0], initAcceleration * heading[1], initYawRate) # yaw velocity is currently set to 0
+
+    slipAngle = calcSlipAngle(initYawRate, velocity, steerAngle, Parameters)
+    slipRatio = 0.15
+    tireTraction = calcTraction(tireLoad, slipAngle, slipRatio, speed, 80, 40, Parameters, Magic)
+    longTraction = 0
+    latTraction = 0
+    for x, y in tireTraction:
+        longTraction += x
+        latTraction += y
+    return np.sqrt(longTraction**2 + latTraction**2)
 
-        slipAngle = calcSlipAngle(initYawRate, velocity, steerAngle, Parameters)
-        slipRatio = 0.15
-        tireTraction = calcTraction(tireLoad, slipAngle, slipRatio, speed, 80, 40, Parameters, Magic)
-        longTraction = 0
-        latTraction = 0
-        for x, y in tireTraction:
-            longTraction += x
-            latTraction += y
-        return np.sqrt(longTraction**2 + latTraction**2)
-    
-        #tempTire = tire.Tire(500 , 0.15, 0, self.speed, 80, 40, Parameters, Magic)
-        #return  ((tempTire.getLongForce()/500 * self.weight * 0.7477)/1.6547084)/(1.0-(0.247718 * tempTire.getLongForce()/500 / 1.6547084))
+    #tempTire = tire.Tire(500 , 0.15, 0, self.speed, 80, 40, Parameters, Magic)
+    #return  ((tempTire.getLongForce()/500 * self.weight * 0.7477)/1.6547084)/(1.0-(0.247718 * tempTire.getLongForce()/500 / 1.6547084))
diff --git a/FullVehicleSim/SimulationControlInputs/simulationControls.csv b/FullVehicleSim/SimulationControlInputs/simulationControls.csv
index ccebd32..680a7fc 100644
--- a/FullVehicleSim/SimulationControlInputs/simulationControls.csv
+++ b/FullVehicleSim/SimulationControlInputs/simulationControls.csv
@@ -1,6 +1,6 @@
-time,throttle,brakePressureFront,brakePressureRear,brakePedalTravel,steerAngle
-0.0,0.0,0.0,0.0,0.0,0.0
-10.0,1.0,0.0,0.0,0.0,0.0
-20.0,0.0,0.0,0.0,0.0,0.0
-30.0,0.0,300.0,300.0,0.0,0.0
-40.0,0.0,0.0,0.0,0.0,0.0
\ No newline at end of file
+time,throttle,brakePressureFront,brakePressureRear,steerAngle
+0.0,0.0,0.0,0.0,0.0
+10.0,1.0,0.0,0.0,0.1
+20.0,0.0,0.0,0.0,0.1
+30.0,0.0,300.0,300.0,0.1
+40.0,0.0,0.0,0.0,0.0
diff --git a/FullVehicleSim/SimulationControlInputs/testing.csv b/FullVehicleSim/SimulationControlInputs/testing.csv
new file mode 100644
index 0000000..ea0f262
--- /dev/null
+++ b/FullVehicleSim/SimulationControlInputs/testing.csv
@@ -0,0 +1,17 @@
+time,throttle,brakePressureFront,brakePressureRear,steerAngle
+0.0,0.0,0.0,0.0,0.0
+5.0,1.0,0.0,0.0,0.0
+10.0,1.0,0.0,0.0,0.0
+15.0,0.7,0.0,0.0,0.1
+30.0,0.7,0.0,0.0,0.1
+35.0,0.7,0.0,0.0,-0.1
+45.0,0.7,0.0,0.0,0.1
+50.0,0.7,0.0,0.0,0.0
+52.0,0.7,0.0,0.0,0.15
+55.0,0.7,0.0,0.0,0.15
+60.0,0.7,0.0,0.0,-0.1
+75.0,0.7,0.0,0.0,-0.1
+80.0,0.0,200.0,200.0,-0.1
+90.0,0.0,200.0,200.0,0.0
+100.0,0.0,0.0,0.0,0.0
+110.0,0.0,0.0,0.0,0.0
\ No newline at end of file
diff --git a/FullVehicleSim/basicViewer.py b/FullVehicleSim/basicViewer.py
index c674698..a5f088f 100644
--- a/FullVehicleSim/basicViewer.py
+++ b/FullVehicleSim/basicViewer.py
@@ -2,7 +2,8 @@
 import matplotlib.pyplot as plt
 
 df = pl.read_parquet("FullVehicleSim/simulation_output.parquet")
-dfReal = pl.read_parquet("../fs-data/FS-3/03162026/2_steeper_regen_curve.parquet").fill_null(strategy="forward").fill_null(strategy="backward")
+dfReal = pl.read_parquet("../fs-data/FS-3/03162026/2_steeper_regen_curve.parquet").fill_null(
+    strategy="forward").fill_null(strategy="backward")
 t = df["time"]
 
 dfReal["Time_ms"][-1]
@@ -33,4 +34,9 @@
 plt.xlabel("Time (s)")
 plt.ylabel("RPM")
 plt.show()
-df["speed"].max()
\ No newline at end of file
+df["speed"].max()
+
+plt.plot(dfReal["Time_ms"]/1000, dfReal["VDM_Y_AXIS_YAW_RATE"], label="yaw rate")
+plt.plot(t, df["yawRate"], label = "simulated yaw rate")
+plt.legend()
+plt.show()
\ No newline at end of file
diff --git a/FullVehicleSim/engine.py b/FullVehicleSim/engine.py
index a290a00..b5fb31c 100644
--- a/FullVehicleSim/engine.py
+++ b/FullVehicleSim/engine.py
@@ -1,15 +1,17 @@
 from paramLoader import *
 import numpy as np
+from numpy.typing import NDArray
 from Mech.braking import calcBrakeCooling, calcBrakeHeating, calcBrakeForce
 from Mech.aero import calcDrag, calcDownForce
 from Mech.steering import calcSlipAngle
 from Mech.general import calcResistiveForces
 from Electrical.powertrain import calcCurrent, calcMaxMotorTorque, calcMaxWheelTorque, calcMotorForce, calcMaxPower, calcVoltage
+from yaw_rate_model.double_bicycle_model import calcYawRate
 from scipy.integrate import RK45
 
 # Vibe coded but it looks about right so idk.
 # TODO: Verify that this is correct
-def calculateHeading(worldArray:np.ndarray, step:int) -> np.ndarray:
+def calculateHeading(worldArray:NDArray[np.float64], step:int) -> tuple[np.float64, np.float64, np.float64]:
     time_increment = 1/Parameters["stepsPerSecond"]
     initial_heading = worldArray[step-1, varHeadingX:varHeadingZ] # Yes this removes Z, we just want X and Y for this simplification
     rotation_angle = worldArray[step-1, varYawRate] * time_increment
@@ -24,9 +26,9 @@ def calculateHeading(worldArray:np.ndarray, step:int) -> np.ndarray:
     new_heading = rotation_matrix @ initial_heading
     new_heading = new_heading / np.linalg.norm(new_heading)
 
-    return np.append(new_heading, 0)
+    return (new_heading[0], new_heading[1], np.float64(0))
 
-def stepState(worldArray:np.ndarray, step:int) -> np.ndarray:
+def stepState(worldArray:NDArray[np.float64], step:int) -> NDArray[np.float64]:
     """
     The order by which things get updated in this function is incredibly important. 
     If you calculate velocity before you calculate acceleration, 
@@ -68,16 +70,14 @@ def stepState(worldArray:np.ndarray, step:int) -> np.ndarray:
     arr[varMotorForce] = calcMotorForce(arr[varMotorTorque]) # Newtons, Longitudinal force at the wheel from the motor
     arr[varNetForce] = arr[varMotorForce] + arr[varResistiveForces] # Newtons
     
-    arr[varAcceleration] = arr[varNetForce] / Parameters["Mass"] # m/s^2
+    arr[varAcceleration] = arr[varNetForce] / Parameters["mass"] # m/s^2
     
     arr[varCurrent] = calcCurrent(arr[varPower], arr[varVoltage]) # Amps. clamps for current limit. pack current.
 
     arr[varCharge] = worldArray[step-1, varCharge] - worldArray[step, varCurrent] * delta / 3600.0 / Parameters["parallelCells"] / Parameters["cellCapacity_Ah"]
     arr[varPosX:varPosZ+1] = worldArray[step-1, varPosX:varPosZ+1] + worldArray[step-1, varVelX:varVelZ+1] * delta
     arr[varSpeed] = max(0, worldArray[step-1, varSpeed] + arr[varAcceleration] * delta) # Sometimes braking falls a tad below 0 so we just correct that because otherwise everything breaks
-    arr[varYawRate] = worldArray[step-1, varYawRate]
-    if worldArray[step, varSteerAngle] == 0:
-        arr[varYawRate] = 0
+    arr[varLateralVelocty], arr[varYawRate] = calcYawRate(worldArray, step)
     arr[varVelX:varVelZ+1] = arr[varSpeed] * worldArray[step-1, varHeadingX:varHeadingZ+1]
     arr[varHeadingX:varHeadingZ+1] = calculateHeading(worldArray, step)
 
diff --git a/FullVehicleSim/main.py b/FullVehicleSim/main.py
index 88bcfe5..6f1275a 100644
--- a/FullVehicleSim/main.py
+++ b/FullVehicleSim/main.py
@@ -1,5 +1,4 @@
 import matplotlib.pyplot as plt
-import json
 import polars as pl
 import argparse
 import time
@@ -38,7 +37,7 @@
     ## This is structured so the first row is the initial conditions (inputs don't matter and will just be left to 0), and the
     ## rest are generated as the simulation progresses. This means that a simulation array will always be 1 longer than just the time steps
     ## and duration would indicate. 
-    worldArray = np.zeros((totalSteps + 1, len(VARIABLE_NAMES)), dtype=np.float32)
+    worldArray: NDArray[np.float64] = np.zeros((totalSteps + 1, len(VARIABLE_NAMES)), dtype=np.float64)
 
     # Set the inital time to 0 if not already 0. Eg. [1.79, 2.36, 3.13] becomes [0.0, 0.57, 1.34]
     timeSeries = df_controls['time'] - df_controls['time'][0] # Normalize to start at 0
@@ -58,11 +57,11 @@
         
     # Interpolation to make the command inputs match the simulation time steps
     # Use cubic spline for driver's real inputs
-    if Parameters["interpolationMethod"] == "cubic":
+    if StringParameters["interpolationMethod"] == "cubic":
         from scipy.interpolate import CubicSpline
         cs = CubicSpline(timeSeries, df_controls.drop('time').to_numpy())
         controlInputs = cs(steps)
-    elif Parameters["interpolationMethod"] == "linear":
+    elif StringParameters["interpolationMethod"] == "linear":
         controlInputs = np.zeros((len(steps), 5))
         controlInputs[:,0] = np.interp(steps, timeSeries, df_controls['throttle'])
         controlInputs[:,1] = np.interp(steps, timeSeries, df_controls['brakePressureFront'])
@@ -72,7 +71,7 @@
     else:
         raise Exception("Unsupported interpolation method. Please use 'cubic' or 'linear'.")
 
-    ## Setup initial conditions. Leaves row 0 with no inputs (don't matter anyway since sim runs from 1 -> end)
+    ## Setup initial conditions. Leaves row 0 with no inputs (doesn't matter anyway since sim runs from 1 -> end)
     ## Some other initial conditions based on input parameters.
     worldArray[1:, varThrottle] = controlInputs[:,0]
     worldArray[1:, varBrakePressureFront] = controlInputs[:,1]
@@ -82,33 +81,27 @@
     worldArray[0,varCharge] = Parameters["vehicleSOC"]
     worldArray[0,varFrontBrakeTemperature] = Parameters["initialBrakeTemperature"]
     worldArray[0,varRearBrakeTemperature] = Parameters["initialBrakeTemperature"]
-    worldArray[0, varHeadingX:varHeadingZ+1] = Parameters["initHeading"]
-    worldArray[0, varPosX:varPosZ+1] = Parameters["initPosition"]
-    worldArray[0, varVelX:varVelZ+1] = Parameters["initVelocity"]
+    worldArray[0, varHeadingX:varHeadingZ+1] = ArrayParameters["initHeading"]
+    worldArray[0, varPosX:varPosZ+1] = ArrayParameters["initPosition"]
+    worldArray[0, varVelX:varVelZ+1] = ArrayParameters["initVelocity"]
+    worldArray[0, varLateralVelocty] = Parameters["initLateralVelocity"] # velocity in y direction (needed for yaw rate)
+    worldArray[0, varYawRate] = Parameters["initYawRate"]
     worldArray[:, varTime] = np.arange(0, Parameters["simulationDuration"] + 1/Parameters["stepsPerSecond"], 1/Parameters["stepsPerSecond"])
 
-    start = time.time()
-    for i in range(1, totalSteps):
+    startTime = time.time()
+    lastTime = startTime
+    lastSteps = 0
+    updateTime = 2
+    for i in range(1, totalSteps+1):
         worldArray[i, :] = stepState(worldArray, i) # Step forward!!
-        ## This was above the stepState but I moved it down to make it clearer to read.
-        # timeRunning += 1/stepsPerSecond
-        # timeSinceLastSteer += 1/stepsPerSecond
-        # for commamd in timeBasedInputs:
-        #     if currInput + 1 < len(timeBasedInputs) and timeBasedInputs[currInput+1][0] < timeRunning:
-        #         currInput += 1
-        #         if timeBasedInputs[currInput-1][1][2] != timeBasedInputs[currInput][1][2]:
-        #             timeSinceLastSteer = 0
-        #             initSpeed = max(currVehicle.speed, 5) # Fails below roughly 5ish
+        if time.time() - lastTime > updateTime:
+            steps = i - lastSteps
+            timeToCompletion = (1 - i/totalSteps) * (totalSteps) / (steps/updateTime)
+            print(f"Step {i}/{totalSteps}, {round(i/totalSteps*100)}%, {steps/updateTime} steps/s, estimated time to completion = {round(timeToCompletion, 1)}s")
+            lastSteps = i
+            lastTime = time.time()
         
-    print("*****SIMULATION EXECUTATION TIME****", time.time() -start)
-
-    # columns = ['posX', 'posY', 'velX', 'velY', 'speed', 'acceleration',
-    #            'headingX', 'headingY', 'yawRate', 'steerAngle', 'throttle',
-    #            'brakesFront', 'brakesRear', 'drag', 'resistiveForces', 'motorForce', 'netForce',
-    #            'torque', 'motorTorque', 'maxTraction', 'maxTractionTorqueAtWheel',
-    #            'cooledBrakeTemperature', 'wheelRPM', 'wheelRotationsHZ',
-    #            'rpm', 'motorRotationsHZ', 'charge', 'voltage', 'current',
-    #            'power', 'maxPower', 'stepSize', 'timeSinceLastSteer']
+    print("*****SIMULATION EXECUTATION TIME*****", time.time() -startTime)
     # print(VARIABLE_NAMES)
 
     df = pl.DataFrame(worldArray, schema=VARIABLE_NAMES, orient="row")
@@ -125,13 +118,16 @@
     torque = df['motorTorque']
     yawRate = df['yawRate']
     frontBrakeTemperature = df['frontBrakeTemperature']
-    ax1 = plt.subplot(411)
+
+    fig = plt.figure()
+
+    ax1 = fig.add_subplot(411)
     ax11 = ax1.twinx()
-    ax2 = plt.subplot(412)
+    ax2 = fig.add_subplot(412)
     ax22 = ax2.twinx()
-    ax3 = plt.subplot(413)
+    ax3 = fig.add_subplot(413)
     ax33 = ax3.twinx()
-    ax4 = plt.subplot(414)
+    ax4 = fig.add_subplot(414)
     ax44 = ax4.twinx()
 
     ax1.set_title("I (Blue)/V (Orange) vs Time")
@@ -153,7 +149,9 @@
     ax3.plot(t, df["throttle"], label="Throttle")
     ax33.plot(t, df["brakePressureFront"], color='orange')
 
-    ax4.set_title("rvt")
+    ax4.set_xlabel("Time (s)")
+    ax4.set_ylabel("Yaw Rate (radians)")
+    ax4.set_title("yawRate")
     ax4.plot(t, yawRate)
 
     #ax4.set_ylim([0, 190])
diff --git a/FullVehicleSim/paramLoader.py b/FullVehicleSim/paramLoader.py
index 30cdc51..7b60a6d 100644
--- a/FullVehicleSim/paramLoader.py
+++ b/FullVehicleSim/paramLoader.py
@@ -2,13 +2,18 @@
 from typing import Dict, List, Tuple
 import polars as pl
 import numpy as np
+from numpy.typing import NDArray
 
-Magic: dict
-Parameters: dict
+Magic: dict[str, np.float64]
+Parameters: dict[str, np.float64]
+ArrayParameters: dict[str, NDArray[np.float64]]
+StringParameters: dict[str, str]
 with open('params.json5', 'r') as file:
-    params = json5.load(file)
-    Magic = params["Magic"] #type: ignore
-    Parameters = params["Parameters"] #type: ignore
+    params: dict[str, dict] = json5.load(file)
+    Magic = params["Magic"]
+    Parameters = params["Parameters"]
+    ArrayParameters = params["ArrayParameters"]
+    StringParameters = params["StringParameters"]
     del params
 
 savedHisteresisKernel = pl.read_csv("Electrical/HisteresisCellModel/trained_voltage_kernel.csv").to_numpy()
@@ -68,6 +73,7 @@
 varMaxMotorTorque = 42
 varAcceleration = 43
 varWheelRPM = 44
+varLateralVelocty = 45
 
 # Automatically generate schema from defined variables
 def generate_variable_schema() -> Dict[int, str]:
diff --git a/FullVehicleSim/params.json5 b/FullVehicleSim/params.json5
index 7bf7017..c2bf22c 100644
--- a/FullVehicleSim/params.json5
+++ b/FullVehicleSim/params.json5
@@ -1,69 +1,86 @@
 // Base SI Units unless otherwise specified
 {
-    "Parameters": {
-        "stepsPerSecond": 100,
-        "simulationDuration": 430.0, // Seconds
-        "interpolationMethod": "linear", // "linear" or "cubic", this is for interpolating the simultion controls.
-
-        "ambientTemperature": 20, // °C
-        "tractiveIMax": 400, // A
-        "initialBrakeTemperature": 20, // °C
-        "initialBatteryTemperature": 20, // °C
-        "vehicleSOC": 1, // Out of 1
-        "initSpeed": 0.0, // m/s
+    "ArrayParameters":{
         "initHeading": [1.0, 0.0, 0.0], // Vector pointing in the direction of the front of the car
         "initPosition": [0.0, 0.0, 0.0], // Starting position of the car in the world frame
         "initVelocity": [0.0, 0.0, 0.0], // Initial velocity vector in the world frame
+    },
+    "StringParameters":{
+        "interpolationMethod": "linear", // "linear" or "cubic", this is for interpolating the simultion controls.
+    },
+    "Parameters": {
+        "stepsPerSecond": 100.0,
+        "simulationDuration": 430.0, // Seconds
 
-        "airDensity": 1.230,
+        "ambientTemperature": 20.0, // °C
+        "tractiveIMax": 400.0, // A
+        "initialBrakeTemperature": 20.0, // °C
+        "initialBatteryTemperature": 20.0, // °C
+        "vehicleSOC": 1.0, // Out of 1, starting state of charge
+        "initSpeed": 0.0, // m/s
+        "airDensity": 1.230, /// kg / m^3
         "dragCoeffAreaCombo": 1.0858790012112278, // Combines area and drag coeff into one constant
         "rollingResistanceCoeff": 0.020926359062619436,
 
         "brakeDiscRadius": 0.09525, // meters (3.75 inches) -- Brake pad is ~1 inch wide near the edge of an 8 inch diamater rotor
         "brakeCaliperArea": 1.23, // in^2
-        "brakeRotorArea": 77, // in^2, not simply calculated because the brake disc has holes in it
+        "brakeRotorArea": 77.0, // in^2, not simply calculated because the brake disc has holes in it
         "brakeRotorMass": 0.4908, // kg
-        "4130SpecificHeatCapacity": 540, // J/(kg*k)
+        "4130SpecificHeatCapacity": 540.0, // J/(kg*k)
 
-        "regenMaxTorque": 180, // Nm, this is the maximum amount of torque the regen system can apply at the motor.
+        "regenMaxTorque": 180.0, // Nm, this is the maximum amount of torque the regen system can apply at the motor.
         
-        "wheelCircumferance": 1.35716802635079,
+        "wheelCircumferance": 1.35716802635079, // m
         "wheelRadius": 0.216, // m
         "gearRatio": 3.41667, // 41/12
-        "maxTorque": 180, // Nm, max torque at the motor.
+        "maxTorque": 180.0, // Nm, max torque at the motor.
         "friction-coeff-lat": 1.7333,
         "friction-coeff-long": 1.7333,
         "unloaded-radius": 1.7333,
-        "p_0": 82000,
-        "load_0": 300,
+        "p_0": 82000.0,
+        "load_0": 300.0,
 
-        "Mass": 280, // kg
-        "wheelBase": 1.65471,
+        "mass": 280.0, // kg
+        "wheelBase": 1.65471, // m
         "a": 0.853506,
-        "frontWeightDist": 46.46,
+        "frontWeightDist": 46.46, // %
         "CoG-height": 0.999628,
         "CoG-distanceToRollAxis": 0.999628,
         "polarMoment": 658.088580080000,
 
-        "rollSteerCoefficient": 0,
-        "rollCamberSteerCoefficient": 0,
-        "casterLength": 0,
-        "frontToe": 0,
+        "rollSteerCoefficient": 0.0,
+        "rollCamberSteerCoefficient": 0.0,
+        "casterLength": 0.0,
+        "frontToe": 0.0,
 
-        "brakeSpecificHeatCapacity": 450,
-        "brakeThermalConductivity": 50,
+        "brakeSpecificHeatCapacity": 450.0,
+        "brakeThermalConductivity": 50.0,
         "brakeSurfaceArea": 0.001180643,
         "brakepadThickness": 0.007874,
         "brakeMass": 0.408,
-        "maxBrakeForce": 1500,
+        "maxBrakeForce": 1500.0,
 
-        "seriesCells": 30,
-        "parallelCells": 20,
+        "seriesCells": 30.0,
+        "parallelCells": 20.0,
         "cellCapacity_Ah": 2.6, // Amp hours
         "histeresisKernelLength": 10.0, // seconds
 
-        "GasConstant": 8.31446261815324,
-        "FaradaysConstant": 96485.33212,
+        "gasConstant": 8.31446261815324,
+        "faradaysConstant": 96485.33212,
+
+        "initLateralVelocity": 0.0,
+        "initYawRate": 0.0,
+        "tw": 1083.3862, // mm (simplified track width from steering axis to steering axis [steering axis is also simplified to be A-arm knuckle to A-arm knuckle])
+        "rackRatio": 0.332862903226, // 82.55/248 [4] mm rack displacement/deg pinion rotation
+        "rackShift": 0.0, //  mm of movement of the rack from left to right (left is - right is +)
+        "l_rack": 292.1, // [4] mm (width of steering rack casing)
+        "l_rod": 378.9426, // [3] mm (length of tie rod as left in FS-3 master CAD)
+        "d": 109.7788, // [3] mm (plan view distance between front axis and rack. negative because we have a front steer setup)
+        "l_arm": 71.628, // [3] mm (length of "steer arm", which is the distance from the center of the upright toe rod pickup to the KPA)
+    
+        "Lf": 0.8535, // m
+        "Lr": 0.7365, // m
+        yawInertia: 658.09,  // Not in spec sheet, using previous value
     },
     "Magic": {
 
@@ -178,5 +195,129 @@
         "pressureYB": -9.812999633140862e-05,
         "pressureYC": 0.9998338222503662,
         "gysign": -0.10000000149011612,
-    }
+
+        "q_v2": 1.9079276329655327e-36,
+        "loadA": -0.08525806665420532,
+        "loadB": 0.8007363080978394,
+        "loadC": 3.823115110397339,
+        "q_Fcx": 0.40706977248191833,
+        "q_Fcy": 0.40706977248191833,
+        "Omega": 1.9079276329655327e-36,
+        "q_Fz1": 0.10348843783140182,
+        "q_Fz2": 0.10000000149011612,
+        "P_pFz1": -0.38212499022483826
+    },
+    "Magic-Parameters": {
+        "q_v2": 1.9079276329655327e-36,
+        "Omega": 1.9079276329655327e-36,
+        "q_Fcx": 0.40706977248191833,
+        "q_Fcy": 0.40706977248191833,
+        "q_Fz1": 0.10348843783140182,
+        "q_Fz2": 0.10000000149011612,
+        "P_pFz1": -0.38212499022483826,
+        "shape-factor": 0.696268618106842,
+        "curvature-scaling-factor": 1.7177082300186157,
+        "horizontal-shift-factor": 1.0,
+        "vertical-shift-factor": 0.9601083397865295,
+        "zeta_1": 0.6045444011688232,
+        "p_px1": 0.013196180574595928,
+        "p_px2": 0.8705743551254272,
+        "p_px3": -0.9542407989501953,
+        "p_px4": -0.9245550036430359,
+        "p_dx1": 0.642947793006897,
+        "p_dx2": 0.9363532066345215,
+        "p_dx3": 0.0,
+        "p_ex1": 0.5635436177253723,
+        "p_ex2": -0.5660403966903687,
+        "p_ex3": 0.8500840663909912,
+        "p_ex4": -0.005640119314193726,
+        "p_kx1": 21.55539894104004,
+        "p_kx2": 13.510042190551758,
+        "p_kx3": -0.5750095248222351,
+        "p_hx1": 0.0021615000441670418,
+        "p_hx2": 0.0011597999837249517,
+        "p_vx1": 0.41343268752098083,
+        "p_vx2": -0.28164142370224,
+        "lambda_loadscalarlong": 1.1716148853302002,
+        "lambda_pressurescalarlong": 0.4518716633319855,
+        "tempXAPure": -0.01220773346722126,
+        "tempXBPure": 0.9834595322608948,
+        "tempXCPure": 3.0494847297668457,
+        "r_bx1": 13.225804328918457,
+        "r_bx2": 9.537531852722168,
+        "r_bx3": 0.0,
+        "r_cx1": 1.148189902305603,
+        "r_ex1": -0.23479725420475006,
+        "r_ex2": -0.27553272247314453,
+        "r_hx1": -0.11146939545869827,
+        "lambda_alphastar": 1.14445960521698,
+        "lambda_xalpha": 1.1735954284667969,
+        "lambda_combinedslipcoeff": 0.8948060870170593,
+        "combined_long_offset": 0.8635340929031372,
+        "tempXA": -0.001096199150197208,
+        "tempXB": -0.004315061029046774,
+        "tempXC": 0.9925193786621094,
+        "By_pure": 0.17780134081840515,
+        "p_cy1": 1.2041044235229492,
+        "p_dy1": -0.31575706601142883,
+        "p_dy2": -1.0540627241134644,
+        "p_dy3": 0.0,
+        "p_ey1": -1.6930402517318726,
+        "p_ey2": -2.0134072303771973,
+        "p_ey3": 0.21373338997364044,
+        "p_ey4": -6.697000026702881,
+        "p_ey5": 0.0,
+        "p_ky1": -15.324000358581543,
+        "p_ky2": 1.715000033378601,
+        "p_ky3": 0.3695000112056732,
+        "p_ky4": -6.697000026702881,
+        "p_ky5": 0.0,
+        "p_py1": -0.6255000233650208,
+        "p_py2": -0.06522999703884125,
+        "p_py3": 1.8217451724922284e-06,
+        "p_py4": -0.26475754380226135,
+        "Svy": 31.63314437866211,
+        "zeta3": 1.0,
+        "epsilon_y": 0.009999999776482582,
+        "lambda_alphastarypure": 0.49190351366996765,
+        "lambda_ey": -1.1078534126281738,
+        "lambda_kyalpha": 1.0,
+        "lambda_nominalload": 1.0,
+        "lambda_coeffscalary": 0.8558508157730103,
+        "lambda_loadscalarlat": 0.7529077529907227,
+        "lambda_pressurescalarlat": 1.0000001192092896,
+        "tempYAPure": 0.035267509520053864,
+        "tempYBPure": -4.318601608276367,
+        "tempYCPure": 0.130745992064476,
+        "Byk": 0.7075067758560181,
+        "Cyk": 1.7348066568374634,
+        "Eyk": 0.9768351912498474,
+        "Shyk": 0.6505736708641052,
+        "Svyk": -6.833913803100586,
+        "r_by1": 9.446654319763184,
+        "r_by2": 7.820000171661377,
+        "r_by3": 0.00203699991106987,
+        "r_by4": 0.0,
+        "r_cy1": 0.8584131598472595,
+        "r_ey1": -1.0929341316223145,
+        "r_ey2": -1.7355691194534302,
+        "r_hy1": 0.11233723163604736,
+        "r_hy2": -0.23296165466308594,
+        "r_vy1": 0.534748911857605,
+        "r_vy2": 0.48336413502693176,
+        "r_vy3": 0.0,
+        "r_vy4": 93.80660247802734,
+        "r_vy5": 1.9759562015533447,
+        "r_vy6": 23.584060668945312,
+        "lambda_yk": 1.0,
+        "lambda_vyk": 1.7570732831954956,
+        "zeta_2": 1.7570732831954956,
+        "pressureYA": -3.086921788053587e-05,
+        "pressureYB": -9.812999633140862e-05,
+        "pressureYC": 0.9998338222503662,
+        "gysign": -0.10000000149011612,
+        "loadA": -0.08525806665420532,
+        "loadB": 0.8007363080978394,
+        "loadC": 3.823115110397339
+  }
 }
diff --git a/FullVehicleSim/simulation_output.parquet b/FullVehicleSim/simulation_output.parquet
deleted file mode 100644
index 9231e6e..0000000
Binary files a/FullVehicleSim/simulation_output.parquet and /dev/null differ
diff --git a/FullVehicleSim/yaw_rate_model/ackermann.py b/FullVehicleSim/yaw_rate_model/ackermann.py
new file mode 100644
index 0000000..e854caf
--- /dev/null
+++ b/FullVehicleSim/yaw_rate_model/ackermann.py
@@ -0,0 +1,69 @@
+
+#steering wheel angle --> steering rack psition --> wheel steer angle (how static ackermann affects wheel angle function)
+# equations taken from "rack and pinion" section of: https://www.mathworks.com/help/vdynblks/ref/kinematicsteering.html
+# import scipy
+import numpy as np
+# import matplotlib.pyplot as plt
+# import ipywidgets as widgets
+# from ipywidgets import interact, interactive
+
+#global variables
+#-----------------------------
+# THIS SCRIPT USES MOSTLY FS-3 VALUES. FS-3 values denoted by [3], any theoretical or FS-4 values denoted by [4]
+#-----------------------------
+tw = 1083.3862 #mm (simplified track width from steering axis to steering axis [steering axis is also simplified to be A-arm knuckle to A-arm knuckle])
+rackRatio = 82.55/248 #[4] mm rack displacement/deg pinion rotation
+# wheelInput = 0.0 #in degrees of steering wheel movement (CW + CCW -)
+rackShift = 0.0 # mm of movement of the rack from left to right (left is - right is +)
+l_rack = 292.1 #[4] mm (width of steering rack casing)
+l_rod = 378.9426 #[3] mm (length of tie rod as left in FS-3 master CAD)
+d = 109.7788 #[3] mm (plan view distance between front axis and rack. negative because we have a front steer setup)
+l_arm = 71.628 #[3] mm (length of "steer arm", which is the distance from the center of the upright toe rod pickup to the KPA)
+
+def rackMovement(wheelInput): #returns the amount of L-R displacement (in mm) of the steering rack, with the right direction as "positive"
+
+    rackRatio = 82.55/248 # mm rack displacement/deg pinion rotation
+    rackShift: float = rackRatio*wheelInput # wheelInput
+    return rackShift
+
+def calculateAckermann(wheelInput: float): #calculates the steer angles of both wheels
+
+    l1Left = (0.5*(tw-l_rack)) - rackMovement(wheelInput) #l1 is the instantaneous parallel distance from the rack knuckle to steering axis (KPA). 
+    l1Right = (0.5*(tw-l_rack)) + rackMovement(wheelInput)
+    l_nought = (0.5*(tw-l_rack))
+    beta_nought = betaTrigSolver(l_nought) #used to find the initial "beta" geometry to determine the real steer angle at the wheels
+
+    beta_L = betaTrigSolver(l1Left) - beta_nought #additionally, because there is a static "beta" (simply just arm geometry), we must find the difference to find the actual wheel angles
+    beta_R = betaTrigSolver(l1Right) - beta_nought
+    
+    return beta_L, beta_R
+    #return beta_nought, betaTrigSolver(l1Left), betaTrigSolver(l1Right)
+    
+def betaTrigSolver(l1): #a separate function to solve the big bad trig equation
+    l2 = np.sqrt((l1**2) + (d**2)) #l2 is the instantaneous direct distance from rack knuckle to steering axis (KPA)
+    atan = np.arctan(d/l1) #first term of the "beta" equation
+
+    num = (l_arm**2) + (l2**2) - (l_rod**2) #just simplifying the calculation of the second term 
+    denom = 2*l_arm*l2
+    frac = num/denom
+    acos = np.arccos(frac)
+    beta = (np.pi/2) - atan - acos
+    return beta
+    #return frac
+
+def update(val): #update variables based off of interact()
+    global wheelInput
+    wheelInput = val
+    left_angle, right_angle = calculateAckermann()
+    #stat, bL, bR = calculateAckermann()
+    print(f"wheelInput = {wheelInput}")
+    print(f"rack movement = {rackMovement()}")
+    print("----------------------------")
+    print(f"left wheel radians = {left_angle}")
+    print(f"right wheel radians = {right_angle}")
+    print("----------------------------")
+    print(f"left wheel degrees = {np.rad2deg(left_angle)}")
+    print(f"right wheel degrees = {np.rad2deg(right_angle)}")
+    #print(f"Static value must be within [-1,1] = {stat}")
+    #print(f"Left value must be within [-1,1] = {bL}")
+    #print(f"Right value must be within [-1,1] = {bR}")
diff --git a/FullVehicleSim/yaw_rate_model/double_bicycle_model.py b/FullVehicleSim/yaw_rate_model/double_bicycle_model.py
index b0a78f2..8bdb474 100644
--- a/FullVehicleSim/yaw_rate_model/double_bicycle_model.py
+++ b/FullVehicleSim/yaw_rate_model/double_bicycle_model.py
@@ -6,165 +6,280 @@
 """
 
 import numpy as np
-from dataclasses import dataclass
+from numpy.typing import NDArray
+from paramLoader import *
+import pandas as pd
 from typing import Tuple, List
 import matplotlib.pyplot as plt
+import sys
 
-
-@dataclass
-class VehicleParameters:
-    """Vehicle parameters from 2025 FSAE Design Spec Sheet (Car #216)"""
-
-    # Geometry (meters) - from 2025 FSAE Design EV Spec Sheet
-    wheelbase: float = 1.589989  # 1589.989 mm
-    Lf: float = 0.8535  # Calculated from 46.32% front weight distribution
-    Lr: float = 0.7365  # Calculated from weight distribution
-    track_width_front: float = 1.234008  # 1234.008 mm
-    track_width_rear: float = 1.186  # 1186 mm
-    track_width: float = 1.234008  # Using front track for compatibility
-
-    # Mass properties (with driver)
-    mass: float = 300.0  # Vehicle + driver (from Formula Slug FS-4 specs)
-    mass_without_driver: float = 232.0
-    cg_height: float = 0.3048  # 304.8 mm
-    yaw_inertia: float = 658.09  # Not in spec sheet, using previous value
-
-    # Tire model (stiffness values not in spec sheet, using estimates)
-    # Tires: Front - Hoosier 16.0x6.0-10 LC0, Rear - Hoosier 16.0x7.5-10 LC0
-    C_alpha: float = 180000.0  # Cornering stiffness estimate
-    C_alpha_front: float = 180000.0
-    C_alpha_rear: float = 180000.0
-    mu: float = 1.733
-    longitudinal_inertia: float = 0.0
-
-    # Additional spec sheet info (for reference)
-    # Wheel rates: Front 30.647 N/mm, Rear 35.025 N/mm
-    # Roll rates: Front 407.25 Nm/deg, Rear 429.93 Nm/deg
-    # Natural frequency: Front 3.55 Hz, Rear 3.53 Hz
-
-    def __post_init__(self):
-        tolerance = 0.0001
-        wheelbase_check = self.Lf + self.Lr
-        assert abs(wheelbase_check - self.wheelbase) < tolerance, \
-            f"Wheelbase math is wrong: {self.Lf} + {self.Lr} = {wheelbase_check} != {self.wheelbase}"
-        assert self.mass > 0, "Mass has to be positive"
-        assert self.yaw_inertia > 0, "Yaw inertia has to be positive"
-        assert self.C_alpha > 0, "Tire stiffness has to be positive"
-
-
-@dataclass
 class TireModel:
-    stiffness: float
-    max_slip_angle: float = 0.3
-    saturation_method: str = "linear"
-    friction_coeff: float = 1.733  # Peak friction coefficient
 
-    def lateral_force(self, slip_angle: float, vertical_load: float) -> float:
-        if self.saturation_method == "linear":
-            return self.stiffness * slip_angle
+    def __init__(self, temperature, axle, slipAngle, pressure=12, camber=0):
+        
+        if axle == "front":
+            self.normalForce = Parameters["mass"] * 9.81 * Parameters["Lr"] / Parameters["wheelBase"] / 2.0
+        elif axle == "rear":
+            self.normalForce = Parameters["mass"] * 9.81 * Parameters["Lf"] / Parameters["wheelBase"] / 2.0
+
+        self.slipAngle = slipAngle
+        self.tirePressure = pressure
+        self.tireTemperature = temperature
+        self.actPressure = pressure # Actual PSI
+        self.camber = camber # Radians
+
+        #if(lat):
+        self.normDeltaLoadLat = self.normalizeLoadLat()
+        self.normDeltaPressureLat = self.normalizePressureLat()
+        #if(long):
+        self.normDeltaLoadLong = self.normalizeLoadLong()
+        self.normDeltaPressureLong = self.normalizePressureLong()
+
+        self.normalForce = self.getNormalLoad(self.normalForce)
+
+    def getNormalLoad(self, inputNormalForce):
+        # Neglecting last force
+        # I intentionally neglect the last Fx and Fy because that would involve a large rewrite of this.
+        sqrt_term = np.sqrt(9.81 * Parameters["unloaded-radius"])
+        term1 = (1 + Magic["q_v2"] * abs(Magic["Omega"]) * Parameters["unloaded-radius"]/sqrt_term - Magic["q_Fcx"] - Magic["q_Fcy"])
+        # We assume the deflection is 1 because idk how to do that
+        term2 = (Magic["q_Fz1"] + Magic["q_Fz2"] * self.camber**2) / Parameters["unloaded-radius"]
+        term3 = (1 + Magic["P_pFz1"] * self.normDeltaPressureLong) * inputNormalForce
+
+        return term1 * term2 * term3
+
+    ##### ********************************
+    ##### LATERAL SLIP FUNCTION
+    ##### ********************************
+
+    def getLateralForce(self, worldArray:NDArray[np.float64], step:int):
+
+        velocityX = worldArray[step-1, varVelX]
+
+        Alphas = Magic["lambda_alphastar"] * self.slipAngle * np.copysign(1, velocityX)
+        Byk = Magic["r_by1"]# + Magic["r_by4"] * np.sin(self.camber) ** 2) * np.cos(np.arctan(Magic["r_by2"] * (Alphas - Magic["r_by3"]))) * Magic["lambda_yk"]
+        Cyk = Magic["r_cy1"]
+        Eyk = Magic["r_ey1"] + Magic["r_ey2"] * self.normDeltaLoadLat
+        Shyk = Magic["r_hy1"] + Magic["r_hy2"] * self.normDeltaLoadLat
+        
+        # Use Slip Ratio = (Wheel RPM - GPS Speed) / GPS Speed
+        rpm = worldArray[step-1, varWheelRPM]
+        angular_speed = (2 * np.pi * Parameters['wheelRadius'] * rpm) / 60
+        longitudinal_speed = worldArray[step-1, varSpeed]
+
+        if longitudinal_speed == 0: self.slipRatio = 0
+        else: self.slipRatio = (angular_speed - longitudinal_speed) / longitudinal_speed
+
+        Ks = self.slipRatio + Shyk
+        BykKs = Byk * Ks
+        BykShyk = Byk * Shyk
+        Gykappa = np.cos(Cyk * np.arctan(BykKs - Eyk * (BykKs - np.arctan(BykKs))))
+        Gykappazero =  np.cos(Cyk * np.arctan(BykShyk - Eyk * (BykShyk - np.arctan(BykShyk))))
+
+
+        Dvyk = Parameters["friction-coeff-lat"] * self.normalForce * (Magic["r_vy1"] + Magic["r_vy2"] * self.normDeltaLoadLat + Magic["r_vy3"] * np.sin(self.camber)) * np.cos(np.arctan(Magic["r_vy4"] * np.sin(Alphas)))  * Magic["zeta_2"]
+        Svyk = Dvyk * np.sin(Magic["r_vy5"] * np.arctan(Magic["r_vy6"] * self.slipRatio)) * Magic["lambda_vyk"]
+
+        #print(Byk, Cyk, Eyk, Shyk)
+
+        return Gykappa/Gykappazero * self.getLateralForcePure(worldArray, step) #+ Svyk # + Magic["Svyk"]
+
+    def getLateralForcePure(self, worldArray:NDArray[np.float64], step:int):
+        velocityX = worldArray[step-1, varVelX]
+        Alphas = Magic["lambda_alphastarypure"] * self.slipAngle * np.copysign(1,velocityX)
+
+        loadDependentPeak = Magic["loadA"] * self.normalForce * self.normalForce + Magic["loadB"] * self.normalForce + Magic["loadC"]
+
+        Cy = Magic["p_cy1"]
+        Dy = loadDependentPeak * self.getLateralCoefficientOfFriction() * self.normalForce * (Magic["tempYAPure"] * self.tireTemperature ** 2 + Magic["tempYBPure"] * self.tireTemperature + Magic["tempYCPure"])
+        By = Magic["By_pure"]
+        Ey = self.getLateralE(Alphas)
+
+        Svy = Magic["Svy"]
+        return self.stdCurveSine(By, Cy, Dy, Ey, self.slipRatio) + Svy
+    
+    def getLateralCoefficientOfFriction(self):
+        return (Magic["p_dy1"] + Magic["p_dy2"] * self.normDeltaLoadLat) * (1 + Magic["p_py3"] * self.normDeltaPressureLat + Magic["p_py4"] * self.normDeltaPressureLat ** 2) * (1 - Magic["p_dy3"] * np.sin(self.camber) ** 2) * Magic["lambda_coeffscalary"]
+    
+    def getLateralE(self, Alphas):
+        term1 = (Magic["p_ey1"] + Magic["p_ey2"] * self.normDeltaLoadLat)
+        term2 = (1 + Magic["p_ey5"] * np.sin(self.camber) ** 2 - (Magic["p_ey3"] + Magic["p_ey4"] * np.sin(self.camber)) * Alphas)
+        return term1 * term2 * Magic["lambda_ey"]
+
+
+    ##### ********************************
+    ##### Standard Functioms
+    ##### ********************************
+
+    def stdCurveSine(self, Bx, Cx, Dx, Ex, slip):
+        BxSlip = Bx * slip
+        return Dx * np.sin( Cx * np.arctan( BxSlip - Ex * (BxSlip - np.arctan(BxSlip) ) ) )
 
-        elif self.saturation_method == "nonlinear":
-            # tanh saturation at high slip angles
-            # Saturates at F_max = mu * Fz (friction limit)
-            F_linear = self.stiffness * slip_angle
-            F_max = self.friction_coeff * vertical_load
-            return F_max * np.tanh(F_linear / F_max)
+    def normalizeLoadLong(self):
+        return (self.normalForce - Magic["lambda_loadscalarlong"] * self.normalForce) / (Magic["lambda_loadscalarlong"] * self.normalForce)
 
-        return 0.0
+    def normalizeLoadLat(self):
+        return (self.normalForce - Magic["lambda_loadscalarlat"] * self.normalForce) / (Magic["lambda_loadscalarlat"] * self.normalForce)
 
+    def normalizePressureLong(self):
+        # Only long because lat doesn't use it
+        return (self.tirePressure - Magic["lambda_pressurescalarlong"] * self.tirePressure) / (Magic["lambda_pressurescalarlong"] * self.tirePressure)
+
+    def normalizePressureLat(self):
+        # Only long because lat doesn't use it
+        return (self.tirePressure - Magic["lambda_pressurescalarlat"] * self.tirePressure) / (Magic["lambda_pressurescalarlat"] * self.tirePressure)
 
 class DoubleBicycleModel:
     """2DOF bicycle model: v_y (lateral velocity) and r (yaw rate)"""
 
-    def __init__(self, params: VehicleParameters, tire_model: str = "linear"):
-        self.params = params
-        self.tire_front = TireModel(params.C_alpha_front, saturation_method=tire_model, friction_coeff=params.mu)
-        self.tire_rear = TireModel(params.C_alpha_rear, saturation_method=tire_model, friction_coeff=params.mu)
-
+    def __init__(self):
         self.state = np.array([0.0, 0.0])
-        self.time_history = []
-        self.state_history = []
-        self.input_history = []
+        self.time_history: list[np.float64] = []
+        self.state_history: list[NDArray[np.float64]] = []
+        self.input_history: list[tuple[np.float64, np.float64]] = []
     
-    def get_slip_angles(self, v_y: float, r: float, v_x: float, delta: float) \
-            -> Tuple[float, float]:
+    @staticmethod
+    def get_slip_angles(v_y: np.float64, r: np.float64, v_x: np.float64, delta: np.float64) \
+            -> Tuple[np.float64, np.float64]:
         """Calculate front and rear slip angles"""
         if abs(v_x) < 0.1:
-            return delta, 0.0
+            return delta, np.float64(0)
 
-        alpha_f = delta - np.arctan2(v_y + self.params.Lf * r, v_x)
-        alpha_r = -np.arctan2(v_y - self.params.Lr * r, v_x)
+        alpha_f: np.float64 = delta - np.arctan2(v_y + Parameters["Lf"] * r, v_x)
+        alpha_r: np.float64 = -np.arctan2(v_y - Parameters["Lr"] * r, v_x)
 
         return alpha_f, alpha_r
     
-    def dynamics(self, state: np.ndarray, v_x: float, delta: float,
-                 ax: float = 0.0) -> np.ndarray:
+    @staticmethod
+    def rackMovement(wheelInput: np.float64) \
+        -> np.float64:
+        """
+        returns the amount of L-R displacement (in mm) of the steering rack, with the right direction as "positive"
+        """
+        rackShift: np.float64 = Parameters['rackRatio'] * wheelInput # wheelInput
+        return rackShift
+
+    @staticmethod
+    def calculateAckermann(wheelInput: np.float64) \
+        -> tuple[np.float64, np.float64]: 
+        """
+        calculates the steer angles of both wheels
+        """
+
+        l1Left = (0.5*(Parameters["tw"]-Parameters["l_rack"])) - DoubleBicycleModel.rackMovement(wheelInput) #l1 is the instantaneous parallel distance from the rack knuckle to steering axis (KPA). 
+        l1Right = (0.5*(Parameters["tw"]-Parameters["l_rack"])) + DoubleBicycleModel.rackMovement(wheelInput)
+        l_nought = (0.5*(Parameters["tw"]-Parameters["l_rack"]))
+        beta_nought = DoubleBicycleModel.betaTrigSolver(l_nought) #used to find the initial "beta" geometry to determine the real steer angle at the wheels
+
+        beta_L = DoubleBicycleModel.betaTrigSolver(l1Left) - beta_nought #additionally, because there is a static "beta" (simply just arm geometry), we must find the difference to find the actual wheel angles
+        beta_R = DoubleBicycleModel.betaTrigSolver(l1Right) - beta_nought
+        
+        return beta_L, beta_R
+        #return beta_nought, betaTrigSolver(l1Left), betaTrigSolver(l1Right)
+    @staticmethod 
+    def betaTrigSolver(l1): #a separate function to solve the big bad trig equation
+        l2 = np.sqrt((l1**2) + (Parameters["d"]**2)) #l2 is the instantaneous direct distance from rack knuckle to steering axis (KPA)
+        atan = np.arctan(Parameters["d"]/l1) #first term of the "beta" equation
+
+        num = (Parameters["l_arm"]**2) + (l2**2) - (Parameters["l_rod"]**2) #just simplifying the calculation of the second term 
+        denom = 2*Parameters["l_arm"]*l2
+        frac = num/denom
+        acos = np.arccos(frac)
+        beta = (np.pi/2) - atan - acos
+        return beta
+        #return frac
+
+    @staticmethod
+    def dynamics(state: NDArray[np.float64], v_x: np.float64, delta: np.float64,
+                 worldArray: NDArray[np.float64], step:int, ax: np.float64 = np.float64(0)) -> NDArray[np.float64]:
         """Compute state derivatives [dv_y/dt, dr/dt]"""
         v_y, r = state
 
-        alpha_f, alpha_r = self.get_slip_angles(v_y, r, v_x, delta)
+        alpha_f, alpha_r = DoubleBicycleModel.get_slip_angles(v_y, r, v_x, delta) # old way of getting slip angles
+
+        delta_fl, delta_fr = DoubleBicycleModel.calculateAckermann(wheelInput=delta)
+
+        tire_fl = TireModel(
+            temperature=Parameters['ambientTemperature'], 
+            slipAngle=delta_fl,
+            axle="front",
+        )
 
-        # Static weight distribution (no load transfer)
-        # Front axle load: weight farther back (at distance Lr from front)
-        # Rear axle load: weight farther forward (at distance Lf from rear)
-        Fz_f = self.params.mass * 9.81 * self.params.Lr / self.params.wheelbase / 2.0
-        Fz_r = self.params.mass * 9.81 * self.params.Lf / self.params.wheelbase / 2.0
+        tire_fr = TireModel( 
+            temperature=Parameters['ambientTemperature'], 
+            slipAngle=delta_fr,
+            axle="front",
+        )
 
-        Fy_f = self.tire_front.lateral_force(alpha_f, Fz_f)
-        Fy_r = self.tire_rear.lateral_force(alpha_r, Fz_r)
+        tire_rear = TireModel( 
+            temperature=Parameters['ambientTemperature'], 
+            slipAngle=alpha_r,
+            axle="rear",
+        )
+
+        Fy_fl = tire_fl.getLateralForce(worldArray, step)
+        Fy_fr = tire_fr.getLateralForce(worldArray, step)
+        Fy_r = tire_rear.getLateralForce(worldArray, step)
 
         # Account for both tires per axle
-        Fy_f_total = 2.0 * Fy_f
+        Fy_f_total = Fy_fl + Fy_fr
         Fy_r_total = 2.0 * Fy_r
 
         # Lateral and yaw accelerations
-        a_y = (Fy_f_total * np.cos(delta) + Fy_r_total) / self.params.mass + v_x * r
+        a_y = (Fy_f_total * np.cos(delta) + Fy_r_total) / Parameters["mass"] + v_x * r
         dv_y = a_y
 
-        M_yaw = self.params.Lf * Fy_f_total * np.cos(delta) - self.params.Lr * Fy_r_total
-        dr = M_yaw / self.params.yaw_inertia
+        M_yaw = Parameters["Lf"] * Fy_f_total - Parameters["Lr"] * Fy_r_total
+        dr = M_yaw / Parameters["yawInertia"]
 
         return np.array([dv_y, dr])
     
-    def integrate_step(self, v_x: float, delta: float, dt: float,
-                      ax: float = 0.0, method: str = "rk4") -> None:
+    def integrate_step(self, v_x: np.float64, delta: np.float64, dt: np.float64, worldArray: NDArray[np.float64], step:int,
+                      ax: np.float64 = np.float64(0), method: str = "rk4") -> None:
         """Integrate one timestep using euler, rk2, or rk4"""
         if method == "euler":
-            k1 = self.dynamics(self.state, v_x, delta, ax)
+            k1 = DoubleBicycleModel.dynamics(state=self.state, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
             self.state = self.state + dt * k1
 
         elif method == "rk2":
-            k1 = self.dynamics(self.state, v_x, delta, ax)
-            k2 = self.dynamics(self.state + 0.5*dt*k1, v_x, delta, ax)
+            k1 = DoubleBicycleModel.dynamics(state=self.state, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
+            k2 = DoubleBicycleModel.dynamics(state=self.state + 0.5*dt*k1, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
             self.state = self.state + dt * k2
 
         elif method == "rk4":
-            k1 = self.dynamics(self.state, v_x, delta, ax)
-            k2 = self.dynamics(self.state + 0.5*dt*k1, v_x, delta, ax)
-            k3 = self.dynamics(self.state + 0.5*dt*k2, v_x, delta, ax)
-            k4 = self.dynamics(self.state + dt*k3, v_x, delta, ax)
+            k1 = DoubleBicycleModel.dynamics(state=self.state, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
+            k2 = DoubleBicycleModel.dynamics(state=self.state + 0.5*dt*k1, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
+            k3 = DoubleBicycleModel.dynamics(state=self.state + 0.5*dt*k2, v_x=v_x, delta=delta, ax=ax, worldArray=worldArray, step=step)
+            k4 = DoubleBicycleModel.dynamics(state=self.state + dt*k3, v_x=v_x, delta=delta, ax=ax,worldArray=worldArray, step=step)
             self.state = self.state + (dt/6.0) * (k1 + 2*k2 + 2*k3 + k4)
 
         else:
-            raise ValueError(f"Unknown integration method: {method}")
+            raise ValueError(f"Unknown integration method in DoubleBicycleModel.integrate_step(): {method}")
+    
+    """
+    
+    v_x = longitudinal velocty (forward speed of vehicle (m/s))
+    steering_inputs = time series of steering angles 
     
-    def simulate(self, v_x: float, steering_inputs: List[float],
-                dt: float = 0.01, method: str = "rk4") -> Tuple[np.ndarray, np.ndarray]:
+    """
+    
+    def simulate(self, v_x: np.float64, steering_inputs: List[np.float64], worldArray: NDArray[np.float64], step: int,
+                dt: np.float64 = np.float64(0.01), method: str = "rk4") -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
         """Run simulation with given steering input sequence"""
         self.state = np.array([0.0, 0.0])
-        self.time_history = [0.0]
+        self.time_history = [np.float64(0.0)]
         self.state_history = [self.state.copy()]
-        self.input_history = [(0.0, v_x)]
+        self.input_history = [(np.float64(0.0), v_x)]
 
         for i, delta in enumerate(steering_inputs):
             t = (i + 1) * dt
-            self.integrate_step(v_x, delta, dt, ax=0.0, method=method)
+            self.integrate_step(v_x, delta, dt, ax=np.float64(0), method=method, worldArray=worldArray, step=step)
 
             self.time_history.append(t)
             self.state_history.append(self.state.copy())
             self.input_history.append((delta, v_x))
 
-        return np.array(self.time_history), np.array(self.state_history)
+        return np.array(self.time_history, dtype=np.float64), np.array(self.state_history, dtype=np.float64)
 
     def reset(self):
         self.state = np.array([0.0, 0.0])
@@ -172,7 +287,6 @@ def reset(self):
         self.state_history = []
         self.input_history = []
 
-
 def validate_against_telemetry(csv_path: str, model: DoubleBicycleModel,
                               sample_window: int = 1000) -> dict:
     """Load telemetry and extract stats for model comparison"""
@@ -225,8 +339,8 @@ def validate_against_telemetry(csv_path: str, model: DoubleBicycleModel,
 
     return results
 
-
 def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
+
     if not model.time_history:
         print("No data. Run simulate() first.")
         return
@@ -259,19 +373,55 @@ def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
     plt.tight_layout()
     return fig
 
+# globally create these so calcYawRate() can use it.
+# params = VehicleParameters()
+model = DoubleBicycleModel()
+
+def calcYawRate(worldArray:NDArray[np.float64], step: int) \
+    -> tuple[np.float64, np.float64]:
+    
+    """
+    Calculate the Yaw Rate
+
+    :param worldArray: World State Array
+    :param step: Current step index
+    :return: (Lateral Velocity, Yaw Rate)
+    """
+
+    dt = 1 / Parameters["stepsPerSecond"]
+
+    # load model's previous state so we can use it in integrate_step later
+    model.state = np.array([
+        worldArray[step-1, varLateralVelocty], # v_y
+        worldArray[step-1, varYawRate] # r
+    ])
+
+    # find steering angle for integrating the step
+    delta = worldArray[step, varSteerAngle]
+
+    # create a new state with new v_x and dt
+    v_x = worldArray[step-1, varSpeed]
+    model.integrate_step(v_x=v_x, delta=delta, dt=dt, worldArray=worldArray, step=step)
+
+    # extract yaw rate and lateral velocity
+    lateral_velocity = model.state[0]
+    yaw_rate = model.state[1]
+
+    return lateral_velocity, yaw_rate
 
 if __name__ == "__main__":
+
     print("\n--- FORMULA SLUG - DOUBLE BICYCLE YAW RATE MODEL ---\n")
 
-    params = VehicleParameters()
+    # params = VehicleParameters()
     print("Vehicle Parameters:")
-    print(f"  Wheelbase: {params.wheelbase:.3f} m (Lf={params.Lf:.3f}, Lr={params.Lr:.3f})")
-    print(f"  Track width: {params.track_width:.3f} m")
-    print(f"  Mass: {params.mass:.1f} kg")
-    print(f"  Yaw inertia: {params.yaw_inertia:.1f} kg·m²")
-    print(f"  Tire stiffness: {params.C_alpha:.0f} N/rad")
+    print(f"  Wheelbase: {Parameters['wheelbase']:.3f} m (Lf={Parameters['Lf']:.3f}, Lr={Parameters['Lr']:.3f})")
+    print(f"  Track width: {Parameters['trackWidth']:.3f} m")
+    print(f"  Mass: {Parameters['mass']:.1f} kg")
+    print(f"  Yaw inertia: {Parameters['yawInertia']:.1f} kg·m²")
+    # print(f"  Tire stiffness: {params.C_alpha:.0f} N/rad")
 
-    model = DoubleBicycleModel(params, tire_model="linear")
+    model = DoubleBicycleModel(params=params)
 
     # Test 1: Step steer
     print("\nTEST 1: Step Steer")
@@ -286,7 +436,7 @@ def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
     ])
     steering_step = steering_step[:num_steps]
 
-    time_sim, states_sim = model.simulate(v_x, steering_step, dt=dt, method="rk4")
+    time_sim, states_sim = model.simulate(v_x, steering_step, dt=dt, method="rk4", )
 
     print(f"\nSpeed: {v_x:.1f} m/s ({v_x*3.6:.1f} km/h)")
     print(f"Duration: {duration:.2f} s")
@@ -296,8 +446,8 @@ def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
     print(f"  G-force: {v_x * states_sim[-1, 1] / 9.81:.3f}g")
 
     fig1 = plot_response(model, "Test 1: Step Steering")
-    fig1.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test1_step_steer.png', dpi=150)
-    print("Saved to test1_step_steer.png")
+    # fig1.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test1_step_steer.png', dpi=150)
+    # print("Saved to test1_step_steer.png")
 
     # Test 2: Ramp steer
     print("\nTEST 2: Ramp Steer")
@@ -322,8 +472,8 @@ def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
     print(f"  Steady-state G: {v_x * states_sim[-1, 1] / 9.81:.3f}g")
 
     fig2 = plot_response(model, "Test 2: Ramp Steering")
-    fig2.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test2_ramp_steer.png', dpi=150)
-    print("Saved to test2_ramp_steer.png")
+    # fig2.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test2_ramp_steer.png', dpi=150)
+    # print("Saved to test2_ramp_steer.png")
 
     # Test 3: Lane change
     print("\nTEST 3: Double Lane Change")
@@ -345,8 +495,8 @@ def plot_response(model: DoubleBicycleModel, title: str = "Model Response"):
     print(f"  Max G-force: {v_x * np.max(np.abs(states_sim[:, 1])) / 9.81:.3f}g")
 
     fig3 = plot_response(model, "Test 3: Double Lane Change")
-    fig3.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test3_double_lanechange.png', dpi=150)
-    print("Saved to test3_double_lanechange.png")
+    # fig3.savefig('/Users/brianlee/vscode_projects/formula_slug/fs_yawratemodel/test3_double_lanechange.png', dpi=150)
+    # print("Saved to test3_double_lanechange.png")
 
     print("\n--- Done! ---")
 
diff --git a/README.md b/README.md
index cafad44..9ff6eb3 100644
--- a/README.md
+++ b/README.md
@@ -7,3 +7,17 @@ You can install dependencies either from requirements.txt or environment.yml
 ## Docs
 - [Full Vehicle Simulation Documentation](FullVehicleSim/README.md)
 - [General Guide to fs-data (Accompanying data repository)](<Docs/General Guide.md>)
+
+## Drag Calculations
+- edited blueMaxAnalysis -- added physics of the Drag Equation and used rolling resistance tests. (https://github.com/formulaslug/Sims-Data/blob/43-drag-and-downforce-calculations/Data/blueMaxDragAnalysis.py)
+- calculated drag by pulling RR tests and initially creates a speed array, then looks at residuals with the difference of predicted vs actual, then changes our estimates to lower error, and repeats until the values all line up
+-  Speed vs Time and SpeedxDrag vs Time graphs
+<img width="1206" height="670" alt="image" src="https://github.com/user-attachments/assets/b1cf47bf-f9d7-474a-87d9-29674864c157" />
+
+## Drag Testing Ideas
+- accelerate to high speed, shift to neutral, measure deacceleration, and use for better drag and RR calculations
+  (https://github.com/formulaslug/Sims-Data/blob/43-drag-and-downforce-calculations/testing-plan/drag_test.md)
+
+## Downforce Calculation
+- built downforce calculations using damping forces - validation plot from time 30s-45s
+<img width="2100" height="1500" alt="image" src="https://github.com/user-attachments/assets/6611cfcc-1e4a-46f4-9afe-c831c23390a1" />