diff --git a/tests_jupyter/test.py b/tests_jupyter/test.py
new file mode 100644
index 00000000..006d09ce
--- /dev/null
+++ b/tests_jupyter/test.py
@@ -0,0 +1,409 @@
+# %%
+import numpy as np
+import pychrono as chrono
+
+from rostok.block_builder_api.block_blueprints import (PrimitiveBodyBlueprint,
+                                                       RevolveJointBlueprint,
+                                                       TransformBlueprint)
+from rostok.block_builder_api.block_parameters import JointInputType
+from rostok.block_builder_api.easy_body_shapes import Box, Cylinder, Ellipsoid
+from rostok.block_builder_chrono.blocks_utils import FrameTransform
+from rostok.graph_grammar import rule_vocabulary
+from rostok.graph_grammar.node import ROOT
+from rostok.graph_grammar.node_vocabulary import NodeVocabulary
+from rostok.utils.dataset_materials.material_dataclass_manipulating import (
+    DefaultChronoMaterialNSC, DefaultChronoMaterialSMC)
+from rostok.graph_grammar.node import GraphGrammar
+from rostok.graph_grammar.graph_utils import plot_graph
+
+# %%
+def get_density_box(mass: float, box: Box):
+    volume = box.height_z * box.length_y * box.width_x
+    return mass / volume
+
+def rotation_x(alpha):
+    quat_X_ang_alpha = chrono.Q_from_AngX(np.deg2rad(alpha))
+    return [quat_X_ang_alpha.e0, quat_X_ang_alpha.e1, quat_X_ang_alpha.e2, quat_X_ang_alpha.e3]
+
+def rotation_y(alpha):
+    quat_Y_ang_alpha = chrono.Q_from_AngY(np.deg2rad(alpha))
+    return [quat_Y_ang_alpha.e0, quat_Y_ang_alpha.e1, quat_Y_ang_alpha.e2, quat_Y_ang_alpha.e3]
+
+def rotation_z(alpha):
+    quat_Z_ang_alpha = chrono.Q_from_AngZ(np.deg2rad(alpha))
+    return [quat_Z_ang_alpha.e0, quat_Z_ang_alpha.e1, quat_Z_ang_alpha.e2, quat_Z_ang_alpha.e3]
+
+def_mat = DefaultChronoMaterialNSC()
+
+# %%
+node_vocab = NodeVocabulary()
+node_vocab.add_node(ROOT)
+node_vocab.create_node(label="MB")
+node_vocab.create_node(label="L")
+node_vocab.create_node(label="W")
+node_vocab.create_node(label="J")
+node_vocab.create_node(label="R")
+node_vocab.create_node(label="G")
+
+node_vocab.create_node(label="XT")
+node_vocab.create_node(label="ZT")
+
+
+# %%
+from copy import deepcopy
+# blueprint for the palm
+main_body = []
+
+for i in range(10):
+    main_body.append(PrimitiveBodyBlueprint(
+        Box(0.5, 0.1, 0.3), material=def_mat, color=[255, 0, 0], density=100+i*100,is_collide=False))
+    
+wheel_def_mat = deepcopy(def_mat)
+wheel_def_mat.Friction = 0.5
+wheel_def_mat.RollingFriction=0.0001
+wheel_def_mat.SpinningFriction=0.0001
+wheel_body_cyl = PrimitiveBodyBlueprint(
+    Cylinder(0.03, 0.06), material=wheel_def_mat, color=[0, 120, 255], density=1000)
+
+wheel_body_ell = PrimitiveBodyBlueprint(
+    Ellipsoid(0.06,0.06, 0.04), material=def_mat, color=[0, 120, 255], density=1000)
+
+# blueprint for the base
+base = PrimitiveBodyBlueprint(Box(0.02, 0.03, 0.02),
+                                material=def_mat,
+                                color=[120, 120, 0],
+                                density=1000)
+
+# sets effective density for the links, the real links are considered to be extendable.
+
+length_link = np.linspace(0.05, 0.1, 5)
+# create link blueprints using mass and length parameters
+link = list(map(lambda x: PrimitiveBodyBlueprint(Box(0.02, x, 0.02),
+                                            material=def_mat,
+                                            color=[0, 120, 255],
+                                            density=1000), length_link))
+
+dummy_link = PrimitiveBodyBlueprint(
+    Box(0.01, 0.001, 0.01), material=def_mat, density=1000000)
+
+# %%
+0.3**2*3.14*0.2*500/(0.01**3*0.1)
+
+
+# %%
+for i, bp in enumerate(main_body):
+    node_vocab.create_node(label=f"MB{i}", is_terminal=True, block_blueprint=bp)
+
+for i, bp in enumerate(link):
+    node_vocab.create_node(label=f"L{i}", is_terminal=True, block_blueprint=bp)
+
+node_vocab.create_node(label="B", is_terminal=True,block_blueprint=base)
+node_vocab.create_node(label="WC", is_terminal=True,block_blueprint=wheel_body_cyl)
+node_vocab.create_node(label="WE", is_terminal=True,block_blueprint=wheel_body_ell)
+
+node_vocab.create_node(label="DB", is_terminal=True,
+                        block_blueprint=dummy_link)
+
+# %%
+x_translation_values = np.linspace(0.0,0.25,5)
+X_TRANSLATIONS_POSITIVE = list(
+    map(lambda x: FrameTransform([x, 0, 0], [1, 0, 0, 0]), x_translation_values))
+X_TRANSLATIONS_NEGATIVE=list(
+    map(lambda x: FrameTransform([-x, 0, 0], [1, 0, 0, 0]), x_translation_values))
+    # create transform blueprints from the values
+x_translation_positive = list(
+    map(lambda x: TransformBlueprint(x), X_TRANSLATIONS_POSITIVE))
+x_translation_negative = list(
+    map(lambda x: TransformBlueprint(x), X_TRANSLATIONS_NEGATIVE))
+
+z_translation_values = np.linspace(0.0,0.15,5)
+Z_TRANSLATIONS_POSITIVE = list(
+    map(lambda x: FrameTransform([0, 0, x], [1, 0, 0, 0]), z_translation_values))
+Z_TRANSLATIONS_NEGATIVE = list(
+    map(lambda x: FrameTransform([0, 0, -x], [1, 0, 0, 0]), z_translation_values))
+
+z_translation_positive = list(
+    map(lambda x: TransformBlueprint(x), Z_TRANSLATIONS_POSITIVE))
+z_translation_negative = list(
+    map(lambda x: TransformBlueprint(x), Z_TRANSLATIONS_NEGATIVE))
+
+# %%
+for i, bp in enumerate(x_translation_positive):
+    node_vocab.create_node(label=f"XTP{i}", is_terminal=True, block_blueprint=bp)
+
+for i, bp in enumerate(x_translation_negative):
+    node_vocab.create_node(label=f"XTN{i}", is_terminal=True, block_blueprint=bp)
+
+for i, bp in enumerate(z_translation_positive):
+    node_vocab.create_node(label=f"ZTP{i}", is_terminal=True, block_blueprint=bp)
+
+for i, bp in enumerate(z_translation_negative):
+    node_vocab.create_node(label=f"ZTN{i}", is_terminal=True, block_blueprint=bp)
+
+# %%
+TURN_X = FrameTransform([0, 0, 0], rotation_x(90))
+turn_x_bp = TransformBlueprint(TURN_X)
+
+TURN_Y = FrameTransform([0, 0, 0], rotation_y(90))
+turn_y_bp = TransformBlueprint(TURN_Y)
+
+TURN_Z = FrameTransform([0, 0, 0], rotation_z(90))
+turn_z_bp = TransformBlueprint(TURN_Z)
+
+# %%
+node_vocab.create_node(label='XR',is_terminal=True, block_blueprint=turn_x_bp)
+node_vocab.create_node(label='YR',is_terminal=True, block_blueprint=turn_y_bp)
+node_vocab.create_node(label='ZR',is_terminal=True, block_blueprint=turn_z_bp)
+
+# %%
+stiffness = np.linspace(0.1,5,50)
+
+no_control_joint = list(
+    map(lambda x: RevolveJointBlueprint(JointInputType.UNCONTROL,
+                                            stiffness=x,
+                                            damping=0.005,
+                                            equilibrium_position=0), stiffness))
+motor_bp = RevolveJointBlueprint(JointInputType.TORQUE,  stiffness=0, damping=0.002)
+neutral_bp = RevolveJointBlueprint(JointInputType.UNCONTROL,  stiffness=0, damping=0.002)
+
+# %%
+node_vocab.create_node(label="RM", is_terminal=True, block_blueprint=motor_bp)
+node_vocab.create_node(label="LM", is_terminal=True, block_blueprint=motor_bp)
+node_vocab.create_node(label="NM", is_terminal=True, block_blueprint=neutral_bp)
+
+for i, bp in enumerate(no_control_joint):
+    node_vocab.create_node(label=f"J{i}", is_terminal=True, block_blueprint=bp)
+
+# %%
+rule_vocab = rule_vocabulary.RuleVocabulary(node_vocab)
+# structural rules
+rule_vocab.create_rule("Init", ["ROOT"], ["MB"], 0, 0,[])
+rule_vocab.create_rule("Add_Leg_Base",["MB"],["MB","XT","ZT","B","G"],0,0,[(0,1),(1,2),(2,3),(3,4)])
+
+rule_vocab.create_rule("Add_Dummy", ["G"], ["J","DB", "G"],0,0,[(0, 1), (1, 2)])
+rule_vocab.create_rule("Extension",["G"],["J","L", "G"], 0,2,[(0, 1), (1, 2)])
+rule_vocab.create_rule("R_Wheel",["G"], ["RM","W"],0,0,[(0,1)])
+rule_vocab.create_rule("L_Wheel",["G"], ["LM","W"],0,0,[(0,1)])
+rule_vocab.create_rule("Wheel",["G"], ["J","DB","NM","W"],0,0,[(0,1),(1,2),(2,3)])
+rule_vocab.create_rule("Rotation",["G"],["R","G"],0,0,[(0,1)])
+
+# %%
+for i in range(len(main_body)):
+    rule_vocab.create_rule(f'Terminal_Main_Body{i}',["MB"],[f"MB{i}"],0,0,[])
+
+for i in range(len(link)):
+    rule_vocab.create_rule(f'Terminal_Link{i}',["L"],[f"L{i}"],0,0,[])
+
+for i in range(len(no_control_joint)):
+    rule_vocab.create_rule(f'Terminal_Joint{i}',["J"],[f"J{i}"],0,0,[])
+
+for i in range(len(x_translation_positive)):
+    rule_vocab.create_rule(f'Positive_Translation_X{i}',["XT"],[f"XTP{i}"],0,0,[])
+for i in range(len(x_translation_negative)):
+    rule_vocab.create_rule(f'Negative_Translation_X{i}',["XT"],[f"XTN{i}"],0,0,[])
+for i in range(len(z_translation_positive)):
+    rule_vocab.create_rule(f'Positive_Translation_Z{i}',["ZT"],[f"ZTP{i}"],0,0,[])
+for i in range(len(z_translation_negative)):
+    rule_vocab.create_rule(f'Negative_Translation_Z{i}',["ZT"],[f"ZTN{i}"],0,0,[])
+
+rule_vocab.create_rule(f'Rotation_X',["R"],["XR"],0,0,[])
+rule_vocab.create_rule(f'Rotation_Y',["R"],["YR"],0,0,[])
+rule_vocab.create_rule(f'Rotation_Z',["R"],["ZR"],0,0,[])
+
+rule_vocab.create_rule("Cyl_Wheel",["W"],["WC"],0,0,[])
+rule_vocab.create_rule("Ell_Wheel",["W"],["WE"],0,0,[])
+
+# %%
+i=8
+graph = GraphGrammar()
+rules = ["Init",
+    "Add_Leg_Base","Positive_Translation_X4","Positive_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Positive_Translation_X4","Negative_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}',"Add_Dummy","Rotation","L_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Negative_Translation_X4","Positive_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}', f'Terminal_Joint{i}',"Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Negative_Translation_X4","Negative_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy", "Rotation","L_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3",'Terminal_Joint10','Rotation_Y',
+
+    'Terminal_Main_Body3'
+    
+]
+
+for rule in rules:
+    graph.apply_rule(rule_vocab.get_rule(rule))
+
+
+plot_graph(graph)
+
+# %%
+from rostok.simulation_chrono.simulation_scenario import SuspensionCarScenario
+from rostok.criterion.simulation_flags import EventBodyTooLowBuilder, EventContactInInitialPositionBuilder
+from rostok.control_chrono.controller import SimpleKeyBoardController
+
+parameters = {}
+parameters["forward"] = 1
+parameters["reverse"]= 1
+parameters["forward_rotate"] = 0.5
+parameters["reverse_rotate"] = 0.3
+control =  {"initial_value": [0.0]*4}
+
+# %%
+height = 0
+for i in np.linspace(0.1,1,100):
+    scenario = SuspensionCarScenario(0.0001, 0.01,initial_vertical_pos=i)
+    scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))
+    scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())
+    result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = False, delay=False)
+    if len(list(result.robot_final_ds.get_data("COG").items())[0][1]) > 10:
+        height = i
+        break
+
+print(height)
+
+
+# %%
+#height = 0.29
+
+# %%
+# n=20
+# stiffness = np.zeros(n)
+# for i in range(n):
+#     if i%10 == 0:    
+#         print(i)
+#     graph = GraphGrammar()
+#     rules = ["Init",
+#     "Add_Leg_Base","Positive_Translation_X4","Positive_Translation_Z3","Rotation",
+#     'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+#     "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+#     "Add_Leg_Base","Positive_Translation_X4","Negative_Translation_Z3","Rotation",
+#     'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}',"Add_Dummy","Rotation","L_Wheel", "Cyl_Wheel",
+#     "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+#     "Add_Leg_Base","Negative_Translation_X4","Positive_Translation_Z3","Rotation",
+#     'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}', f'Terminal_Joint{i}',"Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+#     "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+#     "Add_Leg_Base","Negative_Translation_X4","Negative_Translation_Z3","Rotation",
+#     'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy", "Rotation","L_Wheel", "Cyl_Wheel",
+#     "Terminal_Link3","Terminal_Link3",'Terminal_Joint10','Rotation_Y',
+
+#         'Terminal_Main_Body3'
+        
+#     ]
+
+#     for rule in rules:
+#         graph.apply_rule(rule_vocab.get_rule(rule))
+
+#     scenario = SuspensionCarScenario(0.0001, 1,initial_vertical_pos=height)
+#     scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))
+#     scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())
+#     result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = False, delay=False)
+#     stiffness[i]=list(result.robot_final_ds.get_data("COG").items())[0][1][-1][1]
+
+# # %%
+# import matplotlib.pyplot as plt
+# plt.scatter(np.arange(100)[:20],stiffness[:20])
+
+
+# %%
+# i = np.argmax(stiffness)
+# print(i)
+i = 8
+
+graph = GraphGrammar()
+rules = ["Init",
+    "Add_Leg_Base","Positive_Translation_X4","Positive_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Positive_Translation_X4","Negative_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}',"Add_Dummy","Rotation","L_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Negative_Translation_X4","Positive_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}', f'Terminal_Joint{i}',"Add_Dummy","Rotation","R_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3", 'Terminal_Joint10','Rotation_Y',
+
+    "Add_Leg_Base","Negative_Translation_X4","Negative_Translation_Z3","Rotation",
+    'Rotation_Y', "Extension","Extension",f'Terminal_Joint{i}',f'Terminal_Joint{i}', "Add_Dummy", "Rotation","L_Wheel", "Cyl_Wheel",
+    "Terminal_Link3","Terminal_Link3",'Terminal_Joint10','Rotation_Y',
+
+    'Terminal_Main_Body3'
+
+]
+
+for rule in rules:
+    graph.apply_rule(rule_vocab.get_rule(rule))
+
+
+#scenario = SuspensionCarScenario(0.0001, 1,initial_vertical_pos=height)
+#scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))
+#scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())
+#result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=True)
+
+
+
+
+# %%
+from rostok.block_builder_api.block_blueprints import EnvironmentBodyBlueprint
+from rostok.control_chrono.controller import SimpleKeyBoardController
+from rostok.simulation_chrono.simulation_scenario import WalkingScenario
+import pychrono as chrono
+from rostok.utils.dataset_materials.material_dataclass_manipulating import DefaultChronoMaterialNSC
+#from wheels import get_stiff_wheels, get_wheels, get_stiff_wheels_ell, get_stiff_wheels_4
+from rostok.graph_grammar.graph_utils import plot_graph
+from rostok.block_builder_chrono.block_builder_chrono_api sudo python3 tests_jupyter/test.py import \
+    ChronoBlockCreatorInterface
+from rostok.block_builder_api.easy_body_shapes import Box
+
+def create_bump_track():
+    def_mat = DefaultChronoMaterialNSC()
+    floor = ChronoBlockCreatorInterface.create_environment_body(EnvironmentBodyBlueprint(Box(5, 0.05, 5), material=def_mat, color=[215, 255, 0]))
+    chrono_material = chrono.ChMaterialSurfaceNSC()
+    #chrono_material.SetFriction(0.67)
+    mesh = chrono.ChBodyEasyMesh("Bump.obj", 8000, True, True, True, chrono_material, 0.002)
+    floor.body = mesh
+    floor.body.SetNameString("Floor")
+    floor.body.SetPos(chrono.ChVectorD(1.5,-0.07,0))
+    floor.body.GetVisualShape(0).SetTexture("chess.png", 0.03, 0.03)
+    floor.body.SetBodyFixed(True)
+    return floor
+
+def create_track():
+    def_mat = DefaultChronoMaterialNSC()
+    floor = ChronoBlockCreatorInterface.create_environment_body(EnvironmentBodyBlueprint(Box(5, 0.05, 5), material=def_mat, color=[215, 255, 0]))
+    chrono_material = chrono.ChMaterialSurfaceNSC()
+    #chrono_material.SetFriction(0.67)
+    mesh = chrono.ChBodyEasyMesh("TRACKMANIA.obj", 8000, True, True, True, chrono_material, 0.002)
+    floor.body = mesh
+    floor.body.SetNameString("Floor")
+    floor.body.SetPos(chrono.ChVectorD(6.6,-0.02,5.2))
+    floor.body.GetVisualShape(0).SetTexture("chess.png", 0.03, 0.03)
+    floor.body.SetBodyFixed(True)
+    return floor
+
+
+floor = create_track()
+
+scenario = WalkingScenario(0.0001, 10000, SimpleKeyBoardController)
+scenario.set_floor(floor)
+#graph = get_stiff_wheels_4()
+
+parameters = {}
+parameters["forward"] = 0.5
+parameters["reverse"]= 0.5
+parameters["forward_rotate"] = 0.5
+parameters["reverse_rotate"] = 0.3
+
+scenario.run_simulation(graph, parameters, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=True, is_follow_camera = True)
+
+
diff --git a/tests_jupyter/wheels_ruleset.ipynb b/tests_jupyter/wheels_ruleset.ipynb
index 7229eafd..6e9d460f 100644
--- a/tests_jupyter/wheels_ruleset.ipynb
+++ b/tests_jupyter/wheels_ruleset.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,7 +51,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -87,16 +87,16 @@
     "wheel_def_mat.RollingFriction=0.0001\n",
     "wheel_def_mat.SpinningFriction=0.0001\n",
     "wheel_body_cyl = PrimitiveBodyBlueprint(\n",
