From 78ab4eeae9fbc7b3bc52a82ab797cfba14e73601 Mon Sep 17 00:00:00 2001
From: sergeypdev <sergeypoznyak@protonmail.com>
Date: Sat, 26 Apr 2025 20:29:58 +0400
Subject: [PATCH] Start implementing engine simulation

---
 assets/ae86_rpm_torque.csv     |  63 +++++++++++
 game/assets/assets.odin        |  56 +---------
 game/assets/assets_test.odin   |  42 +++++++
 game/assets/parsers.odin       |  79 +++++++++++++
 game/fs.odin                   |   2 +
 game/game.odin                 |  27 ++++-
 game/physics/helpers.odin      |   9 ++
 game/physics/immediate.odin    |  57 ++++++++++
 game/physics/scene.odin        | 199 +++++++++++++++++++++++++++++++++
 game/physics/simulation.odin   | 154 ++++++++++++++++++++++++-
 libs/physfs/Makefile           |   2 +-
 research/engine_friction.ipynb |  98 ++++++++++++++++
 research/pacejka96.ipynb       |  20 ++--
 test.sh                        |   2 +-
 14 files changed, 740 insertions(+), 70 deletions(-)
 create mode 100644 assets/ae86_rpm_torque.csv
 create mode 100644 game/assets/assets_test.odin
 create mode 100644 game/assets/parsers.odin
 create mode 100644 research/engine_friction.ipynb

diff --git a/assets/ae86_rpm_torque.csv b/assets/ae86_rpm_torque.csv
new file mode 100644
index 0000000..006286e
--- /dev/null
+++ b/assets/ae86_rpm_torque.csv
@@ -0,0 +1,63 @@
+rpm,torque
+1000,63.6
+1100,72.3
+1200,79.5
+1300,85.7
+1400,90.9
+1500,95.5
+1600,99.4
+1700,102.9
+1800,106.1
+1900,108.9
+2000,111.4
+2100,113.6
+2200,115.7
+2300,117.6
+2400,119.3
+2500,120.9
+2600,122.4
+2700,123.7
+2800,125
+2900,126.2
+3000,127.3
+3100,128.3
+3200,129.3
+3300,130.2
+3400,131
+3500,131.8
+3600,132.6
+3700,133.3
+3800,134
+3900,134.6
+4000,135.2
+4100,135.8
+4200,136.4
+4300,136.9
+4400,137.4
+4500,137.9
+4600,138.3
+4700,138.8
+4800,139.2
+4900,139.6
+5000,140
+5100,140
+5200,139.8
+5300,139.6
+5400,139.3
+5500,138.9
+5600,138.4
+5700,137.8
+5800,137.2
+5900,136.4
+6000,135.6
+6100,134.7
+6200,133.7
+6300,132.6
+6400,131.4
+6500,130.1
+6600,128.8
+6700,126.3
+6800,123
+6900,118.7
+7000,113.6
+7100,107.7
diff --git a/game/assets/assets.odin b/game/assets/assets.odin
index 0ca2e8d..f148602 100644
--- a/game/assets/assets.odin
+++ b/game/assets/assets.odin
@@ -1,9 +1,6 @@
 package assets
 
-import "core:bytes"
 import "core:c"
-import "core:encoding/csv"
-import "core:io"
 import "core:log"
 import "core:math"
 import lg "core:math/linalg"
@@ -194,58 +191,13 @@ get_curve_2d :: proc(assetman: ^Asset_Manager, path: string) -> (curve: Loaded_C
 		return
 	}
 
-	bytes_reader: bytes.Reader
-	bytes.reader_init(&bytes_reader, data)
-	bytes_stream := bytes.reader_to_stream(&bytes_reader)
+	err2: Curve_Parse_Error
+	curve, err2 = parse_curve_2d(data, context.temp_allocator)
 
-	csv_reader: csv.Reader
-	csv.reader_init(&csv_reader, bytes_stream, context.temp_allocator)
-
-	tmp_result := make([dynamic][2]f32, context.temp_allocator)
-
-	skipped_header := false
-	for {
-		row, err := csv.read(&csv_reader, context.temp_allocator)
-		if err != nil {
-			if err != io.Error.EOF {
-				log.errorf("Failed to read curve %v", err)
-			}
-			break
-		}
-
-		if len(row) != 2 {
-			log.errorf("Curve expected 2 columns, got %v", len(row))
-			break
-		}
-
-		ok: bool
-		key: f64
-		val: f64
-		key, ok = strconv.parse_f64(row[0])
-		if !ok {
-			if skipped_header {
-				log.errorf("Curve expected numbers, got %s", row[0])
-				break
-			}
-			skipped_header = true
-			continue
-		}
-		val, ok = strconv.parse_f64(row[1])
-		if !ok {
-			if skipped_header {
-				log.errorf("Curve expected numbers, got %s", row[1])
-				break
-			}
-			skipped_header = true
-			continue
-		}
-
-		append(&tmp_result, [2]f32{f32(key), f32(val)})
+	if err2 != nil {
+		log.errorf("Failed to parse curve: %s, %v", path, err2)
 	}
 
-	curve.points = make([][2]f32, len(tmp_result), context.temp_allocator)
-	copy(curve.points, tmp_result[:])
-
 	return
 }
 
diff --git a/game/assets/assets_test.odin b/game/assets/assets_test.odin
new file mode 100644
index 0000000..e84089c
--- /dev/null
+++ b/game/assets/assets_test.odin
@@ -0,0 +1,42 @@
+package assets
+
+import "core:testing"
+
+@(private = "file")
+test_csv := `
+rpm,torque
+1000,100
+2000,110.5
+5000,354.123
+`
+
+
+@(private = "file")
+test_invalid_csv := `
+rpm,torque
+rpm,torque
+1000,100
+2000,110.5
+5000,354.123
+`
+
+
+@(test)
+test_curve_parsing :: proc(t: ^testing.T) {
+	curve, err := parse_curve_2d(transmute([]u8)test_csv, context.temp_allocator)
+
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(curve.points), 3)
+	testing.expect_value(t, curve.points[0], [2]f32{1000, 100})
+	testing.expect_value(t, curve.points[1], [2]f32{2000, 110.5})
+	testing.expect_value(t, curve.points[2], [2]f32{5000, 354.123})
+}
+
+@(test)
+test_curve_parsing_error :: proc(t: ^testing.T) {
+	curve, err := parse_curve_2d(transmute([]u8)test_invalid_csv, context.temp_allocator)
+	defer free_all(context.temp_allocator)
+
+	testing.expect_value(t, err, Curve_Parse_Error.ExpectedNumber)
+	testing.expect_value(t, len(curve.points), 0)
+}
diff --git a/game/assets/parsers.odin b/game/assets/parsers.odin
new file mode 100644
index 0000000..a1246e8
--- /dev/null
+++ b/game/assets/parsers.odin
@@ -0,0 +1,79 @@
+package assets
+
+import "core:bytes"
+import "core:encoding/csv"
+import "core:io"
+import "core:log"
+import "core:strconv"
+
+Curve_Parse_Error :: enum {
+	Ok,
+	TooManyColumns,
+	ExpectedNumber,
+}
+
+parse_curve_2d :: proc(
+	data: []byte,
+	allocator := context.allocator,
+) -> (
+	curve: Loaded_Curve_2D,
+	error: Curve_Parse_Error,
+) {
+	bytes_reader: bytes.Reader
+	bytes.reader_init(&bytes_reader, data)
+	bytes_stream := bytes.reader_to_stream(&bytes_reader)
+
+	csv_reader: csv.Reader
+	csv.reader_init(&csv_reader, bytes_stream, context.temp_allocator)
+	defer csv.reader_destroy(&csv_reader)
+
+	tmp_result := make([dynamic][2]f32, context.temp_allocator)
+
+	skipped_header := false
+	for {
+		row, err := csv.read(&csv_reader, context.temp_allocator)
+		if err != nil {
+			if err != io.Error.EOF {
+				log.warnf("Failed to read curve %v", err)
+			}
+			break
+		}
+
+		if len(row) != 2 {
+			log.warnf("Curve expected 2 columns, got %v", len(row))
+			error = .TooManyColumns
+			break
+		}
+
+		ok: bool
+		key: f64
+		val: f64
+		key, ok = strconv.parse_f64(row[0])
+		if !ok {
+			if skipped_header {
+				log.warnf("Curve expected numbers, got %s", row[0])
+				error = .ExpectedNumber
+				break
+			}
+			skipped_header = true
+			continue
+		}
+		val, ok = strconv.parse_f64(row[1])
+		if !ok {
+			if skipped_header {
+				log.warnf("Curve expected numbers, got %s", row[1])
+				error = .ExpectedNumber
+				break
+			}
+			skipped_header = true
+			continue
+		}
+
+		append(&tmp_result, [2]f32{f32(key), f32(val)})
+	}
+
+	curve.points = make([][2]f32, len(tmp_result), allocator)
+	copy(curve.points, tmp_result[:])
+
+	return
+}
diff --git a/game/fs.odin b/game/fs.odin
index 0cf843c..f970082 100644
--- a/game/fs.odin
+++ b/game/fs.odin
@@ -15,7 +15,9 @@ init_physfs :: proc(args: []string) {
 
 	physfs.init(strings.clone_to_cstring(args[0], context.temp_allocator))
 	physfs.setSaneConfig("serega", "gutter-runner", "zip", 0, 1)
+}
 
+init_physifs_raylib_callbacks :: proc() {
 	rl.SetLoadFileDataCallback(raylib_load_file_data_physfs)
 	rl.SetSaveFileDataCallback(raylib_save_file_data_physfs)
 	rl.SetLoadFileTextCallback(raylib_load_file_text_physfs)
diff --git a/game/game.odin b/game/game.odin
index 0a9a04d..3fcc37c 100644
--- a/game/game.odin
+++ b/game/game.odin
@@ -394,6 +394,25 @@ update_runtime_world :: proc(runtime_world: ^Runtime_World, dt: f32) {
 			},
 		)
 
+		engine := physics.immediate_engine(
+			&world.physics_scene,
+			&runtime_world.solver_state,
+			#hash("engine", "fnv32a"),
+			physics.Engine_Config {
+				rpm_torque_curve = assets.get_curve_2d(&g_mem.assetman, "assets/ae86_rpm_torque.csv").points,
+				lowest_rpm = 1000,
+				inertia = 10,
+				internal_friction = 8,
+				gear_ratios = []f32{3.48, 3.587, 2.022, 1.384, 1, 0.861},
+				axle = physics.Drive_Axle_Config {
+					wheels = {wheel_rl, wheel_rr},
+					wheel_count = 2,
+					diff_type = .Fixed,
+					final_drive_ratio = 4.3,
+				},
+			},
+		)
+
 		drive_wheels := []physics.Suspension_Constraint_Handle{wheel_rl, wheel_rr}
 		turn_wheels := []physics.Suspension_Constraint_Handle{wheel_fl, wheel_fr}
 		front_wheels := turn_wheels
@@ -426,11 +445,7 @@ update_runtime_world :: proc(runtime_world: ^Runtime_World, dt: f32) {
 			wheel.brake_impulse = brake_input * (1.0 - BRAKE_BIAS) * BRAKE_IMPULSE
 		}
 
-		for wheel_handle in drive_wheels {
-			wheel := physics.get_suspension_constraint(sim_state, wheel_handle)
-
-			wheel.drive_impulse = gas_input * DRIVE_IMPULSE
-		}
+		physics.get_engine(sim_state, engine).throttle = gas_input
 
 		car_body := physics.get_body(sim_state, runtime_world.car_handle)
 		turn_vel_correction := clamp(30.0 / linalg.length(car_body.v), 0, 1)
@@ -1040,6 +1055,8 @@ game_init :: proc() {
 
 	g_mem^ = Game_Memory{}
 
+	init_physifs_raylib_callbacks()
+
 	physics.init_physics_scene(&g_mem.runtime_world.world.physics_scene, 100)
 
 	game_hot_reloaded(g_mem)
diff --git a/game/physics/helpers.odin b/game/physics/helpers.odin
index 92cd7e2..ca21891 100644
--- a/game/physics/helpers.odin
+++ b/game/physics/helpers.odin
@@ -1,6 +1,7 @@
 package physics
 
 import "collision"
+import "core:math"
 import lg "core:math/linalg"
 import "game:halfedge"
 
@@ -150,3 +151,11 @@ body_get_aabb :: proc(body: Body_Ptr) -> (aabb: AABB) {
 
 	return aabb
 }
+
+rpm_to_angular_velocity :: proc(rpm: f32) -> f32 {
+	return 2.0 * math.PI * (rpm / 60.0)
+}
+
+angular_velocity_to_rpm :: proc(w: f32) -> f32 {
+	return (w / (2.0 * math.PI)) * 60.0
+}
diff --git a/game/physics/immediate.odin b/game/physics/immediate.odin
index aa48446..ceaf4a0 100644
--- a/game/physics/immediate.odin
+++ b/game/physics/immediate.odin
@@ -71,10 +71,40 @@ immediate_suspension_constraint :: proc(
 	return
 }
 
+immediate_engine :: proc(
+	scene: ^Scene,
+	state: ^Solver_State,
+	id: u32,
+	config: Engine_Config,
+) -> (
+	handle: Engine_Handle,
+) {
+	sim_state := get_sim_state(scene)
+	if id in state.immediate_engines {
+		engine := &state.immediate_engines[id]
+		if engine.last_ref != state.simulation_frame {
+			engine.last_ref = state.simulation_frame
+			state.num_referenced_engines += 1
+		}
+		handle = engine.handle
+		update_engine_from_config(sim_state, get_engine(sim_state, handle), config)
+	} else {
+		state.num_referenced_engines += 1
+		handle = add_engine(sim_state, config)
+		state.immediate_engines[id] = {
+			handle   = handle,
+			last_ref = state.simulation_frame,
+		}
+	}
+
+	return
+}
+
 prune_immediate :: proc(scene: ^Scene, state: ^Solver_State) {
 	tracy.Zone()
 	prune_immediate_bodies(scene, state)
 	prune_immediate_suspension_constraints(scene, state)
+	prune_immediate_engines(scene, state)
 }
 
 // TODO: Generic version
@@ -134,3 +164,30 @@ prune_immediate_suspension_constraints :: proc(scene: ^Scene, state: ^Solver_Sta
 		remove_suspension_constraint(get_sim_state(scene), handle)
 	}
 }
