From 68401a1226d0767123f8cd65e6f776e12e5eb207 Mon Sep 17 00:00:00 2001 From: Anton Tetov Date: Mon, 25 Nov 2024 15:47:47 +0100 Subject: [PATCH] changes to robotscript generation --- grasshopper/planes_to_3dp_rapid_program.ghx | 729 ++++++++++++++++---- 1 file changed, 589 insertions(+), 140 deletions(-) diff --git a/grasshopper/planes_to_3dp_rapid_program.ghx b/grasshopper/planes_to_3dp_rapid_program.ghx index c5b571c..12592d7 100644 --- a/grasshopper/planes_to_3dp_rapid_program.ghx +++ b/grasshopper/planes_to_3dp_rapid_program.ghx @@ -16,7 +16,7 @@ 1 0 - 8 + 7 @@ -34,10 +34,9 @@ - + 637057953500735547 - false planes_to_3dp_rapid_program.ghx @@ -49,10 +48,10 @@ - -1937 - -176 + 32 + 329 - 0.8038307 + 0.196874514 @@ -69,37 +68,13 @@ - 4 + 1 - + - - Robert McNeel & Associates - 00000000-0000-0000-0000-000000000000 - Grasshopper - 8.12.24282.7001 - - - - - Robert McNeel & Associates - 00000000-0000-0000-0000-000000000000 - Grasshopper - 8.12.24282.7001 - - - - - Robert McNeel & Associates - 00000000-0000-0000-0000-000000000000 - Grasshopper - 8.12.24282.7001 - - - - GhPython, Version=8.12.24282.7001, Culture=neutral, PublicKeyToken=null - 8.12.24282.7001 + GhPython, Version=7.37.24107.15001, Culture=neutral, PublicKeyToken=null + 7.37.24107.15001 00000000-0000-0000-0000-000000000000 @@ -110,9 +85,9 @@ - 38 + 41 - + c552a431-af5b-46a9-a8a4-0fcbc27ef596 @@ -659,8 +634,8 @@ 0 0 - 3798.0059 - -12.954193 + 3798.006 + -12.95419 @@ -696,16 +671,16 @@ 12.37911 - 210.43997 + 210.44 12.37911 - 210.43997 - 36.011925 + 210.44 + 36.01192 37.3931 - 36.011925 + 36.01192 A quick note Microsoft Sans Serif @@ -721,9 +696,9 @@ 32.3931 - 7.3791103 - 183.04688 - 33.632812 + 7.37911 + 183.0469 + 33.63281 37.3931 @@ -970,8 +945,8 @@ 24 - 3338.3623 - 547.92505 + 3338.362 + 547.925 @@ -1041,8 +1016,8 @@ 0 0 - 2632.9673 - 275.94382 + 2632.967 + 275.9438 @@ -1077,7 +1052,7 @@ 26 1 Value List - Value List + ABB speeddata false 0 @@ -1267,9 +1242,9 @@ - 2625 + 2611 318 - 146 + 152 22 @@ -1815,7 +1790,6 @@ from ghpythonlib.treehelpers import tree_to_list - EXT_AXES = "[9E9,9E9,9E9,9E9,9E9,9E9]" def rg_plane_to_posdata(plane): @@ -1835,23 +1809,22 @@ if wobj_name is None: if tool_name is None: tool_name = "tool0" +if retract is None: + retract = False + if start_configuration is None: start_configuration = [0, 0, 0, 0, 0, 0] -heater_on = "DO_1" -stepper_on = "DO_10" - -if print_speed_value is None: - print_speed_value = "s_printSpeed" - -TRAVEL_SPEED_VALUE = "v300" +heater_on = "DO_10" +stepper_fw = "DO_11" +stepper_bw = "DO_12" PRINT_SPEED_NAME = "s_printSpeed" TRAVEL_SPEED_NAME = "s_travelSpeed" module_level_vars = """VAR speeddata {}:={}; VAR speeddata {}:={}; -""".format(PRINT_SPEED_NAME, print_speed_value, TRAVEL_SPEED_NAME, TRAVEL_SPEED_VALUE) +""".format(PRINT_SPEED_NAME, print_speed_value, TRAVEL_SPEED_NAME, travel_speed_value) main_proc = """PROC main() @@ -1867,17 +1840,15 @@ extrude10sec_proc = """PROC Extrude10Sec () SetDO {}, 1; SetDO\SDelay:=10, {}, 0; ENDPROC -""".format(stepper_on, stepper_on) +""".format(stepper_fw, stepper_fw) + home_joint_pos = "[" + ",".join([str(c) for c in start_configuration]) + "]" layers = tree_to_list(planes, retrieve_base=None) is_travel_point_layers = tree_to_list(is_travel_point, retrieve_base=None) move_abs_j_start = "MoveAbsJ [{}, {}], {}, fine, tool0;".format(home_joint_pos,EXT_AXES,TRAVEL_SPEED_NAME) -move_j_start = "MoveJ {}, {}, fine, {}, \WObj:={};".format(rg_plane_to_posdata(layers[0][0]), - TRAVEL_SPEED_NAME, - tool_name, - wobj_name) + rapid = """MODULE fdm_print {} {} @@ -1889,38 +1860,45 @@ rapid = """MODULE fdm_print TPWrite "Press play when extruder is at right temperature"; Stop; ENDIF - {} ! First layer """.format(module_level_vars, extrude10sec_proc, main_proc, move_abs_j_start, - heater_on, - move_j_start) + heater_on) last_is_travel_pt = True for layer, is_travel_point_layer in zip(layers, is_travel_point_layers): for plane, tp in zip(layer, is_travel_point_layer): new_lines = "" if tp: - if not last_is_travel_pt: - new_lines = " SetDO {}, 0; ! stepper off\n".format(stepper_on) + move_type = "MoveJ" + zone = "fine" speed = TRAVEL_SPEED_NAME + if not last_is_travel_pt: + new_lines += " SetDO {}, 0; ! stepper off\n".format(stepper_fw) + if retract: + new_lines += " SetDO {}, 1; ! stepper backwards\n".format(stepper_bw) + new_lines += " WaitTime {};\n".format(retraction_time) + new_lines += " SetDO {}, 0; ! stop stepper backwards\n".format(stepper_bw) else: - if last_is_travel_pt: - new_lines = " SetDO {}, 1; ! stepper on\n".format(stepper_on) + move_type = "MoveL" + zone = print_zone speed = PRINT_SPEED_NAME + if last_is_travel_pt: + new_lines += " SetDO {}, 1; ! stepper forward\n".format(stepper_fw) + posdata = rg_plane_to_posdata(plane) - new_lines += " MoveL {}, {}, fine, {}, \WObj:={};".format(posdata, speed, tool_name, wobj_name) - + new_lines += " {} {}, {}, {}, {}, \WObj:={};".format(move_type, posdata, speed, zone, tool_name, wobj_name) rapid += new_lines + "\n" last_is_travel_pt = tp - rapid += " ! New layer \n" + rapid += " ! end layer \n" -rapid += """ SetDO {}, 0; ! stepper off +rapid += """ SetDO {}, 0; ! stepper fw off + SetDO {}, 0; ! stepper bw off SetDO {}, 0; ! heater off ENDPROC -ENDMODULE""".format(stepper_on, heater_on) +ENDMODULE""".format(stepper_fw, stepper_bw, heater_on) GhPython provides a Python script component 143 @@ -1942,34 +1920,36 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3146 - 182 + 152 167 - 124 + 184 3261 244 - true - - 6 + + 9 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 + 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 + 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 + 84fa917c-1ed8-4db3-8be1-7bdc4a6495a2 2 3ede854e-c753-40eb-84cb-b48008f14fd4 8ec86459-bf01-4409-baee-174d0d2b13d0 - + 2 @@ -1987,18 +1967,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 184 + 154 98 20 3198.5 - 194 + 164 - true @@ -2020,18 +1999,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 204 + 174 98 20 3198.5 - 214 + 184 - true @@ -2053,18 +2031,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 224 + 194 98 20 3198.5 - 234 + 204 - true @@ -2084,18 +2061,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 244 + 214 98 20 3198.5 - 254 + 224 - true @@ -2116,18 +2092,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 264 + 234 98 20 3198.5 - 274 + 244 - true @@ -2148,18 +2123,110 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3148 - 284 + 254 + 98 + 20 + + + 3198.5 + 264 + + + + + + + + true + Script input travel_speed_value. + 16f1a3cd-7c04-4617-8cac-505fcfa894ca + travel_speed_value + travel_speed_value + true + 0 + true + 02cb0cb6-5e92-49e8-9725-43a82fa7dafc + 1 + 87f87f55-5b71-41f4-8aea-21d494016f81 + + + + + + 3148 + 274 98 20 3198.5 + 284 + + + + + + + + true + Script input print_zone. + 614c4dbd-6a73-4292-be9f-3ab8c279b03e + print_zone + print_zone + true + 0 + true + 41e19496-702a-47d9-9537-094529b8e2aa + 1 + 87f87f55-5b71-41f4-8aea-21d494016f81 + + + + + + 3148 294 + 98 + 20 + + + 3198.5 + 304 + + + + + + + + true + Script input retract. + 9c08782f-2d48-4f23-9679-8ae6dd4e0a4d + retract + retract + true + 0 + true + fbefb524-852a-4721-8518-1266b68299d6 + 1 + d60527f5-b5af-4ef6-8970-5f96fe412559 + + + + + + 3148 + 314 + 98 + 20 + + + 3198.5 + 324 - true @@ -2175,18 +2242,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3276 - 184 + 154 35 - 60 + 90 3293.5 - 214 + 199 - true @@ -2202,18 +2268,17 @@ ENDMODULE""".format(stepper_on, heater_on) - + 3276 244 35 - 60 + 90 3293.5 - 274 + 289 - true @@ -2641,7 +2706,7 @@ layers = list_to_tree(layers, source=[]) 0 2873.541 - 476.50726 + 476.5073 @@ -2688,7 +2753,7 @@ layers = list_to_tree(layers, source=[]) 24 - 65.371574 + 65.37157 66.94979 @@ -6264,19 +6329,19 @@ layers = list_to_tree(layers, source=[]) true - 2190.2068 + 2190.207 332.6346 - 2539.5964 + 2539.596 332.6346 - 2539.5964 + 2539.596 356.5726 - 2190.2068 + 2190.207 356.5726 A quick note @@ -6292,13 +6357,13 @@ layers = list_to_tree(layers, source=[]) - 2185.2068 + 2185.207 327.6346 - 359.38965 + 359.3896 33.93799 - 2190.2068 + 2190.207 332.6346 @@ -6358,8 +6423,8 @@ layers = list_to_tree(layers, source=[]) 20 - 1627.1565 - 468.76956 + 1627.156 + 468.7696 @@ -6388,7 +6453,7 @@ layers = list_to_tree(layers, source=[]) true - 1784.5623 + 1784.562 363.4368 @@ -6397,11 +6462,11 @@ layers = list_to_tree(layers, source=[]) 2075.59 - 387.10623 + 387.1062 - 1784.5623 - 387.10623 + 1784.562 + 387.1062 A quick note Microsoft Sans Serif @@ -6416,13 +6481,13 @@ layers = list_to_tree(layers, source=[]) - 1779.5623 + 1779.562 358.4368 - 301.02783 - 33.669434 + 301.0278 + 33.66943 - 1784.5623 + 1784.562 363.4368 @@ -6677,8 +6742,8 @@ layers = list_to_tree(layers, source=[]) 20 - 3435.0903 - -94.949455 + 3435.09 + -94.94946 @@ -6833,7 +6898,7 @@ layers = list_to_tree(layers, source=[]) 20 - 3423.5488 + 3423.549 44.58687 @@ -7065,6 +7130,390 @@ for layer, tp_layer in zip(plane_layers, tp_layers): + + + 00027467-0d24-4fa7-b178-8dc0ac5f42ec + Value List + + + + + Provides a list of preset values to choose from + 02cb0cb6-5e92-49e8-9725-43a82fa7dafc + 26 + 1 + Value List + ABB speeddata + false + 0 + + + + + "v5" + v5 + false + + + + + "v10" + v10 + false + + + + + "v20" + v20 + false + + + + + "v30" + v30 + false + + + + + "v40" + v40 + false + + + + + "v50" + v50 + false + + + + + "v60" + v60 + false + + + + + "v80" + v80 + false + + + + + "v100" + v100 + true + + + + + "v150" + v150 + false + + + + + "v200" + v200 + false + + + + + "v300" + v300 + false + + + + + "v400" + v400 + false + + + + + "v500" + v500 + false + + + + + "v600" + v600 + false + + + + + "v800" + v800 + false + + + + + "v1000" + v1000 + false + + + + + "v1500" + v1500 + false + + + + + "v2000" + v2000 + false + + + + + "v2500" + v2500 + false + + + + + "v3000" + v3000 + false + + + + + "v4000" + v4000 + false + + + + + "v5000" + v5000 + false + + + + + "v6000" + v6000 + false + + + + + "v7000" + v7000 + false + + + + + "vmax" + vmax + false + + + + + + 2628 + 354 + 152 + 22 + + + 2715 + 354 + + + + + + + + + + 00027467-0d24-4fa7-b178-8dc0ac5f42ec + Value List + + + + + Provides a list of preset values to choose from + 41e19496-702a-47d9-9537-094529b8e2aa + 14 + 1 + Value List + ABB zonedata + false + 0 + + + + + "fine" + fine + false + + + + + "z1" + z1 + true + + + + + "z5" + z5 + false + + + + + "z10" + z10 + false + + + + + "z15" + z15 + false + + + + + "z20" + z20 + false + + + + + "z30" + z30 + false + + + + + "z40" + z40 + false + + + + + "z50" + z50 + false + + + + + "z60" + z60 + false + + + + + "z80" + z80 + false + + + + + "z100" + z100 + false + + + + + "z150" + z150 + false + + + + + "z200" + z200 + false + + + + + + 2635 + 421 + 140 + 22 + + + 2716 + 421 + + + + + + + + + + 2e78987b-9dfb-42a2-8b76-3923ac8bd91a + Boolean Toggle + + + + + Boolean (true/false) toggle + fbefb524-852a-4721-8518-1266b68299d6 + Boolean Toggle + Boolean Toggle + false + 0 + false + + + + + + 2891 + 430 + 146 + 22 + + true + + + + + + @@ -7072,7 +7521,7 @@ for layer, tp_layer in zip(plane_layers, tp_layers): - iVBORw0KGgoAAAANSUhEUgAAALwAAAB9CAIAAACXn57tAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAACnLSURBVHhe7Z0HWFN5vve97/s+7773ujuzs7Nl9s7O7r679+5O25mdcey9ooKogIjSVCzj6GJFFBFBkCZI772E3nuvoXdIA5JAQhJCxzrOWHK/Jyc4xBlRMSDRfJ/fczj5n0rO5/zK/3+SzFNJpelIopJKz60foDlY+0c5q//D3sLfXQ21HB240aeSUkkgEHR3i2Io5ySP9ki+3yO5v/fOuO6Db4kZyffPZxKjlMRVPh5fFeSsFQm0eeztsF729vq6zXLQmNR8IGd17+sV/FYFjTKKgIYtiol+GWiMo8KXWlp86nl9gaPd58kJKzNTV4cGLdml9Uc5aA5U/0HOat/fnf8bOxU0SigFeJoH+twuTR5nezdzG+y723qDQi1M+3p2yEGzv+p9Oav5T928d+1CL44OqqBRMk3yNHrThOa+/r1berVUtdEBnaa6zYx2DfgecZ9WY618eNpH/U85q/79rtxfqaBRRikAmgf6d8Z3x0QuF/TssLr4KbV8E6ABOmdPf/QMaHRy37ELsVBBo3RSSHgaG9Tx8VzIomlEhi6VPNJHatxSv8XW5jM5aIwrfy9nVe9p5/wS0IypoFE2KSo88bk7bo7sGhRqP/oO2+rfGtWFyUFjVPGenFF/p5X9lm3IBRU0SqdJnma60MCwssQALoeYki3EvKEcNIblv5Ozyt/uzPqFChpllGKg+Ul7ZCAHjUHZb+Ws4jc7Mn9+JVgFjfJpBqF5+CxoNDPnXwk+PzZ4U3YuKimJZhAaImZNgka/9DdyVv5rzYz/UEGjjJpIhM1mPDztLfm1ftmviWk5Md1b9q5G2v+zD7e8MXxHdi4qKYkmPM0MQPNA3tPsLX1XK/WdPcXvbk98R6/g3b1lv9JM/49j9vuHRGMDomFhn1jY1z9hIkGfEIbTk52mSnNJMwjNE+Fpmd3P13m9tdb9F4suzt9d8M6e0ne0895eq7/Y2sqaJazv5ndw+CwOv5PL7+b19Qr6BCKBWCwYHhSMS21sQDCKl/2CQaGgX4qUiqdXptmDBqwsuTx/ifX8pVfm6+YT0Kin/swp3Ha3yVar2q9cmRvtO5ZdaV9wpf1Lh44V7jTNQPq+GKZZIssqiWWT0elc3B1ax8lq66ns4rXz+3giwQBIGhSOiQVDwEvqllSaJc0gNETX8CRo1ILf0s17RyP2bfXot/WKf6VX/I5W7ltLdT4P8PXvGaDRefXNvSVUTkJ2t1sM66wbXd2q7RObti/86Hsyu1wzO10pzDNBNBN/mqFfh0FAh3EY7VgS07qwK6iOk83sbYZzEgtGBoWEN5K6IpUfmkHNJDTyiTBcy+4iwsHAdAt+ubvo7c3J/8fS79TdG9/3CwbgOXC9EYMGBTeGBDeQ2bB4zaWciFDmYX+GQQE7ACsMC28Bji4eDf6mmpOW2+mdwLgU1nE8qP1gcMdhCt08l+VTz8nDCuBG6oQAkEj2j6qkOCkGGgn4MJJ2AcMwAyNbJkGjW/D2rvwfTLfw7U2J/2YdfG586JbsXCYJ4QbpC+jBtKmnIJRx2IOmWcVJJlsA0AD8ijTRwTyX39XeU1XWTUlmXA3vMA1qOxTWfjydca2Onc3hdRIsConVVO5HUVIANA8NG2o2u7kuyM9em5e9NjpiWVjwEka7RkToUjloJhNDQrMxcd7lwLNT99PgSoOPAcEYlZPk1qEez7yIyw/P1NfHf7wCqi0pRqPwLiJBfzePAX+Twbwe3m4a2HqI0nG+kBVK72nAOohfmBIbqfQSUgA0EsPqik3XXb6sLN14yeLT8JClZUUbSgrWZ6evkYNGJ++tybar4K0NCc+GZkIC1FC8Pm4I/XAQ/QCP3yPl5idEMCToR3YsBUjM7G0p74pLoF0Oaj0U0XaqgBXM6GnEtgPCEawm20alF5RCPE0tVS3AdxEoiYlanpKwEvPNdVv8vBfKQaOd+4vJppP/i/XxgObM+OBPhKefEh8XGzTEMs8F00zIHh3ZkqcIAIEbxCYggkq+qjstgWYd1Hwkqu1saScFkQuL+gVDqrD1olJITvPoO2JYm5iSmc1D6XD3E6PcWjk/n2zaeT9fFzfP6gWgIST1IiPh9ONxTAuELQKM5xNCGNB5TE9su2Vwy9GUDsdmTrkUrBFV0f78UgA0j4wyU1dHhi0tyFk30K8zJNIeEGphyu3UlINGp3D+ZNtVPH994jwLvxMvBA2EpITfx/dq31XBTkAuLGt9bqGeAiLIjlm9LXnMwLDmE5EtZpWdKfw+HjIeVcx6HikipzGODFt29tRHHm4LHK/+Mz5mRWriqkC/RdvU35eDZqnvvMm2zH/ep47zrkXajg+/GDQQ8uJ6bq5X2y64jWlfZjgYUIKZmq5MSqtFaPPJQkYYh8eSlloqdKaSInIag9bGrfXVashsKko2DPdrD/Vr3xzZRS3bKAdNZHKEnCVFUNIobA5bJJxOV8qQYDyWbpHOchkSjsuapiVEpQEhMTrRyqlMarcPbvomh+YHdFReZwpNQHP2ZXIaZDDf3dEjO2mwbSddQ8jb+WROc2P05hM2PnIDxCDWyM7lRYQEtqOnxqd1L4fPUsTVFYAbhC3UVsntjkGNQMcfmbIUHVX34JNSADT392L9ksL1xCYSfWQzZmc+ykpb3Vy/RQ4a2QEVJ8SRGNr5ws4QMsooRGQ1TifQcQpp/FcRIwK5jjRNVlVYP0ghnubhvb0t9VswlTwy6O/TCglcPD6s6+L8xUxDM4I6KLzdVNpno8iLKiLR4TYktNqFN56p7sxAAtQvHJQtfuOlqPB07+Zuosx+oP/tzd08znbshNGuPrPQoIpGIhzYepDRS/T2yloVJwQssXC4iV0S3WxBabrUxqkGSaocGVIANA/16a3qnfRtMCKPIcYpkc1gemBmoYFwFeM7rEo6ozAja1K0xMIhgFLJTA5tOJ3e5iHtEnzTO3UUAA1Rci9FHhMauCQ5cVVB7rri/PWous3PfTIL0IyWdkYn0q7MHDSQtMIa6eGzs9v9QupPlTMTERD7hYr3bcoiBUDzyCg9meiYCQte4um2oLZKra5Krbxkw8Xzn844NLh47dzq8NaTSFdn+u5HjYaMu4NbT2m0imu2Zfa0vrEuRyE5zf272BbpsHQrBCZiGIGMUDMMDephxIuwlhOs3tbZ6VZBOowDFdMpwbWnSuixiFxIfWTL3hgpxNNkp6+hRC4ryls3MqQ7ItYZ6tfGtI+nNePQ4PxxCaNbLeq788WzdfEEAkSrUSa3Na7JltJgTec0DopG3yiXo6ic5sypjxCbnOz/mRC7IjVJOoygIT+MIDugooUCJ6XduZQVgwspa5oVITKiDi9nJIXWmRXQIgV9gjenJlcANA8MOlrUkcfUV6uVFa0fEGrxODuGRNoVJRtmAxokFjk0v1x64Izmwj8peJdB4UhXDy2p2XnC5bwRWY4CoJnY5N6t3dIym3zcE2YyS9CUMeNS21xQG8uaZldkv181KzO87nwJLY54OQOdRnNKighPRnGU5Q52/0yOX9narE5rVae3qbc2bk1LXT0b0ICV2s6chNarolf3HCdi04BopKuXltjolNDo2NnTgZev8ciDQqCJjVp+9crnXu5fOdh9npG6OjeTyIv37P7TbECD27qFXRnTfBlx4dVeJ5FwAFZGT4qotaAyMuB+XtfuY4WEp9EB4tmr4X7t3u7t393Wuzm6C+W3uG82qiei+4TV20ZputTDY7/yEWnS5TC4LfEN9qlN7kT3sWhYtuw1kiISYf1upia3SxPESCT7pN0zpM38MAIk7arpojRZdfcyZqer5pnqR0kuEBZ1UKJqrepZRQPCodfs+YoJaM5IHu2ebniaGEYIWpKasroob31Jwfr05FUWF2a+RxgSCIQ9fHZsow2rp23uhAOiL0c00s6ui62zy24J7OX3vKo8fSakCGiM0pJWBfgsCg0khhFqqMQjfKVFGy7MwtgThFSGx++Na7SjcxtRucha54bEwkF+Hz+vNSym1ra1qwqhCjDJlimzFAANaQ/0sQkxkoDAdF86jEB87d5sQEMkvwmNDu2c2rkGDYTANCAcbu6qADeFbdFoeQ36ABUAzUPD4vx1WWmrqWUbb4zr3R4jvtfz7o3dt8b1ZgkagUCU1OjS3F0xZ0eeEZt6+Jys5oCEWmcauxEYKXWWo5CcJjxk6Yl//R0lt6P9F4mxKxJiVgT4/ujTCLIDKl7EJ+LSmjzrWYVz+SZGkg506piFlBrborYYhC0EL9kyZZNCPE1V+aas9DX52WuT4lbyODu6Gdv43B0JsStmBxoidchq9q9mZM95zy8Qi4a5vO7MpsC4Gqe2rhq8VEaXo5CchlgfqQzmJfsnxhBgs1JyQ7iDc1tDK2lpSnHvosTDedYzi2OrHfJbopDFK53LUUR4MkI8cnP5EjVUJ1OTzSKsi76tvGzT7EFT2EYp60hSorJWmuVwc5pD46qdmzup4GaOdDI9jxSS01Aill08/6mH2wJb68+SE1amJ68KDVqiOTuPRkB4x0vbE4va4pQIGgiBCWfe3FkZV30tpymc09s1IBrC9ZAtnsNSADT39ft6dnA6NXu6t9NatqJ6Gu7XvndrNzKb2YOmkpZe0BItFilfBxrOmcfvKWqNjau6VtWRIxAI5/7TxwqA5oF+P38n8WlckbY0pzGcsFl5NALCu1xDz89tDlfSh72JvhzREJPTml7vn1zj1dpVg39EJJxzfU6PpZDwFBVOhKfo8KXFhRuqyjfWUtWK89e7u301e9AgLchsCMS7r7wPJIASWCOzLKnGI7shjMVpF4vmaKIzAc3pl0mEUxJWent8FeS/2O3alyWF68uK1melrTlx/O+zBA3ea3p3U3qdf18fX3mhgXDyCLX8Pn5lR1ZClVtRczy7pxPxa66V5QqA5v7euzd2I4mBIaEhRg+IAQSD727PSo8whPe0i8tIrfXr5XFfg8Ed/AsAhcPrLmpJSKC6lzQnS9GB15kr6CgAmocGo2IdN9cvkQt/e3fvrVHdbtZ2Fk3D033BLEGDd7mHx0mrDejmMufaTTlt4R+B1+nmMgqb4pOqvEtaUtg9LKAjEr76gKUAaB4Z9PXu9PL4CjmNuvr7ibErLM5/gpzmyS9qlB1wBkSGpIzaEDq7ZS68pwoUMfggGuzuYcHfpFT7FTYlMNht+B+RxuHKyVaadSkAmgcGKLkzU1cz2zXCQ5bwuTuQ1gCaIL9FswQNhPsyt57SwkLdMXeLjmmL9Dqc3u7KtpzU6sCcuugWVi0SuFcVsxQAzfd7vye+0chA+lwEWXIbS222hhEgvH1lLRnUtlwlrbqfRwQ6okE+n9dAL8uqicioDqW25XVxmYTjERHPCsrWm3kpABqJUULsCo/rC9KTV3V3bud2bed2EiMJVVS12YMGrDTQKwobEl9LTzNZRO8fgYiI3t1a0pyeXhWSXxfXSK/k9HTjf++HS5p5ehQBjXF0xDIL80883BbY2XyWHD/rwwgQ3kQWuyOrOgr16isM9rMoAelgenhc3C15tXHp1LCCusRGGhX0iIQiLMJ0ht4KBUDzQJ/P2cFmaqJ6am/aiuppSKT97c3dnTSN2YMGuTCfz8+uprDYNOG0vvlRSUUOOwAgsNJAq8yvTcykRhXUJtW0lTC62hHLZO5HoQApBBqxQGt0QGdYrC3NY8gxhNn6hOVj4d0pbkivay/DTSZrepOEqCT1LgQ9LYy6ssbsnKq4HGp8SX1WQzuV2UXr5fVIPZAY60gZmn4UUwA00mEEywufUiKWlRRtqK7YVFelVlq43tND/mvuZQecMeG9aGXU59UkvlGe5sci6JF6F8x3shkNHdTS+uz8quQ8alJRTUZ1c2krvYHVTe/p5eLakxj1YyIUCYVCkPQ8Dgnr9PYOxceZSR7pTjsRRh7j6fZVoO8iV6cvUGyDmIyU1ceO/m1WoSH+E15vdmVsF4f5hnNDCiEbqZ6UCQIgNrerjdFY1VxSUpOdX5maV5lSSM0oq82vba5obq/vYLR2sVncHg6PzyNg+kH9UpuQlK3h4eH6erqXJypkEDAtaO7v/e62Huzebb0bw7vQQnzHkeyrG2cRGgjvTmVjQWVTwZsZoaYUAMIFR+5MhCeUC5weNr2zo6m9rqqhpKwmv5iaU1iRBSuqyC6h5pdVFVXWlFTXVdQ1Vje1NLR1tMLaO9roDFpnF6uhocHQ6KjLNelXR08PmocGDTWba6lqbU1bJQ8NH97bc//uHumPayCzmV1ocGOxOZ1ZZXHcXs5LVp7kfYV7DiJfisVicp7U5PnJQnt/f/8Ta05+ORckPSMwBB9COhJkOUJkzfA03exOOrOjndbS0tbY2FxX31hTU0etrC4vp5ZWUsuo1ZW19TUhocF79h7MSLN6mZwmPGTpqRMf+nkvCg1ekpG6OieD+KmwA/v/OtvQQLiTKuoLYKRPnoZQhQ0MDDCZzI6ODry1eAliWCxWY2OjNOoLMB0cHOTxCDeO9R83ki+xcmtrK5fLfdzeIxVmsAh7xg6lx5lzwtlKz5c8UwhuiTDMoYVcQAr3j+UlRyvLrUS9Mz1oHhkW5q5LiFmRFL8yPGQJrU29o0UdXsfbfbaep5ks/NsoE7JLExidHdPjBte1pqbG09MzMTGxoKAgIyNjdHTU1dXV398/IiJibGyMzWbHx8fHxMRwOJyhoSEAgU3AELbFS2zl4+OTn5+Pd7a3txdTMNTV1YUL0tbWlp2djRbyQMorcCMQjL1U9QTDyhLy+xlRaT8uufe9AmggsNJOb84uSertxf39whkxsrygoKCWlpa8vDwKhXL+/PmEhITLly8HBARcu3atsrIyOjp63759V65cAVjJycleXl7h4eF2dnbAaGRkJD093dnZGbRFSYVNsH5wcLC7uzs2uXjxItaRHUlphRuAze6PjXkJaB4ZpqesCgtakp+9lter1c/XEvJ29vN3Mhnyv/ckO+CsCNzUNVELyjOI4PKC3AAaXH44GFxmEJOamgoHY25ujuwPdxhcjre3t5WVVWhoKBadPXsWKx8+fDgsLAzowAk1NTWlpKScOnUKmxcVFdnY2GRlZWFzAGRmZgZ3hdAmO5LSCtBI+2lOvUTJbRwhzWncXBZYWf4DcSqesiLAZ9HGDe+9MmhQbaJGqKovLyjL4vZwkZnKFjyHEMLxpsTGxgYGBhYXF7e3twMXXH7AhOjj5ORUX1+fmZlZVlZGo9EwDQkJwdLm5ma040BUKhWOqra2Fo4KO6moqEBsAmf29vaIeoWFhdg5JDuYcgrn/7LQPDCgtxFf1NhUv7m0cP2wWEfE24nau6pc/veeZAecLeEfw+VvaK7NK06nM5DfEAWCbNnTJY3WfQwGjc3u7unhdnd3MZkMFovZ1dVJp9MaGxsyMzPQgqWdnSzMYAUul4Mp1oHRaB1Yk8NhY4pGrIYZrAmGOjraH2/1QhDPQSkAmvt7b47sun9X7874bunQAfnxStihVwkNBH8DVlBAFpTmVFaX4VoCI+hpNzraEc5CQ8NdXDzd3Hzc3HylU3KGmHd39/X1DZ5on7z0GTOengEeHn5ki7Oze3Z2jlKnwwqARjrKbW31j9jo5TVVm5vqtrQ0bKmlboqMWPaKoSGF0hEo1DXWFJbkUavKGUw6ymqSHqlfIUSuiSII3uLaNc/U1LKkpKKUlJKUlNLk5GLMpKaWpqWVSVsIw0usg5mEhIIXssTEQgol293dG8d8fFylE878paExio9ZYW/7T2/Phfa2n2dnrMnNXIsW/T1/nhPQQPgngQ5q46aWxpLy4pLyoqpqamtbC4IFMh4gBXoQMpCyODjYW1rago/w8BQfnygURoGBsT4+kW5uIVevegQEINGJw0sXlwBHR5+AgJjY2OyYmKksNjZnYiZXOp8TGZnu6xvwpkNzXx8ZzOiAztjQLkHvjvt392AP2Fw66D03oCGFfxXRCn+7urtaWpurq6llFaWlZSVl5aWVlRVoQb2zb5+xt3cwHMn587bnzlkfO3b2+PFzR46cPHz4hKHhYW3tvYaGh77++tSBA8cwxSIKJQueQzp90qKjM+PichMS8jEFLngJQ3tkZJqTkwvyK+XNbBQAzUN9ZocGi6bBZqHGNpY80p/4Xe79cwuax4JfIcMT5uF+UN2gDkK1jHrYyMjI0zMQIcnGxtXC4urp05YXLti5uQU7OfmcPXv5669Pm5vbXr8ehKUXLzqYml4ID08l+fixARQXF/9Tpy46O/t6eITt3/8N9kMCZGxscu6cGU4DIk9JuaQAaKTDCGdPfxQcsDgxbmV+9tqSgvXJCSvNzn48R6GZLPz/JEO471FUX7/ueuGCNZIPXPWIiDRYVJQMgqioDNLIl2FhKQg0eIkpDOjExWbGUlLiY1JjYuBO0hGPzM1twMrhwydNTI4fPGiKYIc4FRKSFB0dZ2xshOIcWZTsPJRKioDGMC9rTVT4stio5UF+ixpqN9dXq6HedrD7XAmgmSxcQgaD7uzsGR2dJSWGoAFG0gN7Yv7xy9iYbHePMGuHMOvrxccsUpyuBcfG5UZFZ3p6htnaunl6hmMK/+TtHUkiuG/fQdLT4N2XHVuppABoiGchiPWJTyP88FuE5HiCEkLj6OiOSwtHgtADg2PAlOTj8RQXnpzBajB/n4gTJy4v2Gy33ZytYcY+cPCyr0886YqkSUwGpvBJ2CQsLDU4ONHW1gEV3Bud0zwyzExbHRm2tCBnXR9fWyzQ6ufvxLS7a4eSQCMQ8FGWDwwP3bjp6+tz7pwVPE1oaDJwQXAxM7N2cQn09Y2GwVv4+8d4eUXY2bmjHSUVOAjwjzW7nL7fvEjvQv2JsJt6joNXDy9POfmxj0dYWHg69iNvKf7+sZ6evqj3ldTNQIoIT0ROc9KUGEa4PGkYYf26VzeM8FwSiviDI/yh0T5kNYz2G82V6V7Oe/bscXBwQ2ACMb6+FF1dI5RIyH81NHQOHPjm0CHTI0dObd+uq69vgmJq376jqLoD/aMP2vRpmvO/sUk+7RSjf8yu3fdXbNv/6+4cGBKWBr8ib8Ru3dy83vSS+4FBe/PW6opN9TVqRbnrhkTawt6dY4M65cWz8ntP0xC/X8wbHhOwOweLUsaCbG46Hb1lf+iBx8l4k20HDx9xc/eHPwgMjA8Kire0dES5dOqUpbHx1yizjx83R0oLXNBiYWFvZeXs7R3u7Rm56WjvKt0YdtzfbuS+eyfj3yWJ/6v6m/993cE/KITYj7wleHtHXb/u+aZDc5/40D82+ZZ4vnMuDSP8WAhDvJFxIb1tNNzplo3RTZfjwwm+/bUlgi4m8RTb4JDlRQtT03Ph4WkBAXGkIZoEBSVgxsbmuodHOC485v38KH5+MZgh+vq8ozfvClTbajoa8U6X58/izn7qYfCx8541Xlg5KJHcySSL9/KKBDRkX7TstJRNCoBG+p17Vy5/FkdZXl+7paVxS1vTVhRQsZTZ+krY5xQikaCHOxrlcvvSnrHgK6LWOv7AEFwOpkSoEggGB4dYLKaNjRP8AZggDdCQU+CC6WSTreMfExySePnMN50W81rN511cO//UcUvfsFy0YxOEOdlqMosFedeuuQ0PDylpJw00Ac3Jl4DGKI6y4uqVz709viKGEdLX5GSsAUCz9HtPzyWBkD8yLqbm37baO+5lLqS18Edu8MWDWCBbQSqxWEyn06ytHf3943x8op8w5CLkhccMaZgnF/kHxDtedbt8aKeNyXazvdsd7T3Rgp3Y2XmcO3fl8WqPd6Kru9fBwQHFmpI6GwVAc19/bEhnRKwzOqDTxyWGEW6PEcMI0q/gmxIaHHt4eHhwcBDFJ9k/Swq3INond3yhZbr3Jb+vX8wfHB6J87pzQRtJDOFaCFzkhDPBOdy8eTMG78TJ82TmIW/RmLq5hbq7h2LGx4eCKQINOCBX8PWL9QpIhfkGpfr6xaAFO0EGvXLl+smrYT/Xr4cEBITs22dcVVWl5J17LwHNQ/1O+rZuxjZul6bs956eZxgBB+7p6cnLyysuLu7o6GCxWMACVw7T7u7u3Nzc2tpavKdoIZ8i4HA4L96xwSdCT1/fuNe5W/YHhSw6iMGRyWUQjjU0NDQyMkIeNCoqavduXQsLWzgJXOnJBvdw+bLLkSOnTUz+paWlf/68LdJhTU1dxBpw8MTKpCESnTx58ejRsyQuZCM5Y2Jy5OjRo+TT5rJTUSopABqJcUToUrPTH4cELk6KX5mfs7a0cH1q4ipzsymHEQBEeXm5vb19UVERlUqNjIzEZevs7BwfH09PT/fy8rKzsysrK+vt7cXUxcUlOjoa7/Jkh/RM8YfHUEvfst0/7mcJQKQAyT4JgP2AFR6PBzo9PT0vXbpkbW2tqalpavovFxdvL68oT8+IyQZXgURYT2+/urr2rl1GJ05c0Nc/iDoc0ACCJ1YmDYt8fZEMxcm3R7q6hpw5Y47kSUndDKQIaAyRxICb6Ihl/j4L66qJ33uqKNloZ/PZVNAgKgEac3PzwsLCYKksLS2PHDnCYDBwIW1sbCIiIhITE3FHXr58+ezZs2jx8PDAxcYZy3YxhQQC3sgNcXURQtJwoh/RGUOMb5NLBMAFfgv7P3fuHHDBDM6EzWbzeL2nT586fNgUF9vdPWyySbPXADs7T3t7b1fXYIQYmIODzxOrPdOwHwcHP1dXz4GB1+AhrJeA5vu9xEfjEJLIl7LwRA4mTOlpEJhiYmIw4+joiNv9xIkT8C6AJisrKzk5+datW97e3gYGBufPn4dDQiALCwuDK3qmSyfq6uHx4YzwO+e1BkozkfMiESYXIcAhHmH/J0+exEGRVaBldHQUBGO3SKSYTMbZs5be3hS4hCcM7gftMC8vxCNEGSKzeWKdZxq2cnICfI6vRcn9EtA8MiwuWJ+eQvze080berdGdceHd2E6OqI7FTS4SMhjGEzmyPiN5rZ2RmdXQ3NLUWnZ4MhoF4fL7ukdu3kLLakZmS3tHcXlFWhs7+hAtJr6veYPDKN+Hgu2vX1ZX9TWwB8el7Xz+cAF8cjZ2fnMmTOlpaXwN2Bl8t5wSnA2uKKmphdOn7acGbt07JhZeHikUn8mQQHQSIzDgpecMv3Q0+0rN9cFyfErM1JWhwYu1trxwVTQ4CqKB8S8Xn5VYUlTZXVDRVUztZZeV99eUUivKu2sraBVlTdTa2j1TU2VNa3VdfVllXwegszTcxqi4+6GqKXulu2BG+5nBL1cFE2yRdIPpiDdBi6urq7kS7L9CSH8IXLV1FTX1tbU1dUq3LDbhoZ6vOmTYVU6SaHpfwFoHkyEIbJEIh65Mqiu2FSQu64obx1wQdXN5+7gcXakJ035Y+4CgZAnEOe7mzfaLmp1XAlrc1lZfGmFw9faVw/vNN256qLWP2nXVrY6EYtaHVc02S7K97zAFw5gS9kuSAkE0mGBcQGXPRrlcueCzlBqMPwNGh+nvXAqTU1Nx48fJz/PNnU2jaWImDMqpSYGelFoiLECYkYfAWhAoDU2tEtaZpNmLJEYIb8ZGdCR5jRTltyopDkcQbHVFknyh5L4DyUJH0uS/jvi4sY1W7SWr17714/+8dv3fttk92dJxqeS+I+IFRL/Vmizo5cnFokH+CiF+sWohlAf8cWDQnrrKMXttpX+uI8F5tH4OImB4FRAzLFjx1CUjY2NKfsFmwt6IWge3ttTnL9O+o0QRtTyjVcufwbXkpu7vqluM6NNndupCa/z7d09aUmrHtzb0znFr7DgqKL+/vMXrCNNPpPEfywJ/1AS8yH10n+pbVE/cfK0mpqa+tati5avX//p29+G/V0S9ZEk/O+S2I8DjD6zvGQHaIS9XBGteaA8eyTe+6ar6W0bo/EAq/7GKv7QCGKe7BjSCIjUgU6nw8ekpaWBGNkClV5OLwTNo+/2oJwmlkqMaqvU7Gw+v+b4habG+6i09xv/Beig/c4dvZDAJVXlGzesf/qjEbj7MzIz9x842uisIwn9syT4vySRfzm84f3Valrnzc01NDSuXr26cOHCeT/7ZYbpHyXR/y0J/qsk6IMmjwMH9h0pP6p5/9rXt+xMbl47PhZ8ZbA4RdDFRFH9435eBAIul4s8hkKhqIhRoF40PCEkEU/o3ddH7tLF2DYi1mEzt90Y3jU2hJBE/LjyjZFd5cUbOukadTVg6CnQiMXi5paWXbuNU49+IQn5k8TvT5KwP7vr/uavnywwMzunq6uLkvjnv/z153/7oMf+A0nwnyV+f5QE/TH+m6W79Yzb89KGOhoE3Sy+SEyEJ2S7E30wk0V2Ll+6dMnX1xd5jCoqKVAvCg1BxuOZiSc7793Wq6tSGx0EN+SXT++7ObKLWv70nyNE4BgeGSkooqYe+lAS+HuJzx8k/n+44/7eio9/8/bv//K79//07nt/mP/rD6IO/VES8j6x1Od9if97cYe+KC6rGRy/ye8fQF2Nc5ft7kcCLghMTk5Ojo6OZB+MbIFKitALQ/Nje2TQ36dlI81vHO2/QA3l67WwsXYzJXLKT1gKhMKevsH8UyvuWv/bvavz79nNf+AyP83wZ5+9P3/pX99e8P9/abj4Vzes//2eA7EIdtdqXp7ZJp5wGBvKdvEU4V8aHR318/OztLQELi8+YqXSM6QQaLhdmgmxK7LT1xw/+rc6qlpwwGIAFBGydCpoINHAYG12ctblfbm2B3LtTGCF9iYpVvuSL+1LurQvy2Z/gb1Jri3RjhWyrPfV5aaJfpS4/FggBqU1UhkkNK/BNwjNQSkAGiTI3xNbIVQRv/F0f++3t3bfvbF7uP/Zn7Dk9yMjGRjni5HGEtYnHu0fGiNNOIhyWtZOLBoYJ1ae6Hp5mpDwZmdno8Cm0WhDQ8r3k5ZKIYV4muqKTUh+EZIePTC4f1fv+zt60tGoKceefhBSk+e0Zwk+pqys7OjRo7W1tSjQkDnJFqikUE1Ac2L60BCfRlhy+uRHfl4Lg/wXpyWtys1cExm2dJ/RX54PGkUI/wZ8TFFR0ddffw1uUC7JFqg0A1IANI8MKko25GevzclYkxi7opO+jd6m3knbhixHDhokpNMQkhJMcZay8/0pYQVQQj5HUVlZCX8jW6DSzGgSNLumndNg5RGxDjFDlNxGmD68t4fPkf+wXFNT42NrbGxoa2tjsVjMZ4nBYHZ1dU3BDcIQFnl4eJw8eRL7VfmYWZACoHlkIBZoW5z/BJlNSfEmWqt6StLqloYt3h7yXwnr6ur92Dw9A86etdiwYeOWLVu3bFGfwtTUtmzcqBYfn/DEuDRqaeS5aCwuLj59+rSjoyNqJVXmOztSCDTc7u0hgYspEcvWrf1despqckwqNnq5HDTkt0rFx+fDsrKqjh0z27Rpo46OjtbTtXPnTl3d3WvXrjtx4jRcyODg4MDAAEAh3UlBQYGtrS2IycnJQSO8EfkvqTTTUgA094kR7/bmrd/e3I1s5va4bjdzWydNo6xwvRw05uZXrK1dIiPTw8NTExIKjh49ra4ON7Nl89Olpqa2fft2LS3tLVs0bGys6XR6XV1damqqp6fnhQsXLC0tExISenp6wNDTgpdKMyEFQPNAv5e9HTmNoHfnxCcsyd+wlP+EpYnJcVPT8/7+McHBiRRK9qFDpmvWrF63bt3ap2vNmjVqaptWr17j6OhsYGBgYmJiZWWFSBQVFVVVVUU+HD71wzEqzYQUAI300wjmZh9HhCzNzV5XXrKBWrYxL3uto8MXctC4ugY5Ofl5e0f5+cWEhaXt3//NkiWLV65cueLpWr58ObgBNFu3bjM3P4esBWeMIAVWXoNHmZRXioDGKDVxlafbV0H+i687f1lWtKG0cH1u5hrTY/K/9+TnFyv95CIFFhaWbmBw+MMP/75w4cKvptSiRYs+/PAjE5PD5AN1OF0VK69c8tAQxfMLQ/M98XtP398h7ObILqQ4xObkkMITOc1js7R0MDQ8tGDB4qVLV0xtS5Ys/+KLhf7+garel7kjBUDz0KCuSg0hqbVhC+axLeiZ+FasSdCgNn6soqKi8vLy6uqaqqrqqY1KraqvV/onsV8zTUBjOn1oJMbhwdJhBO+FQQGyYYSosKX7jeWHEYamKyQxKmLmlBQAjXQYISN1dVba6jjKcmaHRkfLVlqreljwEjloZAdUSfmlAGjIT1gSz3oSSbH0yT0YZl7R7z2pNNNSRHgyzExdHRK4OD97raBPW8TfKejZKezdSaM9/dMIKim1FJPThCwxO/ORm8sCe9vPk+JXpqcQDGlsfV8FzespBUDzQL+Lvq29aWtHi3pV+cYRsU5/n9bYoE59tZocNCqp9JySQaOSSi+gefP+B/h97ByZfkWsAAAAAElFTkSuQmCC + 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