-    "    Cylinder(0.03, 0.02), material=wheel_def_mat, color=[0, 120, 255], density=500)\n",
+    "    Cylinder(0.03, 0.06), material=wheel_def_mat, color=[0, 120, 255], density=1000)\n",
     "\n",
     "wheel_body_ell = PrimitiveBodyBlueprint(\n",
-    "    Ellipsoid(0.06,0.06, 0.04), material=def_mat, color=[0, 120, 255], density=500)\n",
+    "    Ellipsoid(0.06,0.06, 0.04), material=def_mat, color=[0, 120, 255], density=1000)\n",
     "\n",
     "# blueprint for the base\n",
     "base = PrimitiveBodyBlueprint(Box(0.02, 0.03, 0.02),\n",
     "                                material=def_mat,\n",
     "                                color=[120, 120, 0],\n",
-    "                                density=500)\n",
+    "                                density=1000)\n",
     "\n",
     "# sets effective density for the links, the real links are considered to be extendable.\n",
     "\n",
@@ -105,7 +105,7 @@
     "link = list(map(lambda x: PrimitiveBodyBlueprint(Box(0.02, x, 0.02),\n",
     "                                            material=def_mat,\n",
     "                                            color=[0, 120, 255],\n",
-    "                                            density=500), length_link))\n",
+    "                                            density=1000), length_link))\n",
     "\n",
     "dummy_link = PrimitiveBodyBlueprint(\n",
     "    Box(0.01, 0.001, 0.01), material=def_mat, density=1000000)"
@@ -113,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -122,7 +122,7 @@
        "282600000.0"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -133,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -153,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -201,7 +201,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -217,7 +217,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -228,11 +228,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "stiffness = np.linspace(0.1,10,100)\n",
+    "stiffness = np.linspace(0.1,5,50)\n",
     "\n",
     "no_control_joint = list(\n",
     "    map(lambda x: RevolveJointBlueprint(JointInputType.UNCONTROL,\n",
@@ -245,7 +245,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -259,7 +259,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -268,16 +268,17 @@
     "rule_vocab.create_rule(\"Init\", [\"ROOT\"], [\"MB\"], 0, 0,[])\n",
     "rule_vocab.create_rule(\"Add_Leg_Base\",[\"MB\"],[\"MB\",\"XT\",\"ZT\",\"B\",\"G\"],0,0,[(0,1),(1,2),(2,3),(3,4)])\n",
     "\n",
+    "rule_vocab.create_rule(\"Add_Dummy\", [\"G\"], [\"J\",\"DB\", \"G\"],0,0,[(0, 1), (1, 2)])\n",
     "rule_vocab.create_rule(\"Extension\",[\"G\"],[\"J\",\"L\", \"G\"], 0,2,[(0, 1), (1, 2)])\n",
-    "rule_vocab.create_rule(\"R_Wheel\",[\"G\"], [\"J\",\"DB\",\"RM\",\"W\"],0,0,[(0,1),(1,2),(2,3)])\n",
-    "rule_vocab.create_rule(\"L_Wheel\",[\"G\"], [\"J\",\"DB\",\"LM\",\"W\"],0,0,[(0,1),(1,2),(2,3)])\n",
+    "rule_vocab.create_rule(\"R_Wheel\",[\"G\"], [\"RM\",\"W\"],0,0,[(0,1)])\n",
+    "rule_vocab.create_rule(\"L_Wheel\",[\"G\"], [\"LM\",\"W\"],0,0,[(0,1)])\n",
     "rule_vocab.create_rule(\"Wheel\",[\"G\"], [\"J\",\"DB\",\"NM\",\"W\"],0,0,[(0,1),(1,2),(2,3)])\n",
     "rule_vocab.create_rule(\"Rotation\",[\"G\"],[\"R\",\"G\"],0,0,[(0,1)])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -304,18 +305,17 @@
     "rule_vocab.create_rule(f'Rotation_Z',[\"R\"],[\"ZR\"],0,0,[])\n",
     "\n",
     "rule_vocab.create_rule(\"Cyl_Wheel\",[\"W\"],[\"WC\"],0,0,[])\n",