+
+prune_immediate_engines :: proc(scene: ^Scene, state: ^Solver_State) {
+	if int(state.num_referenced_engines) == len(state.immediate_engines) {
+		return
+	}
+
+	num_unreferenced_engines := len(state.immediate_engines) - int(state.num_referenced_engines)
+	assert(num_unreferenced_engines >= 0)
+
+	engines_to_remove := make([]u32, num_unreferenced_engines, context.temp_allocator)
+
+	i := 0
+	for k, &v in state.immediate_engines {
+		if v.last_ref != state.simulation_frame {
+			engines_to_remove[i] = k
+			i += 1
+		}
+	}
+
+	assert(i == len(engines_to_remove))
+
+	for k in engines_to_remove {
+		handle := state.immediate_engines[k].handle
+		delete_key(&state.immediate_engines, k)
+		remove_engine(get_sim_state(scene), handle)
+	}
+}
diff --git a/game/physics/scene.odin b/game/physics/scene.odin
index 097c9a5..9ebce02 100644
--- a/game/physics/scene.odin
+++ b/game/physics/scene.odin
@@ -2,6 +2,7 @@ package physics
 
 import "collision"
 import lg "core:math/linalg"
+import "game:container/spanpool"
 
 MAX_CONTACTS :: 1024 * 16
 