-    "rule_vocab.create_rule(\"Ell_Wheel\",[\"W\"],[\"WE\"],0,0,[])\n",
-    "\n"
+    "rule_vocab.create_rule(\"Ell_Wheel\",[\"W\"],[\"WE\"],0,0,[])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVuElEQVR4nO3de3wU5b0/8M/MZJOQezb3hMsGwlUNIhKsorSoeCnVIxcNoMhBW7XVczgX4ZyevtqentPzU6ivY62//uqltopoIsQW7xfq/RoMxhARBEkgbAJJ2GRJNiTZzMzvj7BrrjObZDc7s/N5v16+THZnl2cznzzzzTzPzCOoqqqCiIiILEsMdwOIiIgovFgMEBERWRyLASIiIotjMUBERGRxLAaIiIgsjsUAERGRxbEYICIisrioQDZSFAX19fVITEyEIAihbhMREREFgaqqaGtrQ25uLkRx+L//AyoG6uvrMWnSpKA1joiIiMZPXV0dJk6cOOzzARUDiYmJ/jdLSkoKTsuIiIgopE6fPo1Jkyb5j+PDCagY8A0NJCUlsRggIiIyGb0hfk4gJCIisjgWA0RERBbHYoCIiMjiWAwQERFZHIsBIiIii2MxQEREZHEsBoiIiCyOxQAREZHFsRggIiKyOBYDREREFsdigIiIyOJYDBAREVkciwEiIiKLYzFARERkcSwGiIiILI7FABERkcWxGCAiIrI4FgNEREQWx2KAiKAoaribQERhFBXuBhDR+Kt2urGjog7lNS4cbmqHV1ZhkwQUZCSgKN+OVfMn4dy85HA3k4jGCYsBIgupbfZgU1kVymtdkEQBcp8zAl5ZxVcn2vB1Yzue/Pgoihx2bFlRCEd6fBhbTETjgcMERBaxq9KJpQ++h4pjLQDQrxDoy/d4xbEWLH3wPeyqdI5bG4koPHhmgMgCdlU6sbG0EiOZGSArKmSo2FhaCQC4/vy8kLSNiMKPZwaIIlxNswf37qwaUSHQlwrg3p1VqG32BLNZRGQgLAaIItzmsirI6tiuFpBVFZvKqoLUIiIyGg4TEEUoh8OB0+0eJG54HILU+6veebQKJ5/9KRIvvA5x0y9C445fIsp+9vS/IiPxwuuQeP7VAICWd5/CmcOfAkLv3wynL1qJ6mVzeJUBUQRiMUAUwWJTMtH1TTliZ1wMAGivegPR2dP9z0fZ85C74XcAgJ7TzXA+cjviZ18GMSYOyQuXI3Xxut7n2ppR/9hdePLtH2DrzZeO/wchopDiMAFRBEs5fylOf/EGAEDp9KDLeRATpl4w5LZKdwdEW6z/LIIYm+B/Tu3uBADsPdoS4hYTUTjwzABRBGtPmYoe9/PoaTuFM4c/RdysS/yn/QGgx+VE/RP3AHIPvK0NsF95J4SoaP/zpz97AW17X4bc1oy0a/4Bx86wyyCKRPzNJopQqqqiRwHiz/kePPv+ho5DHyP9B/8Kz5fv+LcZOExw4ul7EZ1dgJjsAgBA0oXXIenC69B98giaX3oAsfnzoCgqRFEIx0ciohBhMUBkQrIso6GhAXV1dairq8OxY8cGfd3Y2IgcRUb8uUvQ8Od/hC01Dzb78PcKiEpKR0zuTHQe/cJfDPhEZ02FlJCGzppK5ORsxKRJkzB58uR+//d9nZ2dDUmSQv0jIKIgYjFAZDCqqsLlcg15gPd9XV9fj56eHv9rEhIS/AflefPm4frrr8dvf/tb5KXEomlCGlIX3wpb2kTNf1fp9KD7xGHEn/M9AEB38zFEp08GAHhbGtB98ghyr5mIlXff7W/P7t27cezYMbS3t/vfJyoqCrm5uYOKhL5f2+12CALPLhAZBYsBonHW3t7uP7AP91f9mTNn/NvbbDb/gdThcOCyyy4bdJBNTk72H1y7urrw2muv4cyZM6jd+z4SF61BQuGVQ7bFP2cAgCp7EX/O9xA3fSEAoPXtP6HHfRIQJQiiBPsVP8IEeDF37lxs2rQJMTExva9TVbjd7n7t7/uZPvnkExw/fhxer9f/706YMGHIIqHv/+PjuSYC0XgRVFX/biSnT59GcnIy3G43kpKSxqNdRKbk9XrhdDqHPCj6vm5p+XZGviAIyM7O1jwoZmZmQhS1L/zxer146623UFJSgr/85S9wu90oLCzE5SvX4/mOGUH7fAkfPIwvP3gNycnJWL58OYqLi7FkyRJERWn/XaEoChobGzXPdpw4cQJ9u6PU1FTNswt5eXmw2WxB+2xEkSjQ4zeLAaIAheKAlpubi+joaI1/Vbs977//PkpKSrBz5040Nzdj+vTpWL16NW666SbMmTMHAHDjIx+j4ljLsAsTBUISBcyfnIrn7vgO9u/fj5KSEpSUlODQoUNIT0/HqlWrUFxcjEWLFukWLsPp7u5GfX295s830ELK93UghRRRJGMxQDQCvlPdWgcivVPdAw9EEydOREJCgsa/Orp2lpeXo6SkBM899xzq6+sxefJkFBcXo7i4GOeff/6gsfjaZg+WPvgeumVl1P9utCTijY2X9VvOWFVVfP755ygpKUFpaSmOHTuG3Nxc3HTTTSguLsaCBQuCPi9gpEMs0dHRyMvLG3YfDRxiIYo0LAaI+jhz5ozuQaTvJDhJkvodRMI5CU5VVVRVVfkPujU1NcjOzsaNN96I4uJiLFy4UPev39GsWugjAHjwpvM1Vy1UFAWffPKJv0g5efIk8vPz/UXKeeedN24/K73Jl06nE7Is+1/Td/LlcEXdhAkTQt52olBgMUCW0dPTg4aGBs0DQHNzc7/XZGZmah4AjHB53MGDB1FaWopnn30WBw4cgN1ux8qVK1FcXIzLLrtsxO3bVenEvTt7Fy0KZMhAEgVIgoCtKwtHtHyxLMt49913UVJSgrKyMrhcLsyePdtfGMyYEbw5DKMhyzJOnDihOa+jsbGx32vS09M153Xk5OTozpsgCgcWAxQRVFVFc3Oz7mV2ivLtKfCkpCTdiWexsbFh/FTDq62txXPPPYeSkhJ8/vnnSExMxA033IDi4mJcccUVY54wV9vswaayKpTXuiCJwpBFge/xhfl23L+8sN/QwEh1d3dj9+7dKCkpwV//+le0tbVh3rx5KC4uxk033YQpU6aM5eOETGdnJ44fP655Jun06dP+7SVJQm5u7rCZmzRpEtLT0zkcQeOOxQCZQltb27CdrW+cvrOz0799TEwMJk6cOOzB3jcGbCYNDQ3YsWMHSkpK8PHHH2PChAlYtmwZVq9ejWuuuSYkhUu1040dFXXYU9uCQ41t8MoqbJKA6ZmJWOBIxar5k4K+OuGZM2fw6quvoqSkBC+++CI6Ozvxne98B8XFxVi1ahVycnKC+u+Fmu9ySq2Cobu72799bGxsv5wOleHExMQwfiKKRCwGKOy6urr6XWY3VIfpdrv924uiiJycHM2/6jMyMiLir6vm5mY8//zzKCkpwTvvvIOoqChcffXVKC4uxg9+8INxPyiM9y2G29ra8OKLL6KkpASvvfYaenp68N3vfhfFxcVYsWIF0tLSxq0toaIoCpqamjSLhYaGhn5ntZKTkzWHI/Ly8vz3dyAKBIsBCilZlnHy5EnNA/3Jkyf7vSYtLU1z9n1OTk5EXzfudruxa9culJSU4M0334SqqliyZAmKi4txww03IDU1NdxNDIuWlhb85S9/wbPPPou33noLoijiyiuvRHFxMa6//nrTnekZCa/Xi/r6es2C4dSpU/1ek52drXl2ITs7m5dTkp+liwEupDI2qqqipaVl2DvK+WZk970dbnx8/LCdk++/uLi4MH6q/sYrIx0dHXjppZdQUlKCV155BV1dXbj00ktRXFyMlStXIjMzM+RtMJPGxkbs3LkTJSUleP/99xETE4Nrr70WxcXFWLZs2bhlyEh9SEdHh2axUFdXB4/H498+KioKEydO1CwYUlNTI+IMWzgZKSNaLFUM+MY/y2tcONzU7h//LMhIQFG+PSTjn2bm61y0/qrv6Ojwb+/rXLRO36ekpBi6cxnPjHR1deH1119HSUkJXnjhBXg8HixYsADFxcW48cYbMXGi9hoB1Kuurs4/l2LPnj2Ij4/Hddddh+LiYlx11VVBPV1u5j6kb/E+3O/18ePH+xXvcXFxmsMRRivejcCsGbFEMTCSmdFFDju2rBjbzGgz8J121DrQu1yufq/Ru4tbVlaWaU87BjMjra2tWL9+Pe644w5cc801/Z7r6enx3w74+eefh9vtxnnnneefNT9t2rSQfD6r+Oabb1BaWoqSkhLs27dP93bIr776Kh555BH8+c9/RkpKyrDva5U+xDesp1UwnDhxot9rfMN6w51dyM3NjehhPR+zZyTii4HxumbaSPpOSBpu9v2JEyf6TUhKSUnRPH0fyROSgpkRt9uNJUuWYO/evbj00kvx3nvvQVEUfPDBB/7bATc1NaGgoMB/O+BzzjknVB/N0r788kv//RcOHz6MjIwMrFy5EqtXr8Yll1wCURRx6aWX4oMPPsAFF1yAt956a8h5B1bsQ7T4JvwO1a/4HmttbfVv75vwq1UwZGRkmPYPCSAyMhLRxUCo76YWLgNXfhv49XCXKmmN01v1UqVgZqStrQ2XX3459u7dC1mWIQgCbr/9drzyyitwOp2YNGmS/4Y68+bNM/RwSSTpezvkkpIS1NXVIS8vD9deey0ef/xxqKoKSZIwf/587N69u9/vQqT2IaHmuxRYq5/qeylwdHS07uWURp0gGikZidhioKbZg6tCcJ91n87OTuzevRvXXnttUCta301MtE7ft7W1+bf33cRE6/R9WloaDzxDCGZG0mNVLF26FJ9++mm/My6JiYlYv349iouLcdFFF5n6r59I0Pd2yH/605/63VpaFEUsXLgQb775JuLj40Peh1iZ7yZhWgVDfX19v9tBJyUlaRYLEydODOq9NhRFwcsvv4wrr7xy2PeNpIxEbDEQ7BXY+vrwww9x66234ptvvsFbb72F733vewG9nyzLaGho0Jx939TU1O81GRkZw4bfdztc3t50dIKVkXkTk1Cx5RbU1tb2e04QBFxwwQX47LPPxthSCoX58+dj7969gx53OBzYv38/bn2qMmR9COnz3T5cq2AY2F9mZmZqFgw5OTkB35777bffxpIlS1BQUIAnn3wSF1988aBtQnmcGW+BHr8NfbRpbW3F3LlzUVJSgu985zvY53Rjd9mT6Dj4EZQzbYAgoKelAWJcMsSY3pmvGddvxqnXHkbP6SaIMXFQe7oRN2sRUi+7xf++sqLijW2/g3Dnxfj8889RUFCAn/70p3j44Yf9f+H5DgCqquLUqVOap8UGLnySmJjoD+oFF1yA66+/vl+AufBJ8IQyI7u3/x7uAYWAzWZDT08PKioqcPToUcPeTteqamtrsXfvXgiCgKioqH6rTB49ehS73tuL3WXbAsqHt+ko8u58HGJs7192TX/5H0yYVoSEwisgKyrKa1347PAJrLtuCaKjo1FZWRmOj2w6UVFR/r5wOGfOnPHfDnpgv7t7924cO3ZsyIXFtAoG35nUmpoaAEBNTQ0uueQSJCYm4q9//SuWLFkCAPjpf2/FC49tG1M+gN4+5JNDDZg2YxYS42INnw9DFwMpKSl45JFHsH79elRWVuKRFz/A6Q9LkbXuN7ClZAMATmz/NyQtuB5xM/pXX/bLb0fcjO9A7mxHwxP/gJicGYibvhAA0FV/EN0nDiE5Mxfvvvsurr76ajQ2NkJVVf+Y8H/913/hvvvuQ13d4CVRfdfwTp06FYsXLx4UPKOOgUWikGckIxclT/0REyZMwJEjR/z/nTp1CtHR0eP+eUlbTEwMrrrqKqSlpWHq1KmYOnUqmpqa8Mgjj+CLL77Avz39bsD5EGLi4P5kB1K/u37If0sSBfxk47/gkksuwZ49e0L90SxlwoQJmD59OqZPnz7k874lx4c7u1BeXo7jx4/3m2PlW3Lc6/VCEAT/H3BtbW1YunQpSkpKMHfuXDz0m/uQtXYrhKQsAKPPBwC43/0zpjnOhdJ4eIw/kdAzdDEAAFdffTUWL16Mf/3Xf8Uzr7yL5EvX+n+JAyHFJiAmdwa8LicAQPF2wvXmH5Bxw0/RtH0TNm7cOOg1vpGTZcuWDaoyMzMzOT5sMKHMiKvk35GdnY3zzz8fixcvDtVHoCDJycnBa6+9Nujxw4cPY/PmzSPKR/JFK9D6/nYkzv8BohIH3x65/cjn8NQdx/3/+p8sBsaZIAhISUlBSkoKzjvvvCG3URQFjY2NgwqG559/HgNHx2VZxqpVqzB9+nRMWfr38JwtBLTo5eNMbSV6Tp+C7aKb0MViIDgeeOABTJ06FV3xucicd43+C/roOd2MruP7kTjvWgBA69t/QuK8axGVlAEFAr7//e/jiy++wPHjxxEVFeW/Mce0adPwwAMPBP2zUGiEKiPeMUwgIuMYTT6k+FQknn813B9sR9o1/9DvOaWzHa1v/wm5q38ViuZSEIiiiOzsbGRnZ2PBggX+x7/44gv/MLCvz8/NzcWpU6eQk5OD+hlLADmAywgDyEfmjf+J4y11yAjqJwsNU/yJ67staXfLCShdHfovAOD62+Oof+IeND3/ayRfXIzYKYU4U/M5etyNSCi8EgCgqsCvfvVfOHbsGPbs2YO77rrLf3/4+vr6kH0eCr5QZkQZwyQiMobR5AMAkhauwJnDe+A9Vdfvcdebf0DSd1ZBjU1mPkzG17enpqbixz/+MT777DM8+uijSE9Px9GjR9HV4dF5h2/p5UOKT4EcQGFhBIY/M+ByuXDnnXfi+eefx9If/wotbz0+qAobim88uK/Oo1+g++Q3OP77DQAAua0Zy5Z9H4888gh+8IMf4MILL8QDDzyAN954I2JvxBOJxjMjZD6jzQcAiDFxSLpoJVreeRJCn+HBzrr96Kzbj9a3n8CaPwlwuVyYOXMmDh48GKqPQUHy0EMPoaurC0uXLoXNZoPL5cINN9yA559/Hk8++SSefvuPSL36noDeSy8fLW89AcjdcHV7DJ8PwxcDP/nJT3DzzTejqKgIC268B+/8n/U4U7MXE/IvGPF7pX53fb/JHo2P9t445vzzz/c/ZrPZ8P3vfz8ILafxMt4ZIXMZaz4S512L05+9AACYMK0IADDxx08AAObkJGFToYyNGzcafrY49briiiv6fd83H+eccw7+NGVG0PIBAFnt36Dr/ScMnw9DDxPs3LkT1dXV+OUvfwkAuHhWHjK+vxGnXv0dlM7AT+UMRRIFREcZ+uNTAJgR0hKMfAhRNqRcuhayu/+S3JIoYIHDmstOR4qB+YiPj8eqf/5vuIKQD6A3I7OyzXEXWFPddKja6cayhz8I2vu9dPciQ64yRaPHjJAW5oP0RFpGAj1+m+rPnnPzklHksEMa4xrSkiigyGHnL3EEYkZIC/NBeqyaEVMVAwCwZUUhpDHej18SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjhr+aYCi+ZSHNvs40hQ4zQlqYD9JjtYyYagLhQLXNHmwqq0J5rQuSMPRNoyRRgKyoWJhvx/3LzVWp0dj1zYgIFcoQtT4zYl39+pCzORiI+bA2sx9nInYJ46FUO93YUVGHXR99iRYlBoJkg6AqmJ2bggWOVKyaP8k0kzgoNKqdbpSUH8W21z4EknMgSDZIAjAzO4kZIX8f8nZ1HY62dkGQbFDlHszJS0VRvp35IH9Gyt77Am1iPATJBhEKZuUY+zhjqWLAp6mpCTk5OZBlBd98cxhTp04Nd5PIYB555BHceeedKJg+A4e+Nu7dwCh8ZsyYgUOHDuMPf/h/uOOOO8LdHDKYI0eOYNq0aZCkKJw40YD09PRwN0lTRF5aqCcjIwO33XYblq9YzkKAhrR+/XrMnDkT9913X7ibQgZ1//33Y8bMmVi/fn24m0IGNHXqVKxYsQK33X6b4QuBkYiIMwO+0zflNS4cbmqHV1ZhkwQUZCTwFB8BYEZIG/NBesyaEUsME4xk8k+Rw44tK4w1sYNCjxkhLcwH6TF7RiK+GNhV6bTMJR80OswIaWE+SE8kZCTQ47cp7zOwq9KJjaWVGMkq0bKiQoaKjaWVAGCYHUWhwYyQFuaD9FgtI6abQFjT7MG9O6tGtIP6UtF7E4na5rGtaEfGxYyQFuaD9FgxI6YrBjaX9Z6yGQtZVbGprCpILSKjYUZIC/NBeqyYEUPPGXjhhRfw85//3P99p1fG4WP1kNtbYMt0AABkTwugKJAS0wAASQuXo8dVj7a9L0NKTIMqexGdkQ/71T+BFJuA5pcfRPeJw4AgYEZOCn77wFZcfvnl4/aZKHgG5gMAGk40ovHkCd18uD98Fllr70PspHMBAKcrXkR3w2GkL/sneFtPoPkv/weqqmBKaizOP+8cPProo0hN5dr1ZtQ3J51eGUeaPVA63EHpR6ZmJCAxLhb33Xcf+xGTGstxJpB+JD9tAqIEFbNnzw5LPxKREwg3P/MR/vfuVUi8aCUS5y4FALS+vx1Klwf2K37k367vY6oio+mv9yEqOQv2y2+H0tkOMTYBkijg8gwPdv7qDjQ3N0MUTXeShAZobW3FtDlzIc37O8QVauejvfotRCWkIvuW3wDo/0us9nihqgpsMbG4eeFktP7tMQDAb3/72/H/UBRUv3ihGk+9ux/H/7QRSRetGlM/YotLxM0LJ+PvJnlx+eWXsx+JECM5zuj1I6KgYt2i6fjP687FP/7jPwIY/34k4m46pCgK/vTrf0HMlEL/DgqEIEqY4DgfPS4nAECMTQDQO9Hji28aQtJWGn+KomDt2rWIzz/fXwhoiSsogirL6Dj40aDnhCgbRFsMZEVF+ZFmeDweCGNczpSM4dNvmnFy11bETpk75n5EVlTsqW2B2+0OVXNpnI30OKPXj6hSNPbUtkCWZcP3I6a5muAXv/gFTrtbkbVm84hep3i70PH1J4jJm+V/rOWdP6PjwAeo62zH7ldeYDUfAX7xi1/A5XIh+rv/hp5AXiAISPnurXC9+QdMmL5w0NOq7EXDk/+MutONWFQ0Hy+88ELQ20zjr7zsEchn2pCx/D9G9Lrh+pE3D3yAT4QulJWVsR+JACM+zgTQj/zt17ci/RctKCwsNHQ/Yor07tq1C3/84x+R/nf/DkGyBfQaz5fvoP6Jf8CJbffClj4JSRet9D+X+t31yLvzcaT/3b9h06ZN6O7uDlXTaRz48rFjx070jKC+neA4H1GJGWivenPQc4JkQ+6G32HiPU9j5syZeOSRR4LZZAqDv/zlrzj9xRvIuOGnQe1HSkpK2Y9EgNEcZwD9fiRnw+/Q0HACs2bNMnQ/Yvhi4ODBg7jtttvw3HPPYUJK4PeBjj/nu8jd8BByNzwE+xU/gmiLGbRN0rR5aGtrw759+4LZZBpHffMxcWIebNLITsOlfPdWuD8sgertGvL56OhobNiwAdu2bQtGcylMDh48iB/+8HZkL/83RJ2dBBYIvX7EJglYuvRK9iMmN9rjjI9WP2KTBMTGxuDv//7vDd2PGLoYaGtrww033ID//M//xKJFi1CQkTCm91PlHnhb6v3fZ5ypQ2NjIxc1MqmB+QAw4ozEZBcgZuIctH3+qv+xHncjFG9n7/ulx2PHjh0oLCwMXsNpXPXNyXkXDD6VO1J9+5HpmYkoLy9nP2JiwTjOaPUj0zMToSiK4fsRQ88Z+L//9//i4MGDeOyxx/DYY4/hxOlOtHi6oQLIXPXLEVX4AKAqPTj10v9C6fJAECXI9mTs3LmTl4yZ1MB8APBnJGME+UhZvA71j97p/767sQat722DAKBjQhQyFn8HDz30UCg+Ao2Dvjnp24cAY+1HOtCZGIt/ykljP2JiwTrODNWPuN/bhq44GwofjcYFF1xg6H7EVJcWVjvdWPbwB0F7v5fuXmTIVaZo9JgR0sJ8kJ5Iy0jEXVoIAOfmJaPIYYckju3yDEkUUOSw85c4AjEjpIX5ID1WzYipigEA2LKiENIYr9WUBAFbVhh37IbGhhkhLcwH6bFiRkxXDDjS47F1ZSFGu5sEAFtXGmu9aQouZoS0MB+kx4oZMfQEwuH4loU0+zrTFDrMCGlhPkiP1TJiqgmEA9U2e7CprArltS6IAjDUvpJEAbKiYmG+HfcvN1elRmPXNyNQFUAYfDKMGbGuvvmQREBWBm/DfFhbv+MMVChDnC8wckYicqGi4VQ73Xjuszpsf+MT9MSn9949SunB7NxUFOXbsWr+JNNM4qDQqHa68ejuKux893PY0idDkGwQoWBWTgoWOFKZEYurdrqxo6IOL36yH6d6oiFINqiyFwUZ8Vg0M4f5IFQ73SjdcwzbXvsIalLW2eOMjDl5qYbuQyxVDPi8/vrruPrqqwEI2LbtKdx8883hbhIZzOrVq1FSUoKYmFicONGAlJSUcDeJDKS1tRXZ2dno6urG6tXFeOaZZ8LdJDKYbdu2Yd26dQAEvP76a1i6NPAFr8LBksWAqqrIysqCx+OB2+1GVJQpp0RQCO3fvx/nnHMObrzxRpSWloa7OWRAN910E5577jl8+eWXmDNnTribQwbT09OD5ORkxMfH4+TJk4ZeiRAI/PgdUUdLQRBQXl4OT0cHCwEa0pw5c/DOO+9g4cKLwt0UMqht27bhzrvuYiFAQ4qKisJnn32GmNhYwxcCIxERR0zfeF95jQuHm9rhlVXYpFoUZCRwzgABGJgRD7yv7YZNEpgRAjBMH7L7FeaD/IY+znwVMRkx9TBB/5nAwpCXfvgeL3LYsWWFsWZ5UugxI6SF+SA9Zs9IxM8Z2FXptMz1nzQ6zAhpYT5ITyRkJKLnDOyqdGJjaSX0d823ZEWFDBUbSysBwDA7ikKDGSEtzAfpsVpGTHc74ppmD+7dWTWiHdSXit47StU2e4LZLDIQZoS0MB+kx4oZMV0xsLms95TNWMiqik1lVUFqERkNM0JamA/SY8WMmGqYYJ/T3Xtb2SEc//0GCFE2CFHRUGUvorOmIe3qeyBGxw7aVlZUlNe6UO10m3r2Jw3GjJAWrXwAgWeE+YhcVu1DTHVmYGdFHaI01pjOuH4zcjf8Drm3/x5qlweefbuH3VYSBeyoqAtFMymMmBHSopcPIPCMMB+Ryap9iKmKgfIaF3oCmNEJuQeKtwtibMLwmygq9tS2BLF1ZATMCGkJOB+AbkaYj8hk1T7EVMMEh5vaNZ9v2nU/hKho9LgbEZM9DXGzL9Xc/lBjWzCbRwbAjJAWvXwAI8sI8xF5rNqHmKYYUBQVXlm7Wsu4fjOis6ZCVWSceu1htLz9J9gvv33Y7b2yCkVRIeqcNiRzYEZISyD5AEaWEeYjsli5DzHNMIEoCrBJgf0wBVFC/MyL0VmzV3M7myQYfgdR4JgR0jKSfACBZYT5iCxW7kNMUwwAQEHG8GMzA3UerUKUXfuGD9MzE8faJDIYZoS0jCQfgH5GmI/IY9U+xDTDBABQlG/H143tw94W0jeWA0VGVHIm7Ff9ZNj3kkQBCxypoWoqhQkzQlr08gEEnhHmIzJZtQ8x1doE1U43lj38QdDe76W7F5ni+k8KHDNCWpgP0hNpGQn0+G2qYYJz85JR5LBDGuP4iyQKKHLY+UscgZgR0sJ8kB6rZsRUxQAAbFlRCEkY404SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjpppA6ONbFtLs60xT6DAjpIX5ID1Wy4ipJhAOVNvswaayKpTXuiAJwFD3ipBEAbKiYmG+HfcvN1elRmPXNyMiVChD1PrMiHX160PO5mAg5sPazH6cCfT4bepiwKfa6caOijrs+vhLtMgxECQbBFXB7NwULHCkYtX8SaaZxEGhUe10o3TPUTz16odAcg4EyQZJAGZmJzEj5O9D3q6uw9HWLgiSDarcgzl5qSjKtzMf5M9I2XtfoE2MhyDZIELBrBxjH2csVQz4NDc3Izs7G7Ks4JtvDmPq1KnhbhIZzKOPPoo77rgDBdNn4NDXB8PdHDKgGTNm4NChw3jkkT/gRz/6UbibQwZz5MgRTJs2DZIUhRMnGpCenh7uJmmKyEsL9aSnp+OHP/whVq5ayUKAhrR+/XrMmjULW7ZsCXdTyKC2bt2KmbNmYf369eFuChnQ1KlTsWrVKtz+w9sNXwiMREScGfCdvimvceFwUzu8sgqbJKAgI4Gn+AgAM0LamA/SY9aMWGKYYCSTf4ocdmxZYayJHRR6zAhpYT5Ij9kzEvHFwK5Kp2Uu+aDRYUZIC/NBeiIhI4Eev015n4FdlU5sLK2E/q75lqyokKFiY2klABhmR1FoMCOkhfkgPVbLiOkmENY0e3DvzqoR7aC+VPTeRKK22RPMZpGBMCOkhfkgPVbMiOmKgc1lvadsxkJWVWwqqwpSi8homBHSwnyQHitmxFTDBPucbpTXugAATS9sRVRyJlIX3+p/vnHHLxEzuRCt7/wZtowpwNmdmbL4VsQVLPBvJysqymtdqHa6DTn7k0bPl5Gx5ANgRiIV+xDSY9WMmOrMwM6KOkSdXVbSvvQueL58B10NXwMA2r54A0pXB+JmXgwhegJyN/wOubc9jJTF69D8whaoitzvvSRRwI6KunH/DBRavoyMNR8AMxKJ2IeQHqtmxFTFQHmNCz1nZ3RKsQlIu/punHr5QXhdTrjffxppy/4ZwoB7z8dOmQu1+wyUzvZ+j8uKij21LePWdhofvoyMNR8AMxKJ2IeQHqtmxFTFwOGm/j/oCVPnI2biHDQ8+c9IvmQ1bCnZg17TcfBDxE4phBQ3+DTNoca2kLWVwqNvRsaaD4AZiTTsQ0iPVTNimjkDiqLCO8RyUUkLV8Cz/10kzrvG/5jafQb1T9wDpbMdSsdpZK3+9ZDv6ZVVKIoKURztqtVkJENlZCz5AJiRSMI+hPRYOSOmOTMgigJs0uAfpiCIgND/Y/jGcvLuegJJF61E064tUHu6B73WJgmG30EUuKEyMpZ8AMxIJGEfQnqsnBHTFAMAUJCRMKLtBUFA8iXFkOKS0Lb3lUHPT89MDFbTyCBGkhG9fADMSKRhH0J6rJoRUxUDRfl2SCOssARBQOqS2+D+dCcUb6f/cUkUsMCRGuwmUpiNNCPD5QNgRiIR+xDSY9WMmGptgmqnG8se/iBo7/fS3YtMcf0nBY4ZIS3MB+mJtIwEevw21ZmBc/OSUeQYedU2kCQKKHLY+UscgZgR0sJ8kB6rZsRUxQAAbFlRCEkY404SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjprnPQF++ZSHNvs40hQ4zQlqYD9JjtYyYagLhQLXNHmwqq0J5rQuiAAy1ryRRgKyoWJhvx/3LzVWp0dj1zQhUZdC1wgAzYmV98yGJgKwM3ob5sLZ+xxmoUIY4X2DkjAR6/DZ1MeBT7XTjuc/q8Mybn8Ablw5BsgFKD2bnpqIo345V8yeZZhIHhUa1041Hd+/Dznf3wpY+GYJkgwgFs3JSsMCRyoxYXLXTjR0VdXjxk69wqscGQbJBlb0oyEjAopnZzAeh2ulG6Z5j2PbaR1CTss4eZ2TMyUs1dB9iqWLA5/XXX8fVV18NQMDTT2/D2rVrw90kMpg1a9bg2WefRWzsBDQ01CMlJSXcTSIDaW1tRXZ2Nrq6urFmzWps37493E0ig3n66adxyy23ABDw+uuvYenSpeFukiZLFgOqqiIrKwsdHR1wu92QJCncTSKD2b9/P8455xzcdNNNKCkpCXdzyICKi4tRWlqK/fv3Y/bs2eFuDhlMT08PUlJSEBcXh5MnT0IY41UHoWbJYgAAjh07Bk9HB2bPmhXuppBBffDBB7jwwgWIjY0Jd1PIgLq7u/HJp5/isksvDXdTyKAOHjyImNhYOKZMCXdTdFmqGPCN95XXuHC4qR1eWYVNElCQkcA5AwSAGSFtzAfpMWtGLFEM9J8JLAx56Yfv8SKHHVtWGGuWJ4UeM0JamA/SY/aMRHwxsKvSaZnrP2l0mBHSwnyQnkjISKDHb1PedGhXpRMbSyuhv2u+JSsqZKjYWFoJAIbZURQazAhpYT5Ij9UyYrrbEdc0e3DvzqoR7aC+VPTeUaq22RPMZpGBMCOkhfkgPVbMiOmKgc1lvadsxkJWVWwqqwpSi8homBHSwnyQHitmxFTDBPuc7t7byg5w/PcbkLniZxBsMXC98f8ge1oBVUHyJcWIn33ZoO1lRUV5rQvVTrchZ3/S6DEjpGW4fAAjywjzEbms2oeYqhjYWVGHKFFAzzATOU69/CDiC69A4tyrIHe40fDnjYiZOAdRiemDtpVEATsq6kyxkyhwzAhp0csHEHhGmI/IZNU+xFTDBOU1Ls1f4u7GGkyYeiEAQIpLRnRmPjq+en/IbWVFxZ7alpC0k8KHGSEtevkAAs8I8xGZrNqHmKoYONzUrvl8dHYBPF++DQDwtp5Al/MAetyNw25/qLEtqO2j8GNGSItePoCRZYT5iDxW7UNMM0ygKCq8snZFn/79f0LLW39E/RP3ICopE7FT5gLi8PWOV1ahKCpE0dj3lqbAMCOkJZB8ACPLCPMRWazch5imGBBFATZJ0NxRUSlZyFj+U//3J0t/jtj8ecNub5MEw+8gChwzQloCyQcwsowwH5HFyn2IqYYJCjISNJ+XPS1QVQUAcOZIBbyn6hA/Z/Gw20/PTAxq+yj8mBHSopcPYGQZYT4ij1X7ENOcGQCAonw7vm5sH3xbSFWGEGVDx+FynP54JyCKkBLsyFz1C4i2oVemk0QBCxyp49BqGk/MCGkZNh/AiDPCfEQmq/YhpioGVs2fhCc/PtrvsZ52F5SuDkhJGUicexUS514V0HvJiopV8yeFopkURswIaRkqH8DoMsJ8RCar9iGmKgbOzUtGkcOOimMtkBUVp8v/grbK15C65DaIttiA30cSBcyfnGqKaz9pZJgR0jIwHwBGlRHmI3JZtQ8x3aqFtc0eLH3wPXTLyqjfI1oS8cbGywy1zCQFDzNCWpgP0hNJGQn0+G2qCYQA4EiPx9aVhRjt3EwBwNaVxlpvmoKLGSEtzAfpsWJGTDVM4ONbFtLs60xT6DAjpIX5ID1Wy4jphgn6qm32YFNZFcprXZAEYKhLQyVRgKyoWJhvx/3LzVWp0dj1zYgIFcoQtT4zYl39+pCzORiI+bA2sx9nAj1+m7oY8Kl2urGjog67Pv4SLXIMBMkGQVUwOzcFCxypWDV/kmkmcVBoVDvdKN1zFE+9+iGQnANBskESgJnZScwI+fuQt6vrcLS1C4Jkgyr3YE5eKory7cwH+TNS9t4XaBPjIUg2iFAwK8fYxxlLFQM+zc3NyM7OhiwrOHLkG+Tn54e7SWQwjz76KO644w5MnzETXx88EO7mkAHNmDEDhw4dxqOPPoIf/vCH4W4OGcyRI0cwbdo0SFIUTp48gbS0tHA3SVPETiDUkp6ejjvuuAM33nQjCwEa0vr16zFnzhzcf//94W4KGdTWrVsxe84c3HrrreFuChnQ1KlTcdNNN+FHd/zI8IXASETEmQHf6ZvyGhcON7XDK6uwSQIKMhJ4io8AMCOkjfkgPWbNiCWGCUYy+afIYceWFcaa2EGhx4yQFuaD9Jg9IxFfDOyqdFrmkg8aHWaEtDAfpCcSMhLo8duU9xnYVenExtJK6O+ab8mKChkqNpZWAoBhdhSFBjNCWpgP0mO1jJhuAmFNswf37qwa0Q7qS0XvTSRqmz3BbBYZCDNCWpgP0mPFjJiuGNhc1nvKZixkVcWmsqogtYiMhhkhLcwH6bFiRkw1TLDP6UZ5ravfY8d/vwGZK36G6Kyp/sda3n0KZw5/Cgi9tU7yRSsRP2ex/3lZUVFe60K1023I2Z80egMzMpp8AMxIpGIfQnqs2oeYqhjYWVGHKFFAj85EjuSFy5G6eB0AoKetGfWP3YVYx/mQ4r7dIZIoYEdFnSl2EgUukIwEkg+AGYlE7ENIj1X7EFMNE5TXuHR/iQFAjE3wf612d579ov/rZEXFntqWoLaPwi+QjASSD4AZiUTsQ0iPVfsQU50ZONzUHvC2pz97AW17X4bc1oy0a/4BUnzKoG0ONbYFsXVkBIFmJJB8AMxIpGEfQnqs2oeYphhQFBXeoZaLGkbShdch6cLr0H3yCJpfegCx+fMgTeh/jaVXVqEoKkRxtKtWk5GMJCOB5ANgRiIJ+xDSY+U+xDTDBKIowCaN/IcZnTUVUkIaOo/uG/ScTRIMv4MocKPJiFY+AGYkkrAPIT1W7kNMUwwAQEFGgv5GALqbj/m/9rY0oPvkEUSnTx603fTMxKC1jYwhkIwEmg+AGYk07ENIj1X7ENMMEwBAUb4dXze2D7ot5MnSn0OQJP/3NvtEyJ4WQJQgiBLsS++ELX1Sv9dIooAFjtRxaTeNn6EyMpp8AMxIJGIfQnqs2oeYam2Caqcbyx7+IGjv99Ldi0xxyQcFjhkhLcwH6Ym0jAR6/DbVMMG5eckoctghjXH8RRIFFDns/CWOQMwIaWE+SI9VM2KqYgAAtqwohCSMcScJArasKAxSi8homBHSwnyQHitmxHTFgCM9HltXFmK0u0kAsHWlsdabpuBiRkgL80F6rJgRU00g9PEtC2n2daYpdJgR0sJ8kB6rZcRUEwgHqm32YFNZFcprXRAFYKh9JYkCZEXFwnw77l9urkqNxq5vRqAq/oVF+mJGrKtvPiQRkJXB2zAf1tbvOAMVyhDnC4yckUCP36YuBnyqnW4891kdnnnzE3jj0iFINkDpwezcVBTl27Fq/iTTTOKg0Kh2uvHY3/Zhxzt7YUufDEGyQYSCWTkpWOBIZUYsrtrpxo6KOrz4yVc41WODINmgyl4UZCRg0cxs5oNQ7XSj9LNj2PbqR1CTss4eZ2TMyUs1dB9iqWLA54033sBVV10FQMDTT2/D2rVrw90kMpi1a9fimWeeQWzsBDQ01CMlJSXcTSIDaW1tRU5ODjo7u7BmzWps37493E0ig9m+fTtuvvlmAALeeON1XHnlleFukiZLFgOqqiIrKwsdHR1wu92Q+twkgggAvvrqK8yZMwc33XQTSkpKwt0cMqDi4mKUlpZi//79mD17dribQwYjyzKSk5MRHx+PEydOQBjjVQehZsliAACOHz8OT0cHZs6YEe6mkEF99NFHmD//QsTERIe7KWRAXq8Xn5aXY9Ell4S7KWRQhw4dQkxsLCZPGnzXQaOxVDHgG+8rr3HhcFM7vLIKmySgICOBcwYIADNC2pgP0mPWjFiiGOg/E1gY8tIP3+NFDju2rDDWLE8KPWaEtDAfpMfsGYn4YmBXpdMy13/S6DAjpIX5ID2RkJFAj9+mvOnQrkonNpZWQn/XfEtWVMhQsbG0EgAMs6MoNJgR0sJ8kB6rZcR0tyOuafbg3p1VI9pBfanovaNUbbMnmM0iA2FGSAvzQXqsmBHTFQOby3pP2YyFrKrYVFYVpBaR0TAjpIX5ID1WzIiphgn2Od29t5Ud4PjvNyBzxc8g2GLgeuP/Qfa0AqqC5EuKET/7skHby4qK8loXqp1uQ87+pNFjRkjLcPkARpYR5iNyWbUPMVUxsLOiDlGigJ5hJnKcevlBxBdegcS5V0HucKPhzxsRM3EOohLTB20riQJ2VNSZYidR4JgR0qKXDyDwjDAfkcmqfYiphgnKa1yav8TdjTWYMPVCAIAUl4zozHx0fPX+kNvKioo9tS0haSeFDzNCWvTyAQSeEeYjMlm1DzFVMXC4qV3z+ejsAni+fBsA4G09gS7nAfS4G4fd/lBjW1DbR+HHjJAWvXwAI8sI8xF5rNqHmGaYQFFUeGXtij79+/+Elrf+iPon7kFUUiZip8wFxOHrHa+sQlFUiKKx7y1NgWFGSEsg+QBGlhHmI7JYuQ8xTTEgigJskqC5o6JSspCx/Kf+70+W/hyx+fOG3d4mCYbfQRQ4ZoS0BJIPYGQZYT4ii5X7EFMNExRkJGg+L3taoKoKAODMkQp4T9Uhfs7iYbefnpkY1PZR+DEjpEUvH8DIMsJ8RB6r9iGmOTMAAEX5dnzd2D74tpCqDCHKho7D5Tj98U5AFCEl2JG56hcQbTFDvpckCljgSB2HVtN4YkZIy7D5AEacEeYjMlm1DzFVMbBq/iQ8+fHRfo/1tLugdHVASspA4tyrkDj3qoDeS1ZUrJpv/OUnaWSYEdIyVD6A0WWE+YhMVu1DTFUMnJuXjCKHHRXHWiArKk6X/wVtla8hdcltEG2xAb+PJAqYPznVFNd+0sgwI6RlYD4AjCojzEfksmofYrpVC2ubPVj64HvolpVRv0e0JOKNjZcZaplJCh5mhLQwH6QnkjIS6PHbVBMIAcCRHo+tKwsx2rmZAoCtK4213jQFFzNCWpgP0mPFjJhqmMDHtyyk2deZptBhRkgL80F6rJYR0w0T9FXb7MGmsiqU17ogCcBQl4ZKogBZUbEw3477l5urUqOx65sRESqUIWp9ZsS6+vUhZ3MwEPNhbWY/zgR6/DZ1MeBT7XRjR0UdXvj4S7jkGAiSDYKqYHZuChY4UrFq/iTTTOKg0Kh2ulG65yieevUjIDkbgmSDJAAzs5OYEfL3IW9X1+FoaxcEyQZV7sGcvFQU5duZD/JnpOy9L9AmxkOQbBChYFaOsY8zlioGfE6dOoWsrCzIsoKamiNwOBzhbhIZzGOPPYYf/ehHmDFzFg4e+CrczSEDmjlzJr7++hAee+xR3H777eFuDhlMTU0Npk6dCkmKwsmTJ5CWlhbuJmkK9PhtyjkDw0lLS8Ndd92FpuZmFgI0pFtvvRUPPfQQ/uu/fx3uppBBbd26FT/9j59h3bp14W4KGVB+fj6Ki4uRlp5u+EJgJCLizIDv9E15jQuHm9rhlVXYJAEFGQk8xUcAmBHSxnyQHrNmxBLDBCOZ/FPksGPLCmNN7KDQY0ZIC/NBesyekYgvBnZVOi1zyQeNDjNCWpgP0hMJGYnoOQO7Kp3YWFoJ/V3zLVlRIUPFxtJKADDMjqLQYEZIC/NBeqyWEdPdgbCm2YN7d1aNaAf1paL3JhK1zZ5gNosMhBkhLcwH6bFiRkxXDGwu6z1lMxayqmJTWVWQWkRGw4yQFuaD9FgxI6YaJtjndKO81tXvseO/34DMFT9DdNZU/2Mt7z6FM4c/BYTeWif5opWIn7PY/7ysqCivdaHa6Tbk7E8avYEZGU0+AGYkUrEPIT1W7UNMVQzsrKhDlCigR2ciR/LC5Uhd3HuNcE9bM+ofuwuxjvMhxX27QyRRwI6KOlPsJApcIBkJJB8AMxKJ2IeQHqv2IaYaJiivcen+EgOAGJvg/1rt7jz7Rf/XyYqKPbUtQW0fhV8gGQkkHwAzEonYh5Aeq/YhpjozcLipPeBtT3/2Atr2vgy5rRlp1/wDpPiUQdscamwLYuvICALNSCD5AJiRSMM+hPRYtQ8xTTGgKCq8Qy0XNYykC69D0oXXofvkETS/9ABi8+dBmtD/GkuvrEJRVIjiaFetJiMZSUYCyQfAjEQS9iGkx8p9iGmGCURRgE0a+Q8zOmsqpIQ0dB7dN+g5myQYfgdR4EaTEa18AMxIJGEfQnqs3IeYphgAgIKMBP2NAHQ3H/N/7W1pQPfJI4hOnzxou+mZiUFrGxlDIBkJNB8AMxJp2IeQHqv2IaYZJgCAonw7vm5sH3RbyJOlP4cgSf7vbfaJkD0tgChBECXYl94JW/qkfq+RRAELHKnj0m4aP0NlZDT5AJiRSMQ+hPRYtQ8x1doE1U43lj38QdDe76W7F5nikg8KHDNCWpgP0hNpGQn0+G2qYYJz85JR5LBDGuP4iyQKKHLY+UscgZgR0sJ8kB6rZsRUxQAAbFlRCEkY404SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjpppA6ONbFtLs60xT6DAjpIX5ID1Wy4ipJhAOVNvswaayKpTXuiAKwFD7ShIFyIqKhfl23L/cXJUajV3fjAiqAlUYfDKMGbGuvvmQREBWBm/DfFhbv+MMVChDnC8wckYCPX6buhjwqXa68dxndXjmzU/hjUuDINkApQezc1NRlG/HqvmTTDOJg0Kj2unGY3+rxo53KmBLnwxBskGEglk5KVjgSGVGLK7a6caOijq8+MlXONVjgyDZoMpeFGQkYNHMbOaDUO10o/SzY9j26kdQk7LOHmdkzMlLNXQfYqliwOfNN9/E0qVLAQjYvv1prFmzJtxNIoO5+eabsX37dsTGTsCJEw1ITjbeLy+Fj9vtRnZ2Njo7u7B27Ro8/fTT4W4SGcwzzzyDtWvXAhDw5ptv4Iorrgh3kzRZshhQVRU5OTlob2+H2+2G1OcmEUQAcODAAcyePRurV6/GM888E+7mkAGtWbMGzz77LL766ivMmjUr3M0hg5FlGcnJyUhISEBDQwOEMV51EGqWLAYAwOl0ouPMGUwvKAh3U8igPv30U5x//jzExESHuylkQF6vF59VVOA7F10U7qaQQX3zzTeIjonBpIkTw90UXZYqBnzjfeU1LhxuaodXVmGTBBRkJHDOAAFgRkgb80F6zJoRSxQD/WcCC0Ne+uF7vMhhx5YVxprlSaHHjJAW5oP0mD0jEV8M7Kp0Wub6TxodZoS0MB+kJxIyEujx25Q3HdpV6cTG0kro75pvyYoKGSo2llYCgGF2FIUGM0JamA/SY7WMmO52xDXNHty7s2pEO6gvFb13lKpt9gSzWWQgzAhpYT5IjxUzYrpiYHNZ7ymbsZBVFZvKqoLUIjIaZoS0MB+kx4oZMdUwwT6nG+W1LgBA0wtbEZWcidTFt/qfb9zxS8RMLkTrO3+GLWMKcHZnpiy+FXEFC/zbyYqK8loXqp1uQ87+pNHzZWQs+QCYkUjFPoT0WDUjpjozsLOiDlFn15i2L70Lni/fQVfD1wCAti/egNLVgbiZF0OInoDcDb9D7m0PI2XxOjS/sAWqIvd7L0kUsKOibtw/A4WWLyNjzQfAjEQi9iGkx6oZMVUxUF7jQs/ZGZ1SbALSrr4bp15+EF6XE+73n0basn+GMGARidgpc6F2n4HS2d7vcVlRsae2ZdzaTuPDl5Gx5gNgRiIR+xDSY9WMmKoYONzU/wc9Yep8xEycg4Yn/xnJl6yGLSV70Gs6Dn6I2CmFkOIGn6Y51NgWsrZSePTNyFjzATAjkYZ9COmxakZMM2dAUVR45cETOpIWroBn/7tInHeN/zG1+wzqn7gHSmc7lI7TyFr96yHf0yurUBQVomjse0tTYIbKyFjyATAjkYR9COmxckZMc2ZAFAXYpME/TEEQgQFr1PvGcvLuegJJF61E064tUHu6B73WJgmG30EUuKEyMpZ8AMxIJGEfQnqsnBHTFAMAUJCRMKLtBUFA8iXFkOKS0Lb3lUHPT89MDFbTyCBGkhG9fADMSKRhH0J6rJoRUxUDRfl2SCOssARBQOqS2+D+dCcUb6f/cUkUsMCRGuwmUpiNNCPD5QNgRiIR+xDSY9WMmGptgmqnG8se/iBo7/fS3YtMcf0nBY4ZIS3MB+mJtIwEevw21ZmBc/OSUeQYedU2kCQKKHLY+UscgZgR0sJ8kB6rZsRUxQAAbFlRCEkY404SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjprnPQF++ZSHNvs40hQ4zQlqYD9JjtYyYagLhQLXNHmwqq0J5rQuSAAxxrwhIogBZUbEw3477l5urUqOx65sRESqUIWp9ZsS6+vUhZ3MwEPNhbWY/zgR6/DZ1MeBT7XRjR0UdXvh4P1xyNATJBkFVMDs3BQscqVg1f5JpJnFQaFQ73SjdcxRPvfoRkJwNQbJBEoCZ2UnMCPn7kLer63C0tQuCZIMq92BOXiqK8u3MB/kz8vz7X+C0EA9BskGEglk5xj7OWKoY8Dl16hSysrIgywpqa2swZcqUcDeJDObxxx/HD3/4Q8ycNRsHvtof7uaQAc2aNQsHD36Nxx9/DLfddlu4m0MGU1tbi/z8fEhSFBobT8Jut4e7SZoCPX6bcs7AcNLS0vDjH/8YzadOsRCgIa1btw4PPfQQ/vvX/xPuppBB/eY3v8G///Q/sG7dunA3hQzI4XBgzZo1SEtPN3whMBIRcWbAd/qmvMaFw03t8MoqbJKAgowEnuIjAMwIaWM+SI9ZM2KJYYKRTP4pctixZYWxJnZQ6DEjpIX5ID1mz0jEFwO7Kp2WueSDRocZIS3MB+mJhIxE9JyBXZVObCythP6u+ZasqJChYmNpJQAYZkdRaDAjpIX5ID1Wy4jp7kBY0+zBvTurRrSD+lLRexOJ2mZPMJtFBsKMkBbmg/RYMSOmKwY2l/WeshkLWVWxqawqSC0io2FGSAvzQXqsmBFTDRPsc7pRXusCABz//QZkrvgZTu/Zhc7azyHG9c7inOCYh9QlGwAAircTp155CN0NhwBBQMridYiftQiyoqK81oVqp9uQsz9p9JgR0sJ8kB6rZsRUxcDOijpEiQJ6BkzkSFq4AkkLrh+0/elP/wJBsiHvzsfgbT2BE0/9C2KnFEKakARJFLCjos4UO4kCx4yQFuaD9Fg1I6YaJiivcQ3aQVo6DryPxHnXAABsKdmInXweOr7+GEDvRI89tS0haSeFDzNCWpgP0mPVjJjqzMDhpvYhHz/92Qtor3oTUUkZSLnsFkRnTQUA9JxugpSc6d8uKjkTsrvJ//2hxrbQNpjGHTNCWpgP0mPVjJimGFAUFd4hlotKWXwLpAQ7BEFEx8GP0PjcL5B7x6MQoyfovqdXVqEoKkRxtKtWk5EwI6SF+SA9Vs6IaYYJRFGATRr8w4xKTIcg9H6MuJkXQ4iJg9fl7H0uKQOyu9G/bY+7EVJyhv97myQYfgdR4JgR0sJ8kB4rZ8Q0xQAAFGQkDHqs53Sz/+su5wEoZ9pgS8kBAMTNvARtn78KAPC2nkDnsX2Im36Rf/vpmYkhbjGNN2aEtDAfpMeqGTHNMAEAFOXb8XVje+9tIVUZQpQNp17+X8gdrYAgQoiKRsbf/RvE2N77QictXIFTr/wWzj/cDggi7FfeCenspSGSKGCBIzWMn4ZCgRkhLcwH6bFqRkxVDKyaPwlPfnwUPe0uKF0dkJIykLX618NuL0bHIuPvNg/5nKyoWDV/UqiaSmHCjJAW5oP0WDUjpioGzs1LRsrh17H/reeRuuQ2iLbYUb2PJAqYPznVFNd+0sgwI6SF+SA9Vs2I6VYtrG32YOmD76FbVkb9HtGSiDc2XmaoZSYpeJgR0sJ8kJ5Iykigx29TTSAEAEd6PLauLMRo52YKALauNNZ60xRczAhpYT5IjxUzYqphAh/fspBmX2eaQocZIS3MB+mxWkZMN0zQV22zB5vKqlBe64IoAEPtK0kUICsqFubbcf9yc1VqNHZ9MyKoClRh8MkwZsS6+uZDEoGhzgozH9bW7zgDFcoQ5wuMnJFAj9+mLgZ8qp1uPPdZHZ5581N449IgSDZA6cHs3FQU5duxav4k00zioNCodrrx2FvV2PH2XtjSJ0GQbBChYFZOChY4UpkRi6t2urGjog4vfvoVTnltECQbVNmLgowELJqZzXwQqp1ulH52DNte/QhqUtbZ44yMOXmphu5DLFUM+OzevRtXXnklAAHPPLMdq1evDneTyGBuueUWPP3004iNnYATJxqQnGy8X14KH7fbjezsbHR2duHmm9di27Zt4W4SGcyzzz6LNWvWABCwe/ebuPzyy8PdJE2WLAZUVUVOTg48Hg9aW1shSVK4m0QGc/DgQcyaNQtr1qzB9u3bw90cMqC1a9fimWeewYEDBzBz5sxwN4cMRpZlpKSkID4+Hg0NDRAEY99q2JLFAADU19fjTGcnpk2dGu6mkEHt2bMHc+eej+hoW7ibQgbk9Xqx9/PPsbCoKNxNIYOqqamBLToaE/OMP0nQUsWAb7yvvMaFw03t8MoqbJKAgowEzhkgAMwIaWM+SI9ZM2KJYqD/TGBhyEs/fI8XOezYssJYszwp9JgR0sJ8kB6zZyTii4FdlU7LXP9Jo8OMkBbmg/REQkYCPX6b8qZDuyqd2FhaCf1d8y1ZUSFDxcbSSgAwzI6i0GBGSAvzQXqslhHT3Y64ptmDe3dWjWgH9aWi945Stc2eYDaLDIQZIS3MB+mxYkZMVwxsLus9ZTMWsqpiU1lVkFpERsOMkBbmg/RYMSOmGibY53SjvNYFADj++w0Qos7eKczbBVv6ZCRdtBKxE2ejvWo3XH97FFHJWcDZHZpy6c2Im3ERgN5TOeW1LlQ73Yac/Umjx4yQFuaD9Fg1I6YqBnZW1CFKFNBzdiJHxvWbEZ3Vez+BjoMfoXHHL5F1068AALGTC5G54mcAgC7nATTu/JV/JwG9Ez12VNSZYidR4JgR0sJ8kB6rZsRUwwTlNS7/DhoobubFSJx3DU5/+vyg55QuD8TYhH6PyYqKPbUtIWknhQ8zQlqYD9Jj1YyY6szA4aZ2zedjcmbgzKFPMWHaAnQeq0L9E/dA9XZBbj+F9Os3D9r+UGNbqJpKYcKMkBbmg/RYNSOmKQYURYVXDnxCR9/TN91NtThZ8jNEr/8tohLT/Nt4ZRWKokIUjX1vaQoMM0JamA/SY+WMmGaYQBQF2CTtH2ZXw9ewZUwZ9Hh0hgNRSRnocn7V73GbJBh+B1HgmBHSwnyQHitnxDTFAAAUZCQM+1zH15+g7fNXkVR0w6Dnek43o8dVD1tqbr/Hp2cmBr2NFF7MCGlhPkiPVTNimmECACjKt+Prxnb/bSGbdt3f55KPSchc9UvE5M6Et7nOP5YDAFBkpCy+1T8jFOid5bnAkRqOj0EhxIyQFuaD9Fg1I6Zam6Da6cayhz8I2vu9dPciU1zyQYFjRkgL80F6Ii0jgR6/TTVMcG5eMoocdkhjHH+RRAFFDjt/iSMQM0JamA/SY9WMmKoYAIAtKwohCWPcSYKALSsKg9QiMhpmhLQwH6THihkxXTHgSI/H1pWFGO1uEgBsXWms9aYpuJgR0sJ8kB4rZsRUEwh9fMtCmn2daQodZoS0MB+kx2oZMdUEwoFqmz3YVFaF8loXJBGQlcHbSKIAWVGxMN+O+5ebq1KjseubEREqlCFqfWbEuvr3IcKQHT7zYW39MiIAQ92TyMgZCfT4bepiwKfa6caOijq88PF+uORoCJINgqpgdm4KFjhSsWr+JNNM4qDQqHa6UbrnGJ569UMgORuCZIMkADOzk5gR8vchb1fX4WhrV++lZHIP5uSloijfznyQPyPPv/8FTgvxECQbRCiYlWPs44yligEfl8uFzMxMKIqKmpojmDJl8F2iyNr++Mc/4vbbb8fMWbNx4Kv94W4OGdDs2bNx4MBB/PGPj2PDhg3hbg4ZzNGjR+FwOCBJUWhsPAm73R7uJmkK9PhtyjkDw7Hb7bjnnnvQ1NzMQoCGtG7dOjz00EP471//T7ibQgb1m9/8Bv/+0//ALbfcEu6mkAFNmTIFa9euRXpGhuELgZGIiDMDvtM35TUuHG5qh1dWYZMEFGQk8BQfAWBGSBvzQXrMmhFLDBOMZPJPkcOOLSuMNbGDQo8ZIS3MB+kxe0YivhjYVem0zCUfNDrMCGlhPkhPJGQkoucM7Kp0YmNpJQJfdRqQFRUyVGwsrQQAw+woCg1mhLQwH6THahkx3R0Ia5o9uHdn1Yh2UF8qem8iUdvsCWazyECYEdLCfJAeK2bEdMXA5rLeUzZjIasqNpVVBalFZDTMCGlhPkiPFTNiqmJgn9ON8loXjj7893A+egfqn7gHzkfvgPvjHQCAntaTOHrfMjTu/K9+r2t9fzuO3rcMHV9/DKD3VE55rQvVTve4fwYKLV9GZEXF8d9vQPfJI/2eb37pf3H0vmXoPvGN/zGlqwPHHlj57brkYEYi1cB8jLYfYT4il1X7EFMVAzsr6hB1dlnJjOs3I3fD75C1+tdwf7IDXfUHAQBCTDy8LU7InhYAgKoq8Ox/F7YMR7/3kkQBOyrqxrX9FHp9MzKc6OwCtFe96f/ec+B92NImDdqOGYk8A/Mxln6E+YhMVu1DTFUMlNe40DNgRmdUYjps9onoOd3kfyzhnO+hvfotAEBnbSWis6ZBjE3o9zpZUbGntiX0jaZxNVRGBoqbcTE6vtkDtccLAPBU7UZC4ZWDtmNGIs9w+RhNP8J8RCar9iGmKgYON7UPesx7qg7KmTbETj7P/1j8uZfDs+9vAID2qjeRUHjFkO93qLEtNA2lsBkqIwMJthhMcJyPjkMfw3uqDoAKW9rEIbdlRiLLcPkYbT/CfEQeq/Yhprm0UFFUePssF9W0635AENBzyonUy2+HFJeMnu5OAEBUUjqkxHR0HC5H94nDiL3uXv94YF9eWYWiqBB1TgmROQzMiJaEwivR+v52RGfmI/68oYtFgBmJJEPlY6z9CPMRWazch5imGBBFATZJ8O+ojOs3IzprKs7UVqJp568QO2UuxOgJ/u0TCq/AqZcfROK8ayAIQ58AsUmC4XcQBW5gRrTE5M2C3H4KnlN1yL399+g+cXjI7ZiRyDFUPsbajzAfkcXKfYiphgkKMhIGPTbBcT4S5l2D1ve29Xs8bvp3kLRwORLmXTPs+03PTAx6Gym8hsrIcFKv+BFSl2yAGBM37DbMSGQZLh+j7UeYj8hj1T7ENGcGAKAo346vGweP5yRfshr1f/gh5M5vx2aEKBuSL1o57HtJooAFjtSQtJPCx5cR361DT5b+HIIk+Z+32ScCWVMB9B4AtDAjkWdgPvoaaT/CfEQmq/YhplqboNrpxrKHPwja+7109yJDrjJFo8eMkBbmg/REWkYCPX6bapjg3LxkFDnskMY4/iKJAoocdv4SRyBmhLQwH6THqhkxVTEAAFtWFEISxriTBAFbVhQGqUVkNMwIaWE+SI8VM2K6YsCRHo+tKwsx2t0kANi60ljrTVNwMSOkhfkgPVbMiKkmEPr4loU0+zrTFDrMCGlhPkiP1TJiqgmEA9U2e7CprArltS6IAjDUvpJEAbKiYmG+HfcvN1elRmPXNyOCqkAd4lpxZsS6+uZDEgFZGbwN82Ft/Y4zUKEMcb7AyBkJ9Pht6mLAp9rpxnOf1eGZ3Z/COyENgmQDlB7Mzk1FUb4dq+ZPMs0kDgqNaqcbj71VjR1v74UtfRIEyQYRCmblpGCBI5UZsbhqpxs7Kurw4qdf4ZTXBkGyQZW9KMhIwKKZ2cwHodrpRulnx/D0ax9BScw6e5yRMScv1dB9iKWKAZ+//e1vuOKKKwAIePbZZ1BcXBzuJpHBrFu3Dtu2bUNs7AScPHnC0Hmm8Xf69GlkZWWhs7MLt9xyM5566qlwN4kMpqSkBKtXrwYg4G9/240lS5aEu0maLFkMqKqKnJwceDwetLa2QupzowgiADh48CBmzZqFtWvX4umnnw53c8iAbr75Zmzfvh0HDhzAzJkzw90cMhhZlpGSkoKEhATU19dDGONVB6FmyWIAAE6cOIEznZ3IdzjC3RQyqIqKCpx3XiGio23hbgoZUE9PDz6vrMSCCy8Md1PIoGpraxEdE4PcnJxwN0VXoMdvU15NMJBvvK+8xoXDTe3wyips0n4UZCRwzgABGCIjO9+ATRKYEQIwTB/y11eYD/Ib+jgTOX2Iqc8M9J8JLAx56Yfv8SKHHVtWGGuWJ4UeM0JamA/SY/aMRPwwwa5Kp2Wu/6TRYUZIC/NBeiIhIxE9TLCr0omNpZXQ3zXfkhUVMlRsLK0EAMPsKAoNZoS0MB+kx2oZMd3tiGuaPbh3Z9WIdlBfKnrvKFXb7Alms8hAmBHSwnyQHitmxHTFwOay3lM2YyGrKjaVVQWpRWQ0zAhpYT5IjxUzYqphgn1ON954+mHIp5uRdu0/AAA6677Eye2bkbX6fxA7pXeFqFOvPQwpLhnJi9bA/VEpPPvfgyCKgCghJmcGUr/39yivVVHtdJt69icNxoyQFuaD9Fg1I6YqBnZW1CHeMReNLz3of6zzWBWic2ei89g+/07qPLYPaVf9BKde+S2UM23IXvcbSLEJUFUVHQc/hNzZDltcInZU1JliJ1HgmBHSwnyQHqtmxFTDBOU1LkTlzIDc7kLP6WYAQNexfUi5pBidx/YBAHraXZBPN0GMS0LHgQ+R9v2NkGITAACCICB+1iLYUrIhKyr21LaE7bNQaDAjpIX5ID1WzYipioHDTe0QJBti8mah81gV1B4velpPYsK0BZDbTkHt6UbX0SpE586Ct7kOUak5kOKGr8gONbaNY+tpPDAjpIX5ID1WzYhphgkURYVX7p3QETulEJ3H9iEqKRPRuTMAADF5M9HlPHD2NM55Ab2nV1ahKCpE0dj3lqbAMCOkhfkgPVbOiGnODIiiAJvU+8OMmVyIrqNV6DxWhdjJvTskZtK56PQ9NmUuorOnoaelAfKZ08O+p00SDL+DKHDMCGlhPkiPlTNimmIAAAoyesdkYnKmQ+5ww/PlO/6dFDv5PHi+eg9yewticmbAlpqLuJkX49QrD0HpbAfQu6qh58CH8LaeAABMz0wMzwehkGFGSAvzQXqsmhHTDBMAQFG+HV83tkNGFGImzoG3sQa2tEkAAJs9D2r3GcRMnANB6v1Yadf+I9wflaLhqX+BIEpQVQWxk87FBMdcSKKABY7UcH4cCgFmhLQwH6THqhkx1doE1U43lj38QdDe76W7F5nikg8KHDNCWpgP0hNpGQn0+G2qYYJz85JR5LBDGuP4iyQKKHLY+UscgZgR0sJ8kB6rZsRUxQAAbFlRCEkY404SBGxZURikFpHRMCOkhfkgPVbMiOmKAUd6PLauLMRod5MAYOtKY603TcHFjJAW5oP0WDEjpppA6ONbFtLs60xT6DAjpIX5ID1Wy4ipJhAOVNvswaayKpTXuiCJwpA7y/f4wnw77l9urkqNxo4ZIS3MB+kxe0YCPX6buhjwqXa6saOiDntqW3CosQ1eWYVNEjA9MxELHKlYNX+SaSZxUGgwI6SF+SA9Zs2IpYqBgcxw60cKL2aEtDAfpMcsGYnISwsDZYYdROHFjJAW5oP0RFpGIrIYICIiosCxGCAiIrI4FgNEREQWx2KAiIjI4lgMEBERWRyLASIiIotjMUBERGRxLAaIiIgsjsUAERGRxbEYICIisjgWA0RERBbHYoCIiMjiWAwQERFZHIsBIiIii2MxQEREZHEsBoiIiCyOxQAREZHFsRggIiKyuKhANlJVFQBw+vTpkDaGiIiIgsd33PYdx4cTUDHQ1tYGAJg0adIYm0VERETjra2tDcnJycM+L6h65QIARVFQX1+PxMRECIIQ1AYSERFRaKiqira2NuTm5kIUh58ZEFAxQERERJGLEwiJiIgsjsUAERGRxbEYICIisjgWA0RERBbHYoCIiMjiWAwQERFZHIsBIiIii/v/tgXuR2yzjQ0AAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -329,20 +329,20 @@
     "graph = GraphGrammar()\n",
     "rules = [\"Init\",\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint50','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint50','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",\"Rotation\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint50','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint50','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\", \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    'Terminal_Main_Body3'\n",
     "    \n",
@@ -357,9 +357,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Jupyter environment detected. Enabling Open3D WebVisualizer.\n",
+      "[Open3D INFO] WebRTC GUI backend enabled.\n",
+      "[Open3D INFO] WebRTCWindowSystem: HTTP handshake server disabled.\n"
+     ]
+    }
+   ],
    "source": [
     "from rostok.simulation_chrono.simulation_scenario import SuspensionCarScenario\n",
     "from rostok.criterion.simulation_flags import EventBodyTooLowBuilder, EventContactInInitialPositionBuilder\n",
@@ -369,29 +379,30 @@
     "parameters[\"forward\"] = 1\n",
     "parameters[\"reverse\"]= 1\n",
     "parameters[\"forward_rotate\"] = 0.5\n",
-    "parameters[\"reverse_rotate\"] = 0.3"
+    "parameters[\"reverse_rotate\"] = 0.3\n",
+    "control =  {\"initial_value\": [0.0]*4}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.2\n"
+      "0.28181818181818186\n"
      ]
     }
    ],
    "source": [
     "height = 0\n",
     "for i in np.linspace(0.1,1,100):\n",
-    "    scenario = SuspensionCarScenario(0.0001, 0.01,initial_vertical_pos=i, controller_cls=SimpleKeyBoardController)\n",
+    "    scenario = SuspensionCarScenario(0.0001, 0.01,initial_vertical_pos=i)\n",
     "    scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))\n",
     "    scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())\n",
-    "    result = scenario.run_simulation(graph, parameters, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=False)\n",
+    "    result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = False, delay=False)\n",
     "    if len(list(result.robot_final_ds.get_data(\"COG\").items())[0][1]) > 10:\n",
     "        height = i\n",
     "        break\n",
@@ -401,55 +412,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
-    "height = 0.29"
+    "#height = 0.29"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([0.1       , 0.10909091, 0.11818182, 0.12727273, 0.13636364,\n",
-       "       0.14545455, 0.15454545, 0.16363636, 0.17272727, 0.18181818,\n",
-       "       0.19090909, 0.2       , 0.20909091, 0.21818182, 0.22727273,\n",
-       "       0.23636364, 0.24545455, 0.25454545, 0.26363636, 0.27272727,\n",
-       "       0.28181818, 0.29090909, 0.3       , 0.30909091, 0.31818182,\n",
-       "       0.32727273, 0.33636364, 0.34545455, 0.35454545, 0.36363636,\n",
-       "       0.37272727, 0.38181818, 0.39090909, 0.4       , 0.40909091,\n",
-       "       0.41818182, 0.42727273, 0.43636364, 0.44545455, 0.45454545,\n",
-       "       0.46363636, 0.47272727, 0.48181818, 0.49090909, 0.5       ,\n",
-       "       0.50909091, 0.51818182, 0.52727273, 0.53636364, 0.54545455,\n",
-       "       0.55454545, 0.56363636, 0.57272727, 0.58181818, 0.59090909,\n",
-       "       0.6       , 0.60909091, 0.61818182, 0.62727273, 0.63636364,\n",
-       "       0.64545455, 0.65454545, 0.66363636, 0.67272727, 0.68181818,\n",
-       "       0.69090909, 0.7       , 0.70909091, 0.71818182, 0.72727273,\n",
-       "       0.73636364, 0.74545455, 0.75454545, 0.76363636, 0.77272727,\n",
-       "       0.78181818, 0.79090909, 0.8       , 0.80909091, 0.81818182,\n",
-       "       0.82727273, 0.83636364, 0.84545455, 0.85454545, 0.86363636,\n",
-       "       0.87272727, 0.88181818, 0.89090909, 0.9       , 0.90909091,\n",
-       "       0.91818182, 0.92727273, 0.93636364, 0.94545455, 0.95454545,\n",
-       "       0.96363636, 0.97272727, 0.98181818, 0.99090909, 1.        ])"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "np.linspace(0.1,1,100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -458,51 +430,48 @@
      "text": [
       "0\n",
       "10\n",
-      "20\n",
-      "30\n",
-      "40\n"
+      "20\n"
      ]
     },
     {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
+     "ename": "RuntimeError",
+     "evalue": "SWIG director method error. Error detected when calling 'TorqueFunctor.evaluate'",
      "output_type": "error",
      "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[41], line 33\u001b[0m\n\u001b[0;32m     31\u001b[0m scenario\u001b[38;5;241m.\u001b[39madd_event_builder(event_builder\u001b[38;5;241m=\u001b[39mEventBodyTooLowBuilder(\u001b[38;5;241m0.15\u001b[39m))\n\u001b[0;32m     32\u001b[0m scenario\u001b[38;5;241m.\u001b[39madd_event_builder(event_builder\u001b[38;5;241m=\u001b[39mEventContactInInitialPositionBuilder())\n\u001b[1;32m---> 33\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mscenario\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_simulation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstarting_positions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvis\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdelay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m     34\u001b[0m stiffness[i]\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlist\u001b[39m(result\u001b[38;5;241m.\u001b[39mrobot_final_ds\u001b[38;5;241m.\u001b[39mget_data(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCOG\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mitems())[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m1\u001b[39m][\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m][\u001b[38;5;241m1\u001b[39m]\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation_scenario.py:302\u001b[0m, in \u001b[0;36mSuspensionCarScenario.run_simulation\u001b[1;34m(self, graph, controller_data, starting_positions, vis, delay)\u001b[0m\n\u001b[0;32m    297\u001b[0m robot_data_dict \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m    298\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCOG\u001b[39m\u001b[38;5;124m\"\u001b[39m: (SensorCalls\u001b[38;5;241m.\u001b[39mBODY_TRAJECTORY, SensorObjectClassification\u001b[38;5;241m.\u001b[39mBODY,\n\u001b[0;32m    299\u001b[0m             SensorCalls\u001b[38;5;241m.\u001b[39mBODY_TRAJECTORY),\n\u001b[0;32m    300\u001b[0m }\n\u001b[0;32m    301\u001b[0m simulation\u001b[38;5;241m.\u001b[39madd_robot_data_type_dict(robot_data_dict)\n\u001b[1;32m--> 302\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msimulation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvis\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation.py:320\u001b[0m, in \u001b[0;36mSingleRobotSimulation.simulate\u001b[1;34m(self, number_of_steps, step_length, fps, event_container, visualize)\u001b[0m\n\u001b[0;32m    318\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(number_of_steps):\n\u001b[0;32m    319\u001b[0m     current_time \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system\u001b[38;5;241m.\u001b[39mGetChTime()\n\u001b[1;32m--> 320\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcurrent_time\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    321\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresult\u001b[38;5;241m.\u001b[39mtime_vector\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system\u001b[38;5;241m.\u001b[39mGetChTime())\n\u001b[0;32m    322\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m visualize:\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation.py:266\u001b[0m, in \u001b[0;36mSingleRobotSimulation.simulate_step\u001b[1;34m(self, step_length, current_time, step_n)\u001b[0m\n\u001b[0;32m    264\u001b[0m robot\u001b[38;5;241m.\u001b[39msensor\u001b[38;5;241m.\u001b[39mcontact_reporter\u001b[38;5;241m.\u001b[39mreset_contact_dict()\n\u001b[0;32m    265\u001b[0m robot\u001b[38;5;241m.\u001b[39msensor\u001b[38;5;241m.\u001b[39mupdate_current_contact_info(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system)\n\u001b[1;32m--> 266\u001b[0m \u001b[43mrobot\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata_storage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_storage\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_n\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    268\u001b[0m \u001b[38;5;66;03m#controller gets current states of the robot and environment and updates control functions\u001b[39;00m\n\u001b[0;32m    269\u001b[0m robot\u001b[38;5;241m.\u001b[39mcontroller\u001b[38;5;241m.\u001b[39mupdate_functions(current_time, robot\u001b[38;5;241m.\u001b[39msensor,\n\u001b[0;32m    270\u001b[0m                                   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39menv_creator\u001b[38;5;241m.\u001b[39mdata_storage\u001b[38;5;241m.\u001b[39msensor)\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\virtual_experiment\\sensors.py:257\u001b[0m, in \u001b[0;36mDataStorage.update_storage\u001b[1;34m(self, step_n)\u001b[0m\n\u001b[0;32m    255\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_storage\u001b[39m(\u001b[38;5;28mself\u001b[39m, step_n):\n\u001b[0;32m    256\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m key, sensor_callback \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcallback_dict\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m--> 257\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_data(key, \u001b[43msensor_callback\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msensor\u001b[49m\u001b[43m)\u001b[49m, step_n)\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\virtual_experiment\\sensors.py:114\u001b[0m, in \u001b[0;36mSensor.get_body_trajectory_point\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    108\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, body \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbody_map_ordered\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m    109\u001b[0m     output[idx] \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m    110\u001b[0m         \u001b[38;5;28mround\u001b[39m(body\u001b[38;5;241m.\u001b[39mbody\u001b[38;5;241m.\u001b[39mGetPos()\u001b[38;5;241m.\u001b[39mx, \u001b[38;5;241m4\u001b[39m),\n\u001b[0;32m    111\u001b[0m         \u001b[38;5;28mround\u001b[39m(body\u001b[38;5;241m.\u001b[39mbody\u001b[38;5;241m.\u001b[39mGetPos()\u001b[38;5;241m.\u001b[39my, \u001b[38;5;241m4\u001b[39m),\n\u001b[0;32m    112\u001b[0m         \u001b[38;5;28mround\u001b[39m(body\u001b[38;5;241m.\u001b[39mbody\u001b[38;5;241m.\u001b[39mGetPos()\u001b[38;5;241m.\u001b[39mz, \u001b[38;5;241m4\u001b[39m)\n\u001b[0;32m    113\u001b[0m     ]\n\u001b[1;32m--> 114\u001b[0m     output[idx] \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnan_to_num\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m[\u001b[49m\u001b[43midx\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnan\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m9999\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mtolist()\n\u001b[0;32m    115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output\n",
-      "File \u001b[1;32md:\\Anaconda\\envs\\rostok\\lib\\site-packages\\numpy\\lib\\type_check.py:497\u001b[0m, in \u001b[0;36mnan_to_num\u001b[1;34m(x, copy, nan, posinf, neginf)\u001b[0m\n\u001b[0;32m    403\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_nan_to_num_dispatcher)\n\u001b[0;32m    404\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnan_to_num\u001b[39m(x, copy\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, nan\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.0\u001b[39m, posinf\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, neginf\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m    405\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    406\u001b[0m \u001b[38;5;124;03m    Replace NaN with zero and infinity with large finite numbers (default\u001b[39;00m\n\u001b[0;32m    407\u001b[0m \u001b[38;5;124;03m    behaviour) or with the numbers defined by the user using the `nan`,\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    495\u001b[0m \u001b[38;5;124;03m    array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])\u001b[39;00m\n\u001b[0;32m    496\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 497\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[43m_nx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msubok\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    498\u001b[0m     xtype \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mtype\n\u001b[0;32m    500\u001b[0m     isscalar \u001b[38;5;241m=\u001b[39m (x\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)\n",
-      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_22274/798630575.py\u001b[0m in \u001b[0;36m?\u001b[0;34m()\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m     \u001b[0mscenario\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSuspensionCarScenario\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.0001\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0minitial_vertical_pos\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mheight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m     \u001b[0mscenario\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_event_builder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevent_builder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEventBodyTooLowBuilder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.15\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m     \u001b[0mscenario\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_event_builder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mevent_builder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEventContactInInitialPositionBuilder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 34\u001b[0;31m     \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscenario\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_simulation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontrol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstarting_positions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdelay\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     35\u001b[0m     \u001b[0mstiffness\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrobot_final_ds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"COG\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Python/rostok_project/code/main_rep/rostok/simulation_chrono/simulation_scenario.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, graph, controller_data, starting_positions, vis, delay)\u001b[0m\n\u001b[1;32m    298\u001b[0m             \"COG\": (SensorCalls.BODY_TRAJECTORY, SensorObjectClassification.BODY,\n\u001b[1;32m    299\u001b[0m                     SensorCalls.BODY_TRAJECTORY),\n\u001b[1;32m    300\u001b[0m         }\n\u001b[1;32m    301\u001b[0m         \u001b[0msimulation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_robot_data_type_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrobot_data_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 302\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msimulation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_steps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep_length\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10000\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mevent_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/Python/rostok_project/code/main_rep/rostok/simulation_chrono/simulation.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, number_of_steps, step_length, fps, event_container, visualize)\u001b[0m\n\u001b[1;32m    316\u001b[0m         \u001b[0mstop_flag\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    317\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime_vector\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    318\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber_of_steps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    319\u001b[0m             \u001b[0mcurrent_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchrono_system\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGetChTime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimulate_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_length\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcurrent_time\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    321\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime_vector\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchrono_system\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGetChTime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    322\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mvisualize\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    323\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvis_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvisualization_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_length\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Python/rostok_project/code/main_rep/rostok/simulation_chrono/simulation.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, step_length, current_time, step_n)\u001b[0m\n\u001b[1;32m    255\u001b[0m                 \u001b[0mcurrent_time\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcurrent\u001b[0m \u001b[0mtime\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0msimulation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    256\u001b[0m                 step_n: number of the current step\"\"\"\n\u001b[1;32m    257\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    258\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchrono_system\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUpdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 259\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchrono_system\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDoStepDynamics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_length\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    260\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_n\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    261\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    262\u001b[0m         \u001b[0mrobot\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mRobotChrono\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrobot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Python/anaconda3/envs/rostok/lib/python3.10/site-packages/pychrono/core.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, step_size)\u001b[0m\n\u001b[1;32m  22163\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mDoStepDynamics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m  22164\u001b[0m         \u001b[0;34mr\"\"\"DoStepDynamics(ChSystem self, double step_size) -> int\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 22165\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mChSystem_DoStepDynamics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m: SWIG director method error. Error detected when calling 'TorqueFunctor.evaluate'"
      ]
     }
    ],
    "source": [
-    "stiffness = np.zeros(100)\n",
-    "for i in range(100):\n",
+    "n=20\n",
+    "stiffness = np.zeros(n)\n",
+    "for i in range(n):\n",
     "    if i%10 == 0:    \n",
     "        print(i)\n",
     "    graph = GraphGrammar()\n",
     "    rules = [\"Init\",\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",\"Rotation\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\", \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "        'Terminal_Main_Body3'\n",
     "        \n",
@@ -511,24 +480,22 @@
     "    for rule in rules:\n",
     "        graph.apply_rule(rule_vocab.get_rule(rule))\n",
     "\n",
-    "    scenario = SuspensionCarScenario(0.0001, 0.5,initial_vertical_pos=height, controller_cls=SimpleKeyBoardController)\n",
+    "    scenario = SuspensionCarScenario(0.0001, 1,initial_vertical_pos=height)\n",
     "    scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))\n",
     "    scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())\n",
-    "    result = scenario.run_simulation(graph, parameters, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = False, delay=False)\n",
-    "    stiffness[i]=list(result.robot_final_ds.get_data(\"COG\").items())[0][1][-1][1]\n",
-    "\n",
-    "\n"
+    "    result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = False, delay=False)\n",
+    "    stiffness[i]=list(result.robot_final_ds.get_data(\"COG\").items())[0][1][-1][1]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x27d7ac9b460>]"
+       "<matplotlib.collections.PathCollection at 0x7964ec3b17b0>"
       ]
      },
      "execution_count": 20,
@@ -537,7 +504,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -548,71 +515,77 @@
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
-    "plt.plot(stiffness)\n"
+    "plt.scatter(np.arange(100)[:20],stiffness[:20])\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "99\n"
+      "Cannot use default video driver - fall back to OpenGL\n"
      ]
     },
     {
-     "ename": "RuntimeError",
-     "evalue": "SWIG director method error. Error detected when calling 'TorqueFunctor.evaluate'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[40], line 33\u001b[0m\n\u001b[0;32m     31\u001b[0m scenario\u001b[38;5;241m.\u001b[39madd_event_builder(event_builder\u001b[38;5;241m=\u001b[39mEventBodyTooLowBuilder(\u001b[38;5;241m0.15\u001b[39m))\n\u001b[0;32m     32\u001b[0m \u001b[38;5;66;03m#scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())\u001b[39;00m\n\u001b[1;32m---> 33\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mscenario\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_simulation\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstarting_positions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvis\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdelay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation_scenario.py:302\u001b[0m, in \u001b[0;36mSuspensionCarScenario.run_simulation\u001b[1;34m(self, graph, controller_data, starting_positions, vis, delay)\u001b[0m\n\u001b[0;32m    297\u001b[0m robot_data_dict \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m    298\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCOG\u001b[39m\u001b[38;5;124m\"\u001b[39m: (SensorCalls\u001b[38;5;241m.\u001b[39mBODY_TRAJECTORY, SensorObjectClassification\u001b[38;5;241m.\u001b[39mBODY,\n\u001b[0;32m    299\u001b[0m             SensorCalls\u001b[38;5;241m.\u001b[39mBODY_TRAJECTORY),\n\u001b[0;32m    300\u001b[0m }\n\u001b[0;32m    301\u001b[0m simulation\u001b[38;5;241m.\u001b[39madd_robot_data_type_dict(robot_data_dict)\n\u001b[1;32m--> 302\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msimulation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_steps\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m10000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvis\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation.py:320\u001b[0m, in \u001b[0;36mSingleRobotSimulation.simulate\u001b[1;34m(self, number_of_steps, step_length, fps, event_container, visualize)\u001b[0m\n\u001b[0;32m    318\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(number_of_steps):\n\u001b[0;32m    319\u001b[0m     current_time \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system\u001b[38;5;241m.\u001b[39mGetChTime()\n\u001b[1;32m--> 320\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msimulate_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcurrent_time\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    321\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mresult\u001b[38;5;241m.\u001b[39mtime_vector\u001b[38;5;241m.\u001b[39mappend(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system\u001b[38;5;241m.\u001b[39mGetChTime())\n\u001b[0;32m    322\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m visualize:\n",
-      "File \u001b[1;32md:\\work\\projects\\rostok\\rostok\\simulation_chrono\\simulation.py:259\u001b[0m, in \u001b[0;36mSingleRobotSimulation.simulate_step\u001b[1;34m(self, step_length, current_time, step_n)\u001b[0m\n\u001b[0;32m    251\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Simulate one step and update sensors and data stores\u001b[39;00m\n\u001b[0;32m    252\u001b[0m \u001b[38;5;124;03m\u001b[39;00m\n\u001b[0;32m    253\u001b[0m \u001b[38;5;124;03m    Args:\u001b[39;00m\n\u001b[0;32m    254\u001b[0m \u001b[38;5;124;03m        step_length (float): the time of the step\u001b[39;00m\n\u001b[0;32m    255\u001b[0m \u001b[38;5;124;03m        current_time (float): current time of the simulation\u001b[39;00m\n\u001b[0;32m    256\u001b[0m \u001b[38;5;124;03m        step_n: number of the current step\"\"\"\u001b[39;00m\n\u001b[0;32m    258\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchrono_system\u001b[38;5;241m.\u001b[39mUpdate()\n\u001b[1;32m--> 259\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mchrono_system\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDoStepDynamics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_length\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    260\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_data(step_n)\n\u001b[0;32m    262\u001b[0m robot: RobotChrono \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrobot\n",
-      "File \u001b[1;32md:\\Anaconda\\envs\\rostok\\lib\\site-packages\\pychrono\\core.py:21183\u001b[0m, in \u001b[0;36mChSystem.DoStepDynamics\u001b[1;34m(self, step_size)\u001b[0m\n\u001b[0;32m  21181\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mDoStepDynamics\u001b[39m(\u001b[38;5;28mself\u001b[39m, step_size):\n\u001b[0;32m  21182\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"DoStepDynamics(ChSystem self, double step_size) -> int\"\"\"\u001b[39;00m\n\u001b[1;32m> 21183\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_core\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mChSystem_DoStepDynamics\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstep_size\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[1;31mRuntimeError\u001b[0m: SWIG director method error. Error detected when calling 'TorqueFunctor.evaluate'"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Irrlicht Engine version 1.8.5\n",
+      "Linux 6.5.0-45-generic #45~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Mon Jul 15 16:40:02 UTC 2 x86_64\n",
+      "Using plain X visual\n",
+      "This driver is not available in Linux. Try OpenGL or Software renderer.\n",
+      "Irrlicht Engine version 1.8.5\n",
+      "Linux 6.5.0-45-generic #45~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Mon Jul 15 16:40:02 UTC 2 x86_64\n",
+      "Using renderer: OpenGL 4.6\n",
+      "Mesa Intel(R) UHD Graphics 630 (CFL GT2): Intel\n",
+      "OpenGL driver version is 1.2 or better.\n",
+      "GLSL version: 4.6\n",
+      "Loaded texture: /home/be2r-lab-210134/Python/anaconda3/envs/rostok/share/chrono/data/fonts/arial80.bmp\n",
+      "Loaded texture: /home/be2r-lab-210134/Python/anaconda3/envs/rostok/share/chrono/data/skybox/sky_lf.jpg\n",
+      "Loaded texture: /home/be2r-lab-210134/Python/anaconda3/envs/rostok/share/chrono/data/skybox/sky_up.jpg\n",
+      "Loaded texture: /home/be2r-lab-210134/Python/anaconda3/envs/rostok/share/chrono/data/skybox/sky_dn.jpg\n"
      ]
     }
    ],
    "source": [
-    "i = np.argmax(stiffness)\n",
-    "print(i)\n",
-    "i = 30\n",
+    "# i = np.argmax(stiffness)\n",
+    "# print(i)\n",
+    "i = 8\n",
+    "\n",
     "graph = GraphGrammar()\n",
     "rules = [\"Init\",\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Positive_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Positive_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",\"Rotation\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"R_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}', f'Terminal_Joint{i}',\"Add_Dummy\",\"Rotation\",\"R_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\", 'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    \"Add_Leg_Base\",\"Negative_Translation_X4\",\"Negative_Translation_Z3\",\"Rotation\",\n",
-    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
-    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint0','Rotation_Y',\n",
+    "    'Rotation_Y', \"Extension\",\"Extension\",f'Terminal_Joint{i}',f'Terminal_Joint{i}', \"Add_Dummy\", \"Rotation\",\"L_Wheel\", \"Cyl_Wheel\",\n",
+    "    \"Terminal_Link3\",\"Terminal_Link3\",'Terminal_Joint10','Rotation_Y',\n",
     "\n",
     "    'Terminal_Main_Body3'\n",
-    "    \n",
+    "\n",
     "]\n",
     "\n",
     "for rule in rules:\n",
     "    graph.apply_rule(rule_vocab.get_rule(rule))\n",
     "\n",
     "\n",
-    "scenario = SuspensionCarScenario(0.0001, 10,initial_vertical_pos=height, controller_cls=SimpleKeyBoardController)\n",
+    "scenario = SuspensionCarScenario(0.0001, 1,initial_vertical_pos=height)\n",
     "scenario.add_event_builder(event_builder=EventBodyTooLowBuilder(0.15))\n",
     "#scenario.add_event_builder(event_builder=EventContactInInitialPositionBuilder())\n",
-    "result = scenario.run_simulation(graph, parameters, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=True)\n"
+    "result = scenario.run_simulation(graph, control, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=True)\n"
    ]
   },
   {
@@ -637,7 +610,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -691,9 +664,7 @@
     "parameters[\"forward_rotate\"] = 0.5\n",
     "parameters[\"reverse_rotate\"] = 0.3\n",
     "\n",
-    " \n",
-    "\n",
-    "scenario.run_simulation(graph, parameters, starting_positions=[[-45,60,0], [-45,60,0], [-45,60,0], [-45,60,0]], vis = True, delay=True, is_follow_camera = True)"
+    "scenario.run_simulation(graph, parameters, starting_positions=[[-30,30,0,0], [30,-30,0,0], [-30,30,0,0], [30,-30,0,0]], vis = True, delay=True, is_follow_camera = True)"
    ]
   }
  ],