@@ -43,18 +44,26 @@ contact_container_copy :: proc(dst: ^Contact_Container, src: Contact_Container)
 Sim_State :: struct {
 	bodies:                                    #soa[dynamic]Body,
 	suspension_constraints:                    #soa[dynamic]Suspension_Constraint,
+	engines:                                   [dynamic]Engine,
 	// Number of alive bodies
 	num_bodies:                                i32,
+	num_engines:                               i32,
 
 	// Slices. When you call get_body or get_suspension_constraint you will get a pointer to an element in this slice
 	bodies_slice:                              #soa[]Body,
 	suspension_constraints_slice:              #soa[]Suspension_Constraint,
 	first_free_body_plus_one:                  i32,
 	first_free_suspension_constraint_plus_one: i32,
+	first_free_engine_plus_one:                i32,
 
 	// Persistent stuff for simulation
 	contact_container:                         Contact_Container,
 	convex_container:                          Convex_Container,
+
+	// NOTE: kinda overkill, but it simplifies copying sim states around a lot
+	// Engine array data
+	rpm_torque_curves_pool:                    spanpool.Span_Pool([2]f32),
+	gear_ratios_pool:                          spanpool.Span_Pool(f32),
 }
 
 Scene :: struct {
@@ -167,12 +176,80 @@ Suspension_Constraint :: struct {
 	next_plus_one:          i32,
 }
 
+Diff_Type :: enum {
+	Fixed,
+	// TODO: LSD
+}
+
+Drive_Wheel :: struct {
+	wheel:   Suspension_Constraint_Handle,
+	impulse: f32,
+}
+
+Drive_Axle :: struct {
+	// Params
+	wheels:            [2]Drive_Wheel,
+	wheel_count:       i32,
+	diff_type:         Diff_Type,
+	final_drive_ratio: f32,
+
+	// State
+	// Diff angular vel
+	w:                 f32,
+	// Impulse that constrains diff and engine motion
+	engine_impulse:    f32,
+	// Impulse that constrains wheels motion relative to each other
+	diff_impulse:      f32,
+}
+
+Engine_Curve_Handle :: distinct spanpool.Handle
+Gear_Ratios_Handle :: distinct spanpool.Handle
+
+// This actually handles everything, engine, transmission, differential, etc. It's easier to keep it in one place
+Engine :: struct {
+	alive:             bool,
+	// Engine Params
+	rpm_torque_curve:  Engine_Curve_Handle,
+	lowest_rpm:        f32,
+	inertia:           f32,
+	internal_friction: f32,
+
+	// Transmission Params
+	// 0 - reverse, 1 - first, etc.
+	gear_ratios:       Gear_Ratios_Handle,
+	axle:              Drive_Axle,
+
+	// Engine State
+	// Angular velocity, omega
+	q:                 f32,
+	w:                 f32,
+
+	// Impulse applied when engine is stalling (rpm < lowest_rpm)
+	unstall_impulse:   f32,
+	// Friction that makes rpm go down when you're not accelerating
+	friction_impulse:  f32,
+	// Impulse applied from releasing throttle
+	throttle_impulse:  f32,
+
+	// Transmission State
+	// -1 - reeverse, 0 - neutral, 1 - first, etc.
+	gear:              i32,
+
+	// Controls
+	throttle:          f32,
+
+	// Free list
+	next_plus_one:     i32,
+}
+
 // Index plus one, so handle 0 maps to invalid body
 Body_Handle :: distinct i32
 Suspension_Constraint_Handle :: distinct i32
+Engine_Handle :: distinct i32
 
 INVALID_BODY :: Body_Handle(0)
 INVALID_SUSPENSION_CONSTRAINT :: Suspension_Constraint_Handle(0)
+INVALID_ENGINE :: Engine_Handle(0)
 
 is_body_handle_valid :: proc(handle: Body_Handle) -> bool {
 	return i32(handle) > 0
@@ -180,13 +257,18 @@ is_body_handle_valid :: proc(handle: Body_Handle) -> bool {
 is_suspension_constraint_handle_valid :: proc(handle: Suspension_Constraint_Handle) -> bool {
 	return i32(handle) > 0
 }
+is_engine_handle_valid :: proc(handle: Engine_Handle) -> bool {
+	return i32(handle) > 0
+}
 is_handle_valid :: proc {
 	is_body_handle_valid,
 	is_suspension_constraint_handle_valid,
+	is_engine_handle_valid,
 }
 
 Body_Ptr :: #soa^#soa[]Body
 Suspension_Constraint_Ptr :: #soa^#soa[]Suspension_Constraint
+Engine_Ptr :: ^Engine
 
 _invalid_body: #soa[1]Body
 _invalid_body_slice := _invalid_body[:]
@@ -264,6 +346,25 @@ Suspension_Constraint_Config :: struct {
 	mass:              f32,
 }
 
+Drive_Axle_Config :: struct {
+	wheels:            [2]Suspension_Constraint_Handle,
+	wheel_count:       i32,
+	diff_type:         Diff_Type,
+	final_drive_ratio: f32,
+}
+
+Engine_Config :: struct {
+	rpm_torque_curve:  [][2]f32,
+	lowest_rpm:        f32,
+	inertia:           f32,
+	internal_friction: f32,
+
+	// Transmission Params
+	// 0 - reverse, 1 - first, etc.
+	gear_ratios:       []f32,
+	axle:              Drive_Axle_Config,
+}
+
 calculate_body_params_from_config :: proc(
 	config: Body_Config,
 ) -> (
@@ -335,6 +436,53 @@ update_suspension_constraint_from_config :: proc(
 	constraint.inv_inertia = 1.0 / (0.5 * config.mass * config.radius * config.radius)
 }
 
+add_engine_curve :: proc(sim_state: ^Sim_State, curve: [][2]f32) -> Engine_Curve_Handle {
+	handle := spanpool.allocate_elems(&sim_state.rpm_torque_curves_pool, ..curve)
+	return Engine_Curve_Handle(handle)
+}
+
+remove_engine_curve :: proc(sim_state: ^Sim_State, handle: Engine_Curve_Handle) {
+	spanpool.free(&sim_state.rpm_torque_curves_pool, spanpool.Handle(handle))
+}
+
+get_engine_curve :: proc(sim_state: ^Sim_State, handle: Engine_Curve_Handle) -> [][2]f32 {
+	return spanpool.resolve_slice(&sim_state.rpm_torque_curves_pool, spanpool.Handle(handle))
+}
+
+add_gear_ratios :: proc(sim_state: ^Sim_State, gear_ratios: []f32) -> Gear_Ratios_Handle {
+	handle := spanpool.allocate_elems(&sim_state.gear_ratios_pool, ..gear_ratios)
+	return Gear_Ratios_Handle(handle)
+}
+
+remove_gear_ratios :: proc(sim_state: ^Sim_State, handle: Gear_Ratios_Handle) {
+	spanpool.free(&sim_state.gear_ratios_pool, spanpool.Handle(handle))
+}
+
+get_gear_ratios :: proc(sim_state: ^Sim_State, handle: Gear_Ratios_Handle) -> []f32 {
+	return spanpool.resolve_slice(&sim_state.gear_ratios_pool, spanpool.Handle(handle))
+}
+
+update_engine_from_config :: proc(
+	sim_state: ^Sim_State,
+	engine: Engine_Ptr,
+	config: Engine_Config,
+) {
+	remove_engine_curve(sim_state, engine.rpm_torque_curve)
+	engine.rpm_torque_curve = add_engine_curve(sim_state, config.rpm_torque_curve)
+
+	remove_gear_ratios(sim_state, engine.gear_ratios)
+	engine.gear_ratios = add_gear_ratios(sim_state, config.gear_ratios)
+
+	engine.lowest_rpm = config.lowest_rpm
+	engine.inertia = config.inertia
+	engine.internal_friction = config.internal_friction
+
+	engine.axle.final_drive_ratio = config.axle.final_drive_ratio
+	engine.axle.wheels[0].wheel = config.axle.wheels[0]
+	engine.axle.wheels[1].wheel = config.axle.wheels[1]
+	engine.axle.wheel_count = config.axle.wheel_count
+	engine.axle.diff_type = config.axle.diff_type
+}
 
 add_body :: proc(sim_state: ^Sim_State, config: Body_Config) -> Body_Handle {
 	body: Body
@@ -425,6 +573,54 @@ remove_suspension_constraint :: proc(sim_state: ^Sim_State, handle: Suspension_C
 	}
 }
 
+invalid_engine: Engine
+
+get_engine :: proc(sim_state: ^Sim_State, handle: Engine_Handle) -> Engine_Ptr {
+	index := int(handle) - 1
+	if index < 0 || index >= len(sim_state.bodies_slice) {
+		return &invalid_engine
+	}
+
+	return &sim_state.engines[index]
+}
+
+add_engine :: proc(sim_state: ^Sim_State, config: Engine_Config) -> Engine_Handle {
+	sim_state.num_engines += 1
+
+	engine: Engine
+	update_engine_from_config(sim_state, &engine, config)
+
+	engine.alive = true
+
+	if sim_state.first_free_engine_plus_one > 0 {
+		index := sim_state.first_free_engine_plus_one
+		new_engine := get_engine(sim_state, Engine_Handle(index))
+		next_plus_one := new_engine.next_plus_one
+		new_engine^ = engine
+		sim_state.first_free_engine_plus_one = next_plus_one
+		return Engine_Handle(index)
+	}
+
+	append(&sim_state.engines, engine)
+	index := len(sim_state.engines)
+	return Engine_Handle(index)
+}
+
+remove_engine :: proc(sim_state: ^Sim_State, handle: Engine_Handle) {
+	if is_handle_valid(handle) {
+		engine := get_engine(sim_state, handle)
+
+		remove_engine_curve(sim_state, engine.rpm_torque_curve)
+		remove_gear_ratios(sim_state, engine.gear_ratios)
+
+		engine.alive = false
+		engine.next_plus_one = sim_state.first_free_engine_plus_one
+		sim_state.first_free_engine_plus_one = i32(handle)
+		sim_state.num_engines -= 1
+	}
+}
+
+
 _get_first_free_body :: proc(sim_state: ^Sim_State) -> i32 {
 	return sim_state.first_free_body_plus_one - 1
 }
@@ -434,7 +630,10 @@ destry_sim_state :: proc(sim_state: ^Sim_State) {
 	delete_soa(sim_state.suspension_constraints)
 	delete_soa(sim_state.contact_container.contacts)
 	delete_map(sim_state.contact_container.lookup)
+	delete(sim_state.engines)
 	convex_container_destroy(&sim_state.convex_container)
+	spanpool.destroy_spanpool(&sim_state.rpm_torque_curves_pool)
+	spanpool.destroy_spanpool(&sim_state.gear_ratios_pool)
 }
 
 destroy_physics_scene :: proc(scene: ^Scene) {
diff --git a/game/physics/simulation.odin b/game/physics/simulation.odin
index c746ba8..96e6ddb 100644
--- a/game/physics/simulation.odin
+++ b/game/physics/simulation.odin
@@ -9,6 +9,7 @@ import "core:math"
 import lg "core:math/linalg"
 import "core:math/rand"
 import "core:slice"
+import "game:container/spanpool"
 import "libs:tracy"
 
 _ :: rand
@@ -31,13 +32,16 @@ Solver_State :: struct {
 	// Number of immediate bodies referenced this frame
 	num_referenced_bodies:                 i32,
 	num_referenced_suspension_constraints: i32,
+	num_referenced_engines:                i32,
 	immedate_bodies:                       map[u32]Immedate_State(Body_Handle),
 	immediate_suspension_constraints:      map[u32]Immedate_State(Suspension_Constraint_Handle),
+	immediate_engines:                     map[u32]Immedate_State(Engine_Handle),
 }
 
 destroy_solver_state :: proc(state: ^Solver_State) {
 	delete(state.immedate_bodies)
 	delete(state.immediate_suspension_constraints)
+	delete(state.immediate_engines)
 }
 
 Immedate_State :: struct($T: typeid) {
@@ -57,9 +61,11 @@ sim_state_copy :: proc(dst: ^Sim_State, src: ^Sim_State) {
 	dst.num_bodies = src.num_bodies
 	dst.first_free_body_plus_one = src.first_free_body_plus_one
 	dst.first_free_suspension_constraint_plus_one = src.first_free_suspension_constraint_plus_one
+	dst.first_free_engine_plus_one = src.first_free_engine_plus_one
 
 	resize(&dst.bodies, len(src.bodies))
 	resize(&dst.suspension_constraints, len(src.suspension_constraints))
+	resize(&dst.engines, len(src.engines))
 
 	dst.bodies_slice = dst.bodies[:]
 	dst.suspension_constraints_slice = dst.suspension_constraints[:]
@@ -70,9 +76,12 @@ sim_state_copy :: proc(dst: ^Sim_State, src: ^Sim_State) {
 	for i in 0 ..< len(dst.suspension_constraints) {
 		dst.suspension_constraints[i] = src.suspension_constraints[i]
 	}
+	copy(dst.engines[:], src.engines[:])
 
 	contact_container_copy(&dst.contact_container, src.contact_container)
 	convex_container_copy(&dst.convex_container, src.convex_container)
+	spanpool.copy(&dst.rpm_torque_curves_pool, src.rpm_torque_curves_pool)
+	spanpool.copy(&dst.gear_ratios_pool, src.gear_ratios_pool)
 }
 
 Step_Mode :: enum {
@@ -204,6 +213,7 @@ simulate :: proc(
 	state.simulation_frame += 1
 	state.num_referenced_bodies = 0
 	state.num_referenced_suspension_constraints = 0
+	state.num_referenced_engines = 0
 }
 
 GLOBAL_PLANE :: collision.Plane {
@@ -474,6 +484,119 @@ pgs_solve_contacts :: proc(
 	}
 }
 
+pgs_solve_engines :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f32, inv_dt: f32) {
+	for &engine in sim_state.engines {
+		if engine.alive {
+			rpm_torque_curve := get_engine_curve(sim_state, engine.rpm_torque_curve)
+			gear_ratios := get_gear_ratios(sim_state, engine.gear_ratios)
+
+			// Unstall impulse
+			{
+				engine_lowest_velocity := rpm_to_angular_velocity(engine.lowest_rpm)
+
+				delta_omega := engine_lowest_velocity - engine.w
+
+				inv_w := engine.inertia
+
+				incremental_impulse := inv_w * delta_omega
+				new_total_impulse := max(engine.unstall_impulse + incremental_impulse, 0)
+				applied_impulse := new_total_impulse - engine.unstall_impulse
+				engine.unstall_impulse = new_total_impulse
+
+				engine.w += applied_impulse / engine.inertia
+			}
+
+			// Internal Friction
+			{
+				delta_omega := -engine.w
+
+				inv_w := engine.inertia
+
+				friction :=
+					math.pow(
+						max(engine.w - rpm_to_angular_velocity(engine.lowest_rpm), 0) * 0.001,
+						4,
+					) *
+						engine.internal_friction +
+					engine.internal_friction
+
+				incremental_impulse := inv_w * delta_omega
+				new_total_impulse := math.clamp(
+					engine.friction_impulse + incremental_impulse,
+					-friction,
+					friction,
+				)
+				applied_impulse := new_total_impulse - engine.friction_impulse
+				engine.friction_impulse = new_total_impulse
+
+				engine.w += applied_impulse / engine.inertia
+			}
+
+			// Throttle
+			{
+				rpm := angular_velocity_to_rpm(engine.w)
+
+				torque: f32
+
+				idx, _ := slice.binary_search_by(
+					rpm_torque_curve,
+					rpm,
+					proc(a: [2]f32, k: f32) -> slice.Ordering {
+						return slice.cmp(a[0], k)
+					},
+				)
+
+				if idx > 0 && idx < len(rpm_torque_curve) - 1 {
+					cur_point := rpm_torque_curve[idx]
+					next_point := rpm_torque_curve[idx + 1]
+					rpm_diff := next_point[0] - cur_point[0]
+					alpha := (rpm - cur_point[0]) / rpm_diff
+
+					torque = math.lerp(cur_point[1], next_point[1], alpha)
+				} else {
+					torque = rpm_torque_curve[math.clamp(idx, 0, len(rpm_torque_curve) - 1)][1]
+				}
+
+				torque *= engine.throttle
+
+				engine.w += torque / engine.inertia
+			}
+
+			// Transmission
+			{
+				// TODO: update from game
+				engine.gear = 1
+
+				power_split := 1.0 / f32(engine.axle.wheel_count)
+				for i in 0 ..< engine.axle.wheel_count {
+					drive_wheel := &engine.axle.wheels[i]
+					wheel := get_suspension_constraint(sim_state, drive_wheel.wheel)
+
+					ratio := gear_ratios[1] * engine.axle.final_drive_ratio
+					inv_ratio := f32(1.0 / ratio)
+
+					w1 := wheel.inv_inertia
+					w2 := f32(1.0 / (engine.inertia * ratio))
+
+					w := w1 + w2
+					inv_w := f32(1.0 / w)
+
+					delta_omega := -engine.w - wheel.w * ratio
+
+					incremental_impulse := -inv_w * delta_omega * power_split
+					drive_wheel.impulse += incremental_impulse
+
+					wheel.w += -incremental_impulse * wheel.inv_inertia * inv_ratio
+					engine.w += -(incremental_impulse / engine.inertia)
+				}
+			}
+
+			// tracy.Plot("rpm", f64(angular_velocity_to_rpm(engine.w)))
+			log.debugf("rpm: %v", angular_velocity_to_rpm(engine.w))
+		}
+	}
+}
+
 pgs_solve_suspension :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f32, inv_dt: f32) {
 	// Solve suspension velocity
 	for _, i in sim_state.suspension_constraints {
@@ -604,7 +727,7 @@ pgs_solve_suspension :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f
 					slip_len = slip_len == 0 ? 0 : min(slip_len, 1) / slip_len
 					slip_vec *= slip_len
 
-					log.debugf("slip_vec: %v", slip_vec)
+					// log.debugf("slip_vec: %v", slip_vec)
 
 					long_friction :=
 						abs(
@@ -712,6 +835,28 @@ pgs_substep :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f32, inv_d
 			}
 		}
 
+		for i in 0 ..< len(sim_state.engines) {
+			e := &sim_state.engines[i]
+
+			if e.alive {
+				gear_ratios := get_gear_ratios(sim_state, e.gear_ratios)
+				e.w += e.unstall_impulse / e.inertia
+
+				e.w += e.friction_impulse / e.inertia
+
+				for i in 0 ..< e.axle.wheel_count {
+					drive_wheel := &e.axle.wheels[i]
+					wheel := get_suspension_constraint(sim_state, drive_wheel.wheel)
+
+					ratio := gear_ratios[1] * e.axle.final_drive_ratio
+					inv_ratio := f32(1.0 / ratio)
+
+					wheel.w += -drive_wheel.impulse * wheel.inv_inertia * inv_ratio
+					e.w += -(drive_wheel.impulse / e.inertia)
+				}
+			}
+		}
+
 		for i in 0 ..< len(sim_state.suspension_constraints) {
 			s := &sim_state.suspension_constraints_slice[i]
 
@@ -739,6 +884,7 @@ pgs_substep :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f32, inv_d
 
 	apply_bias := true
 	pgs_solve_contacts(sim_state, config, dt, inv_dt, apply_bias)
+	pgs_solve_engines(sim_state, config, dt, inv_dt)
 	pgs_solve_suspension(sim_state, config, dt, inv_dt)
 
 	for i in 0 ..< len(sim_state.bodies_slice) {
@@ -763,6 +909,12 @@ pgs_substep :: proc(sim_state: ^Sim_State, config: Solver_Config, dt: f32, inv_d
 		}
 	}
 
+	for i in 0 ..< len(sim_state.engines) {
+		e := &sim_state.engines[i]
+
+		e.q = math.mod_f32(e.q + 0.5 * e.w * dt, math.PI * 2)
+	}
+
 	for i in 0 ..< len(sim_state.suspension_constraints_slice) {
 		s := &sim_state.suspension_constraints_slice[i]
 
diff --git a/libs/physfs/Makefile b/libs/physfs/Makefile
index bf33716..118849f 100644
--- a/libs/physfs/Makefile
+++ b/libs/physfs/Makefile
@@ -1,7 +1,7 @@
 configure_cmake:
 	cmake -B build ./physfs
 build_physfs: configure_cmake
-	cmake --build build --config Release -j8
+	cmake --build build --config Debug -j8
 libphysfs.a: build_physfs
 	cp ./build/libphysfs.a .
 libphysfs.so: build_physfs
diff --git a/research/engine_friction.ipynb b/research/engine_friction.ipynb
new file mode 100644
index 0000000..1b0570b
--- /dev/null
+++ b/research/engine_friction.ipynb
@@ -0,0 +1,98 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "1002b4fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib widget"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "fadc7b33",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sympy import Symbol, sin, atan, exp, solve, diff, simplify,Eq\n",
+    "from sympy.plotting import plot, plot3d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3074424c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dfc8c93ea1774a788835f524f65b6843",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rpm = Symbol('rpm', positive=True)\n",
+    "\n",
+    "friction = pow(rpm - 1000, 4) * 10\n",
+    "\n",
+    "plot(friction + 10, (rpm, 1000, 7000))\n",
+    "\n",
+    "pow(0, 4) * 10 + 10"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/research/pacejka96.ipynb b/research/pacejka96.ipynb
index 313afed..eee10f6 100644
--- a/research/pacejka96.ipynb
+++ b/research/pacejka96.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 276,
+   "execution_count": 281,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 277,
+   "execution_count": 282,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 278,
+   "execution_count": 283,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -44,7 +44,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 284,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,24 +63,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 280,
+   "execution_count": 285,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "245af2cc48ed4b118eabc0e2d03902a7",
+       "model_id": "efbfae9030f7463a92499d89a3f1bc48",
        "version_major": 2,
        "version_minor": 0
       },
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXqBJREFUeJzt3Xd8W/W9//G3JNvyXvF2nL3IXpCaGSAQxs0tl44wWiAU+qNAb0t+XeECKbcXwo+2FC5Nm1so5d5bNmW0hYZCIIQRSEkII2QvZ3jGQ56SLZ3fH0eS7cR2JFuyJPv1fDz00PHRkfS1EMk7n++yGIZhCAAAAMOGNdINAAAAwOAiAAIAAAwzBEAAAIBhhgAIAAAwzBAAAQAAhhkCIAAAwDBDAAQAABhmCIAAAADDDAEQAABgmCEAAgAADDMEQAAAgGGGAAgAADDMEAABAACGGQJgHwzDkMPhkGEYkW4KAABAyBAA+9DY2KiMjAw1NjZGuikAAAAhQwAEAAAYZgiAAAAAwwwBEAAAYJghAAIAAAwzBEAAAIBhhgAIAAAwzBAAAQAAhhkCIAAAwDBDAAQAABhmCIAAAADDDAEQAABgmCEAAgAADDMEQAAAgGGGAAgAADDMxEwA3LBhg5YsWaKioiJZLBa99NJLfV7/wgsv6IILLlBubq7S09NVWlqq1157bdDaCwAAEK1iJgA2Nzdr1qxZWr16dUDXb9iwQRdccIFeffVVbd68Weeee66WLFmijz/+OOxtBQAAiGYWwzCMSDciWBaLRS+++KIuu+yyoJ43bdo0LV26VHfddVdA1zscDmVkZKihoUHp6en9bC0AAEB0iYt0AwaLx+NRY2OjsrOze73G6XTK6XT6f3Y4HMG/0d63pA9+K2WPlc67Q7Kn9bfJ6EN9i0v7appVXt+m6sY2VTc5VdPoUku7W60ut9ra3Wptd8tjGLJZLLJaLLJapTirVSl2m1Lt8UpLjFN6YpzSEuOVnZKg/PRE5aXblZ+WqPSkOFkslkj/mgAAhMWwCYC/+MUv1NTUpK9//eu9XrNq1Srdfffd/X+Tqu3Sk0sltzdEVu+QvvGiZI2Znvao4/EY2n+sWVvL6rX1UL22lzu0r6ZZtc2usL6vPc6qvHS7RmYma/SIZJVkJ2tUtnk8KjtZmckJYX1/AADCaVh0AT/55JO68cYb9fLLL2vRokW9XtdTBbCkpCTwLuDnvyV9/rw0YoLUcETqaJUuf0Sa2XvoxImONTm1YXe1Nuyq0YZd1TrWS9grSE/UyKwk5aXblZtq14hUu1LtcUpKsCk5wSZ7nE1Wi+QxDLk9ktsw1OH2qNnlVmNbuxrbOtTU1iFHW7uONblU1dimSodTDa3tJ21jVnK8JualaUJ+qibmpWpiXpom5acqN81O5RAAEPWGfAXw6aef1g033KDnnnuuz/AnSXa7XXa7vX9v5GqWdvzVPP7Ko9KeN6Q3/0N690FpxtckQkGfmpwd+vu2Cr209aje21Mjt6fz3yX2OKtmFGdoVkmmZo7M0PjcVI3NSVGKPTxf37Z2t6obnapwtOlQbYvKaltUdsy8P1jboupGp+pa2rXpQK02Hajt9tz0xDhNzE/T1MJ0TStK19SidE3KT1NivC0sbQUAoD+GdAB86qmndP311+vpp5/WpZdeGt4327de6miTMkdLhbOlrDHSO7+SqrZJe9+UJpwf3vePUXurm/T4ewf0/ObDam13+8+fUpiuhZNzdc6kXM0dlaWEuMHrRk+Mt6kk2+z2PXXMiWNGW1wd2lfdrD1VTdpd1ajdlU3aU9WkA8ea5Wjr0OaDddp8sM5/vc1q0YTcVH8gnFqUrmmFGcpIjh+03wkAgK5iJgA2NTVpz549/p/379+vrVu3Kjs7W6NGjdKKFSt05MgR/c///I/k7fa99tpr9dBDD2nBggWqqKiQJCUlJSkjIyP0DTz4vnk/4Xyz2peUJc35hrTpv6StTxIAj/NxWZ0efnOP3txR5T83NidFX55dpC/PLtbYnJSItq8vyQlxml6coenF3b9Hbe1uHTjWrJ0VjfriqEPbjjq07WiD6lratbOyUTsrG/XCx0f814/KTtbMkRmaXZKpWSWZmlaUruSEmPlfEgAQw2JmDOD69et17rnnnnD+2muv1eOPP67rrrtOBw4c0Pr16yVJCxcu1Ntvv93r9YEIahmYRy+QDm+SLlsjzb7SPHdks/TIeVJ8svSD3ZI9NaD3Hcp2VTbq56/t1OtfVEoys/L5U/J0/RljVTp+xJAbP2cYhiocbdp2xKEvys1AuO2oQ4frWk+41mqRJuWnaXZJpmaOzNSskgxNyk9TvI1JRACA0IqZABgJAQdAj1u6t9ic9HHLP6TcSeZ5w5AenivV7hv2k0GanB361eu79Pj7B+T2GLJapMvnjtQt506I6mpfuDS0tOuzIw365HC9PjlkznCuanSecJ09zqrpxRn+SuGckiyVZCcNuaAMABhc9DeFQt0BM/zZ7NKI8Z3nLRZp2uXSO7+QdrwybAPguu2V+rcXP1eFo02SdOHUfP3oosmakDd810jMSI7XmRNzdObEHP+5ioY2fyD85HC9Pj3coMYexhTmpCZodkmW5ozK1NxRWZo5MiNsE2IAAEMTf2uEQvUO8z53kmQ9brbn5IvNALj3TanDJcUNn/XjWl1u3fPqF/rjB2WSd8zb3V+epnMn50W6aVGpICNRBRkFWjytQOqyBuInh8ww+PGhen1xtEE1TS69sb1Sb2w3u9GtFmlyQbrmjsrUnFFZmjsqU2NzUqgSAgB6RQAMhZpd5n3O5BMfK5orJedILTVS2UZp3DmD3rxI2FPVqJv+uEV7qpokSTecOVY/WDyZ5VCCYLVaND43VeNzU3X53JGSd6LJtqMOfVxWp4/L6rWlrE7lDW3aXu7Q9nKHnvjQDNuZyfGaXWJWCOeMMieZpCcy6xgAYCIAhkLdAfM+e9yJj1mt0qTF0tYnpN1/HxYB8M0dlfrXp7aqydmhvDS7fvn1WTprYm6kmzUkJMbbNG90luaNzvKfK29o1VZvGPy4rF6fHmlQfUu71u+s1vqd1ZJ3NMLEvFTNKcnS3NFmpXBCbqqsVqqEADAcEQBDwRcAs8b0/PjEC80AuGuttPieQW3aYDIMQ7/bsE/3rd0hw5BOG5ut3149VyNS+7m4NgJSmJGkwhlJunhGoSTJ1eHR9nKzSrilrF4fH6rTodpW7aps0q7KJj3z0SFJUpo9TrNHZWpOSabmjM7SnJJMtrgDgGGCABgKdQfN+94C4PjzJGucdGyPVLtfyh47qM0bDIZhaNXfduh3G/ZJkq5aMEo/XTJtUBdwhikhzqpZ3rUFrzvDPFfd6DS7jQ/V6+OyOn1yqEGNzg69s7tG7+yu8T93XG5KZ5WwJEuT8lMVxzI0ADDkEAAHyuORGg6bx5mjer4mMV0aeao5BnD/20MuALo9hu546TM9tcmsLN1x6Sm64aweusMRMblpdl04rUAXeieYdLg92lnZaFYIy+q0taxe+2qata/avP1pi/mdTk6wadbITM0elalZIzM1Z1Sm8tMTI/zbAAAGigA4UK21kqfdPE7N7/26seeYAXDf29K86wateeHm8Rj64fOf6IUtR2S1SPddPlNfP7Uk0s3CScTZrJpWlKFpRRn65pdGS5Lqml3aeqhzLOHWQ/VqcnZo475j2rjvmP+5BemJml3SGQpZhgYAYg8LQfchoIWgK7dJvz1dSh4h/Whf7y928H3pDxebM4J/sNucHBLjDMPQ3X/5Qo+/f0A2q0UPXTFb/zSzKNLNQoi4PYb2VDWZXcaH6/VxWb12VTbKc9yfGFaLNDEvzb+l3eySTLqOASDK8c/2gWo09xjus/onScXzzS3hWmqkqi+kgumD0rxwevCN3Xr8fXMCzC++NpPwN8TYrBZNLkjT5II0XXGaObyh2dmhz480aKt395JPDtXraEObf69j3wSTpHibZhRn+KuEs0dlqigjkbUJASBKEAAHqqnKvD9ZAIxLkEafLu15wxwHGOMB8Nl/HNJD63ZLku7+52n6lzkjI90kDIIUe5wWjBuhBeNG+M9VOdr8gXCrd9HqJmeHNh2o1aYDtf7rclLtZtdxSYZml2RpRnGGMpJZmxAAIoEAOFBNAVYA5R0HuOcNcxxg6S1hb1q4fHSgVv/20meSpH89b4KuPb2X2c8YFvLSE7tNMPF4DO2tbuoWCndUNKqmydltBxNJGj0iWdOLMzSjOEMzizM0rThDGUmEQgAINwLgQPkqgGkBBEDfItAH35Pc7ZIt9v6iO1Lfqpv+uFntbkOXzCjQ9xdNinSTEGWsVosm5qdpYn6avjbfnBDU6nJr29GGbqHwcF2rDh5r0cFjLXrl03L/88d0CYUzRmZoenEGu5gAQIgRAAcq0DGAkpQ/Q0rKNmcOH9kijVoQ9uaFkrPDrf/zvx+ppsmlUwrT9YuvzWInCQQkKcGm+WOyNX9Mtv9cXbNLnx9t0GdHGvTZYfP+cF2rDhxr0YFjLfprl1A4NifFGwrTNaM4U9OK0wmFADAABMCBCnQMoLzbwo09S/riZXMcYIwFwPvX7tTnRxzKSo7XI9fMU3ICXx/0X1ZKgs6amNttm8C6ZpcZCI806PMjDfr0cIOO1Ldqf02z9tc06y+fHPVf6wuF04vSNbUoXVML09l1BgACxN/gAxXMGEB5xwF+8bI5DvCcH4W1aaH01o4q/f7d/ZKkX3xtlkZmJUe6SRiCslISdPakXJ09qTMU1ja79PmR7pXC3kJhfrpdUwt9gTBDU4vSNTo7mUo1AByHADhQ/jGABYFdP9Y7DvDwJqm9VYpPCl/bQqTK0aYfPPeJJOm608fo/FMCDLtACGT3EAqPNTn1+VGHPj/SoC+OOvRFuUP7a5pV6XCq0lGtt3ZW+69NTrDplML0LsEwXZML0pQYb4vQbwQAkUcAHIj2NsnpMI9Tck92tWnEeCmtSGo8Kh36UBq3MKxNHCjDMHT7i5/pWLM57u8nF0+JdJMAjUi165xJuTqnSyhscnZoZ4XDHwi/OOrQjopGtbjc2nywTpsP1vmvtVqk8bmp/kB4ijcU5qXZWasQwLBAAByItnrz3mKV7L3sFHI8i0Uae7b06dPS/g1RHwBf+axcb2yvUrzN3OmDqgmiVao9TvNGZ2ve6M6JJh1uj/bXNPsD4RflDm076lBts0u7q5q0u6pJL2/t7ELOTI7X5Pw0TSlI0+SCdE0uSNWk/DSlMeEEwBBDAByIVm8ATMwIbmu3rgEwitU1u/TTP2+TJN1y7gRNyk+LdJOAoMTZrP4lab48u1jyVrWrGp1dAmGDdlQ06kBNs+pb2vXh/lp9uL+22+sUZyZpSkGaJhX4wmGaxuWkKiGO7e4AxCYC4ED4KoCJmcE9b+xZ5v2RLVKbQ0oMsHo4yP7jle2qaXJpYl6qvrNwfKSbA4SExWJRfnqi8tMTde6UPP/5tna39lQ1aWeFua3djopG7apoVIWjTUfqW3WkvlXrdlT5r4+zWjQuN0WTC9LNcJifpol5qSrJTpaNSScAohwBcCB8FcCkIANg5igpa6xUt18q2yhNWhyW5g3Eh/uO6U9bDstike77ykzZ4+j6xdCWGG8zl5Upzuh2vr7F5Q+FOys6b43ODu2qbNKuyib95ZPO6xPirBqXk6IJeamamJdm3uenasyIFCqGAKIGAXAg+lsBlLcbuG6/2Q0cZQHQ7TF091++kCRdddoozRudFekmARGTmZxwwv7HhmHoaEObdlWYlcKdFQ7trGzSvuomOTs82uE9L3UuZm2zWjR6RLIm5Kb6Q+GE3DSNz0thTU0Ag44/dQaivxVAeQPglv82F4SOMs9vPqQvyh1KS4zT8gvY6g04nsViUXFmkoozk7p1I7s9ho7UtWp3VaP2eCeZ7Klq0t6qJjU6O7Svuln7qpv19y8qu71ecWaSt2JohsOxOSkal5uqnNQEZiUDCAsC4EAMtAIoSRWfSS21UnL2yZ4xKBrb2vXz13ZKkr53/kR2VgCCYLNaNGpEskaNSO62XqZhGKp0OL2hsDMc7q1q0rFml3+M4du7qru9Xpo9TuNyUzQ2J0Vjc1K7HKcoxc4f3wD6jz9BBmIgFcDUPCn3FKl6u3TgHWnql0PevP5Y/dZe1TS5NC4nRdeUjol0c4AhwWKxqCAjUQUZiTpzYk63x2qbXdrjrRTurmrU3upm7a9p0uG6VjU6O/TJ4QZ9crjhhNcsSE80w2BuisblpHjDYapKspIUZ2OsIYC+EQAHYiAVQHmrgNXbzXGAURAAKx1t+sN75nZvt19yCgPWgUGQnZKg08Zm67Sx3XsB2trdKqttMbuNa5q0v9rc+m5fTbNqm12qcLSpwtGmjfuOdXtenLcKOS4nRaNHpGjMiGSNGpGi0dnJKs5KUjzhEAABcIAGUgGUNwBu+q+oWQ/wN2/tkbPDo/mjs3T+KXkBPANAuCTG2zQpP63H9TfrW1xmGPSGwv01zdpb3aQDx5rV1u7xjzU8ns1qjl0cPSLZvGWnaFSX46QEZvsDwwUBcCAGWgEcc4Yki1SzS3KUS+mFIW1eMI7Wt+qpTYckScsvmMTAcyCKZSYnaM6oBM0Z1X2GvsdjqMLR5g2GTTpwrEUHj7WorLZZB4+1yNnhUVlti8pqW/TO7hNfNy/N7g2HZsVw1IhkjRmRotEjkpWZnDB4vyCAsCMADsRAK4BJWVLhLKl8qzkOcObXQ9q8YPz6rT1yuT360rhsnT4hJ4BnAIg2VqtFRZlJKspMOmGsocdj7oBy8JgZBg96Q2FZbYsO1DTL0dahqkanqhqd+seBuhNeOz0xTiOzklWSnWTeZ3nvs5M1MiuJSSlAjOH/2IEYaAVQ3m7g8q3mcjARCoCHalv07D981b/JEWkDgPCyWjsnonRd09CnvsWlg8dadOBYs8qOtehgbYs/LFY1OuVo6zD3VC539Pj62SkJGpmVpJFZSSrJMkPhyOzOoMg+4kB0IQAOxEArgJI09hzp/f+M6DjA/9qwVx0eQ2dNzDlhIDqA4SEzOUGZyQmaVXLin2etLnNCypH6Fh2qbdXhOu+99+eG1nbVNrtU2+zSpz3MWJaknFT7CdXDwsxEFXsrlqlUEIFBxf9x/dXhlDpazeOBVABHfUmyxkn1ZVLdASlrcJdeOdbk1HMfHZYk3XLuhEF9bwCxISnBpskFaZpccOKEFElytLXrsDcYHq5r1SHffa153+TsUE2TUzVNTn1cVt/ja6Qnxvm7r4syE837jM6f89MTmcEMhBABsL/aunSD2NP7/zr2VKl4vnToA7MKOMgB8H82HpSzw6OZIzO0gOofgH5IT4zX1KJ4TS068c9CwzDU0Nquw3VdKofegHi0oU1H680KoqOtQw7/FnonslqkvLTEznCYmaSijC7HmUnKSo5nAhsQIAJgf7mazPuEVMk6wH+Vjj27MwDOvSYkzQtEq8ut/9l4QJL07bPH8QcngJCzWCz+7uXpxRk9XtPs7FB5Q6uO1JuB0Lx5jxtaVV7fJpfb41/7cEsvVcTEeKsKM5KUn25XQXqi8jMSVZhujnvM997nptpZKBsgAA6APwCmDPy1xp4tbbjfDICGIQ1SEHt+8yHVtbSrJDtJF00rGJT3BIDjpdjjNCEvTRPyeu5i9ngMHWt2+cPhkfpWlTe0dfm5TTVNTrW1e/zrIvbGajHHIxZkJKqgazg8LigyJhFDHd/w/nJ5/4AJRQAceaoUlyg1VZprAuaGfyau22Po0XfNXT9uOHMc/yIGELWsVoty0+zKTbP3OElFkpwdbpXXmxXCSkebKhraVN7gPXa0qbKhTVWNTnV4l8OpanTqU/U8YUXefZjzvSHRDIV25aUlKi/Nrrx0u3JTE5WXbmd2M2IWAbC/unYBD1R8olSywFwKZt/bgxIA395VpYPHWpSRFK+vzR8Z9vcDgHCyx9k0JidFY3J6/0e5x2Ooptmpyganyhta/eGwosGpSkeb95xTTc4ONTo71Ojdo7kvaYlxyvOG024BsevPaYlKT4pjmA2iCgGwv5whDICSNG6hGQD3vikt+HZoXrMPf/ygTJL09fkjlZzA1wDA0Ge1WryhLFEzRvY8HlGSmpwdqmjorCT6qopVDqeqGtv8FURXh0eNbR1qbOvQ3h623usqIc6q3FQzHPYYGFMTlZtmV3ZKAvuwY1DwN39/hbILWJImLJLW3W2OA+xwSnH20LxuDw7VtuitnVWSpKsWjA7b+wBALEq1x2lCXqom5PX+D3zDMORo61C1NxBWNzr9AbHaGxCrGp2qcrTJ0dYhV4dHR7zjF08mIyleI1ITlJNqV473fkSKXTlpCRqRYleu9z4nza6UBBuVRfQLAbC/fAHQHqIKYMEMKTXfHAdYttGsCIbJU5vKZBjSmRNyNLaP7hIAQM8sFosykuKVkRTf6+QVn7Z2tz8UVncNiA6nqpu8VUWHU8eaXXJ7zGVzGlrbte8kVUV5Zz6PSOkSFP33ned857OSE2SzEhZhIgD2l8u7VlWoKoAWi1kF3PqEtPv1sAVAV4dHz35kbvv2jS+NCst7AAA6JcbbVJJt7pvcF483/JmLZrtU0+TUMe/xsWanqhvNe/O8Sy0ut9raA68sWi3mln1db1nJCRqRkqCs4895AyOTXIYuAmB/+buAQ1QBlKQJ55sBcM86afE9oXvdLtZuq1BNk0v56XYtOiU/LO8BAAie1WpRljeMTQzgj+cWV4eONblU7Q2EXQNjTddzzS7VtbjkMeR9zBVwm1ISbN3CYXayNyQeFyR9j2UkxctKlTEmEAD7yxnCdQB9xp0rWaxS9Xap4bCUEfrZuU99aE7+uOLUUSz9AgAxLDkhTsnZcSetLEpSh9uj2haXahrNMHis2aU67/7Ntc0u1ba4VNtkPuY71+Ex1Oxyq9nVqsN1J68wyltlzEruDIhZyfHKSk5QRnK8MpPMnzOT472Lg3sfS4qn0hgBBMD+CkcFMDnb3Bbu8CZpzxvSvOtC99qSDte1aOO+Y5LE0i8AMIzE2az+GdCBMAxDjc4O1TV3hkV/aOwSFrsGSUdbhzyGdMx7bTCS4m3KTDbHVGZ5w2FnSDTDY0Zy18fMc8yY7j8CYH+Fch3AriYsMgPg7tdDHgBf+viIJKl03AiNzDr5vxgBAMOTxWJRemK80hPjNXpEYD1d7W6P6lpcqmtu17Fmp2qbXapvaVd9i3lf19KuhlaX6rqcq29tl9tjqLXdrdYGt8ob2oJqZ0qCTZneKmJWihkKM5Pjle6doJORZP4OGUnxSk+K859LS4wf9hNiCID9Fcqt4LqauEhaf6+5ILS7XbLFh+RlDcPQC1vMAHj53OKQvCYAAD7x3aqMfc+M9vFVGhta2lXnD4ouNbS2dx77HvOeq/c+7jHk76IOZBLM8dLscUpP8oXFuC5BsUt49IZG32O+x4dClzUBsL9CvQyMT+EcKXmE1HJMOvShNObMkLzs1kP12lfTrKR4my6eURiS1wQAYCC6VhoDGcvo4/EYamzr6BIMO6uNdS3tcrSZS+k4WtvlaO0wj73nWlxuSTJ3e3F29Cs8JsRZvaEwrlto9AXFifmp+vLs6C62EAD7K1wVQKtVGn++9NmzZjdwiAKgr/p30fQCNjkHAMQ0q9WijOR4ZSQH30tm7uDiDYhtHf51Fx2++7buwbFreHR4K4+uDo93uR5nj+9xzqRcAuCQFeqt4LqaeIEZAHe9Jl1w94Bfztnh1p8/OSrR/QsAGOYS4qwa4V0sO1iGYajJ6a0oHldZdHQJkeP72EUmWhAA+yscs4B9Jl4gWWzmcjC1+6TscQN6ubd2VKuhtV356XadPj4nZM0EAGA4sVgsSks0J5EoK9KtGRjmT/dXqPcC7iopSxpzhnm849UBv9wrn5VLkv55VtGwn/UEAAAIgP3j8UjtYawAStLkS837nQMLgG3tbq3bXilJuoTJHwAAIJYC4IYNG7RkyRIVFRXJYrHopZdeOulz1q9fr7lz58put2vChAl6/PHHQ9OY9i4bdIejAihJUy4x78s2Ss3H+v0y63dWq8XlVnFmkmaXZIaufQAAIGbFTABsbm7WrFmztHr16oCu379/vy699FKde+652rp1q77//e/rhhtu0GuvvTbwxvi6fy1WKT5p4K/Xk8xRUsEMyfBIu9b2+2Ve9Xb/Xjy9QBYL3b8AACCGJoFcfPHFuvjiiwO+fs2aNRo7dqx++ctfSpJOOeUUvfvuu/rVr36lxYsXD6wxvgAYnyKFM1RNvlSq+MzsBp5zddBP79b9O5PuXwAAYIqZCmCwNm7cqEWLFnU7t3jxYm3cuLHX5zidTjkcjm63HrV7F42MD2xPxX7zdQPvfbPzPYPw9q5qNbvcKspI1By6fwEAgNeQDYAVFRXKz8/vdi4/P18Oh0OtrT2HqVWrVikjI8N/Kykp6fnFO7x7FYar+9enYKaUUSK1t5ghMEj+7t8ZhXT/AgAAvyEbAPtjxYoVamho8N8OHTrU84XtLeZ9XJgDoMUinbLEPN528kkvXTk73Fq3vUqSdCndvwAAoIshGwALCgpUWVnZ7VxlZaXS09OVlNRzcLPb7UpPT+9261G7rwIY5i5gSZp2uXm/89WguoE/3FerJmeH8tLsmj2S7l8AANBpyAbA0tJSrVu3rtu5119/XaWlpQN/8Q7fGMDAN67ut5HzzW5gV5O0542An+ab/HH+KXmysvgzAADoImYCYFNTk7Zu3aqtW7dK3mVetm7dqrKyMsnbfXvNNdf4r7/pppu0b98+/ehHP9KOHTv0m9/8Rs8++6xuu+22gTfGV4mLG4QKoMUiTf2yefz5CwE9xTAMveHt/j1/Sv5JrwcAAMNLzATAjz76SHPmzNGcOXMkScuXL9ecOXN01113SZLKy8v9YVCSxo4dq1deeUWvv/66Zs2apV/+8pd69NFHB74EjLrOAg7zGECf6d5u4F1rJVfLSS/fWdmoI/WtssdZdcYE9v4FAADdxcw6gAsXLpRhGL0+3tMuHwsXLtTHH38c+sYM1ixgn6K5UuZoqf6gtPvv0rTL+rzcN/njjAk5SkqwDU4bAQBAzIiZCmBUGaxZwD4WizTtX8zjbSfvBu46/g8AAOB4BMD+GMxZwD6+ALjrNamtlwWqJdU0OfXxoXqJ8X8AAKAXBMD+6BjkMYCSVDhLyplsdj9/0fuagG/tqJJhSNOK0lWQMYgBFQAAxAwCYH/4KoCD1QUsbzfwrCvM40+e7vWyt3Z6Z/+eQvUPAAD0jADYH4O1F/DxZi6VZJEOvifVHTjhYbfH0Ht7jkmSFk7OHdy2AQCAmEEA7I/BXAi6q4xiadw55vEnz5zw8GdHGtTQ2q60xDjNLM4Y3LYBAICYQQDsD38XcATG2M260rz/5CnpuGVx3tlVLUk6Y3yO4mz8pwUAAD0jJfSHbxmYwZwE4jPln6T4FKluv3Tow24PvbO7RpJ01iQWfwYAAL0jAPbHYC8E3ZU9tXNruI//6D/d5OzQlrI6SdJZExj/BwAAekcA7A//XsARCICSNOcb5v3nf5LaGiRJH+w9pg6PodEjkjVqxCCPTQQAADGFANgfkZoF7DP6dHNNwPYW6dNnJUnv7DbH/501ke5fAADQNwJgf0RqFrCPxSLNX2Yef/QHyTD0zh5z/N+ZdP8CAICTIAD2RyRnAfvMusJ8/6ptqt7+rvZVN8tmtah0/IjItQkAAMQEAmB/tEdgK7jjJWVJ0y6XJDW//ztJ0syRGcpIio9cmwAAQEwgAPZHJPYC7om3G7j4yFplqEml46j+AQCAkyMABsvdLnk6zONIdgFL0shTpfwZijdcusL2lr5EAAQAAAEgAAbL1/2rKKgAWiyqnXG9JOm6uNc0b2RqZNsDAABiAgEwWL5FoBUFFUBJbyeco2ojXYWWWqXsfSXSzQEAADGAABisrotAWyyRbo3eP9ikP3ZcYP7wwW9O2B8YAADgeATAYEXDDOAuPtxfqyfci+SxxktHNkuHNkW6SQAAIMoRAIPVEQVrAHodrW9VWW2L6qyZck/7mnly468j3SwAABDlCIDB6nCa93EJkW6JPtx/TJI0vShd8Wfeap7c/hepZndkGwYAAKIaATBYbl8AjHwF8IO9tZJkLv+SP02adLEkQ3r3V5FuGgAAiGIEwGB1uMx7W/RUABeMyzZPnP0D8/7TZ6T6sgi2DAAARDMCYLD8YwDtEW1GTZNTB461yGKR5o32BsCR86Wx55gLVb/3UETbBwAAohcBMFhR0gW85WCdJGlSXlr3/X/P/qH3gv+VGisi1DoAABDNCIDBipIu4M1lZgCcOzqz+wNjzpRKFphB9d0HI9M4AAAQ1QiAwfJXACPbBeyrAM4dldX9AYtFWvgT8/ij30v1hyLQOgAAEM0IgMHqiHwAdHV49MnhBknSvNFZJ14w7lxpzFmS2yVtuH/wGwgAAKIaATBYvgBoi1wA3Ha0Qa4Oj7KS4zU2J+XECywW6bw7zeOPn5Bq9gx6GwEAQPQiAAbLHfmFoLeU1Uve6p+lt/2IRy2QJl0kGW7prXsGt4EAACCqEQCD1RH5WcC+8X9zjh//d7zz7jDvt70gHdkyCC0DAACxgAAYLH8XcGQqgIZh6KOD5g4gPY7/66pghjTzCvN47QrJMAahhQAAINoRAIPl9i4DE6FJIEcb2lTpcMpmtWjWyMyTP2HRSik+WTr0gfT5nwajiQAAIMoRAIPl3wkkMl3Am73dv9OK0pWUYDv5E9KLpDNvM49fXym5WsLcQgAAEO0IgMGK8ELQH5f1sv5fX07/rpRRIjkOS+8/HL7GAQCAmEAADFaEF4L+5JA5A3h2SQDdvz7xSdIFd5vH7/5KajgcptYBAIBYQAAMVgQXgm53e7TtqEOSNHNkRnBPnna5NOp0qaNVeuUHTAgBAGAYIwAGK4ILQe+qbJSzw6O0xDiNGdHDAtB9sVikf3pAssZLu/4mbf9zuJoJAACiHAEwWBHsAv7Uu/3bzJEZslp7WQC6L3mnSGd+3zx+9UdSW0OIWwgAAGIBATBYEewC/vSwOf5vZiDLv/TmrB9I2eOlpgrpjbtD1zgAABAzCIDBimAX8CeHzIrdrGDH/3UVnygtecg8/uj30sGNIWodAACIFQTAYPkXgh7cZWDa2t3aWdkoDbQCKEljz5LmfMM8fukmydkYghYCAIBYQQAMVoQWgt521CG3x1BOql2FGSF478X3mmsD1h2QXvu3UDQRAADECAJgsCK0ELRv/N+skRmyWPoxAeR4iRnSZb+VZJG2/Le0828Df00AABATCIDBitAs4M4ZwAPs/u1q7FlS6S3m8Z+/KzXXhO61AQBA1CIABss/C3hwu4A/8c0ALhnABJCenHenlDdVaq6WXvqO5PGE9vUBAEDUIQAGyz8LePC6gBta27WvulmSNCuUFUB5ZwVf/jtzVvPuv0vvPxTa1wcAAFGHABgMw4hIF/C2o2b3b3FmkrJTwhA8C2ZIl/zcPF73M+nAe6F/DwAAEDUIgMHwLQGjwQ2AX3j3/51enB6+N5l7jTTzCslwS89fLzVVhe+9AABARBEAg+Hr/tXgLgTtC4DTikI8/q8r317BuVPMXUKev15yt4fv/QAAQMQQAIPRtQI4iGMAt3kD4NTCMFYAJSkhRfr6/0gJqdKBd6S//Ti87wcAACKCABgM3yLQ1njJOjgfXVu7W3uqmyRJ08LZBeyTO1n6yqPm+oAf/V7a9Ej43xMAAAyqmAqAq1ev1pgxY5SYmKgFCxZo06ZNfV7/4IMPavLkyUpKSlJJSYluu+02tbW19b8BEVgCZmdFo9weQ9kpCSpIH6T3nXyxtOin5vHffiztWz847wsAAAZFzATAZ555RsuXL9fKlSu1ZcsWzZo1S4sXL1ZVVc+TFZ588kn95Cc/0cqVK7V9+3b9/ve/1zPPPKPbb7+9/42IwD7AX5T7xv+lh2YHkECd8b3OSSHPXCNVbhu89wYAAGEVMwHwgQce0I033qhly5Zp6tSpWrNmjZKTk/XYY4/1eP3777+vM844Q1dddZXGjBmjCy+8UFdeeeVJq4Z98nUBD+IEEN8SMGEf/3c8i0Va8pA0qlRyNkh//IpUXza4bQAAAGEREwHQ5XJp8+bNWrRokf+c1WrVokWLtHHjxh6fc/rpp2vz5s3+wLdv3z69+uqruuSSS/rfkI7BrwD6J4AUDXIAlHeR6CufknJPkRrLpf+9XGo+NvjtAAAAIRUX6QYEoqamRm63W/n5+d3O5+fna8eOHT0+56qrrlJNTY3OPPNMGYahjo4O3XTTTX12ATudTjmdnUu9OByO7hf4u4AHZyye22NoR3mjFO4lYPqSlCV940/S7y+Uju2WnvyadO1fzBnDAAAgJsVEBbA/1q9fr3vvvVe/+c1vtGXLFr3wwgt65ZVX9LOf/azX56xatUoZGRn+W0lJSfcLfAHQFh/m1pv21zSptd2tpHibxuZEMHBlFEvffMEMg0c2S09dKbW3Rq49AABgQGIiAObk5Mhms6mysrLb+crKShUUFPT4nDvvvFPf/OY3dcMNN2jGjBn6l3/5F917771atWqVPB5Pj89ZsWKFGhoa/LdDhw51v8C3MPIgrQHo6/6dUpgmm3UQJ4D0JHeydNVz5hqB+9+WnrqCEAgAQIyKiQCYkJCgefPmad26df5zHo9H69atU2lpaY/PaWlpkfW4tfpsNpskyTCMHp9jt9uVnp7e7daNvwI4OAGwcweQCIz/60nJqdLVz0vxKebSMFQCAQCISTERACVp+fLleuSRR/Tf//3f2r59u77zne+oublZy5YtkyRdc801WrFihf/6JUuW6Le//a2efvpp7d+/X6+//rruvPNOLVmyxB8EgzbIXcDbBmMLuGCNLpW+4QuBb0lPX0UIBAAgxsTEJBBJWrp0qaqrq3XXXXepoqJCs2fP1tq1a/0TQ8rKyrpV/O644w5ZLBbdcccdOnLkiHJzc7VkyRLdc889/W/EIHcBb/euAXjKYC8BczKjT5eufk564qvS3jfN2cFXPS0lRlFQBQAAvbIYvfWHQg6HQxkZGWpoaDC7gzf/t/SXf5UmXWwGnjCqbnTq1HvekMUifXH3RUpK6GfVMpwOvi89uVRyOqT8GeZs4bT8AJ4IAAAiKWa6gKPCIHYB76wwl38ZnZ0cneFP3krgda9IKblS5WfSY4ul2v2RbhUAADgJAmAwBrELeEeF2f07uSAt7O81IIUzpetfkzJHSXX7zfUCD2+OdKsAAEAfCIDBGMRZwL4K4OSCKBv/15MR46Xr/y7lT5eaq6THL5E+fyHSrQIAAL0gAAbDXwEchC7gSjMATon2CqBPeqF0/Vpp4mJzz+Tnl0lv3y8xxBQAgKhDAAzGIFUA3R5Duyp9FcAYCYCSZE8z9w7+0i3mz2/dYwZBZ1OkWwYAALogAAZjkAJgWW2L2to9ssdZNWZEjO25a7VJF90r/dOvJGuctO1F6ZHzpOqdkW4ZAADwIgAGY5C6gHd6J4BMzE+N/BZw/TX/enOGcFqhVLNT+t250ud/inSrAAAAATBIg1QB3OGbAJIfAxNA+jLqS9L/2SCNOUtqb5aev1569YfsHAIAQIQRAIPhGZxlYHwzgGNmAkhfUvOkb74knbnc/HnT78xqYMVnkW4ZAADDFgEwGIPWBRyDE0D6YouTFq2Urn5eSsmTqreb4wLf+0/J44l06wAAGHYIgMEYhC7gtna3DhxrloZKBbCriRdIN2+UJl9ifpav3yn9zz+zewgAAIOMABiMQdgKbndlkzyGlJUcr9w0e9jeJ2JScqQrnpSWPCTFJ0sH3pF+Uyq9/7Dk7oh06wAAGBYIgMEYhK3gum4BZ7HE6Azgk7FYpHnXSTe9a04Q6WiV/n6H9PtFjA0EAGAQEACDMQhdwHuqzEWTJ+cPse7fnowYL137F2nJf0r2DOnox9LvFkqvr2TxaAAAwogAGIzB6AL2BsAJwyEAylcNvFa6dZN0yhLJ0yG996D06/nSp8+ylRwAAGFAAAzGIHQB+yqAE3JTw/YeUSmtQFr6R+mKp6SsMVJjufTCjdJjF0lHt0a6dQAADCkEwGCEuQu4rd2tQ3UtkncXkGFpyiXSzR9K591pThI59IHZLfzSzVL9oUi3DgCAIYEAGIwwdwHvrW6SYUiZyfEakRLexaajWnyidPYPpFs/kqZ/VZIhbX1CeniutPZ2qflYpFsIAEBMIwAGI8xdwL7u34l5qUN3BnAwMoqlr/5eumGdOVvY7ZI+WC09NEt6+34migAA0E8EwGCEuQvYP/4vb5h2//Zm5HxztvA3/iQVzJRcjdJb90gPzpA2/Fxqa4h0CwEAiCkEwGCEeSu43ZW+ADhMZgAHw2KRJiySvv229NXHpOxxUmut9OZ/SL+aYd7TNQwAQEAIgMEIdwWwmgrgSVmt0vSvSLf8Q7r8USl3iuRsMCuBD86QXvs3JosAAHASBMBghDEAtrs9OlBj7gE8kQB4crY4aebXpO9slL7+v2bXcHuztPHX5hjB566TDv0j0q0EACAqEQCDEcYu4IPHmtXhMZSSYFNhRmLIX3/Islqlqf8s/Z8N0lXPSmPPlgy3tO1Fc2u5R86XPv8T+wwDANBFXKQbEFPCWAHsHP/HDOB+sVikSYvNW8Vn0ge/lT57TjrykfT89VJaoTTnm9Lca6TMkki3FgCAiKICGCjDCGsA9M0AHk/378AVzJAu+430/c+lc34iJeeYO4tsuN8cJ/jE16Qdr1AVBAAMW1QAA+XpEhbC0AXsmwAykRnAoZOWL527QjprubTjr9Lmx6X9G6TdfzdvaYXS7KulWVdKORMi3VoAAAYNATBQvuqfwt8FjBCLs5szh6d/RTq2V9ry39LHT5hVwXd+Yd6K50kzr5CmXy6l5ES6xQAAhBVdwIHqFgBDWwF0ewztre7cBQRhNGK8dMG/S8u3S1/9gzTxQslik45slv72Q+kXk6Qnvi599rzkao50awEACAsqgIHyzQCWJGtoP7Yjda1ydniUEGdVSXZySF8bvYhLMKt90y+Xmqqkz1+QPn1aOvqxtPs18xaXJE28QJr6ZXNyiZ3ueQDA0EAADFTXCSAhnqW7p7pRkjQuJ0U2KzOAB11qnvSlm8xb9S7p02fMGcT1B6XtfzZvNrs04XxvGLxISsqMdKsBAOg3AmCgBmkJGERY7iTp/Dul8+6Qyj8xw9+2l6TavdLOV82bNV4afboZBCctNruVAQCIIQTAQIVxEWjfEjAEwChisUhFs83beXdKVV9IX/xZ+uJlqXq7tP9t8/baCmnEBDMMTrxQGlVqdi8DABDFCICBCmMFcL93C7jxuQTAqGSxSPnTzNu5K8yZxLtek3atlQ6+Jx3bY25Bt/HXkj3d3I1k/LnSuHOl7HEhHzIAAMBAEQADNQgBcGxOSshfG2EwYrxUerN5a2uQ9r5lriu46zWppcZcc3DHX81rM0ZJ486Rxi00bywxAwCIAgTAQIWpC7ihpV3Hms1wSQCMQYkZ0rTLzJvHIx3dIu17S9q7Xjr0odRQJn38v+ZN3l1KxpwtjS41u4sJhACACCAABsofAENbAdxXY47/y0+3K8XOf46YZrVKI+ebt7N/aK4jeHCjGQj3rZcqPzf3Ka74TPpgtfmcnMlmGBx9hhkI2acYADAISByB8ncBh7YCSPfvEJaQIk1cZN4kc73B/RvMcYMHN5qTSWp2mrfNj5vXZJSYQXDkfKl4vlkxZFIJACDECICB8lUAreEJgOOYADL0peZJM75q3iSppVYq2ygdfN+8lX8iNRySPjskffaseY0tQSqYKY081RsK50lZY5hYAgAYEAJgoDzhGQO4zxcAqQAOP8nZ0pRLzZskOZukw5ukQ/+QjnwkHf5Iaq01j498JH3oe16OGQSLZkuFs8yAmDGSUAgACBgBMFDhqgBW0wUML3uqNP488yZJhiHV7jP3KT7sDYHln5ozjX3b1fkkZZlBsHBWZygcMV6y2iL26wAAohcBMFCeDvPeFrqPzOMxGAOI3lksZogbMV6a+XXzXHubOYnkyGazy7jiU6l6h9Ra17k4tU98Suf6hXlTpbxTzPuUERH7lQAA0YEAGKgwVAArG9vU2u6WzWpRSXZyyF4XQ1h8olRyqnnzaW8zJ5SUf2JWCCs+lSo+l9qbzS7lw5u6v0ZKXmcY9N3nTpYS0wf91wEARAYBMFBhGAPo6/4dlZ2seJs1ZK+LYSY+USqaY958PG5zh5LyT81t7Kq2m/f1B6XmKml/VfdqobwzkHMmSTkTze3tciZKIyZK6UWMLwSAIYYAGCh/BTB0HxkTQBA2VptZ1cud3P28s0mq3tk9FFbvkBrLzRnIDYekveu6Pyc+xeyG9gVCX0AcMcEctwgAiDkEwED5xwCGsALI+D8MNnuqNHKeeeuqpdYMgjW7pJrdZvWwZrdUd8DsSq7wdi0fL7XAXJYme6x5nzVGyvIep+ZROQSAKEUADFQYxgD6A2AuARARlpwtjT7dvHXV4TJD4LEuodB331IjNVWYt0MfnPia8cndA6EvKGaOljKKzYWyAQAREfYA2N7eroqKCrW0tCg3N1fZ2dnhfsvw8IShC7ja3AaOCiCiVlyClDvJvB2vpdYMh3X7zfta733dQclxWGpv8XY1f9HzayePMNcvzCjx3kaaW+H5zqXkUkEEgDAJSwBsbGzUH//4Rz399NPatGmTXC6XDMOQxWLRyJEjdeGFF+rb3/62Tj311ABeLUp43OZ9iJaBcXV4dKiuVZI0LodxVIhBydnmrXjuiY91uMzxhLX7OwOiLyTWl0muRqnlmHkr/6Tn17fZvWHQGwzTR0rphVJaUed9cjYhEQD6IeQB8IEHHtA999yj8ePHa8mSJbr99ttVVFSkpKQk1dbW6vPPP9c777yjCy+8UAsWLNDDDz+siRMnhroZoRfiLuBDdS1yewwlJ9iUn24PyWsCUSMuoXMNw5601ksNh70TTw6bobDhcOe5xgrJ7ZRq95q33tgSpLSC7qEwrcCcuZxW6D1XKMUnhe1XBYBYFPIA+I9//EMbNmzQtGnTenz8tNNO0/XXX681a9boD3/4g955553YCIAhXgam6w4gFioYGG6SMs1bwfSeH+9wSY4j3UOiLxg6yqXGo2b10O0yw2N9Wd/vl5hpBsHUXCk131wLMdV763qcnBPSxd4BIFqF/E+6p556yn/c2NiotLS0Hq+z2+266aabQv324RPiZWCYAQz0IS7BnDCSPbb3azqcZiBsLJccR73HR70BsctxR6vUVm/eqref5I0t5tjEnsJhar45LjElx7wmeQSVRQAxK6z/1D3rrLO0du1aFRQUhPNtBkeIl4HZV2NOAGENQKCf4uxS1mjz1hvDMIOfo1xqqpSaqsyFsJuqTjxuqZEMj3nfUtP75JWu4lO8YTC7SzDM8Y6PHNE9LCbnmFVP9mcGEAXCGgDnzJmjBQsW6LXXXtOUKVP857du3arbb79dr776alCvt3r1av385z9XRUWFZs2apYcfflinnXZar9fX19fr3/7t3/TCCy+otrZWo0eP1oMPPqhLLrkk+F8mxGMA93m7gMcQAIHwsVikpCzzlj+172s9brNb+fhg2FQpNVd3CYreySuednONxIZmqeEkXdCdDTLb4guGSdne9nm7xH1tTczscj5LsmdIVnYLAhA6YQ2Af/jDH7Ry5UqdeeaZeumll5SXl6c77rhDf/rTn4IOYc8884yWL1+uNWvWaMGCBXrwwQe1ePFi7dy5U3l5eSdc73K5dMEFFygvL0/PP/+8iouLdfDgQWVmZvbvl/GPAQzNR3bwWItEFzAQPay2zu7ekzEMydnorRbWSs01ncGwxXvcfKz7ubYGSYbUWmvegmKREjM6A2JfYTEx07w2Md28T0gjPAI4QdhHO999992y2+264IIL5Ha7df7552vjxo19Vu568sADD+jGG2/UsmXLJElr1qzRK6+8oscee0w/+clPTrj+scceU21trd5//33Fx5tVuzFjxvT/F3F7u4BDUAFsa3erwtEmSRo9ggAIxByLxRuw0qXscYE9x90utdZ1CYs15s/+W33nfVt95/n2FjM4+sYx1u0PtrGSPU2yp3eGQt+xPb0zLNq7Ptb1XLqUkMpyO8AQE9YAWFlZqXvvvVePPPKIpk6dqh07dui6664LOvy5XC5t3rxZK1as8J+zWq1atGiRNm7c2ONz/vznP6u0tFS33HKLXn75ZeXm5uqqq67Sj3/8Y9ls/RiDE8KFoMtqzepfWmKcspJDt7MIgChmiw+8wthVh7MzHHYNhq1djrudr5PaHJLTYc6SlmEeOx2So59tt1i7hMYMb6BMNYOhPdWsMgb6c0IKYRKIAmENgGPHjtXkyZP13HPP6dJLL9XatWu1dOlSlZWV6Yc//GHAr1NTUyO32638/Pxu5/Pz87Vjx44en7Nv3z69+eabuvrqq/Xqq69qz549uvnmm9Xe3q6VK1f2+Byn0ymn0+n/2eHo8qdlCCeB+Lp/R49IZgkYAH2Ls0tp+eYtWO1tZvBra/CGwobOcNjmPe87dnb9uct1ng5zcoyvAjlgli7BsOt9WufP9rTO0BifbIZG373/ONmchJOQbP7Mn6VAUMIaAB977DFdccUV/p8vuugivfXWW/qnf/onHThwQKtXrw7be3s8HuXl5el3v/udbDab5s2bpyNHjujnP/95rwFw1apVuvvuu3t+wRAuA3PwmDkBhO5fAGEVn2jegq06+hiG1N56XGBskJxN5hhIV5N57Gr03vf2s/d6GebN1WjeQvq7HhcUewqJCaldjnu4NiG1+/PiE6W4JNaGxJAU1m911/DnM3fuXL3//vu6+OKLA36dnJwc2Ww2VVZWdjtfWVnZ6xIzhYWFio+P79bde8opp6iiokIul0sJCQknPGfFihVavny5/2eHw6GSkhLzh3BUALOTB/xaABA2Fos3GCWbO6wMhGGY4xm7BsJuAdHRc4hsb5FczZ33rhZz9rWrxVzj0ae9xTteMgys8eaaj/FJUlyiGRJ94TA+6bjHfMfHn/c+x/+Y99zxr2eLp5qJQRGRf9aMGTNG77//fsDXJyQkaN68eVq3bp0uu+wyyVvhW7dunW699dYen3PGGWfoySeflMfjkdU7A27Xrl0qLCzsMfzJuzi13d7LtmwhXAbmoHcM4BgqgACGC4ulswtX/ejO7onH0xn8XM3dg2J7S/ew6Lt3NXc519O1PYRLT7vkbDdDarhZbMeFyEQzJMYlmsMB4uxdjgO8twVxLeFz2Ah5ACwrK9OoUaNOel1WVpYk6ciRIyouLj7p9cuXL9e1116r+fPn67TTTtODDz6o5uZm/6zga665RsXFxVq1apUk6Tvf+Y5+/etf63vf+56++93vavfu3br33nv1r//6r/37xUK4FZyvC3jUCCqAANBvVqt3zGBq6F/b45E62sxbe6t562jtctzmDZ/e+27XdXms1+f4Xq+tc6a3JBluswrqagr97xQIf1hMCDBYJpj3toQux/HexxO8548/jg/8OSycHjYhD4CnnnqqLrvsMt1www069dRTe7ymoaFBzz77rB566CF9+9vfDiiULV26VNXV1brrrrtUUVGh2bNna+3atf6JIWVlZf5KnySVlJTotdde02233aaZM2equLhY3/ve9/TjH/+4f7+YfxmYgX1k7W6PjtSZ/7IcTQAEgOhktXZ2f4ebYZgztk8Ijd5w6Haas8E72gK4d3UG10Cf4wufkvlebqfk7KvBg8hiOy4o+o57CJfBXGeL9968P1vjennMe289/txxz43BymnIA+Cll16q1NRUXXDBBUpMTNS8efNUVFSkxMRE1dXV6YsvvtC2bds0d+5c3X///UEtCH3rrbf22uW7fv36E86Vlpbqgw8+GNDv4xeiCuDR+lZ1eAzZ46zKT0sMTdsAALHLYuns3h3s7aUNwxzj3mNA7C00+m6tZnDtcJn3bpd53t31Z5c3VAZxXbf2uc336dolH42sx4XDcQulrzwa6Vb1KeQB8I9//KMOHTqkn/3sZ8rNzVVhYaFqamrU2tqqnJwcXX311Vq8eLGmT58e6rcOrxCNAfRNABmVnSyrNfb+xQAAGEIsls7QYk+LdGu81dB2bxhs7x4UAwqXzu5B8/jndbjMgo7b5X2frse+x9q7PL+jy3F753OP5/E+5o0KahuE8aIDFPIAWFRUpK1bt2rx4sVqbW3Vvffe2+NWbTHHNwt4gOMRWAIGAIBeWCze8Yc9T9aMCr6qaV/hMX6wS7nBC3kA/L//9/9qyZIlWrBggSwWi5544gmdeeaZmj59upKSov8D6VWIloHpugg0AACIMV2rpordv8tDvkP4d7/7XX300Ue66KKLZBiGVq9erdLSUqWnp+uUU07RFVdcofvuu09/+9vfQv3W4RWqLmD/EjCx+6UBAACxLSzrAM6cOVMzZ87U448/ro0bNyolJUWffvqptm7dqq1bt+rll1/WPffco8bGEK8EH04hmgTSuQQMXcAAACAywroQ9O7du/3HCxYs0IIFC/w/G4bRy7OiVAiWgfF4DJVRAQQAABEW8i7gQFlibc2cEFQAqxqdamv3yGa1qCgzhsdDAgCAmBaxABhzQjAG0Nf9OzIrSfE2PnoAABAZpJBA+WcB978LuOsagAAAAJFCAAxUKCqAtb41AAmAAAAgcgiAgfKNARzAJBBfBXAMM4ABAEAEEQAD4fFIhsc8HsAkELqAAQBANCAABsI3/k8DrQCyDRwAAIg8AmAgfN2/6n8FsKGlXY42M0iWZLMEDAAAiBwCYCDcXQJgPyeBHKozu39zUhOUnBDW9bcBAAD6RAAMhMfdedzPCuAh7w4gI7MY/wcAACKLABgIXwXQYpP6uYOJrwJYwgQQAAAQYQTAQIRgG7hDta2SpJIsxv8BAIDIIgAGwjPwRaAPUwEEAABRggAYCN8YQKut3y9xqM5XASQAAgCAyCIABsK/D3D/KoCGYXSpANIFDAAAIosAGIgB7gNc3eRUW7tHVotUlEkABAAAkUUADIS/Ati/9ft8E0AKM5IUb+MjBwAAkUUaCYTbGwD7WQH0df+OZAYwAACIAgTAQAxwGRjfItDMAAYAANGAABiIAY4B7FwDkAAIAAAijwAYCGOAYwCZAQwAAKIIATAQAxwDyDZwAAAgmhAAAzGAMYAdbo+O1rdJdAEDAIAoQQAMxAB2AilvaJPbYyghzqq8NHvo2wYAABAkAmAgBjAJxNf9OzIzSVarJdQtAwAACBoBMBAD2ArusHcG8EjG/wEAgChBAAyEvwIY/Cxg/wQQFoEGAABRggAYCKP/FUAWgQYAANGGABiIAY0BZBFoAAAQXQiAgRjAGMDOCiBdwAAAIDoQAAPhXwg6uDGAbe1uVTU6JSqAAAAgihAAA9HPhaAPe7t/U+1xykzu3y4iAAAAoUYADISnfxVA/xqAWUmyWFgDEAAARAcCYCD62QV8mBnAAAAgChEAA9HPSSDMAAYAANGIABgIT/+WgTncpQsYAAAgWhAAA9HPSSBHvBVAAiAAAIgmBMBAuN3mfZBjAI/UmwGwKJMACAAAogcBMBD9qAC2tbtV0+SSqAACAIAoQwAMRD+2gvNV/1ISbMpIYg1AAAAQPQiAgfDPAg68C9g3/q+YNQABAECUIQAGwhP8GEBfBbCY8X8AACDKEAAD0Y9lYLpWAAEAAKIJATAQ/ZgE0lkBZBFoAAAQXQiAgejHVnBUAAEAQLQiAAaiH1vBMQYQAABEKwJgIIJcBqbD7VGFo01iDUAAABCFYioArl69WmPGjFFiYqIWLFigTZs2BfS8p59+WhaLRZdddln/3tg/BjCwLuAKR5vcHkPxNotyU+39e08AAIAwiZkA+Mwzz2j58uVauXKltmzZolmzZmnx4sWqqqrq83kHDhzQD37wA5111ln9f3P/GMDAKoBH683qX2FGkqxW1gAEAADRJWYC4AMPPKAbb7xRy5Yt09SpU7VmzRolJyfrscce6/U5brdbV199te6++26NGzeu/28e5BjAI/UtEuP/AABAlIqJAOhyubR582YtWrTIf85qtWrRokXauHFjr8/793//d+Xl5elb3/rWwBpgBDcLmBnAAAAgmgW+rkkE1dTUyO12Kz8/v9v5/Px87dixo8fnvPvuu/r973+vrVu3Bvw+TqdTTqfT/7PD4TAPglwGhhnAAAAgmsVEBTBYjY2N+uY3v6lHHnlEOTk5AT9v1apVysjI8N9KSkrMB4LsAj5MBRAAAESxmKgA5uTkyGazqbKystv5yspKFRQUnHD93r17deDAAS1ZssR/zuPxSJLi4uK0c+dOjR8//oTnrVixQsuXL/f/7HA4zBAY5F7AvgrgSCqAAAAgCsVEAExISNC8efO0bt06/1IuHo9H69at06233nrC9VOmTNFnn33W7dwdd9yhxsZGPfTQQ52VvePY7XbZ7T0s2+IJvAvYMAwdracCCAAAoldMBEBJWr58ua699lrNnz9fp512mh588EE1Nzdr2bJlkqRrrrlGxcXFWrVqlRITEzV9+vRuz8/MzJSkE84HxOM2O8uttpNeeqzZpbZ2jywWcxkYAACAaBMzAXDp0qWqrq7WXXfdpYqKCs2ePVtr1671TwwpKyuT1RqmIY2edm8APPnH5ZsBnJdmV0LckBxiCQAAYpzFMAwj0o2IVg6HQxkZGWpYkaX0BLe0fLuUXtTnc179rFw3P7FFc0Zl6sWbzxi0tgIAAASKElUgjMB3AvGvAcgEEAAAEKUIgMEIYAzgESaAAACAKEcADEYAYwB9awCyBAwAAIhWBMBgBBAAWQIGAABEOwJgMAKZBezfBi55EBoEAAAQPAJgME4SAJucHWpobZeoAAIAgChGAAyUxSqdZJ1B3wzgjKR4pdpjZolFAAAwzBAAAxVQ92+LxBIwAAAgyhEAAxVQAGyTJBURAAEAQBQjAAYqgABY7p0AUpSZOAgNAgAA6B8CYKACWAS6vMGsABZmUAEEAADRiwAYqAC2gTtKBRAAAMQAAmCgAukCbmAMIAAAiH4EwECdJAB6PIbKG8wKYGEGFUAAABC9CICBOskYwJpmp9rdhiwWKT+dAAgAAKIXATBQJ6kAlnuXgMlLsyvexscKAACiF0klUCcLgP7uX8b/AQCA6EYADJSt7wB41FsBZBcQAAAQ7QiAgTpJBdC3BAwTQAAAQLQjAAbqpF3A3kWgqQACAIAoRwAM1MkqgN4xgEVUAAEAQJQjAAYqwFnAVAABAEC0IwAGqo91ANvdHlU1+nYBoQIIAACiGwEwUH3sBVzpaJPHkOJtFuWk2Ae1WQAAAMEiAAaqjy5g3wSQgoxEWa2WQWwUAABA8AiAgeqjC7hzCRjG/wEAgOhHAAxUABVAFoEGAACxgAAYqL4CIItAAwCAGEIADFQfAfAIS8AAAIAYQgAMVB97AZezCDQAAIghBMBABTAGkEkgAAAgFhAAA9VLAGxrd6u22SUxCQQAAMQIAmCgegmAvupfcoJN6Ul9bxcHAAAQDQiAgeolAB7tMgPYYmERaAAAEP0IgIE6SQAsovsXAADECAJgoE7SBcwagAAAIFYQAAPVawCkAggAAGILATBQvXYBmxXAIpaAAQAAMYIAGCirrcfT/kkgmXQBAwCA2EAADNRJxwBSAQQAALGBABgoW/wJpxxt7WpydkiSiqgAAgCAGEEADFQPFcBy7/i/zOR4JSewCDQAAIgNBMBA9TAG8GiDbxFoun8BAEDsIAAGqocKoH8RaNYABAAAMYQAGKg+uoCZAQwAAGIJATBQPVUAWQQaAADEIAJgoPqoALIINAAAiCUEwED1FAD9k0DoAgYAALGDABio4wKgYRg66l0Emi5gAAAQSwiAgTouANY2u+Tq8MhikfLTqQACAIDYQQAM1HHrAPq2gMtJtSshjo8RAADEDpJLoI7bCq7CGwALqP4BAIAYQwAM1HFdwOUObwBkAggAAIgxBMBAHRcAK5gBDAAAYlRMBcDVq1drzJgxSkxM1IIFC7Rp06Zer33kkUd01llnKSsrS1lZWVq0aFGf15/UcWMAKxqcEhVAAAAQg2ImAD7zzDNavny5Vq5cqS1btmjWrFlavHixqqqqerx+/fr1uvLKK/XWW29p48aNKikp0YUXXqgjR470rwHHVwAdVAABAEBsipkA+MADD+jGG2/UsmXLNHXqVK1Zs0bJycl67LHHerz+iSee0M0336zZs2drypQpevTRR+XxeLRu3br+NeD4MYDeSSAsAQMAAGJNTARAl8ulzZs3a9GiRf5zVqtVixYt0saNGwN6jZaWFrW3tys7O7vXa5xOpxwOR7db5xt2zgI2DMM/C7iQbeAAAECMiYkAWFNTI7fbrfz8/G7n8/PzVVFREdBr/PjHP1ZRUVG3EHm8VatWKSMjw38rKSnpfLDLGEBHW4daXG6JZWAAAEAMiokAOFD33Xefnn76ab344otKTOw9sK1YsUINDQ3+26FDhzof7NIFXOldAiYzOV5JCbaeXgoAACBqxQVwTcTl5OTIZrOpsrKy2/nKykoVFBT0+dxf/OIXuu+++/TGG29o5syZfV5rt9tlt9t7frBLACxnEWgAABDDYqICmJCQoHnz5nWbwOGb0FFaWtrr8+6//3797Gc/09q1azV//vyBNaJLAGQNQAAAEMtiogIoScuXL9e1116r+fPn67TTTtODDz6o5uZmLVu2TJJ0zTXXqLi4WKtWrZIk/b//9/9011136cknn9SYMWP8YwVTU1OVmpoa2Jt6PJ3HPVUACYAAACAGxUwAXLp0qaqrq3XXXXepoqJCs2fP1tq1a/0TQ8rKymS1dhY0f/vb38rlcumrX/1qt9dZuXKlfvrTnwb2pp6OzmNb1wqgrwuYGcAAACD2xEwAlKRbb71Vt956a4+PrV+/vtvPBw4cGPgbdg2AXbuAHb4lYKgAAgCA2BMTYwAjprcASBcwAACIYQTAvvQSAMsbqAACAIDYRQDsi8fdeWwxP6oWV4caWtslSfkEQAAAEIMIgH3xVQAtcZLFInXp/k1JsCnNHlNDKAEAACQC4En4AmAv4/8s3lAIAAAQSwiAfekpAPpnALMEDAAAiE0EwL4Y3oWgrZ37/bIINAAAiHUEwL64zckePXYBsw8wAACIUQTAvvi7gKkAAgCAoYMA2BdfALTF+09VOFol1gAEAAAxjADYF986gF0qgBUNTokKIAAAiGEEwL74AqDFHAPo6vCopskMgMwCBgAAsYoA2JfjloGp9C4BkxBnVVZyfF/PBAAAiFoEwL54fLOAzS5g3xqABeksAg0AAGIXAbAvRvcxgMwABgAAQwEBsC/+SSBmd29lg28XEAIgAACIXQTAvhw3BpAKIAAAGAoIgH05biFo/xqA7AICAABiGAGwLx7GAAIAgKGHANiX4/YC9u8DzBqAAAAghhEA+9JlIWi3x1BVo28RaCqAAAAgdhEA+9JlL+CaJqfcHkM2q0U5qfZItwwAAKDfCIB98U8CsfrH/+Wn2WWzsgg0AACIXQTAvvgXgo5TRYM5Azif7l8AABDjCIB96bIOYDmLQAMAgCGCANiXLgGwcx9gZgADAIDYRgDsS9cASAUQAAAMEQTAvnRZCJpFoAEAwFBBAOxLDxVAAiAAAIh1BMC+eCuAhsXWZQwgARAAAMQ2AmBfvFvBtXmscnV4JEn5BEAAABDjCIB98a4D2NxuSJJyUu1KiOMjAwAAsY000xfvGMBGsxDIDGAAADAkEAD74g2ATS7zR7p/AQDAUEAA7It3EojDZXYBUwEEAABDAQGwL74A2GYGQJaAAQAAQwEBsC8ec/Cfw2XOAKYCCAAAhgICYF+8YwDr2swASAUQAAAMBQTAvni7gOt8XcBMAgEAAEMAAbAv3gDY6rZIVAABAMAQQQDsi7cL2C2rMpLilZwQF+kWAQAADBgBsC+GGQA7DBsTQAAAwJBBAOyLdy9gj6x0/wIAgCGDANgXjzn7t11xVAABAMCQQQDsi38MoIVt4AAAwJBBAOyLNwB2iDGAAABg6CAA9qXLLOCCjKRItwYAACAkCIB98QdAKoAAAGDoIAD2weP2BkDDxixgAAAwZBAA++D2BkBbfLzS7CwCDQAAhgYCYB/cHeY6gBkpibJYLJFuDgAAQEgQAPvg6wLOTGECCAAAGDoIgH0wvJNAMlOTI90UAACAkImpALh69WqNGTNGiYmJWrBggTZt2tTn9c8995ymTJmixMREzZgxQ6+++mpwb+itAGanUgEEAABDR8wEwGeeeUbLly/XypUrtWXLFs2aNUuLFy9WVVVVj9e///77uvLKK/Wtb31LH3/8sS677DJddtll+vzzzwN+T4vhrQCmEQABAMDQYTEMw4h0IwKxYMECnXrqqfr1r38tSfJ4PCopKdF3v/td/eQnPznh+qVLl6q5uVl//etf/ee+9KUvafbs2VqzZk1A71m5IlcF99Vo7bq3tPi8hSH8bQAAACInJtY2cblc2rx5s1asWCFJMgxDTU1NOvvss7VhwwbdfPPNJzznvffe06233iqHw+E/t3DhQv31r3/tdq4rp9Mpp9PZ+b5OswKYaDN6fQ4AAECkpKWl9WulkpioAB49elTFxcV6//33VVpaKofDoYyMjEg3CwAAIKIaGhqUnp4e9PNiogJ4vLS0NDU0NOjOO+/Ue++9pzfffPOEa0aMGKE1a9boa1/7mv/cI488ovvuu0979+7t8XW7VgA7PIY+e+MJ/fO3Vmjbp1s0cvT4MP5Gw5PD4VBJSYkOHTrUry8v+sbnGz58tuHF5xtefL7hNdifb1paWr+eFxMBMCcnRzabTZWVlZIki8Wi9PR01dfXq7i4uMcPuLCwUI2Njd0eczgcKioqCvg/SNyF35C0QulZufxPEkbp6el8vmHE5xs+fLbhxecbXny+4RXtn29MzAJOSEjQvHnztG7dOv85j8ejdevWqbS0tMfnlJaWdrtekl5//fVerwcAABguYqICKEnLly/Xtddeq/nz5+u0007Tgw8+qObmZi1btkySdM0116i4uFirVq2SJH3ve9/TOeeco1/+8pe69NJL9fTTT+ujjz7S7373uwj/JgAAAJEVMwFw6dKlqq6u1l133aWKigrNnj1ba9euVX5+viSprKxMVmtnQfP000/Xk08+qTvuuEO33367Jk6cqJdeeknTp08P+D3tdnu3e4SW3W7XypUr+XzDhM83fPhsw4vPN7z4fMMrVj7fmJgFHCm+2cb9nWEDAAAQjWJiDCAAAABChwAIAAAwzBAAAQAAhhkCIAAAwDBDAOyDb8mY3NxcLViwQJs2bYp0k4aEn/70p7JYLN1uU6ZMiXSzYtKGDRu0ZMkSFRUVyWKx6KWXXur2uGEYuuuuu1RYWKikpCQtWrRIu3fvjlh7Y83JPt/rrrvuhO/yRRddFLH2xpJVq1bp1FNPVVpamvLy8nTZZZdp586d3a5pa2vTLbfcohEjRig1NVVf+cpX/BsCoG+BfL4LFy484ft70003RazNseS3v/2tZs6c6V/subS0VH/729/8j8fCd5cA2ItnnnlGt99+uyTpnXfe0axZs7R48WJVVVVFumlDwrRp01ReXu6/vfvuu5FuUkxqbm7WrFmztHr16h4fv//++/Wf//mfWrNmjT788EOlpKRo8eLFamtrG/S2xqKTfb6SdNFFF3X7Lj/11FOD2sZY9fbbb+uWW27RBx98oNdff13t7e268MIL1dzc7L/mtttu01/+8hc999xzevvtt3X06FFdfvnlEW13rAjk85WkG2+8sdv39/77749Ym2PJyJEjdd9992nz5s366KOPdN555+nLX/6ytm3bJsXKd9dAj0477TTjxhtvNCQZDQ0NhtvtNoqKioxVq1ZFumkxb+XKlcasWbMi3YwhR5Lx4osv+n/2eDxGQUGB8fOf/9x/rr6+3rDb7cZTTz0VoVbGruM/X8MwjGuvvdb48pe/HLE2DSVVVVWGJOPtt982DO93NT4+3njuuef812zfvt2QZGzcuDGCLY1Nx3++hmEY55xzjvG9730vou0aSrKysoxHH300Zr67VAB74HK5tHnzZi1cuNB/zmq1atGiRdq4cWNE2zZU7N69W0VFRRo3bpyuvvpqlZWVRbpJQ87+/ftVUVGhRYsW+c9lZGRowYIFfI9DaP369crLy9PkyZP1ne98R8eOHYt0k2JSQ0ODJCk7O1uStHnzZrW3t3f7/k6ZMkWjRo3i+9sPx3++Pk888YRycnI0ffp0rVixQi0tLRFqYexyu916+umn1dzcrNLS0pj57sbMTiCDqaamRm63W3l5ed3O5+fna8eOHRFr11CxYMECPf7445o8ebLKy8t1991366yzztLnn3+utLS0SDdvyKioqJC839uu8vPz/Y9hYC666CJdfvnlGjt2rPbu3avbb79dF198sTZu3CibzRbp5sUMj8ej73//+zrjjDP8uzVVVFQoISFBmZmZ3a7l+xu8nj5fSbrqqqs0evRoFRUV6dNPP9WPf/xj7dy5Uy+88EJE2xsrPvvsM5WWlqqtrU2pqal68cUXNXXqVG3dujUmvrsEQAy6iy++2H88c+ZMLViwQKNHj9azzz6rb33rWxFtGxCMK664wn88Y8YMzZw5U+PHj9f69et1/vnnR7RtseSWW27R559/zljgMOnt8/32t7/tP54xY4YKCwt1/vnna+/evRo/fnwEWhpbJk+erK1bt6qhoUHPP/+8rr32Wr399tuRblbA6ALuQU5Ojmw22wkTPiorK1VQUBCxdg1VmZmZmjRpkvbs2RPppgwpvu/q8TPP+B6Hz7hx45STk8N3OQi33nqr/vrXv+qtt97SyJEj/ecLCgrkcrlUX1/f7Xq+v8Hp7fPtyYIFCySJ72+AEhISNGHCBM2bN0+rVq3SrFmz9NBDD8XMd5cA2IOEhATNmzevW5L3eDxat26dSktLI9q2oaipqUl79+5VYWFhpJsypIwdO1YFBQVat26d/5zD4dCHH37I9zhMDh8+rGPHjvFdDoBhGLr11lv14osv6s0339TYsWO7PT5v3jzFx8d3+/7u3LlTZWVlfH8DcLLPtydbt26VJL6//eTxeOR0OmPmu0sXcC+WL1+ua665RvL+h3v00UfV3NysZcuWRbppMe8HP/iBlixZotGjR+vo0aNauXKlbDabrrzyykg3LeY0NTV1+9f6/v37tXXrVmVnZ2vUqFH6/ve/r//4j//QxIkTNXbsWN15550qKirSZZddFtF2x4q+Pt/s7Gzdfffd+spXvqKCggLt3btXP/rRjzRhwgQtXrw4ou2OBbfccouefPJJvfzyy0pLS/OPjcrIyFBSUpIyMjL0rW99S8uXL1d2drbS09P13e9+V6WlpfrSl74U6eZHvZN9vnv37tWTTz6pSy65RCNGjNCnn36q2267TWeffbZmzpwZ6eZHvRUrVujiiy/WqFGj1NjYqCeffFLr16/Xa6+9Fjvf3UhPQ45m999/vyHJiI+PN0477TTjgw8+iHSThoSlS5cahYWFRkJCglFcXGwsXbrU2LNnT6SbFZPeeustQ9IJt2uvvdYwvEvB3HnnnUZ+fr5ht9uN888/39i5c2ekmx0z+vp8W1pajAsvvNDIzc014uPjjdGjRxs33nijUVFREelmx4SePldJxh/+8Af/Na2trcbNN99sZGVlGcnJyca//Mu/GOXl5RFtd6w42edbVlZmnH322UZ2drZht9uNCRMmGD/84Q+NhoaGSDc9Jlx//fXG6NGjjYSEBCM3N9c4//zzjb///e/+x2Phu2sxzC8KemAYhhobG5WWliaLxRLp5gAAAIQEARAAAGCYYRIIAADAMEMABAAAGGYIgAAAAMMMARAAAGCYIQACAAAMMwRAAACAYYYACAAAMMwQAAEAAIYZAiAAAMAwQwAEAAAYZgiAABCgp556SklJSSovL/efW7ZsmWbOnKmGhoaItg0AgsFewAAQIMMwNHv2bJ199tl6+OGHtXLlSj322GP64IMPVFxcHOnmAUDA4iLdAACIFRaLRffcc4+++tWvqqCgQA8//LDeeecdwh+AmEMFEACCNHfuXG3btk1///vfdc4550S6OQAQNMYAAkAQ1q5dqx07dsjtdis/Pz/SzQGAfqECCAAB2rJlixYuXKj/+q//0uOPP6709HQ999xzkW4WAASNMYAAEIADBw7o0ksv1e23364rr7xS48aNU2lpqbZs2aK5c+dGunkAEBQqgABwErW1tTr99NO1cOFCrVmzxn/+0ksvldvt1tq1ayPaPgAIFgEQAABgmGESCAAAwDBDAAQAABhmCIAAAADDDAEQAABgmCEAAgAADDMEQAAAgGGGAAgAADDMEAABAACGGQIgAADAMEMABAAAGGYIgAAAAMMMARAAAGCYIQACAAAMMwRAAACAYYYACAAAMMwQAAEAAIYZAiAAAMAwQwAEAAAYZgiAAAAAw8z/B7LWWoWc8GfGAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/html": [
        "\n",
        "            <div style=\"display: inline-block;\">\n",
        "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
        "                    Figure\n",
        "                </div>\n",
-       "                <img src='data:image/png;base64,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' width=640.0/>\n",
+       "                <img src='data:image/png;base64,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' width=640.0/>\n",
        "            </div>\n",
        "        "
       ],
@@ -94,10 +94,10 @@
     {
      "data": {
       "text/plain": [
-       "<sympy.plotting.backends.matplotlibbackend.matplotlib.MatplotlibBackend at 0x7fe2f47f5d10>"
+       "<sympy.plotting.backends.matplotlibbackend.matplotlib.MatplotlibBackend at 0x7fe2f4699590>"
       ]
      },
-     "execution_count": 280,
+     "execution_count": 285,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/test.sh b/test.sh
index 281d443..a08c60a 100755
--- a/test.sh
+++ b/test.sh
@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-odin test game -collection:common=./common -collection:game=./game -collection:libs=./libs -strict-style -vet
+odin test game/assets -collection:common=./common -collection:game=./game -collection:libs=./libs -strict-style -vet -sanitize:memory