diff --git a/.ipynb_checkpoints/Corey-checkpoint.ipynb b/.ipynb_checkpoints/Corey-checkpoint.ipynb new file mode 100644 index 00000000..18e14281 --- /dev/null +++ b/.ipynb_checkpoints/Corey-checkpoint.ipynb @@ -0,0 +1,1459 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n", + "GRAPH: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11), (11, 12), (12, 13), (13, 14), (14, 15), (15, 16), (16, 17), (17, 18), (18, 19), (19, 20), (20, 21), (21, 22), (22, 23), (23, 24), (24, 25), (25, 26), (26, 27), (27, 28), (28, 29), (29, 30), (30, 31), (31, 32), (32, 33), (33, 34), (34, 35), (35, 36), (36, 37), (37, 38), (38, 39), (39, 40), (40, 41), (41, 42), (42, 43), (43, 44), (44, 45), (45, 46), (46, 47), (47, 48), (48, 49), (49, 50), (50, 51), (51, 52), (52, 53), (53, 54), (54, 55), (55, 56), (56, 57), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (62, 63), (63, 64), (64, 65), (65, 66), (66, 67), (67, 68), (68, 69), (69, 70), (70, 71), (71, 72), (72, 73), (73, 74), (74, 75), (75, 76), (76, 77), (77, 78), (78, 79), (79, 80), (80, 81), (81, 82), (82, 83), (83, 84), (84, 85), (85, 86), (86, 87), (87, 88), (88, 89), (89, 90), (90, 91), (91, 92), (92, 93), (93, 94), (94, 95), (95, 96), (96, 97), (97, 98), (98, 99)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + " points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + " points.append([1,0])\n", + " points.append([2,0])\n", + " points.append([3,0])\n", + " points.append([4,0])\n", + " points.append([5,0])\n", + " points.append([6,0])\n", + " points.append([7,0])\n", + " points.append([8,0])\n", + " points.append([9,0])\n", + " points.append([10,0])\n", + " points.append([11,0])\n", + " points.append([12,0])\n", + " points.append([13,1])\n", + " points.append([12,2])\n", + " points.append([11,2])\n", + " points.append([10,2])\n", + " points.append([9,2])\n", + " points.append([8,2])\n", + " points.append([7,2])\n", + " points.append([6,2])\n", + " points.append([5,2])\n", + " points.append([4,2])\n", + " points.append([3,2])\n", + " points.append([2,2])\n", + " points.append([1,2])\n", + " points.append([0,3])\n", + " points.append([1,4])\n", + " ##\n", + " points.append([2,4])\n", + " points.append([3,4])\n", + " points.append([4,4])\n", + " points.append([5,4])\n", + " points.append([6,4])\n", + " points.append([7,4])\n", + " points.append([8,4])\n", + " points.append([9,4])\n", + " points.append([10,4])\n", + " points.append([11,4])\n", + " points.append([12,4])\n", + " points.append([13,5])\n", + " points.append([12,6])\n", + " points.append([11,6])\n", + " points.append([10,6])\n", + " points.append([9,6])\n", + " points.append([8,6])\n", + " points.append([7,6])\n", + " points.append([6,6])\n", + " points.append([5,6])\n", + " points.append([4,6])\n", + " points.append([3,6])\n", + " points.append([2,6])\n", + " points.append([1,6])\n", + " points.append([0,7])\n", + " points.append([1,8])\n", + " ##\n", + " points.append([2,8])\n", + " points.append([3,8])\n", + " points.append([4,8])\n", + " points.append([5,8])\n", + " points.append([6,8])\n", + " points.append([7,8])\n", + " points.append([8,8])\n", + " points.append([9,8])\n", + " points.append([10,8])\n", + " points.append([11,8])\n", + " points.append([12,8])\n", + " points.append([13,9])\n", + " points.append([12,10])\n", + " points.append([11,10])\n", + " points.append([10,10])\n", + " points.append([9,10])\n", + " points.append([8,10])\n", + " points.append([7,10])\n", + " points.append([6,10])\n", + " points.append([5,10])\n", + " points.append([4,10])\n", + " points.append([3,10])\n", + " points.append([2,10])\n", + " points.append([1,10])\n", + " points.append([0,11])\n", + " points.append([1,12])\n", + " ##\n", + " points.append([2,12])\n", + " points.append([3,12])\n", + " points.append([4,12])\n", + " points.append([5,12])\n", + " points.append([6,12])\n", + " points.append([7,12])\n", + " points.append([8,12])\n", + " points.append([9,12])\n", + " points.append([10,12])\n", + " points.append([11,12])\n", + " points.append([12,12])\n", + " points.append([13,13])\n", + " points.append([12,14])\n", + " points.append([11,14])\n", + " points.append([10,14])\n", + " points.append([9,14])\n", + " points.append([8,14])\n", + " points.append([7,14])\n", + " points.append([6,14])\n", + " points.append([5,14])\n", + " points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " #\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "#from braket.devices import LocalSimulator\n", + "#device = LocalSimulator(\"braket_ahs\")\n", + "#small_ahs_run = device.run(small_ahs_program, shots=50)\n", + "\n", + "\n", + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io) \n", + "\n", + " \n", + "# Results are loaded and saved to file\n", + "#result = small_ahs_run.result()\n", + "#save_result_json(\"classical_results/small_kings_graph_mis_trial_5.json\",result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "b55aa0ab-d318-41fa-9b58-182ecc18953e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trial_file = \"classical_results/small_kings_graph_mis_trial_5.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 323, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "c82602ba-5305-43a7-be0e-e3d9f0d5d5dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "Average pre-processed size: 5.1400\n", + "Average post-processed IS size: 5.1400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(trial_file)\n", + "\n", + "for result in result_json[\"measurements\"]:\n", + " print(result)\n", + "\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()\n", + " \n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 325, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'G' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[325], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m color_lookup \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m0\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m1\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m'\u001b[39m}\n\u001b[1;32m 10\u001b[0m seqs_color \u001b[38;5;241m=\u001b[39m [color_lookup[seqs[i][j]] \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(seqs[i]))]\n\u001b[0;32m---> 11\u001b[0m visualize_graph(ax,\u001b[43mG\u001b[49m,pos,node_colors \u001b[38;5;241m=\u001b[39m seqs_color)\n\u001b[1;32m 12\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mNameError\u001b[0m: name 'G' is not defined" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,G,pos,node_colors = seqs_color)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T06:51:59.331Z', endedAt='2023-01-29T06:52:48.394Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0,\n", + " 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]))])" + ] + }, + "execution_count": 326, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 327, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 28.5714\n", + "Average post-processed IS size: 27.0667\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/.ipynb_checkpoints/jade-checkpoint.ipynb b/.ipynb_checkpoints/jade-checkpoint.ipynb new file mode 100644 index 00000000..363fcab7 --- /dev/null +++ b/.ipynb_checkpoints/jade-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/.ipynb_checkpoints/snakeysnakesnaketest-checkpoint.json b/.ipynb_checkpoints/snakeysnakesnaketest-checkpoint.json new file mode 100644 index 00000000..e21ee5d6 --- /dev/null +++ b/.ipynb_checkpoints/snakeysnakesnaketest-checkpoint.json @@ -0,0 +1,4344 @@ +{ + "measurements": [ + { + "pre_sequence": [ + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 0 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "pre_sequence": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "post_sequence": [ + 1, + 1, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1 + ] + } + ] +} \ No newline at end of file diff --git a/Avneesh.ipynb b/Avneesh.ipynb new file mode 100644 index 00000000..9e946b15 --- /dev/null +++ b/Avneesh.ipynb @@ -0,0 +1,1018 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "05f09b7a-bc43-4f5e-880a-e3237d284fd6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n", + "2 3 5 7 8 " + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "#corey's stuff\n", + "\n", + " \n", + "# Recursive Function to find the\n", + "# Maximal Independent Vertex Set \n", + "def graphSets(graph):\n", + " \n", + " # Base Case - Given Graph\n", + " # has no nodes\n", + " if(len(graph) == 0):\n", + " return []\n", + " \n", + " # Base Case - Given Graph\n", + " # has 1 node\n", + " if(len(graph) == 1):\n", + " return [list(graph.keys())[0]]\n", + " \n", + " # Select a vertex from the graph\n", + " vCurrent = list(graph.keys())[0]\n", + " \n", + " # Case 1 - Proceed removing\n", + " # the selected vertex\n", + " # from the Maximal Set\n", + " graph2 = dict(graph)\n", + " \n", + " # Delete current vertex\n", + " # from the Graph\n", + " del graph2[vCurrent]\n", + " \n", + " # Recursive call - Gets\n", + " # Maximal Set,\n", + " # assuming current Vertex\n", + " # not selected\n", + " res1 = graphSets(graph2)\n", + " \n", + " # Case 2 - Proceed considering\n", + " # the selected vertex as part\n", + " # of the Maximal Set\n", + " \n", + " # Loop through its neighbours\n", + " for v in graph[vCurrent]:\n", + " \n", + " # Delete neighbor from\n", + " # the current subgraph\n", + " if(v in graph2):\n", + " del graph2[v]\n", + " \n", + " # This result set contains VFirst,\n", + " # and the result of recursive\n", + " # call assuming neighbors of vFirst\n", + " # are not selected\n", + " res2 = [vCurrent] + graphSets(graph2)\n", + " \n", + " # Our final result is the one\n", + " # which is bigger, return it\n", + " if(len(res1) > len(res2)):\n", + " return res1\n", + " return res2\n", + " \n", + "# Driver Code\n", + "V = 8\n", + " \n", + "E = [ (1, 2),\n", + " (1, 3),\n", + " (2, 4),\n", + " (5, 6),\n", + " (6, 7),\n", + " (4, 8)]\n", + " \n", + "graph = dict([])\n", + " \n", + "# Constructs Graph as a dictionary\n", + "# of the following format-\n", + " \n", + "# graph[VertexNumber V]\n", + "# = list[Neighbors of Vertex V]\n", + "for i in range(len(E)):\n", + " v1, v2 = E[i]\n", + " \n", + " if(v1 not in graph):\n", + " graph[v1] = []\n", + " if(v2 not in graph):\n", + " graph[v2] = []\n", + " \n", + " graph[v1].append(v2)\n", + " graph[v2].append(v1)\n", + " \n", + "# Recursive call considering\n", + "# all vertices in the maximum\n", + "# independent set\n", + "maximalIndependentSet = graphSets(graph)\n", + " \n", + "# Prints the Result\n", + "for i in maximalIndependentSet:\n", + " print(i, end =\" \")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx\n", + "from scipy.optimize import minimize" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "from braket.devices import LocalSimulator\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]\n", + "test: []\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " points=np.array([[1,2],[1,3],[0,1]])\n", + " \n", + " points=[]\n", + " for x in range (0,3):\n", + " for y in range (0,3):\n", + " points.append([x,y])\n", + " \n", + " print(points)\n", + " points=np.array(points)\n", + " print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(5,6,0.8,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7725e2d3-0205-4bae-ab8f-057376d73431", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.timings.time_series import TimeSeries\n", + "from braket.ahs.driving_field import DrivingField" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "n_flux = 100 # Number of alternations of problem and mixer hamiltonian for QAOA\n", + "max_time = float(capabilities.rydberg.dict()['rydbergGlobal']['timeMax'])\n", + "time_points = [i*max_time/(n_flux*4) for i in range(4*n_flux+1)]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 15e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_pattern = n_flux*[1,1,0,0] + [0]\n", + "detuning_pattern = n_flux*[-1,0,1,0] + [1]\n", + "phase_pattern = n_flux*[0,0,0,0] + [0]\n", + "\n", + "amplitude_values = [amplitude_max*elem for elem in amplitude_pattern] # piecewise linear\n", + "detuning_values = [Delta_final*elem for elem in detuning_pattern] # piecewise linear\n", + "phase_values = [2*np.pi*elem for elem in phase_pattern] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90b0a55f-e7a5-41ed-8e5d-a235fd1021cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5175c9c6-1482-4581-8438-5e031e4254b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "max_time = float(capabilities.rydberg.dict()['rydbergGlobal']['timeMax'])\n", + "time_res = float(capabilities.rydberg.dict()['rydbergGlobal']['timeResolution'])\n", + "\n", + "max_rabi = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyRange'][1])\n", + "rabi_res = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyResolution'])\n", + "\n", + "max_detuning = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningRange'][1])\n", + "detuning_res = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningResolution'])\n", + "\n", + "max_slew_rate = min(\n", + " float(capabilities.rydberg.dict()['rydbergGlobal']['detuningSlewRateMax']),\n", + " float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencySlewRateMax'])\n", + ")\n", + "ramp_time = max_rabi/max_slew_rate # run = slope/rise. This is greater than time res\n", + "\n", + "p = 3\n", + "time_without_ramps = max_time - 2*ramp_time*p\n", + "init_params = [(max_time - time_without_ramps)/6 for i in range(2*p)] # default params [mixer, cost]\n", + "\n", + "def get_ham_values(params):\n", + " max_rabi = 15800000.0\n", + " max_detuning = 125000000.0\n", + " \n", + " p = int(len(params)/2)\n", + " time_points = [0]\n", + " amplitude_values = [0]\n", + " detuning_values = [max_detuning]\n", + " phase_values = [0]\n", + " time_count = 0\n", + " \n", + " for i in range(0,p,2):\n", + " time_points.extend([\n", + " time_count+ramp_time, time_count+ramp_time + params[i], \n", + " time_count+ramp_time+params[i] + ramp_time, time_count+ramp_time+params[i] + ramp_time + params[i+1]\n", + " ])\n", + "\n", + " time_count = time_points[-1]\n", + "\n", + " amplitude_values.extend([max_rabi, max_rabi, 0, 0])\n", + " detuning_values.extend([0, 0, max_detuning, max_detuning])\n", + " phase_values.extend([np.pi, 0, -1*np.pi, 0])\n", + " \n", + " return time_points, amplitude_values, detuning_values, phase_values\n", + " \n", + "time_points, amplitude_values, detuning_values, phase_values = get_ham_values(init_params)\n", + " \n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "device = LocalSimulator(\"braket_ahs\")\n", + "small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + "\n", + "\n", + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io) \n", + "\n", + " \n", + "# Results are loaded and saved to file\n", + "result = small_ahs_run.result()\n", + "save_result_json(\"classical_results/small_kings_graph_mis_trial_1.json\",result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b55aa0ab-d318-41fa-9b58-182ecc18953e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trial_file = \"classical_results/small_kings_graph_mis_trial_1.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json, print_extra = True):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " if print_extra:\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " print(avg_no_pp)\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_pp)\n", + " \n", + " if print_extra:\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "c82602ba-5305-43a7-be0e-e3d9f0d5d5dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 0.6980\n", + "Average post-processed IS size: 1.3864\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(trial_file)\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()\n", + " \n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "09a1dad6-1be4-4a56-9c2c-2731877f72d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average post-processed IS size: 1.4164\n", + "Average post-processed IS size: 2.0728\n", + "Average post-processed IS size: 1.7487\n", + "Average post-processed IS size: 2.1246\n", + "Average post-processed IS size: 1.9753\n", + "Average post-processed IS size: 2.0967\n", + "Average post-processed IS size: 2.1754\n", + "Average post-processed IS size: 2.2409\n", + "Average post-processed IS size: 1.9744\n", + "Average post-processed IS size: 2.0400\n", + "Average post-processed IS size: 1.9638\n", + "Average post-processed IS size: 1.9245\n", + "Average post-processed IS size: 1.8450\n", + "Average post-processed IS size: 2.0691\n", + "Average post-processed IS size: 1.8436\n", + "Average post-processed IS size: 2.4108\n", + "Average post-processed IS size: 1.9869\n", + "Average post-processed IS size: 2.2561\n", + "Average post-processed IS size: 1.9410\n", + "Average post-processed IS size: 2.3554\n", + "Average post-processed IS size: 2.3822\n", + "Average post-processed IS size: 2.2696\n", + "Average post-processed IS size: 2.3595\n", + "Average post-processed IS size: 2.6501\n", + "Average post-processed IS size: 2.1633\n", + "Average post-processed IS size: 2.2307\n", + "Average post-processed IS size: 2.5400\n", + "Average post-processed IS size: 2.0151\n", + "Average post-processed IS size: 2.5040\n", + "Average post-processed IS size: 2.3367\n", + "Average post-processed IS size: 2.2062\n", + "Average post-processed IS size: 2.0654\n", + "Average post-processed IS size: 2.7554\n", + "Average post-processed IS size: 2.5531\n", + "Average post-processed IS size: 2.6366\n", + "Average post-processed IS size: 2.7020\n", + "Average post-processed IS size: 2.3626\n", + "Average post-processed IS size: 2.7045\n", + "Average post-processed IS size: 2.3313\n", + "Average post-processed IS size: 2.6498\n", + "Average post-processed IS size: 2.7521\n", + "Average post-processed IS size: 2.7160\n", + "Average post-processed IS size: 2.7065\n", + "Average post-processed IS size: 2.5968\n", + "Average post-processed IS size: 2.7270\n", + "Average post-processed IS size: 2.7371\n", + "Average post-processed IS size: 2.7400\n", + "Average post-processed IS size: 2.7029\n", + "Average post-processed IS size: 2.6616\n", + "Average post-processed IS size: 2.6717\n", + "Average post-processed IS size: 2.7013\n", + "Average post-processed IS size: 2.7161\n", + "Average post-processed IS size: 2.6896\n", + "Average post-processed IS size: 2.6302\n", + "Average post-processed IS size: 2.6613\n", + "Average post-processed IS size: 2.6760\n", + "Average post-processed IS size: 2.6917\n", + "Average post-processed IS size: 2.7545\n", + "Average post-processed IS size: 2.7004\n", + "Average post-processed IS size: 2.7318\n", + "Average post-processed IS size: 2.6127\n", + "Average post-processed IS size: 2.6594\n", + "Average post-processed IS size: 2.7758\n", + "Average post-processed IS size: 2.6892\n", + "Average post-processed IS size: 2.7067\n", + "Average post-processed IS size: 2.6688\n" + ] + } + ], + "source": [ + "def objective(params):\n", + " scaled_params = [elem*10**(-6) for elem in params]\n", + " time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_params)\n", + " # Define the drive\n", + " drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + " #show_global_drive(drive);\n", + " \n", + " small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + " )\n", + " \n", + " # Define Device\n", + " device = LocalSimulator(\"braket_ahs\")\n", + " small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + " \n", + " # Run\n", + " result = small_ahs_run.result()\n", + " \n", + " # Store results in json string\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " #json.dumps(result_dict,io,indent=2) # dumps instead of dump to avoid saving file\n", + " \n", + " IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_dict, print_extra=False)\n", + " return -1*IS_sizes.mean() # Multiply by -1 since we want to minimze rather than maximize\n", + "\n", + "def enforce_time_bound(x):\n", + " return 0.000004*(10**6) - (sum(x) + (15800000.0*(10**6)/250000000000000.0)*(len(x)))\n", + "\n", + "def enforce_positive_params(x):\n", + " for elem in x:\n", + " if elem < 0:\n", + " return -1 # penalty for negative parameter\n", + " \n", + " return 1\n", + "\n", + "cons = (\n", + " {\n", + " 'type': 'ineq', \n", + " 'fun': enforce_time_bound # sum of times must be less than max time\n", + " },\n", + " {\n", + " 'type': 'ineq',\n", + " 'fun': enforce_positive_params\n", + " }\n", + ")\n", + "\n", + "init_params = [elem*10**6 for elem in init_params]\n", + "optimized_params = minimize(objective, init_params, method='COBYLA', constraints = cons)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f2894719-8561-4234-b36d-d832eee77824", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " fun: -2.668831168831169\n", + " maxcv: 1.0\n", + " message: 'Did not converge to a solution satisfying the constraints. See `maxcv` for magnitude of violation.'\n", + " nfev: 66\n", + " status: 4\n", + " success: False\n", + " x: array([ 1.95530549, -0.37557566, 1.16592846, -0.10135442, 0.06870458,\n", + " 1.21442959])\n", + "1.0\n" + ] + } + ], + "source": [ + "print(optimized_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "60b24395-8e6e-4a81-ad9e-aff932a1a5df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scaled_optimal_params = [elem*(10**-6) for elem in optimized_params['x']]\n", + "time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_optimal_params)\n", + "\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);\n", + "\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")\n", + "\n", + "device = LocalSimulator(\"braket_ahs\")\n", + "small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + "\n", + "trial_file = \"classical_results/small_kings_graph_mis_trial_1.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10b3ce43-c4c6-4a00-88e5-32a995895bb0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "764501b9-fae8-486c-9e1a-7af44d4f208f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Corey.ipynb b/Corey.ipynb new file mode 100644 index 00000000..18e14281 --- /dev/null +++ b/Corey.ipynb @@ -0,0 +1,1459 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n", + "GRAPH: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11), (11, 12), (12, 13), (13, 14), (14, 15), (15, 16), (16, 17), (17, 18), (18, 19), (19, 20), (20, 21), (21, 22), (22, 23), (23, 24), (24, 25), (25, 26), (26, 27), (27, 28), (28, 29), (29, 30), (30, 31), (31, 32), (32, 33), (33, 34), (34, 35), (35, 36), (36, 37), (37, 38), (38, 39), (39, 40), (40, 41), (41, 42), (42, 43), (43, 44), (44, 45), (45, 46), (46, 47), (47, 48), (48, 49), (49, 50), (50, 51), (51, 52), (52, 53), (53, 54), (54, 55), (55, 56), (56, 57), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (62, 63), (63, 64), (64, 65), (65, 66), (66, 67), (67, 68), (68, 69), (69, 70), (70, 71), (71, 72), (72, 73), (73, 74), (74, 75), (75, 76), (76, 77), (77, 78), (78, 79), (79, 80), (80, 81), (81, 82), (82, 83), (83, 84), (84, 85), (85, 86), (86, 87), (87, 88), (88, 89), (89, 90), (90, 91), (91, 92), (92, 93), (93, 94), (94, 95), (95, 96), (96, 97), (97, 98), (98, 99)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + " points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + " points.append([1,0])\n", + " points.append([2,0])\n", + " points.append([3,0])\n", + " points.append([4,0])\n", + " points.append([5,0])\n", + " points.append([6,0])\n", + " points.append([7,0])\n", + " points.append([8,0])\n", + " points.append([9,0])\n", + " points.append([10,0])\n", + " points.append([11,0])\n", + " points.append([12,0])\n", + " points.append([13,1])\n", + " points.append([12,2])\n", + " points.append([11,2])\n", + " points.append([10,2])\n", + " points.append([9,2])\n", + " points.append([8,2])\n", + " points.append([7,2])\n", + " points.append([6,2])\n", + " points.append([5,2])\n", + " points.append([4,2])\n", + " points.append([3,2])\n", + " points.append([2,2])\n", + " points.append([1,2])\n", + " points.append([0,3])\n", + " points.append([1,4])\n", + " ##\n", + " points.append([2,4])\n", + " points.append([3,4])\n", + " points.append([4,4])\n", + " points.append([5,4])\n", + " points.append([6,4])\n", + " points.append([7,4])\n", + " points.append([8,4])\n", + " points.append([9,4])\n", + " points.append([10,4])\n", + " points.append([11,4])\n", + " points.append([12,4])\n", + " points.append([13,5])\n", + " points.append([12,6])\n", + " points.append([11,6])\n", + " points.append([10,6])\n", + " points.append([9,6])\n", + " points.append([8,6])\n", + " points.append([7,6])\n", + " points.append([6,6])\n", + " points.append([5,6])\n", + " points.append([4,6])\n", + " points.append([3,6])\n", + " points.append([2,6])\n", + " points.append([1,6])\n", + " points.append([0,7])\n", + " points.append([1,8])\n", + " ##\n", + " points.append([2,8])\n", + " points.append([3,8])\n", + " points.append([4,8])\n", + " points.append([5,8])\n", + " points.append([6,8])\n", + " points.append([7,8])\n", + " points.append([8,8])\n", + " points.append([9,8])\n", + " points.append([10,8])\n", + " points.append([11,8])\n", + " points.append([12,8])\n", + " points.append([13,9])\n", + " points.append([12,10])\n", + " points.append([11,10])\n", + " points.append([10,10])\n", + " points.append([9,10])\n", + " points.append([8,10])\n", + " points.append([7,10])\n", + " points.append([6,10])\n", + " points.append([5,10])\n", + " points.append([4,10])\n", + " points.append([3,10])\n", + " points.append([2,10])\n", + " points.append([1,10])\n", + " points.append([0,11])\n", + " points.append([1,12])\n", + " ##\n", + " points.append([2,12])\n", + " points.append([3,12])\n", + " points.append([4,12])\n", + " points.append([5,12])\n", + " points.append([6,12])\n", + " points.append([7,12])\n", + " points.append([8,12])\n", + " points.append([9,12])\n", + " points.append([10,12])\n", + " points.append([11,12])\n", + " points.append([12,12])\n", + " points.append([13,13])\n", + " points.append([12,14])\n", + " points.append([11,14])\n", + " points.append([10,14])\n", + " points.append([9,14])\n", + " points.append([8,14])\n", + " points.append([7,14])\n", + " points.append([6,14])\n", + " points.append([5,14])\n", + " points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " #\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "#from braket.devices import LocalSimulator\n", + "#device = LocalSimulator(\"braket_ahs\")\n", + "#small_ahs_run = device.run(small_ahs_program, shots=50)\n", + "\n", + "\n", + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io) \n", + "\n", + " \n", + "# Results are loaded and saved to file\n", + "#result = small_ahs_run.result()\n", + "#save_result_json(\"classical_results/small_kings_graph_mis_trial_5.json\",result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "b55aa0ab-d318-41fa-9b58-182ecc18953e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "trial_file = \"classical_results/small_kings_graph_mis_trial_5.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 323, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "c82602ba-5305-43a7-be0e-e3d9f0d5d5dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "{'pre_sequence': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'post_sequence': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + "Average pre-processed size: 5.1400\n", + "Average post-processed IS size: 5.1400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(trial_file)\n", + "\n", + "for result in result_json[\"measurements\"]:\n", + " print(result)\n", + "\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()\n", + " \n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 325, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'G' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[325], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m color_lookup \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m0\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m1\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m'\u001b[39m}\n\u001b[1;32m 10\u001b[0m seqs_color \u001b[38;5;241m=\u001b[39m [color_lookup[seqs[i][j]] \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(seqs[i]))]\n\u001b[0;32m---> 11\u001b[0m visualize_graph(ax,\u001b[43mG\u001b[49m,pos,node_colors \u001b[38;5;241m=\u001b[39m seqs_color)\n\u001b[1;32m 12\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mNameError\u001b[0m: name 'G' is not defined" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,G,pos,node_colors = seqs_color)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T06:51:59.331Z', endedAt='2023-01-29T06:52:48.394Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0,\n", + " 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]))])" + ] + }, + "execution_count": 326, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 327, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 28.5714\n", + "Average post-processed IS size: 27.0667\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 00000000..3eabb18a --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,51 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8433327c-1616-401e-b336-589ee70dc4fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hello world\n" + ] + } + ], + "source": [ + "print(\"hello world\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eba751f3-83a6-4d7c-8196-3b076e2fa60e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/iquhack_utils.py b/iquhack_utils.py new file mode 100644 index 00000000..dab95775 --- /dev/null +++ b/iquhack_utils.py @@ -0,0 +1,258 @@ +import matplotlib.pyplot as plt +import matplotlib.gridspec as gridspec +from matplotlib.axes import Axes +import numpy as np +from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation +from braket.ahs.atom_arrangement import AtomArrangement,SiteType +import warnings +import networkx as nx + +C6 = 5.42E-24 + +def is_IS(graph,node_types): + inds = np.argwhere(np.array(node_types)==0).ravel() + subgraph = nx.subgraph(graph,inds) + print(subgraph) + return subgraph.number_of_edges() == 0 + + +def find_UDG_radius(positions, graph): + '''Computes the optimal unit disk radius for a particular set of positions and graph. + + Args + position (dict): dictionary containing the coordinates of the nodes in the plane. + graph (networkx.Graph): network connectivity graph. This should be a unit disk graph. + + Return + tuple: elements include: + radius (float): Optimal unit disk radius of the graph + rmin (float): Minimum distance + rmax (float): Maximum distance + ''' + + rmin = 0 + rmax = np.inf + for n,r_1 in positions.items(): + for m,r_2 in positions.items(): + if n==m: continue + dist = np.linalg.norm(np.array(r_1)-np.array(r_2)) + + if (n,m) in graph.edges: + dist = np.linalg.norm(np.array(r_1)-np.array(r_2)) + if rmindist: + rmax = dist + + if rmin>rmax: + raise BaseException("rmin > rmax, Graph is not a unit disk graph!") + + return np.sqrt(rmin*rmax),rmin,rmax + + +def visualize_graph(ax,graph,pos_dict,node_colors = "#6437FF"): + """Visualize graph using networkx + + Args: + ax (matplotlib.axes.Axes): Axes object to plot graph on. + graph (networkx.Graph): Graph to be plotted + pos_dict (dict): dictionary containing the x,y coordiantes where the nodes are the keys. + node_colors (str or list, optional): Defaults to "#6437FF". The color(s) to color the nodes of the graph. + + """ + + ax.set_aspect('equal') + ax.axis('off') + + # pos_dict = {a:positions[a] for a in range(positions.shape[0])} + nx.draw_networkx_edges(graph,pos_dict,width=10/np.sqrt(len(graph.nodes)),ax=ax) + nx.draw_networkx_nodes(graph,pos_dict,node_size=1225/np.sqrt(len(graph.nodes)),node_color=node_colors,ax=ax) + + +def get_graph_from_blockade_radius(register : AtomArrangement, blockade_radius:float): + """Get graph based on blockade radius. + + Args: + register (braket.ahs.atom_arrangement.AtomArrangement): register for analog quantum simulation. + blockade_radius (float): the blockade radius calculated using (C_6/final_detuning)^(1/6). + + Returns: + networkx.Graph: The graph of the effective unit disk graph set by the blockade radius. + """ + filled_sites = [site.coordinate for site in register if site.site_type == SiteType.FILLED] + graph = nx.Graph() + + positions = {n:c for n,c in enumerate(filled_sites)} + + graph.add_nodes_from(positions.keys()) + + for n,r_1 in positions.items(): + for m,r_2 in positions.items(): + if n <= m: continue + dist = np.linalg.norm(np.array(r_1)-np.array(r_2)) + if dist < blockade_radius: + graph.add_edge(n,m) + + return graph,positions + + +def get_blockade_radius(detuning: float, rabi: float) -> float: + """calculate Blockade Radius given the detuning and rabi amplitude. + + Args: + detuning (float): detuning value. + ravi (float): rabi value + Returns: + float: blockade radius + """ + + demon = np.sqrt(detuning**2+rabi**2) + if demon > 0: + return (C6/demon)**(1/6) + else: + return np.inf + + + +def plot_task_results( + ahs_program : AnalogHamiltonianSimulation, + n_shots : int, + pre_processed_shot : list[int], + post_processed_shot : list[int], +): + """function to generate figure summarizing iQuHack task results. + + Args: + ahs_program (AnalogHamiltonianSimulation): Braket AHS program used to generate shots + n_shots (int): number of shots for Task + pre_processed_shot (list[int]): The list showing the independent set before post processing, + post_processed_shot (list[int]): The list showing the independent set after post processing + """ + + fig = plt.figure(tight_layout=True,figsize=(9,6)) + gs = gridspec.GridSpec(6, 3) + + graph_axs = [ + fig.add_subplot(gs[0:3, 2]), + fig.add_subplot(gs[3:6, 2]) + ] + + drive_axs = [ + fig.add_subplot(gs[0:2, 0:2]), + fig.add_subplot(gs[2:4, 0:2]), + fig.add_subplot(gs[4:6, 0:2]) + ] + + drive_axs[0].sharex(drive_axs[1]) + drive_axs[1].sharex(drive_axs[2]) + + + register = ahs_program.register + drive = ahs_program.hamiltonian + + data = { + 'amplitude [rad/s]': drive.amplitude.time_series, + 'detuning [rad/s]': drive.detuning.time_series, + 'phase [rad]': drive.phase.time_series, + } + + detuning_data = list(data['detuning [rad/s]'].values()) + blockade_radius = get_blockade_radius(detuning_data[-1],0) + + + + graph,positions = get_graph_from_blockade_radius(register,blockade_radius) + + + for ax, data_name in zip(drive_axs, data.keys()): + ax.tick_params('both',direction='in') + ax.tick_params('x',top=True) + ax.tick_params('y',left=True) + + if data_name == 'phase [rad]': + ax.step(data[data_name].times(), data[data_name].values(), '.-', where='post') + else: + ax.plot(data[data_name].times(), data[data_name].values(), '.-') + ax.xaxis.set_ticklabels([]) + + ax.set_ylabel(data_name) + ax.grid(ls=':') + ax.set_xlabel("time (s)") + + color = { + 0:'red', + 1:'black' + } + + pre_processed_shot = [s for s,site in zip(pre_processed_shot,register) if site.site_type == SiteType.FILLED] + post_processed_shot = [s for s,site in zip(post_processed_shot,register) if site.site_type == SiteType.FILLED] + + shots = [ + pre_processed_shot, + post_processed_shot + ] + + titles = [ + "pre-processed", + "post-processed" + ] + + if not is_IS(graph,post_processed_shot): + warnings.warn("'post_processed_shot' is not a valid independent set of the effective graph.") + + + for (ax,shot,title) in zip(graph_axs,shots,titles): + colors = [color[s] for s in shot] + visualize_graph(ax,graph,positions,colors) + ax.title.set_text(title) + + fig.tight_layout() + fig.subplots_adjust(hspace=0.25) + fig.suptitle(f'number of shots: {n_shots}') + return fig,drive_axs,graph_axs + + +def generate_test_program(Nx,Ny,lattice_spacing=6.5e-6): + from quera_ahs_utils.drive import get_drive + + + register = AtomArrangement() + for ix in range(Nx): + for iy in range(Ny): + x = ix * lattice_spacing + y = iy * lattice_spacing + register.add((x,y)) + + + time_points = [0, 2.5e-7, 2.75e-6, 3e-6] + amplitude_min = 0 + amplitude_max = 1.57e7 # rad / s + + detuning_min = -5.5e7 # rad / s + detuning_max = 5.5e7 # rad / s + + amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piece-wise linear + detuning_values = [detuning_min, detuning_min, detuning_max, detuning_max] # piece-wise linear + phase_values = [0, 0, 0, 0] # piece-wise constant + + + drive = get_drive(time_points, amplitude_values, detuning_values, phase_values) + + return AnalogHamiltonianSimulation( + register=register, + hamiltonian=drive + ) + +if __name__ == '__main__': + L = 10 + ahs_program = generate_test_program(L,L,lattice_spacing=4e-6) + pre_processed_shot = list(np.random.randint(2,size=L*L)) + post_processed_shot = list(np.random.randint(2,size=L*L)) + + fig,drive_axs,graph_axs = plot_task_results( + ahs_program,100,pre_processed_shot,post_processed_shot + ) + + plt.show() diff --git a/jade.ipynb b/jade.ipynb new file mode 100644 index 00000000..4e83b98e --- /dev/null +++ b/jade.ipynb @@ -0,0 +1,60 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f742a45b-deec-4907-9e31-f7080b33eba4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# installed environments:\n", + "#\n", + "qsharp /opt/.qbraid/environments/qsharp_b54crn\n", + "default \u001b[0;31mjobs\u001b[0m /opt/.qbraid/environments/qbraid_000000\n", + "amazon_braket \u001b[0;32mjobs\u001b[0m /home/jovyan/.qbraid/environments/aws_braket_kwx6dl\n", + "\n", + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "#jade's file\n", + "import braket\n", + "!qbraid envs list\n", + "!qbraid jobs enable amazon_braket" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bff30723-e0cd-4849-9434-a2b40b3e9979", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/state_prep.md b/state_prep.md index 069bc1a0..4a84b1c9 100644 --- a/state_prep.md +++ b/state_prep.md @@ -4,7 +4,7 @@ The idea behind quantum state preparation is to leverage the limited resources i ## The Basics -We can understand the dynamics of a quantum system beyond the adiabatic theorem through something called adiabatic perturbation theory. The idea for a well-behaved quantum system, the quantum wavefunction, can be expanded as a function of the speed of the Hamiltonian, $v$. We won't go too much into the theory here, but from dimensional analysis, we know that the wavefunction amplitudes and probability are dimensionless. The adiabatic theorem states that if we start in the ground state, the probability of being in an excited state is 0. That implies, to leading order in $v$, the probability amplitudes of the wavefunction for the excited states must be 0. Since the quantum problem is well-behaved, the wavefunction amplitudes must be analytic functions of $v$. As such, we know that the probability of being in an excited state must be: +We can understand the dynamics of a quantum system beyond the adiabatic theorem through something called adiabatic perturbation theory. The idea for a well-behaved quantum system, the quantum wavefunction, can be expanded as a function of the speed of the Hamiltonian, $v$. We won't go too much into the theory here, but from dimensional analysis, we know that the wavefunction amplitudes and probability are dimensionless. The adiabatic theorem states that if we start in the ground state, the probability of being in an excited state is 0. That implies, to leading order in $v$, the probability amplitudes of the wavefunction for the excited states must be 0. Since the quantum problem is well-behaved, the wavefunction amplitudes must be analytic functions of $v$. As such, we know that the prob ability of being in an excited state must be: $p_{excitation} = C v + \cdots$ diff --git a/team_solutions/q/.ipynb_checkpoints/100_qubit_snake-checkpoint.ipynb b/team_solutions/q/.ipynb_checkpoints/100_qubit_snake-checkpoint.ipynb new file mode 100644 index 00000000..2954f5c3 --- /dev/null +++ b/team_solutions/q/.ipynb_checkpoints/100_qubit_snake-checkpoint.ipynb @@ -0,0 +1,1268 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n", + "GRAPH: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11), (11, 12), (12, 13), (13, 14), (14, 15), (15, 16), (16, 17), (17, 18), (18, 19), (19, 20), (20, 21), (21, 22), (22, 23), (23, 24), (24, 25), (25, 26), (26, 27), (27, 28), (28, 29), (29, 30), (30, 31), (31, 32), (32, 33), (33, 34), (34, 35), (35, 36), (36, 37), (37, 38), (38, 39), (39, 40), (40, 41), (41, 42), (42, 43), (43, 44), (44, 45), (45, 46), (46, 47), (47, 48), (48, 49), (49, 50), (50, 51), (51, 52), (52, 53), (53, 54), (54, 55), (55, 56), (56, 57), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (62, 63), (63, 64), (64, 65), (65, 66), (66, 67), (67, 68), (68, 69), (69, 70), (70, 71), (71, 72), (72, 73), (73, 74), (74, 75), (75, 76), (76, 77), (77, 78), (78, 79), (79, 80), (80, 81), (81, 82), (82, 83), (83, 84), (84, 85), (85, 86), (86, 87), (87, 88), (88, 89), (89, 90), (90, 91), (91, 92), (92, 93), (93, 94), (94, 95), (95, 96), (96, 97), (97, 98), (98, 99)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + " points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + " points.append([1,0])\n", + " points.append([2,0])\n", + " points.append([3,0])\n", + " points.append([4,0])\n", + " points.append([5,0])\n", + " points.append([6,0])\n", + " points.append([7,0])\n", + " points.append([8,0])\n", + " points.append([9,0])\n", + " points.append([10,0])\n", + " points.append([11,0])\n", + " points.append([12,0])\n", + " points.append([13,1])\n", + " points.append([12,2])\n", + " points.append([11,2])\n", + " points.append([10,2])\n", + " points.append([9,2])\n", + " points.append([8,2])\n", + " points.append([7,2])\n", + " points.append([6,2])\n", + " points.append([5,2])\n", + " points.append([4,2])\n", + " points.append([3,2])\n", + " points.append([2,2])\n", + " points.append([1,2])\n", + " points.append([0,3])\n", + " points.append([1,4])\n", + " ##\n", + " points.append([2,4])\n", + " points.append([3,4])\n", + " points.append([4,4])\n", + " points.append([5,4])\n", + " points.append([6,4])\n", + " points.append([7,4])\n", + " points.append([8,4])\n", + " points.append([9,4])\n", + " points.append([10,4])\n", + " points.append([11,4])\n", + " points.append([12,4])\n", + " points.append([13,5])\n", + " points.append([12,6])\n", + " points.append([11,6])\n", + " points.append([10,6])\n", + " points.append([9,6])\n", + " points.append([8,6])\n", + " points.append([7,6])\n", + " points.append([6,6])\n", + " points.append([5,6])\n", + " points.append([4,6])\n", + " points.append([3,6])\n", + " points.append([2,6])\n", + " points.append([1,6])\n", + " points.append([0,7])\n", + " points.append([1,8])\n", + " ##\n", + " points.append([2,8])\n", + " points.append([3,8])\n", + " points.append([4,8])\n", + " points.append([5,8])\n", + " points.append([6,8])\n", + " points.append([7,8])\n", + " points.append([8,8])\n", + " points.append([9,8])\n", + " points.append([10,8])\n", + " points.append([11,8])\n", + " points.append([12,8])\n", + " points.append([13,9])\n", + " points.append([12,10])\n", + " points.append([11,10])\n", + " points.append([10,10])\n", + " points.append([9,10])\n", + " points.append([8,10])\n", + " points.append([7,10])\n", + " points.append([6,10])\n", + " points.append([5,10])\n", + " points.append([4,10])\n", + " points.append([3,10])\n", + " points.append([2,10])\n", + " points.append([1,10])\n", + " points.append([0,11])\n", + " points.append([1,12])\n", + " ##\n", + " points.append([2,12])\n", + " points.append([3,12])\n", + " points.append([4,12])\n", + " points.append([5,12])\n", + " points.append([6,12])\n", + " points.append([7,12])\n", + " points.append([8,12])\n", + " points.append([9,12])\n", + " points.append([10,12])\n", + " points.append([11,12])\n", + " points.append([12,12])\n", + " points.append([13,13])\n", + " points.append([12,14])\n", + " points.append([11,14])\n", + " points.append([10,14])\n", + " points.append([9,14])\n", + " points.append([8,14])\n", + " points.append([7,14])\n", + " points.append([6,14])\n", + " points.append([5,14])\n", + " points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " #\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T13:35:26.515Z', endedAt='2023-01-29T13:36:03.638Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0]))])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 34.9571\n", + "Average post-processed IS size: 33.1852\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/team_solutions/q/.ipynb_checkpoints/99_qubits_random-checkpoint.ipynb b/team_solutions/q/.ipynb_checkpoints/99_qubits_random-checkpoint.ipynb new file mode 100644 index 00000000..e0fcd5eb --- /dev/null +++ b/team_solutions/q/.ipynb_checkpoints/99_qubits_random-checkpoint.ipynb @@ -0,0 +1,1311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "99\n", + "GRAPH: [(0, 1), (0, 4), (0, 14), (0, 21), (0, 32), (0, 53), (1, 4), (1, 21), (1, 37), (1, 38), (1, 53), (1, 62), (2, 6), (2, 10), (2, 20), (2, 34), (2, 43), (2, 49), (2, 63), (3, 8), (3, 59), (3, 75), (3, 85), (3, 93), (4, 21), (4, 38), (4, 62), (4, 95), (4, 98), (5, 81), (6, 20), (6, 31), (6, 41), (6, 43), (6, 70), (6, 89), (6, 91), (7, 55), (7, 79), (7, 88), (8, 35), (8, 54), (8, 75), (8, 85), (8, 93), (9, 26), (9, 33), (9, 48), (10, 16), (10, 29), (10, 43), (10, 49), (10, 57), (10, 63), (11, 26), (11, 48), (11, 67), (12, 13), (12, 15), (12, 32), (12, 80), (13, 32), (13, 51), (13, 53), (13, 80), (13, 94), (14, 21), (14, 27), (14, 73), (14, 98), (15, 40), (15, 80), (16, 28), (16, 29), (16, 63), (17, 19), (17, 52), (18, 69), (18, 87), (19, 52), (19, 65), (20, 34), (20, 39), (20, 43), (20, 49), (20, 70), (20, 91), (21, 95), (21, 98), (22, 92), (23, 35), (23, 51), (23, 54), (23, 92), (23, 94), (24, 61), (24, 66), (24, 84), (24, 96), (25, 36), (25, 38), (25, 42), (25, 78), (25, 79), (25, 83), (26, 33), (26, 48), (27, 33), (27, 48), (27, 68), (27, 73), (28, 29), (28, 57), (28, 65), (28, 77), (29, 57), (29, 63), (29, 77), (30, 48), (30, 67), (30, 68), (30, 86), (31, 40), (31, 41), (31, 43), (31, 89), (31, 91), (32, 51), (32, 53), (32, 80), (33, 48), (33, 68), (34, 39), (34, 49), (34, 70), (35, 54), (35, 75), (35, 85), (35, 92), (35, 94), (36, 83), (36, 88), (37, 62), (37, 74), (37, 82), (38, 62), (38, 78), (38, 82), (38, 95), (39, 70), (39, 76), (40, 41), (40, 89), (41, 44), (41, 86), (41, 91), (42, 78), (42, 82), (42, 83), (43, 89), (44, 70), (44, 72), (44, 76), (44, 91), (45, 46), (45, 56), (45, 57), (45, 64), (45, 77), (45, 97), (46, 60), (46, 89), (46, 97), (47, 58), (48, 68), (49, 63), (50, 55), (50, 95), (50, 98), (51, 53), (51, 94), (52, 65), (54, 85), (54, 94), (55, 79), (56, 60), (56, 64), (56, 81), (56, 97), (57, 64), (57, 77), (58, 59), (60, 90), (60, 97), (61, 66), (61, 67), (61, 84), (62, 74), (62, 78), (62, 82), (64, 77), (64, 97), (65, 77), (66, 67), (66, 72), (66, 84), (67, 72), (68, 73), (68, 86), (69, 87), (70, 76), (70, 91), (71, 85), (71, 87), (71, 90), (71, 93), (72, 76), (72, 84), (74, 82), (76, 91), (78, 82), (78, 83), (79, 88), (79, 95), (81, 87), (81, 90), (84, 96), (85, 93), (95, 98)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + "# points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + "# points.append([1,0])\n", + "# points.append([2,0])\n", + "# points.append([3,0])\n", + "# points.append([4,0])\n", + "# points.append([5,0])\n", + "# points.append([6,0])\n", + "# points.append([7,0])\n", + "# points.append([8,0])\n", + "# points.append([9,0])\n", + "# points.append([10,0])\n", + "# points.append([11,0])\n", + "# points.append([12,0])\n", + "# points.append([13,1])\n", + "# points.append([12,2])\n", + "# points.append([11,2])\n", + "# points.append([10,2])\n", + "# points.append([9,2])\n", + "# points.append([8,2])\n", + "# points.append([7,2])\n", + "# points.append([6,2])\n", + "# points.append([5,2])\n", + "# points.append([4,2])\n", + "# points.append([3,2])\n", + "# points.append([2,2])\n", + "# points.append([1,2])\n", + "# points.append([0,3])\n", + "# points.append([1,4])\n", + "# ##\n", + "# points.append([2,4])\n", + "# points.append([3,4])\n", + "# points.append([4,4])\n", + "# points.append([5,4])\n", + "# points.append([6,4])\n", + "# points.append([7,4])\n", + "# points.append([8,4])\n", + "# points.append([9,4])\n", + "# points.append([10,4])\n", + "# points.append([11,4])\n", + "# points.append([12,4])\n", + "# points.append([13,5])\n", + "# points.append([12,6])\n", + "# points.append([11,6])\n", + "# points.append([10,6])\n", + "# points.append([9,6])\n", + "# points.append([8,6])\n", + "# points.append([7,6])\n", + "# points.append([6,6])\n", + "# points.append([5,6])\n", + "# points.append([4,6])\n", + "# points.append([3,6])\n", + "# points.append([2,6])\n", + "# points.append([1,6])\n", + "# points.append([0,7])\n", + "# points.append([1,8])\n", + "# ##\n", + "# points.append([2,8])\n", + "# points.append([3,8])\n", + "# points.append([4,8])\n", + "# points.append([5,8])\n", + "# points.append([6,8])\n", + "# points.append([7,8])\n", + "# points.append([8,8])\n", + "# points.append([9,8])\n", + "# points.append([10,8])\n", + "# points.append([11,8])\n", + "# points.append([12,8])\n", + "# points.append([13,9])\n", + "# points.append([12,10])\n", + "# points.append([11,10])\n", + "# points.append([10,10])\n", + "# points.append([9,10])\n", + "# points.append([8,10])\n", + "# points.append([7,10])\n", + "# points.append([6,10])\n", + "# points.append([5,10])\n", + "# points.append([4,10])\n", + "# points.append([3,10])\n", + "# points.append([2,10])\n", + "# points.append([1,10])\n", + "# points.append([0,11])\n", + "# points.append([1,12])\n", + "# ##\n", + "# points.append([2,12])\n", + "# points.append([3,12])\n", + "# points.append([4,12])\n", + "# points.append([5,12])\n", + "# points.append([6,12])\n", + "# points.append([7,12])\n", + "# points.append([8,12])\n", + "# points.append([9,12])\n", + "# points.append([10,12])\n", + "# points.append([11,12])\n", + "# points.append([12,12])\n", + "# points.append([13,13])\n", + "# points.append([12,14])\n", + "# points.append([11,14])\n", + "# points.append([10,14])\n", + "# points.append([9,14])\n", + "# points.append([8,14])\n", + "# points.append([7,14])\n", + "# points.append([6,14])\n", + "# points.append([5,14])\n", + "# points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " ##\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " #points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 316, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 320, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 321, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 322, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "#from braket.devices import LocalSimulator\n", + "#device = LocalSimulator(\"braket_ahs\")\n", + "#small_ahs_run = device.run(small_ahs_program, shots=50)\n", + "\n", + "\n", + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io) \n", + "\n", + " \n", + "# Results are loaded and saved to file\n", + "#result = small_ahs_run.result()\n", + "#save_result_json(\"classical_results/small_kings_graph_mis_trial_5.json\",result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 323, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 325, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'G' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[325], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m color_lookup \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m0\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m1\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m'\u001b[39m}\n\u001b[1;32m 10\u001b[0m seqs_color \u001b[38;5;241m=\u001b[39m [color_lookup[seqs[i][j]] \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(seqs[i]))]\n\u001b[0;32m---> 11\u001b[0m visualize_graph(ax,\u001b[43mG\u001b[49m,pos,node_colors \u001b[38;5;241m=\u001b[39m seqs_color)\n\u001b[1;32m 12\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mNameError\u001b[0m: name 'G' is not defined" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,G,pos,node_colors = seqs_color)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T06:51:59.331Z', endedAt='2023-01-29T06:52:48.394Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0,\n", + " 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]))])" + ] + }, + "execution_count": 326, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 327, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 28.5714\n", + "Average post-processed IS size: 27.0667\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/team_solutions/q/100_qubit_snake.ipynb b/team_solutions/q/100_qubit_snake.ipynb new file mode 100644 index 00000000..2954f5c3 --- /dev/null +++ b/team_solutions/q/100_qubit_snake.ipynb @@ -0,0 +1,1268 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n", + "GRAPH: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11), (11, 12), (12, 13), (13, 14), (14, 15), (15, 16), (16, 17), (17, 18), (18, 19), (19, 20), (20, 21), (21, 22), (22, 23), (23, 24), (24, 25), (25, 26), (26, 27), (27, 28), (28, 29), (29, 30), (30, 31), (31, 32), (32, 33), (33, 34), (34, 35), (35, 36), (36, 37), (37, 38), (38, 39), (39, 40), (40, 41), (41, 42), (42, 43), (43, 44), (44, 45), (45, 46), (46, 47), (47, 48), (48, 49), (49, 50), (50, 51), (51, 52), (52, 53), (53, 54), (54, 55), (55, 56), (56, 57), (57, 58), (58, 59), (59, 60), (60, 61), (61, 62), (62, 63), (63, 64), (64, 65), (65, 66), (66, 67), (67, 68), (68, 69), (69, 70), (70, 71), (71, 72), (72, 73), (73, 74), (74, 75), (75, 76), (76, 77), (77, 78), (78, 79), (79, 80), (80, 81), (81, 82), (82, 83), (83, 84), (84, 85), (85, 86), (86, 87), (87, 88), (88, 89), (89, 90), (90, 91), (91, 92), (92, 93), (93, 94), (94, 95), (95, 96), (96, 97), (97, 98), (98, 99)]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAIuCAYAAAArAqvFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkTUlEQVR4nO3dYWyc92Hf8d9zklmtyeaIwTbAjoG2apClUxrFKjwNWds0WQIM3YuRsJsCI7BhgFC03boOhQ3oXd4JsLF1C9Z2AItigIStaVKyLwZ0TZalaaOVEuZUSIS2caukgWwPLRoqjoOGpql79uI52jqLRz535ol3z//zAfhCykG/vwWS+ubuuYdVXdcBANjVO+oDAACzRRwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAwRBwAAEPEAQAw5PhRHwDerPPncirJcpLFJJtJ1lY3crOU/Vk4g337Je93UVXX9VGfASZy/lweSXI5yWNpngVbSLKdpJ/kWpKV1Y3c6ur+LJzBvv2S97tMHDCXBt8Unk1yMns/A7aT5HaSs9P45nDU+7NwBvv2S97vOtccMK8uZ/Q3hQx+/2SSSx3dn4Uz2Ldf8n6neeaAuTN4ffFGkhMtHr6V5PRhvv541PuzcAb79kveL4FnDphHy2n/udtLstSx/Vk4g337Je93njhgHi2mufCojYXrL1x8pqqq+rA+rr948emj3J+FM9i3P0/7ab5nMAZxwDzaTHNFchvbZx6+8GRd19VhfZx56MJTR7k/C2ewb3+e9tN8z2AM4oB5tJbmrUpt9JOsd2x/Fs5g337J+50nDpg7gwuLrqV5q9J+dpJcPewLkY56fxbOYN/+POzXdT21r8GuEwfMq5U072Ee9c1h9z3OKx3dn4Uz2Lc/s/v9+k7/lTu3qz/6i1/5t1Pa7zRxwFwa3NTkbJIrad6qtPv64/bg11eSPLq6kee7uD8LZ7Bvf5b3e9Wx3//tP/7wx//Pn//Mf6uq6u9M4wxdVtXuc8CcG7zneSmv31d9/Qju635k+7NwBvv2Z3W/qqqPJXkiyY/Vdf2X9+tM804cANBpAmF8fiojAJ1W1/XHqqpKks9VVSUQWhAHAHSeQBiPOACgCAKhPXEAQDEEQjviAICiCISDiQMAiiMQ9icOACiSQBhNHABQLIGwN3EAQNEEwr3EAQDFEwjDxAEARCDcTRwAwIBAaIgDALiLQBAHAHCP0gNBHADAHkoOBHEAACOUGgjiAAD2UWIgiAMAOEBpgSAOAKCFUYFw/lxOJVlOsphkM8na6kZuHt1J37yqruujPgMAzI2qqj6W5In3f89/+efv/rs/9Z+SPJakl2QhyXaSfpJrSVZWN3LryA76JogDABjT337rD/2Hf/L3Pv1zC8dO1lVV7fUs/E6S20nOzmMg9I76AAAwb/7Z6f979oFjD1YjwiBpXrY/meTSfTzWofHMAQCMYXCNwY0kJ1o8fCvJ6Xm7BsEzBwAwnuW0//ezl2RpimeZCnEAAONZTHPxYRsLg8fPFXEAAOPZTPOuhDa2B4+fK+IAAMazlubtim30k6xP8SxTIQ4AYAyrG7lZ1/W1fv/OQYGwk+TqvF2MmIgDABhLVVXV+o0zX321/61+Xdc7Ix62e5+Dlft4tEMjDgCgpaq5f/LHN//6Sz/w/771u++tqupKmrcr7l6DsD349ZUkj65u5PkjOuqb4j4HANDCbhikuV3yR+q6fil57b4HS3n9Zyusz+NLCXcTBwBwgFFh0FVeVgCAfZQWBok4AICRSgyDRBwAwJ5KDYNEHADAPUoOg0QcAMCQ0sMgEQcA8Bph0BAHABBhcDdxAEDxhMEwcQBA0YTBvcQBAMUSBnsTBwAUSRiMJg4AKI4w2J84AKAowuBg4gCAYgiDdsQBAEUQBu2JAwA6TxiMRxwA0GnCYHziAIDOEgaTEQcAdJIwmNzxoz5AF5w/l1NJlpMsJtlMsra6kZv27ZdyBvv2Z23/V69WX40wmFhV1/VRn2FunT+XR5JcTvPJ10uykGQ7ST/JtSQrqxu5Zd9+V89g3/4s7td13X9p6yubv/OVf/qXL79y8wPCYHziYEKDT8pnk5zM3s/A7CS5neTsNL447Je9PwtnsG9/lvf7/Z26qnqbVdV737QjvYtcczC5yxn9RZHB759Mcsm+/Y6ewb79md3v9Y5XVdV7cIr7neaZgwkMXt+6keREi4dvJTl9mK+/2S97fxbOYN9+yfsl8MzBZJbT/u+ul2TJvv2OncG+/ZL3O08cTGYxzYUvbSxcf+HiM1VV1Yf1cf3Fi0/bL3d/Fs5g3/487af5ns0YxMFkNtNckdvG9pmHLzxZ13V1WB9nHrrwlP1y92fhDPbtz9N+mu/ZjEEcTGatrut+y8f2k6wf9v7gz7Vf5v4snMG+/ZL3O08cTOBXr1ZffWnruW/0+zsHXc25k+TqYV8IM/jzrg3+fPuF7c/CGezbL3m/BOJgTFVVVUl+8Xe+8uPfqKreZkZ/cu6+x3dlSkdZGfz59svcn4Uz2Ldf8n6niYMx7IZBkve//MrNH62q3vuSXEnzVpnd17+2B7++kuTR1Y08P42zDG7qcdZ+mfuzcAb79kve77qqdp+DVu4OgyQfruv6m7v/2+A9t0t5/b7e60dwX3H7he7Pwhns2y95v4vEQQv7hQEAdI2XFQ4gDAAojTjYhzAAoETiYARhAECpxMEehAEAJRMHbyAMACidOLiLMAAAcfAaYQAADXEQYQAAdys+DoQBAAwrOg6EAQDcq9g4EAYAsLci40AYAMBoxcWBMACA/RUVB8IAAA5WTBwIAwBop4g4EAYA0F7n40AYAMB4Oh0HwgAAxnf8qA9wGM6fy6kky0kWk2wmWfvVq9VXIwwAYGxVXddHfYaJnT+XR5JcTvJYmmdBFpJs13Xdf2nruW/8zld+/Bsvv3LzR4UBALQ3t3EwCINnk5zMHs+A9Ps7dVX1Nquq977Vjdy67wcEgDk1z9ccXM6IMEiSXu94VVW9B5Ncuq+nAoA5N5fPHAyuMbiR5ESLh28lOb26kZvTPRUAdMO8PnOwnPZn7yVZmuJZAKBT5jUOFtNcfNjGwuDxAEAL8xoHm0m2Wz52e/B4AKCFeY2DtST9lo/tJ1mf4lkAoFPmMg4GFxdeS7Kz3+P69Z1+XddXXYwIAO3NZRwMrCS5nRGBUNf1zqt3vtVf+/J7bw5uowwAtDC3cTC4sdHZJFfSvF1x9xqE7SRbVVVdeeGlT7/39ne+/J4k/1EgAEA7c3mfgzca3PdgKa//bIX13ZcSqqp6W5JPJ/mDJD9fd+E/GACmqBNxcBCBAADtze3LCuMY/OCljyT5h/ESAwDsq4g4SAQCALRVTBwkAgEA2igqDhKBAAAHKS4OEoEAAPspMg4SgQAAoxQbB4lAAIC9FB0HiUAAgDcqPg4SgQAAdxMHAwIBABri4C4CAQDEwT0EAgClEwd7EAgAlEwcjCAQACiVONiHQACgROLgAAIBgNKIgxYEAgAlEQctCQQASlHVdX3UZ5grVVW9Lcmnk/xBkp+v67o+fy6nkiwnWUyymWRtdSM379eZ7Je9PwtnsG+/5P0uEgcT2A2Exe/+wS8vnb7+/VVVPZbmWZiFJNtJ+kmuJVlZ3citaZ3j/Lk8kuRyEvsF7s/CGezbL3m/y8TBhP7xOz/19x968EPXHzj2t3q96theL8/sJLmd5Ow0PjkHXxTPJjmZ5Lj9svZn4Qz27Ze833WuOZjQ97798V9eOPa2jAiDpPlkPZnk0pSOcDmjvyjsd39/Fs5g337J+53mmYMJDF7fupHkRIuHbyU5fZivf9kve38WzmDffsn7JfDMwWSW0/7vrpdkyb79jp3Bvv2S9ztPHExmMc2FL20sXH/h4jNVVdWH9XH9xYtP2y93fxbOYN/+PO2n+Z7NGMTBZDbTXBHbxvaZhy88Wdd1dVgfZx668JT9cvdn4Qz27c/Tfprv2YxBHExmLc1bZdroJ1m3b79jZ7Bvv+T9zhMHExhc2HItzVtl9rOT5OphXwhjv+z9WTiDffvzsN+v7/Trup7K12DXiYPJraR5D+2oT87d99iu2Lff0TPYtz+z+3Vd77x656X++pfPPFdVbnc/LnEwocFNNc4muZLmrTK7r39tD359Jcmjqxt53r79Lp7Bvv1Z3q+q6sqtb/7PM5vf+dKjSf69QBhPVbvPwZs2eM/tUl6/r/f6EdxX3H6h+7NwBvv2Z3W/qqqTST6T5PeS/ELtH71WxAEAnSYQxudlBQA6ra7r20k+nORH4iWGVsQBAJ0nEMYjDgAogkBoTxwAUAyB0I44AKAoAuFg4gCA4giE/YkDAIokEEYTBwAUSyDsTRwAUDSBcC9xAEDxBMIwcQAAEQh3EwcAMCAQGuIAAO4iEMQBANyj9EAQBwCwh5IDQRwAwAilBoI4AIB9lBgI4gAADlBaIFR1XR/1GQBgLlRVdTLJZ5L8XpJfqOu6Pn8up5IsJ1lMsplkbXUjN4/wmG+aOACAMewGwuJ3v/eLS6f/8F1VVT2W5pn4hSTbSfpJriVZWd3IrSM86sTEAQCM6YPv/PXT73jwI3/4wLEHe73q2F4v0e8kuZ3k7DwGgmsOAGBMp97+k7+0cOxkRoRBkhxPcjLJpft4rEPjmQMAGMPgGoMbSU60ePhWktPzdg2CZw4AYDzLaf/vZy/J0hTPMhXiAADGs5jm4sM2FgaPnyviAADGs5nmXQltbA8eP1fEAQCMZy3N2xXb6CdZn+JZpkIcAMAYVjdyc+vVv3qu33/1oIfuJLk6bxcjJuIAAMZSVdUHf+vGD72jTv1SmgDYy+59Dlbu38kOjzgAgJaqqvpgkk98e/vry8d6C+9JciXN2xV3r0HYHvz6SpJHVzfy/NGc9M1xnwMAaGE3DJI8Xtf153d/f3Dfg6W8/rMV1ufxpYS7iQMAOMCoMOgqLysAwD5KC4NEHADASCWGQSIOAGBPpYZBIg4A4B4lh0EiDgBgSOlhkIgDAHiNMGiIAwCIMLibOACgeMJgmDgAoGjC4F7iAIBiCYO9iQMAiiQMRhMHABRHGOxPHABQFGFwMHEAQDGEQTviAIAiCIP2xAEAnScMxiMOAOg0YTA+cQBAZwmDyRw/6gN0wflzOZVkOcliks0ka6sbuWnffilnsG9/FveFweSquq6P+gxz6/y5PJLkcpLH0jwLs5BkO0k/ybUkK6sbuWXfflfPYN/+rO5vvfpXz/3WjR96x7e3v74sDMYnDiY0+KR8NsnJ7P0MzE6S20nOTuOLw37Z+7NwBvv2Z3m/3381deqXjvUW3jPtSO8i1xxM7nJGf1Fk8Psnk1yyb7+jZ7Bvf2b3e70Hcqy38JYp7neaZw4mMHh960aSEy0evpXk9GG+/ma/7P1ZOIN9+yXvl8AzB5NZTvu/u16SJfv2O3YG+/ZL3u88cTCZxTQXvrSxcP2Fi89UVVUf1sf1Fy8+bb/c/Vk4g33787Sf5ns2YxAHk9lMc0VsG9tnHr7wZF3X1WF9nHnowlP2y92fhTPYtz9P+2m+ZzMGcTCZtTRv1Wmjn2Tdvv2OncG+/ZL3O08cTGB1Ize3Xv3Gc/3+qwc9dCfJ1cO+EGbw510b/Pn2C9ufhTPYt1/yfgnEwQSqqvrAb904+4469UsZ/cm5+x7flSkdY2Xw59svc38WzmDffsn7nSYOxlRV1QeSfPLb219//Fhv4T1JrqR5q8zu61/bg19fSfLo6kaen8Y5Bjf1OGu/zP1ZOIN9+yXvd11Vu89Ba7thkOQn6rr+3O7vD95zu5TX7+u9fgT3Fbdf6P4snMG+/ZL3u0gctDQqDACga7ys0IIwAKAk4uAAwgCA0oiDfQgDAEokDkYQBgCUShzsQRgAUDJx8AbCAIDSiYO7CAMAEAevEQYA0BAHEQYAcLfi40AYAMCwouNAGADAvYqNA2EAAHsrMg6EAQCMVlwcCAMA2F9RcSAMAOBgxcSBMACAdoqIA2EAAO11Pg6EAQCM5/hRH+AwnD+XU0mWkywm2UyytrqRm8IAAMZX1XV91GeY2PlzeSTJ5SSPpXkWZCHJdpL+1qvfeO63bpx9x7e3v/64MACA9uY2DgZh8GySk9njGZB+/9XUqV861lt4z+pGbt33AwLAnJrnaw4uZ0QYJEmv90CO9RbekuTSfT0VAMy5uXzmYHCNwY0kJ1o8fCvJ6dWN3JzuqQCgG+b1mYPltD97L8nSFM8CAJ0yr3GwmObiwzYWBo8HAFqY1zjYTPOuhDa2B48HAFqY1zhYS9Jv+dh+kvUpngUAOmUu42BwceG1JDv7Pa6u+3eSXHUxIgC0N5dxMLCS5HZGBEJd9++8srPZ+1/PPf5L9/dYADDf5jYOBjc2OpvkSpq3K+5eg7CdZKuqel/4wp//9Ef//PZv/nJVVT92VOcEgHkzl/c5eKPBfQ+W8vrPVljffSnBz1cAgPF0Ig4OIhAAoL25fVlhHHVd/26SJ5L8hpcYAGB/RcRBIhAAoK1i4iARCADQRlFxkAgEADhIcXGQCAQA2E+RcZAIBAAYpdg4SAQCAOyl6DhIBAIAvFHxcZAIBAC4mzgYEAgA0BAHdxEIACAO7iEQACidONiDQACgZOJgBIEAQKnEwT4EAgAlEgcHEAgAlEYctCAQACiJOGhJIABQiqqu66M+w1ypquoDST6Z5Cfquv5ckpw/l1NJlpMsJtlMsra6kZv360z2y96fhTPYt1/yfheJgwnsBsL3Lj7xsx9652/8bJLH0jwLs5BkO0k/ybUkK6sbuTWtc5w/l0eSXLZf5v4snMG+/ZL3u0wcTOj73v7RJ97/Pb/0ie86vtivqt6xPR6yk+R2krPT+OQcfFE8m+RkkuP2y9qfhTPYt1/yfte55mBCH3rnJ/71PmGQNJ+sJ5NcmtIRLmf0F4X97u/Pwhns2y95v9M8czCBwetbN5KcaPHwrSSnD/P1L/tl78/CGezbL3m/BJ45mMxy2v/d9ZIs2bffsTPYt1/yfueJg8ksprnwpY2F6y9cfKaqqvqwPq6/ePFp++Xuz8IZ7Nufp/0037MZgziYzGaaK2Lb2D7z8IUn67quDuvjzEMXnrJf7v4snMG+/XnaT/M9mzGIg8mspXmrTBv9JOv27XfsDPbtl7zfeeJgAoMLW66leavMfnaSXD3sC2Hsl70/C2ewb38e9uu6f2ca+yUQB5NbSfMe2lGfnLvvsV2xb7+jZ7Bvf2b367p/55Wdzd5n//SJ/zyl/U4TBxMa3FTjbJIrad4qs/v61/bg11eSPLq6keft2+/iGezbn+X9qup94Qtf+6mf/Nrmp36lqqofncYZuqyq3efgTRu853Ypr9/Xe/0I7ituv9D9WTiDffuzul9V1QeTfCLJ43Vdf/5+nWneiQMAOk0gjM/LCgB0Wl3X/zvJR5N8yksM7YgDADpPIIxHHABQBIHQnjgAoBgCoR1xAEBRBMLBxAEAxREI+xMHABRJIIwmDgAolkDYmzgAoGgC4V7iAIDiCYRh4gAAIhDuJg4AYEAgNMQBANxFIIgDALhH6YEgDgBgDyUHgjgAgBFKDQRxAAD7KDEQxAEAHKC0QKjquj7qMwDAXKiq6oNJPpHk8bquP58k58/lVJLlJItJNpOsrW7k5tGd8s0TBwAwht1A+L7Fj/70B9/56/8myWNpnolfSLKdpJ/kWpKV1Y3cOrqTTk4cAMCYvu/tT3z0/d/zK//9u44v9quqd2yPh+wkuZ3k7DwGgmsOAGBMH3rnJ39mnzBIkuNJTia5dB+PdWg8cwAAYxhcY3AjyYkWD99KcnrerkHwzAEAjGc57f/97CVZmuJZpkIcAMB4FtNcfNjGwuDxc0UcAMB4NtO8K6GN7cHj54o4AIDxrKV5u2Ib/STrUzzLVIgDABjD6kZu3ulvf7Hf3znoiv6dJFfn7WLERBwAwFiqqjr5qS/9wFvv1N/Zqut6Z8TDdu9zsHIfj3ZoxAEAtFRV1ckkn3n5lZuf7VUPvKuqqitp3q64ew3C9uDXV5I8urqR54/oqG+K+xwAQAu7YZDk95L8Qj34B3Rw34OlvP6zFdbn8aWEu4kDADjAqDDoKi8rAMA+SguDRBwAwEglhkEiDgBgT6WGQSIOAOAeJYdBIg4AYEjpYZCIAwB4jTBoiAMAiDC4mzgAoHjCYJg4AKBowuBe4gCAYgmDvYkDAIokDEYTBwAURxjsTxwAUBRhcDBxAEAxhEE74gCAIgiD9sQBAJ0nDMYjDgDoNGEwPnEAQGcJg8kcP+oDdMH5czmVZDnJYpLNJGurG7lp334pZ7Bvfxb3hcHkKn9Xkzt/Lo8kuZzksTTPwiwk2U7ST3ItycrqRm7Zt9/VM9i3P6v7d/rbX/zUl37grS+/cvOzEQZjEwcTGnxSPpvkZPZ+BmYnye0kZ6fxxWG/7P1ZOIN9+7O83+/v1Hfq72z1qgfe9WvXTkw10rvINQeTu5zRXxQZ/P7JJJfs2+/oGezbn9n9Xu94dbz31geO9U5M82uwszxzMIHB61s3kpxo8fCtJKcP8/U3+2Xvz8IZ7Nsveb8EnjmYzHLa/931kizZt9+xM9i3X/J+54mDySymufCljYXrL1x8pqqq+rA+rr948Wn75e7Pwhns25+n/TTfsxmDOJjMZporYtvYPvPwhSfruq4O6+PMQxeesl/u/iycwb79edpP8z2bMYiDyayleatOG/0k6/btd+wM9u2XvN954mACqxu52e+/+sV+f+egqzl3klw97AthBn/etcGfb7+w/Vk4g337Je+XQBxMoKqqt33yS+9+y536O1t1XY/65Nx9j+/KlI6xMvjz7Ze5PwtnsG+/5P1OEwdjqqrqbUk+/fIrNz/fqx54V1VVV9K8VWb39a/twa+vJHl0dSPPT+Mcg5uKnB3s2C9sfxbOYN9+yftdV9Xuc9Dabhgk+YMkP18P/vIG77ldyuv39V4/gvuK2y90fxbOYN9+yftdJA5aGhUGANA1XlZoQRgAUBJxcABhAEBpxME+hAEAJRIHIwgDAEolDvYgDAAomTh4A2EAQOnEwV2EAQCIg9cIAwBoiIMIAwC4W/FxIAwAYFjRcSAMAOBexcaBMACAvRUZB8IAAEYrLg6EAQDsr6g4EAYAcLBi4kAYAEA7RcSBMACA9jofB8IAAMZz/KgPcBjOn8upJMtJFpNsJllb3chNYQAA46vm+d/L8+fySJLLSR5L8yzIQpLtJP1+/9UvfvJL737Ly6/c/HyEAQC0NrdxMAiDZ5OczB7PgPT7O/Wd+jtbveqBd/3atRO37vsBAWBOzfM1B5czIgySpNc7Xh3vvfWBY70Tl+7vsQBgvs3lMweDawxuJDnR4uFbSU6vbuTmdE8FAN0wr88cLKf92XtJlqZ4FgDolHmNg8U0Fx+2sTB4PADQwrzGwWaadyW0sT14PADQwrzGwVqSfsvH9pOsT/EsANApcxkHg4sLryXZ2e9xdV3vJLnqYkQAaG8u42BgJcntjAiEfn2nv33ndr76jU/8zP09FgDMt7l8K+OuwY2QLiX5B3nDHRLrur669uX3/tnt73z5vUk+XNf1N4/upAAwP+Y6DnYN7nuwlNd/tsL64GcrVEl+Mcn7IxAAoJVOxMF+BAIAjGeerzloZfADl/5dkitJPjP4SY0AwAidj4NEIADAOIqIg0QgAEBbxcRBIhAAoI2i4iARCABwkOLiIBEIALCfIuMgEQgAMEqxcZAIBADYS9FxkAgEAHij4uMgEQgAcDdxMCAQAKAhDu4iEABAHNxDIABQOnGwB4EAQMnEwQgCAYBSiYN9CAQASiQODiAQACiNOGhBIABQkqr5d482qqqqkvxikvcn+XBd199MkvPncirJcpLFJJtJ1lY3cvN+nct+2fuzcAb79kve7yJxMKa7A+FD3//Jf/m9b3/8l5M8luZZmIUk20n6Sa4lWVndyK1pneX8uTyS5LL9Mvdn4Qz27Ze832XiYAJVVVWL3/3e1R9/9+f+xcKxt6WqquN7PGwnye0kZ6fxyTn4ong2yckk9gvbn4Uz2Ldf8n7XueZgAnVd10un//CdDxz7W70RYZA0n6wnk1ya0jEuZ/QXhf3u78/CGezbL3m/0zxzMIHB61s3kpxo8fCtJKcP8/Uv+2Xvz8IZ7Nsveb8EnjmYzHLa/931kizZt9+xM9i3X/J+54mDySymufCljYXrL1x8pqqq+rA+rr948Wn75e7Pwhns25+n/TTfsxmDOJjMZporYtvYPvPwhSfruq4O6+PMQxeesl/u/iycwb79edpP8z2bMYiDyayleatMG/0k6/btd+wM9u2XvN954mACgwtbrqV5q8x+dpJcPewLYeyXvT8LZ7Bvfx7267qe2tdg14mDya2keQ/tqE/O3ffYrti339Ez2Lc/s/v9/p3+9p1v5mubv/nTU9rvNHEwocFNNc6m+XkLW3n99a/twa+vJHl0dSPP27ffxTPYtz/L+1XV+/3/8Uc/cumzf/r4f62q6sFpnKHLqtp9Dt60wXtul/L6fb3Xj+C+4vYL3Z+FM9i3P4v7VVVVST6e5vbKH6nr+qX7daZ5Jw4A6CyBMBkvKwDQWXXz/4B/Ls0FjJ/2EkM74gCAThMI4xMHAHSeQBiPOACgCAKhPXEAQDEEQjviAICiCISDiQMAiiMQ9icOACiSQBhNHABQLIGwN3EAQNEEwr3EAQDFEwjDxAEARCDcTRwAwIBAaIgDALiLQBAHAHCP0gNBHADAHkoOBHEAACOUGgjiAAD2UWIgiAMAOEBpgVA1/70AwEGqqqqSfDzJY0k+Utf1S+fP5VSS5SSLSTaTrK1u5OYRHvNNEwcAMIbdQPib33XqHz3xg3/8173eA4+meSZ+Icl2kn6aZxhWVjdy6wiPOjFxAABj+lePbT3Sr1/9yrHqb5zo9Y5XezxkJ8ntJGfnMRBccwAAYzrWO3H5eO+tD4wIgyQ5nuRkkkv38ViHxjMHADCGwTUGN5KcaPHwrSSn5+0aBM8cAMB4ltP+389ekqUpnmUqxAEAjGcxzcWHbSwMHj9XxAEAjGczzbsS2tgePH6uiAMAGM9amrcrttFPsj7Fs0yFOACAMaxu5Oa3tv7sL/r9nYOu6N9JcnXeLkZMxAEAjKWqqo/99p985JWq6m2mCYC97N7nYOX+nezwiAMAaKmqqo8leeLlV772w1XVe1+SK2nerrh7DcL24NdXkjy6upHnj+Sgb5L7HABAC7thkOTH6rr+y93fH9z3YCmv/2yF9Xl8KeFu4gAADjAqDLrKywoAsI/SwiARBwAwUolhkIgDANhTqWGQiAMAuEfJYZCIAwAYUnoYJOIAAF4jDBriAAAiDO4mDgAonjAYJg4AKJowuJc4AKBYwmBv4gCAIgmD0cQBAMURBvsTBwAURRgcTBwAUAxh0I44AKAIwqA9cQBA5wmD8YgDADpNGIxPHADQWcJgMseP+gBdcP5cTiVZTrKYZDPJ2upGbtq3X8oZ7NufxX1hMLmqruujPsPcOn8ujyS5nOSxNM/CLCTZTtJPci3JyupGbtm339Uz2Lc/q/vf2vqzv/jtP/nIKy+/8rUfFgbjEwcTGnxSPpvkZPZ+BmYnye0kZ6fxxWG/7P1ZOIN9+7O83+/v1FXV26yq3vumHeld5JqDyV3O6C+KDH7/ZJJL9u139Az27c/sfq93vKqq3oNT3O80zxxMYPD61o0kJ1o8fCvJ6cN8/c1+2fuzcAb79kveL4FnDiaznPZ/d70kS/btd+wM9u2XvN954mAyi2kufGlj4foLF5+pqqo+rI/rL1582n65+7NwBvv252k/zfdsxiAOJrOZ5orYNrbPPHzhybquq8P6OPPQhafsl7s/C2ewb3+e9tN8z2YM4mAya2neqtNGP8m6ffsdO4N9+yXvd544mMDgwpZrad6qs5+dJFcP+0IY+2Xvz8IZ7Nsveb8E4mByK2newzvqk3P3Pb4r9u139Az27Ze832niYEKDm2qcTXIlzVtldl//2h78+kqSR1c38rx9+108g337Je93XVW7z8GbNnjP7VJev6/3+hHcV9x+ofuzcAb79kve7yJxAAAM8bICADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ8QBADBEHAAAQ/4/zPilPgPRpAIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + " points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + " points.append([1,0])\n", + " points.append([2,0])\n", + " points.append([3,0])\n", + " points.append([4,0])\n", + " points.append([5,0])\n", + " points.append([6,0])\n", + " points.append([7,0])\n", + " points.append([8,0])\n", + " points.append([9,0])\n", + " points.append([10,0])\n", + " points.append([11,0])\n", + " points.append([12,0])\n", + " points.append([13,1])\n", + " points.append([12,2])\n", + " points.append([11,2])\n", + " points.append([10,2])\n", + " points.append([9,2])\n", + " points.append([8,2])\n", + " points.append([7,2])\n", + " points.append([6,2])\n", + " points.append([5,2])\n", + " points.append([4,2])\n", + " points.append([3,2])\n", + " points.append([2,2])\n", + " points.append([1,2])\n", + " points.append([0,3])\n", + " points.append([1,4])\n", + " ##\n", + " points.append([2,4])\n", + " points.append([3,4])\n", + " points.append([4,4])\n", + " points.append([5,4])\n", + " points.append([6,4])\n", + " points.append([7,4])\n", + " points.append([8,4])\n", + " points.append([9,4])\n", + " points.append([10,4])\n", + " points.append([11,4])\n", + " points.append([12,4])\n", + " points.append([13,5])\n", + " points.append([12,6])\n", + " points.append([11,6])\n", + " points.append([10,6])\n", + " points.append([9,6])\n", + " points.append([8,6])\n", + " points.append([7,6])\n", + " points.append([6,6])\n", + " points.append([5,6])\n", + " points.append([4,6])\n", + " points.append([3,6])\n", + " points.append([2,6])\n", + " points.append([1,6])\n", + " points.append([0,7])\n", + " points.append([1,8])\n", + " ##\n", + " points.append([2,8])\n", + " points.append([3,8])\n", + " points.append([4,8])\n", + " points.append([5,8])\n", + " points.append([6,8])\n", + " points.append([7,8])\n", + " points.append([8,8])\n", + " points.append([9,8])\n", + " points.append([10,8])\n", + " points.append([11,8])\n", + " points.append([12,8])\n", + " points.append([13,9])\n", + " points.append([12,10])\n", + " points.append([11,10])\n", + " points.append([10,10])\n", + " points.append([9,10])\n", + " points.append([8,10])\n", + " points.append([7,10])\n", + " points.append([6,10])\n", + " points.append([5,10])\n", + " points.append([4,10])\n", + " points.append([3,10])\n", + " points.append([2,10])\n", + " points.append([1,10])\n", + " points.append([0,11])\n", + " points.append([1,12])\n", + " ##\n", + " points.append([2,12])\n", + " points.append([3,12])\n", + " points.append([4,12])\n", + " points.append([5,12])\n", + " points.append([6,12])\n", + " points.append([7,12])\n", + " points.append([8,12])\n", + " points.append([9,12])\n", + " points.append([10,12])\n", + " points.append([11,12])\n", + " points.append([12,12])\n", + " points.append([13,13])\n", + " points.append([12,14])\n", + " points.append([11,14])\n", + " points.append([10,14])\n", + " points.append([9,14])\n", + " points.append([8,14])\n", + " points.append([7,14])\n", + " points.append([6,14])\n", + " points.append([5,14])\n", + " points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " #\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAG2CAYAAADhtfbVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAAsTAAALEwEAmpwYAACHXklEQVR4nOzdd1yX9f7/8ceFLNkqSxyBM8NcqDlw5TmOMj0NSypH5dcsy+qc0kp/2jTrVGqdtrlOplZqp6VW5hY13KCIiqhoiiIqyobX749LEBRlfS5Zr/vt9rnB51rP95txvT7XNkQEpZRSqrqzK+8GKKWUUhWBFkSllFIKLYhKKaUUoAVRKaWUArQgKqWUUgDYl3cDlFJKlY+tW7f62tvbzwRaUvU3kHKAyKysrJEhISEJhU2gBVEppaope3v7mf7+/i18fHyS7OzsqvQ1eDk5OcapU6duOXHixExgYGHTVPVPBEoppa6tpY+Pz/mqXgwB7OzsxMfH5xzm1nDh09zA9iillKpY7KpDMcx1qa/XrHuWFUTDMGYZhpFgGEakjZaXbRjGjkuvH2yxTKWUUiqXlVuIc4B+Nlxeqoi0ufQqdP+vUkopC61c6cpddwURHNyCu+4KYuVKV1ss9o033vBt1KhRsIeHR5uXX37ZH+Cf//xnwKRJk/wA7r333sDZs2fXKu7y9u3b59i0adPgkrbDspNqRGStYRiB+YcZhtEY+AjwAVKA/xORaKvaoJRSykaeey6ATz/1Iz3dDhHYu7cmv//uxejRJ5k27XhZFv3ll1/6/P777zGNGzfOtFVzS+NGH0P8HHhaREKA54GPSzCvs2EYEYZhbDIM4x+WtE4ppdTVVq505dNP/UhLM4shgIhBWpodn37qV5YtxQcffLBhfHy8U//+/Zu++uqrvsOGDWt4venXrVvn0qFDh+bBwcEtQkNDmx4+fNghd3jz5s1vad68+S3vv/++b2nacsMKomEYbkAX4FvDMHYAnwF1L427xzCMyEJeK/It4iYRaQ88CEy/tLWplFLKatOn+5KeXni9SE83mD69VAUI4Ouvvz7i6+ubuWbNmphatWplX2/a9PR0Y+zYsQ3/97//HYyKito7fPjw088//3w9gMceeyxw+vTpR/bt27entG25kdch2gFnRaTNlSNEZAmw5Hozi8ixS19jDcNYDbQFDtq+mUoppQqIjXXmWo8KFDE4dMj5RjRj165dTvv37695++23NwPIycnBx8cn8/Tp0zWSk5Nr9O/f/wLAo48+mvjHH394lnT5N6wgish5wzAOGYYxWES+NQzDAFqJyM6i5jUMoxaQIiLphmF4A12Bd6xus1JKKaBRozT27q2JiHHVOMMQgoLSbkQzRMRo0qRJ6o4dOwqce3L69Okatli+lZddLADCgeaGYcQbhvEY8BDwmGEYO4EoYFAxF9cCiLg03ypgqoiUerNYKaVUCTz7bAJOToVvIjo5Cc8+W+it0GytVatWaWfOnLH//fffXcHchRoREeHs7e2d7e7unr1ixQo3gDlz5tQuzfKtPMs07BqjSnwphohsBG4tW4uUUkqVSu/eFxk9+uSls0wNRAwMQ3ByEkaPPknv3hdvRDOcnZ1l4cKFB8eOHdswOTm5RnZ2tvHEE0+cbN++fdqXX34ZN3LkyEDDMOjZs+f50izfkGvtF86dwDCaA4vyDWoETBKR6aUJVEopVTHs3LkzrnXr1qeLPcPKla5Mn+7LoUPOBAWl8eyzCTeqGNrKzp07vVu3bh1Y2LgiC2KBiQ2jBnAMuE1EDl9rOm9vbwkMLDRPKaVUBfHOO+/g7+9/Q7LS09Oz2rZtW+Q5I1a7XkEs6S7T3sDB6xVDgMDAQCIiIkq4aKWUUjfS3r17adGixQ3JioyMzLghQWVQ0pNqhgALChthGMaoSxfOR5w6darsLVNKKWW5kuwlrOxycnIMzOciFqrYBdEwDEfMZ0h9W9h4EflcRNqLSHsfH58SN1QppdSN5ezsTGJiYrUoipeeh+gJXPOBEyXZZdof2CYiJ8vcMqWUUuWufv36xMfHcyP26p04ccI+Ozvb2/Kga8sBIrOyskZea4KSFMQwrrG7VCmlVOXj4OBAUFDQDcm65ZZbdl+6/WaFVaxdpoZhuAJ/p4jbqymllFKVVbG2EEXkIlDH4rYopZRS5eZGP/5JKaWUqpC0ICqllFJoQVQ32I8//kjLli1xc3OjS5cu7Nlz+R7t6enpPPfccwQEBFCrVi2efPJJMjPL9gDt6+WJCBMnTqRevXp4enrSs2dPoqKiLMkaPXo0bm5ueS8nJyfc3d0t6xtAbGwsAwYMwN3dHW9vb8aNG2dJ1pw5c6hRo0aB/q1evdqSrPx69+6NYRhkZWVZkrVw4UKaN2+Op6cnvr6+DB8+nPPnS3WLzGLlzZ07l5CQEDw8PKhfvz7jxo2zrG+RkZH07dsXb29vzAcPKcBcKdj6FRISIkpdKSYmRtzd3WXdunWSmZkpU6ZMkcaNG0tmZqaIiLzyyisSGhoqiYmJkpCQILfddptMmjTJsrxFixZJ3bp15eDBg5KVlSUvvviitG3b1pKsKw0fPlweeeQRy/qWnp4ujRo1kvfee08uXLggqampsnPnTkuyZs+eLV27di11X0qSleurr76Sbt26CXDNn3FZs44cOSKnTp0SEZHk5GR58MEH5emnn7asbx9//LGsXbtW0tPTJT4+Xtq1aydvvfWWJVnR0dEyc+ZM+f7778UsA9YDIsSCemPLlxZEdcN8+OGHcscdd+S9z87OFmdnZ/n9999FRCQkJES++eabvPHz58+X+vXrW5Y3depUGTx4cN74yMhIcXJysiQrvwsXLoibm5usXr26VFnFyfvss88kNDS01MsvSZYtC2Jxfo5nz56Vpk2bSnh4eJkKYkl+Z8nJyTJ06FDp379/qbJKmici8t5778mAAQMszdq/f78WxHwv3WWqbijJd0eM3D/CyMjIa46Pj4/n3LlzluQNGTKEgwcPEhMTQ2ZmJnPnzqVfvxI/naxYWfktXrwYHx8funfvXuqsovI2bdpEYGAg/fv3x9vbm549e7J7925LsgC2b9+Ot7c3zZo14/XXXy/Trr6isl5++WWeeOIJm9yUuqis9evX4+npibu7O4sXL+bZZ5+1NC+/tWvXEhwcfEOylEkLoiq7TZsgLAxCQsyvmzYVOtnf/vY31qxZw+rVq8nIyGDKlClkZGSQkpICQL9+/ZgxYwanTp3ixIkTfPDBBwB5422dV7duXUJDQ2nevDk1a9bk22+/Zdq0aZZk5Td37lyGDRtW+LEbG+XFx8ezcOFCxo4dy/Hjx7nzzjsZNGgQGRkZNs/q3r07kZGRJCQksHjxYhYsWMC///1vS/oVERHBhg0bePrppwud35ZZAKGhoZw7d474+HheeOEFCn2KjwV/I7NmzSIiIoLnn3/e8iyVjxWbnbrLtBqZNEnExUXEMMw98HZ25vtrHPv79ttvJTg4WGrXri1jx46V4OBgmTdvnoiIpKSkyJgxYyQgIECCgoJkypQp4uDgINnZ2ZbkTZgwQTp37ixHjx6VzMxMmT17tgQGBsrFixdtnpXr8OHDYmdnJwcPHrT0Zzlw4EDp2bNn3rQ5OTni4eEhO3bssKxvuRYsWCDt2rWzeb+ys7OlQ4cOebuaDx06dPUuUwv7FR4efvUxZgvyli5dKr6+vrJr1y7Ls3SXqR5DVLYSHm7+Q8LVLxcXc/x1JCUliaurq+zdu7fQ8Z999pl06tTJsrw777xTpk+fXmAaT09P+fPPPy3r2xtvvCHdunW7egYb502cOFF69eqVN75AQbT497Zw4cLLhcOGWUlJSWIYhvj5+Ymfn594e3sLIH5+frJ27VrL+7Vu3Trx8PC4PMCCvGXLlom3t7ds3ry54MT5sg5xkxyhvk36pgWx4KtEDwgurvbt24s+D7EaCAuDRYtAhGeZxg7aFBzv4wu33FJgUHLyVtzc2pCZeYYDB8ZgGPa0aPE1AOnpxwADR8e6JCdvZs+ewTRr9iW1a/cxZ96zB04lAHCAJgA04UCp8+LiXiUp6TeCgxfj4OBDQsJ8YmJG07nzMexjjts0K9eWLc1p0GA8des+WvBnZeO+paTsY+vWtrRs+QNeXr04duwDjh37Dx067MUu+oBNsxITl+Hu3g5HRz9SUqKJiroPH5/BBAZOtmm/RITMzMvPFkhLO8r27R3p1CkeBwcfm/fr5Mn5eHp2w9m5IWlph4mOHoaDQx2Cg5dY8jtLSvqDPXsGExy8FC+vK44v58vaRjtyMNhMJ4LZA3Z2cP/9sKDgraa3bt1KmzZtOHPmDGPGjMHe3p6vvzazRIT09HRiY2MJDg4mNTUVwzBwcnLCKoZhbJUKfi/Tkj4gWKnLYmLMz6jXkpp61aADB57h4sWdGIYDPj6Dadz4/XyTHyQ6ehiZmQk4OTUgKGjq5WIIkFrE8Y8S5jVsOJ7MzAS2bm1DdvZFatZsQnDwYuztvSD1wFXLKksWwLlz4aSnx+PjM7iQ5dm2by4uzbn55q+IiRlNZmYCbm7taNnyB+zsHG2edfbsSvbtG0F29gUcHf3w9X2Yhg1ftnm/DMPA0fHyiTQ5OWkAODr6YRj2Nu9XSsoeYmPHk5WVhL19LerUuYOgoLfyLc+2eYcPv05W1jl2774jb5inZzdatVpWIKsZ+9jLLYSynp8YQNecjbB//1VZzzzzDDt37sTBwYHBgwfz/vv5sw4XuKl3zZo1uemmm4iLi7t+n6o6KzY7dZdpNTFkiHkco7BdRnZ2ImFhlTdP+6ZZFSnviqxYAqUp+8SZFPmfMcj2fbMAlWCXqRZEVXplPIZSofO0b5pVkfIKyUrAWzqwWezIkpkvHbBdlkW0IKqqL/fMt9xPr0Wc+Vap8rRvmlWR8grJSq7pI30bxwiIvPGGSE6O7WNtRQuiqh7Cw81dOiEh5ldbfxIvzzztm2ZVpLxCstLTRR5+2FybP/WUSFaWdfFlURkKop5lqpRSlVxODowbB++9B4MHw3//CxaeMFoqepapUkopy9nZwbvvgr8/vPACJCbC0qXg4VHeLatc9NZtSilVRTz/PMybB2vXQo8ecOJEebeoctGCqJRSVcjQofDjj+Zlwl26wIEiLqlVl2lBVEqpKqZfP/jjDzh/3iyKW7eWd4sqBy2ISilVBd12G2zYAC4u0LMn/PZbebeo4tOCqJRSVVTz5rBxIwQFwZ13wsKF5d2iik0LolJKVWEBAeZJNp07m/fjnz69vFtUcWlBVEqpKs7LC1asgLvvhueegxdfvP59+asrLYhKKVUNODvDt9/C44/D22/DI49AZmZ5t6pi0QvzlVKqmqhRAz75xNyNOnkynDoF33wDrq7l3bKKQbcQlVKqGjEMmDQJPv0Uli+H3r3NO9uUxY8//kjLli1xc3OjS5cu7Nmzp8D4adOmAbQ2DOO8YRizDMOoYDeWM2lBVEqpaujxx+G772DHDggNhSNHSrec/fv389BDD/Hpp59y9uxZ7rrrLgYOHEhWVhYAK1asYOrUqQD7gJuARsCrNumEjWlBVEqpauruu+HXX+Gvv8yzUCMjS76MFStW0K1bN0JDQ7G3t2f8+PEcO3aMNWvWADB37lwee+wxgDQRSQJeB0bYrhe2owVRKaWqse7dYd0686zTbt3M70sq/1OTch+lFHmpukZFRdG6dev8k+8E/AzDqFOmhltAC6JSSlVzt95qXsDv6wt9+sD//gds2mReuBgSYn7dtKnQef/2t7+xZs0aVq9eTUZGBlOmTCEjI4OUlBQALly4gKenZ/5Zzl366m5ln0pDC6JSSikCA81bvbVqBffcncMXPf4LixbBtm3mqai9e5unpl7h5ptvZu7cuTz11FPUrVuX06dPc8stt1C/fn0A3NzcOH/+fP5Zch9KlWx1n0pKC6JSSikAvL3hj6lb6GP8zqiMj3hdJiBgPoE4JcV86GIhW4r33XcfkZGRJCYm8uqrrxIXF0eHDh0ACA4OZufOnfknbw2cFJEynttqe1oQlVJK5XH9fBo/5AxgKPOYxOuEso5Mapgj09Jgxoyr5tm6dSvZ2dmcOnWKUaNGMXDgQG6++WYAhg0bxpdffgngbBiGFzARmHNjelMyWhCVUkpdFhODA5m8y7+oy3E20pXZPGqOy8mB/fuvmuWZZ57By8uL5s2bU6tWLb744ou8cf369WPcuHEAzYEjwGHg6n2vFYAhFtzQrn379hIREWHz5SqllLJYWBiHF22irywjjkDeZjzP8IE5zs4OHngAvv66xIs1DGOriLS3cWttSm/dppRSKs/uO1+k3yIfLuLCr/ShO/muw3B2hrFjy69xFtNdpkoppQDzMVHdnmoNbm6sc+5Dd7sN5gg7O/NJw88/D506lW8jLaRbiEoppVi61LzcMDAQVqzw4Ka/PjBPoNm/H5o2hWeeqdLFELQgKqVUtffZZ/Dkk9ChA/z0k3n5BTd1qvIF8Eq6y1QppaopEXjtNRg9Gvr1g5UrLxXDakq3EJVSqhrKzoannjIfAzV8OHzxBTg4lHerypduISqlVDWTlgb3328Ww/HjYfZsLYZQzIJoGIaXYRjfGYYRbRjGXsMwOlvdMKWUUrZ39qy5e3TJEpg2DaZONR8arIq/y3QGsFxE7jMMwxFwsbBNSimlLHD8OPTvD3v3wvz58OCD5d2iiqXIgmgYhifQnUsPdBSRDCDD2mYppZSypZgY89FOp0+bZ5L26VPeLap4irPLNAg4Bcw2DGO7YRgzDcNwvXIiwzBGGYYRYRhGxKlTp2zeUKWUUqWzZQt07Wo+sGL1ai2G11KcgmgPtAM+EZG2wEXgxSsnEpHPRaS9iLT38fGxcTOVUkqVxooVcPvt4O5uPu+wfYW+m2j5Kk5BjAfiRWTzpfffYRZIpZRSFdhXX8GAAdCkCWzcaN5wRl1bkQVRRE4ARw3DaH5pUG9gj6WtUkopVSbvvQdDh0JoKKxZA/7+5d2iiq+4Z5k+Dcy/dIZpLPCIdU1SSilVWjk5MG6cWRDvu8/cSnRyKu9WVQ7Fug5RRHZcOj7YSkT+ISJJVjesolm3bh1ubm4FXoZhsHjxYgBEhIkTJ1KvXj08PT3p2bMnUVFRlmSlp6fz3HPPERAQQK1atXjyySfJzMwsdd/++OMP2rVrh4eHB40aNeLzzz8vMP7rr7/mpptuwtXVlX/84x+cOXPGkqy//vqLgQMHEhAQgGEYxMXFlTqnOHk///wzoaGheHl54e/vz8iRI0lOTrYka9WqVdx66614eXlRp04d7r77bo4dO2ZZ3/J79NFHMQyDAwcOWJK1evVq7OzsCvy9zp0715IsgFOnTvHggw/i6elJrVq1eOihhyzJmjJlSoE+1axZEzs7O06fPm1Z3z788EOCgoLw8PCgffv2rF+/vkTLz8w07zrz3nswaNAfHDzYDh+fq7NEhDfffJOGDRvi4eHBkCFDOH/+fKn7VWWIiM1fISEhUtWtWrVK3Nzc5MKFCyIismjRIqlbt64cPHhQsrKy5MUXX5S2bdtakvXKK69IaGioJCYmSkJCgtx2220yadKkUi07IyNDPDw85NNPP5WcnBzZsmWLuLq6yo4dO0REJDIyUtzc3GTNmjWSnJwsYWFh8sADD1iSdeLECfnoo49k48aNAsihQ4dKlVPcvPnz58uyZcvk4sWLcubMGenXr588/vjjlvXt2LFjIiKSlpYmL7zwgtx1112W9S3XunXrpHv37gLI/v37LclatWqV1KtXr9R9KUmWiEhoaKg899xzcvbsWcnIyJBt27ZZlpXf5MmTpVevXqXKKk7epk2bxMXFRSIiIiQnJ0c+/vhj8fb2lqysrGItPzlZpG9fERB59dXrZ82ZM0eaN28uR44ckeTkZBk4cKAMGzas1H0rDiBCLKg3tnxpQSylESNGyIgRI/LeT506VQYPHpz3PjIyUpycnCzJCgkJkW+++Sbv/fz586V+/fqlWvaJEycEkIsXL+YNa9++vXz99dciIvLSSy9JWFhY3rgDBw6Ig4ODnD9/3uZZuTIzM21SEIubl2vx4sXSsmVLy7PS0tLkxRdflBYtWpQqq7h5mZmZ0qZNG9m5c2eZCmJRWbYsiEVlrVixQm666aZiF4myZOWXk5MjQUFBMmfOHMvyFi5cKB06dMgbd+HCBQHk+PHjRS47IUGkQwcROzuRL74oOuvee++Vd955J2/chg0bxMnJqcD0tlYZCqLey7QULl68yHfffcfw4cPzhg0ZMoSDBw8SExNDZmYmc+fOpV+/fpZkgflBJv/38fHxnDt3rsTL9/PzIywsjNmzZ5OdnU14eDiHDx8mNDQUgKioKFq3bp03fePGjXF0dCQmJsbmWbZW0ry1a9cSHBxsWdaRI0fw8vKiZs2avPvuu4wbN65UWcXNmzZtGt27d6dVq1alziluVkJCAn5+fgQFBfHcc89x8eJFS7I2bdpE8+bNGT58OHXq1KFDhw6sWbPGsn7lWrduHQkJCdx7772lyipOXv/+/cnOzmbz5s1kZ2cza9Ys2rRpg38RZ8PExZnXGO7ebT7TcOTI4vXtynVIeno6+/fvL3X/qgQrqmyl2kIMDxcZMkSkXTvza3h4kbPMmzdPAgMDJScnJ29Yenq6jB07VgCpUaOGBAYGSmxsrCVZEyZMkC5dukhCQoL89ddf0rFjx6s/SZYg64cffhBfX1+pUaOG1KhRQz7//PO8cbfffrt88sknBaYPCAiQVatW2TwrV5FbiDbOExH59ddfxcvLS/bt22d5VmJiokydOlXCC1uWjfKOHDkijRs3lrNnz4qIFL6FaKOsv/76S6KioiQ7O1tiY2OlW7duMmrUKEuy/u///k8AmTlzpmRkZMiCBQvE09NTTp06ZfOs/B599FEZPnx44QuxUV5OTo68+eabYm9vLzVq1JA6derIli1brpu18787pW5dES8vkfXri5/1xRdfSNOmTeXQoUNy9uxZueuuuwSQjRs3XrPtZUUl2EKs3gVx0iQRFxcRwzB/FHZ25vsijsf17t37qmN2EyZMkM6dO8vRo0clMzNTZs+eLYGBgZd3QdgwKyUlRcaMGSMBAQESFBQkU6ZMEQcHB8nOzi5x1t69e8XFxUWWL18u2dnZEh0dLU2aNJGffvpJREQGDhwob7/9doF53NzcJCIiwuZZua5bEC3ICw8PF29vb/n9998tz8r1119/ia+vr2RmZlqSd88998jcuXPzpr+qIFrYt/DwcKlTp44lWWPHjpXAwMAC87Rs2VK+//57y/p18eJFcXd3lz/++OPqztow74svvpAmTZrIvn37JDs7W5YtWya+vr55x56vzFpt9BQPzko997MSGVmyrOzsbJk0aZLcdNNNUq9ePXn//fcFkCNHjlzdRxvRgliRhYebf1zmMzILvlxcrvkp78iRI1KjRg05cOBAgeF33nmnTJ8+vcAwT09P+fPPP22edaXPPvtMOnXqVKp+ffvtt9KmTZsCw5555hkZM2aMiJjHEB988MG8cQcPHrx8DNHGWbmuWRAtyNu2bZv4+PjIDz/8YHlWfkePHhVAEhMTLcnz9PQUX19f8fPzEz8/PwHE29tb5s+fb3nfNm3aJLVq1bKkXzNnzpSgoKAC42+99VazIFrUr6+++kpuuummAntprOjbmDFj5Nlnny0wvnXr1vLtt99elbWYu8WJVGlBlBx2blbm39mKFSukXr16lz9UW6AyFETDbKdttW/fXiIiImy+XJsKC4NFi0gXB9qxDWfScCffKfc+vnDLLVfNdvjwFJKSltOmzdoCw+PiXiUp6TeCgxfj4OBDQsJ8YmJG07nzMexjjsOpBAAO0ASAJuQ7Bb6EWenpxwADR8e6JCdvZs+ewTRr9iW1a/eBPXtKlJWaepCIiNa0bPkDXl69SEuLZdeuvjRoMI6AgFFcvBjF9u2dadnyZ9zd2xET8zgiWdxyy0KbZwHk5KQhks369W506BCNs/NN2Nk5mwuwed8i2bmzN02afICv7wMFf/g2zjp1agmursHUrNmUzMxEDhwYQ2rqAUJCtlmSl5GRAOTkTR8eXpe2bcNxdW1NjX2HbJqVlLSKmjUb4eTUkPT0eKKjh+HsHMjNN8+2eb8yM8+wZUtjGjeejp/fw5w+vZSYmFF07BiDw/4Em/89Auza1Qd3904EBb1GATbu24kTczly5E1uvXU5zs5BJCX9TlTUIEJCtuESl5OXdZwA9tOUTmziJwZQx+6s+XDDBQvysg4ePEjr1q354Ycf6NWrF7GxsfTt25dx48YxatQozpw5Q1JSEo0aNWLv3r3cf//9jB07llGjLvfb1gzD2CoiFfrGccW9ML/qiYnhvLhxD0vYQzBN2F+wIKamFjrbyZPzaNDghauGN2w4nszMBLZubUN29kVq1mxCcPBi7O29ILWI679KmJWaepDo6GFkZibg5NSAoKCpZjEESE0pUVbNmo1p3nwWBw6MJT39MDVqeOLn9xB1644EwNU1mKZNPyU6+iEyMxOpVetvNG8+25IsgHXrauZ9/+efNwPQo4dYknf06HtkZp5i377H2LfvMQCcnW+iQ4com2dlZBwjNvZfZGQkUKOGO15ePQkOXppvebbNc3T0vWoRDg7e1KhR0+ZZFy5sJzr6YbKyknBwqIO3990EBr5pSb8cHGoTHPwDBw48yf79Y3BxuZng4P/h4OANqXE2zQLzw2dS0h80bfpxIcuzbd/8/IaRmnqQnTt7kpWVhJNTfZo1+wwXl5sh1dzAEOAsXgRyiJX0xoVU83PPFSfDNG7cmFmzZjF27FgOHz6Mp6cnDz30ECNHmlmnT5/mrrvu4ujRo/j4+PDMM89YWgwrDSs2OyvDLtMT/3hc2rJVapApcxlacHeHnZ1IvksNymzIEHOZhe1a0ayKmad906yKlJcvKw1HycDe2r5ZgEqwy7RaFsT9+0Ua1UsVFy7Iz/S/+o/5Osf1SqWUxxA1qxzztG+aVZHybnTfLKAFsQLaulXE11ekdm2R8Ec/N/+Ycj/lFfPMz1LJPUNMsypPnvZNsypS3o3um41pQaxgfvtNxM1NpGFDkb17Lw3Mva4nJKTY1waWmmZVvjztm2ZVpLwb3TcbqgwFsdqcZbpwIQwbBs2bw/LlUK9eebdIKaWqj8pwlmm1uHXbBx+YV1l06gTr1mkxVEopdbUqXRBF4KWX4Jln4B//gBUrwMurvFullFKqIqqy1yFmZcGoUTB7tvn144+hRo3ybpVSSqmKqkpuIaakwN13m8Vw8mT49FMthkoppa6vym0hJibCXXfBpk3wyScwenR5t0gppVRlUKUK4tGj0LcvHDwI334LZXh0mVJKqWqmyhTEqCizGCYnw6+/Qo8e5d0ipZRSlUmVOIa4YQOEhkJ2Nqxdq8VQKaVUyVX6gvjDD/C3v4GPD2zcCK1bl3eLlFJKVUaVuiB++aV5Numtt5pbiUFB5d0ipZRSlVWlLIgi8OabMHIk/P3v8Mcf5haiUkopVVqVriBmZ8PTT8PEieuwt3dj/Xo3/P3dcHNzwzAMFi9eDMDo0aNxc3PLezk5OeHu7l7OrVdKKVVRVaqCmJ4OQ4bARx/Bv/7VjfT0C1y4YL5++ukn3Nzc6NevHwCffvpp3rgLFy4QFhbG4MGDy7kHSimlKqpKc9nFuXPm8cJVq+Ddd+Ff/yo4fu7cudx33324urpeNe/FixdZvHgxP/300w1qrVJKqcqmUhTEEyegf3+IjIT//hcefrjg+IsXL/Ldd9/x448/Fjr/4sWL8fHxoXv37jegtUoppSqjirfLdNMm81lNISEQFsb+b3fQpQvs3w8//nh1MQRYsmQJ3t7e9LjGBYhz585l2LBhGIZhceOVUkpVVhVrC3HyZHN/aGoqiBCxvQZ3LKyHuFzkj1WudOxY+GzXK3hHjhxh9erVfPHFFxY3XimlVGVWcbYQN20yi2FKCoiwjL70lD9w4SIbcrrQMWdTobMdPXqU1atXM2zYsELH//e//6Vr1640atTIytYrpZSq5CpOQZwxw9wyBF7gbe5gGQ04yka60Cwj0hxfiP/+97906dKFxo0bFzp+3rx5jBgxwqpWK6WUqiIqTkGMiTGvuAeasw97MjlDLU7hAzk55kHEQsybN4/hw4cXOi48PJz4+Hi93EIppVSRKs4xxGbNYMcOyMlhJLPoQjh9WUF31vI/4256NvMvdLbo6OhrLrJz585cvHjRogYrpZSqSirOFuIzz4Czc97bW9jLRrpQn3j6yjIW3/pK+bVNKaVUlVdxCmKnTvD88+DiAnZmsxrYHWddzb60r3+SwROa8ckn5dxGpZRSVVbFKYgAr74KK1fC/feb1yHefz+1//iO3/Y15M474cknzSszLh1qVEoppWym4hxDzNWpk/nKxwVYuhQefxxee828c81HH4F9xWu9UkqpSqrSlBR7e5g5E+rWNR/9dPIkLFgANWuWd8uUUkpVBRVrl2kRDAPeeAM+/BB++AH69IGkpPJulVJKqaqgUhXEXE89BQsXwpYt0L07HDtW3i1SSilV2VXKggjmeTfLlsHhw9ClC1znckSllFKqSMUqiIZhxBmGsdswjB2GYURY3ajiuv12WLPGfHBw167m7VCVUkqp0ijJFmIvEWkjIu0ta00ptG0LGzdCrVpmgfzll/JukVJKqcqo0u4yza9RI9iwAVq0gIEDYe7c8m6RUkqpyqa4BVGAXw3D2GoYxqjCJjAMY5RhGBGGYUScOnXKdi0sJj8/WL0aevWCESPgnXf0An6llFLFV9yCGCoi7YD+wBjDMLpfOYGIfC4i7UWkvY+Pj00bWVzu7vDzzzBkCIwfD//8p/mgDKWUUqooxbowX0SOXfqaYBjGUqAjsNbKhpWWoyPMn29uMU6fbl7AP2eOOVwppZS6liK3EA3DcDUMwz33e6APEGl1w8rCzg6mTYOpU8272QwYAMnJ5d0qpZRSFVlxdpn6AesNw9gJbAF+FpHl1jar7AzD3G06ezb88Yd5bDEhofTLW7duHW5ubgVehmGwePHivGliY2MZMGAA7u7ueHt7M27cOEuy5syZQ40aNQqMX716tWX9ytW7d28MwyArK8uSrIULF9K8eXM8PT3x9fVl+PDhnD9/vlRZxcmbO3cuISEheHh4UL9+fcaNG2dZ3yIjI+nbty/e3t4YhlHqPhU3D2DatGn4+/vj4eHBo48+Snp6eqnzsrOzmThxIgEBAbi7u9O2bVvOnj0LQHp6Os899xwBAQHUqlWLJ598kszMTEuyRISJEydSr149PD096dmzJ1FRUZZkjR49usDP18nJCXd391JnFZUHtluHFJVly3VIlSIiNn+FhIRIRfLTTyI1a4o0aSJy8KBtlrlq1Spxc3OTCxcuiIhIenq6NGrUSN577z25cOGCpKamys6dOy3Jmj17tnTt2tUmyy4qK9dXX30l3bp1E0AyMzMtyTpy5IicOnVKRESSk5PlwQcflKefftomWYXlffzxx7J27VpJT0+X+Ph4adeunbz11luWZEVHR8vMmTPl+++/F/PfzrauzFu+fLn4+vpKZGSknDlzRnr06CHjx48v9fInTJggvXr1kri4OMnJyZHdu3dLamqqiIi88sorEhoaKomJiZKQkCC33XabTJo0yZKsRYsWSd26deXgwYOSlZUlL774orRt29aSrCsNHz5cHnnkkVJnFZVn63XI9bKsXIdcCxAhFtQbW76qRUEUEdm4UaR2bRE/P5Ht28u+vBEjRsiIESPy3n/22WcSGhpa9gUXI8vKP+Yrs0REzp49K02bNpXw8HCbFsTCsnIlJyfL0KFDpX///jbJKipPROS9996TAQMGWJq1f/9+SwrilXlhYWHy0ksv5b3//fffxc/Pr1TLPnPmjLi6usqBAwcKHR8SEiLffPNN3vv58+dL/fr1LcmaOnWqDB48OO99ZGSkODk5WZKV34ULF8TNzU1Wr15dqqzi5NlyHVJUlhbEwl9V4jrE4ujcGdavN0+u6d7d3I1aWhcvXuS7775j+PDhecM2bdpEYGAg/fv3x9vbm549e7J79+4yt7uwLIDt27fj7e1Ns2bNeP3110u9q684WS+//DJPPPEE/v7+Zc4oKmv9+vV4enri7u7O4sWLefbZZy3Ny2/t2rUEBwffkCxbKiwvKiqK1q1b571v3bo1J0+eJDExscTL3717N/b29nz33Xf4+/vTrFkzPvroowLTSL5rnESE+Ph4zp07Z/OsIUOGcPDgQWJiYsjMzGTu3Ln069evxDnF7VeuxYsX4+PjQ/fuV51gb7M8W65DitM3K9YhlZ4VVbYibiHmOnpUJDhYxNFRZNEiEQkPFxkyRKRdO/NreHiRy5g3b54EBgZKTk5O3rC///3vYm9vL7/88oukp6fLO++8I0FBQZKenn55RhtlHTx4UGJjYyU7O1t27dolLVq0kClTphSc0UZZf/75p7Ru3VoyMzPl0KFDhW8h2igrv/j4eJk8ebLs27fv6pEW5H355ZdSr169vF22VmUVuYVoo7xGjRrJsmXL8t5nZGQIIIcOHSpx1vz58wWQRx99VFJSUmTnzp3i7e0tv/76q4iYu+a6dOkiCQkJ8tdff0nHjh0FkOPHj9s8Kz09XcaOHSuA1KhRQwIDAyU2NrZUP8OisvK7/fbbZfLkyYUux1Z5tlyHFJVVrHWIjVEJthCrXUEUETlzRiQ0VMQgWz50eE7EMMwfhZ2diIuLSBHHP3r37n3VMZKBAwdKz549897n5OSIh4eH7NixwxwwaZK5bBtkXWnBggXSrl27ywNslJWdnS0dOnTI201UaEG0sF/h4eFXHx+yIG/p0qXi6+sru3btsjzrugXRhnmtWrWSRYsW5b0/ffq0AHL69OkSZy1ZskQAiYuLyxv21FNPybPPPisiIikpKTJmzBgJCAiQoKAgmTJlijg4OEh2drbNsyZMmCCdO3eWo0ePSmZmpsyePVsCAwPl4sWLNs/KdfjwYbGzs5ODhZ2AYMM8W65Ditu3XFetQyygBbECS1m1SQbV+EFAZAKvS455Yxvz5eJyzU9eR44ckRo1aly1b37ixInSq1evvPcF/pjDw81l5s8oQ9aVFi5ceLlw2DArKSlJDMMQPz8/8fPzE29vbwHEz89P1q5da3m/1q1bJx4eHpcHWJC3bNky8fb2ls2bNxccYVHfrlkQbZwXFhYmL7/8ct77lStXXj6GWMKsAwcOCCCHDx/OG/b0009fc+X62WefSadOnSzJuvPOO2X69OkF5vH09JQ///zTsn698cYb0q1bt6s7auO84q5DEqklZ/Gw6e+swDrEIpWhIBpmO22rffv2EhFRYR6KUbiwMLIWfseTfMQXjOIm4ggk7vJ4H1+45ZarZjt8eApJSctp06bgfQlSUvaxdWtbWrb8AS+vXhw79gHHjv2HDh32Yhd9AE6Z13wcoAkATThQ6qzExGW4u7fD0dGPlJRooqLuw8dnMIGBk2HPHptliQiZmSfz3qelHWX79o506hSPg4OPzft18uR8PD274ezckLS0w0RHD8PBoQ7BwUvMCWzYN4CkpD/Ys2cwwcFL8fK64tiQjbPMf7h0UlNjiYgIplu3VMDAzs7JkrwzZ5YTHT2C1q3/wMkpgKioe3B370ijRlNLlbVjR3dcXFrQpMkHpKbGsnNnD1q0WECtWr1JTz8GGDg61iU5eTN79gymWbMvqV27j82z4uJeJSnpN4KDF+Pg4ENCwnxiYkbTufMx7GOO2zQr15YtzWnQYDx16z5a8Idv474Vdx2ygzY4kMkuWlGXE+aF1/ffb150nU/37t1p0aIFH3zwAbGxsfTo0YMFCxbQu3dvli1bRrt27fDz8yM6Opr77ruPwYMHM3nyZKxiGMZWqWAPh7hSse5UUyXFxGBPFp/xOHtoQSYOBcenphY628mT82jQ4IWrhru4NOfmm78iJmY0mZkJuLm1o2XLH7Czc4TUlOu3pYRZZ8+uZN++EWRnX8DR0Q9f34dp2PDlS8uyXZZhGDg6Xj6RJicnDQBHRz8Mw97m/UpJ2UNs7HiyspKwt69FnTp3EBT0Vr7l2Tbv8OHXyco6x+7dd+QN8/TsRqtWy2yelZ5+mM2bg/Ler1tXEyenm+jUKe7S8mybV7t2Pxo0GMfOnb3IyUnF2/teAgNfLXVWixYL2LfvMTZsqIOjoy+Bga/nFY3U1INERw8jMzMBJ6cGBAVNNYuhBVkNG44nMzOBrVvbkJ19kZo1mxAcvBh7ey9IPXDVssqSBXDuXDjp6fH4+AwuZHm27Vtx1yENOcxeWtCFjfxKH5rmHID9+6/KWrBgAY899hh16tTB19eX119/nd69zayVK1cyYsQILly4gJ+fHw8//DAvv/zy9ftTHVix2VkZdpnKkCHmPvjCdnfY2YmEhWlWRcq60XnaN82qSHlXZG2hvXiTID6clD+NDrbvmwWoBLtMq29BLOUxG80qp6wbnad906yKlFdI1j6aSiCx4kqyrJi+x3ZZFtGCWNHlnrWV+8mrmGf1aVY5Zd3oPO2bZlWkvEKyjtdsJK38/hJ7e5H5820faUtaECuD3Ot6QkKKfd2XZpVj1o3O075pVkXKKyTr7FmRHj3Mtfn771sXXVaVoSBW37NMlVKqikhLg4cfhsWLYdw480k/NriHvE1VhrNMq82t25RSqqpydoZFi+CJJ+Cdd2DECCjDA0eqrep72YVSSlUhNWrARx9B3bowaRKcOgXffguuruXdsspDtxCVUqqKMAz4f/8PPvsMVqyA22+H06fLu1WVhxZEpZSqYkaNMo8n7toFoaFw+HB5t6hy0IKolFJV0D/+Ab/+CidPQpcuYIOn0VV5WhCVUqqK6tYN1q27/P3atdefvrrTgqiUUlVYy5awcSP4+0OfPrB0aXm3qOLSgqiUUlXcTTfB+vXQpg3cd5950o26mhZEpZSqBry9YeVK6NcPRo+G114zb4qqLtOCqJRS1YSrK3z/PQwfDpMnw5NPQnZ2ebeq4tCCqJRS1YiDA8yeDePHw6efms8WTksr2zKzs7OZOHEiAQEBuLu707ZtW86ePXvVdIZhrDQMQwzDqJA3hamQjVJKKWUdwzDvd+rvD889Z+5G/f578PIq3fImT57Mxo0bCQ8Pp2HDhkRFReHs7HzlZLWBIp6qXL705t5KKVWNff21ee/TFi1g2TIICCjZ/ElJSTRo0ICdO3fSuHHjQqc5d+4cXl5e6UBPIBxwEJGssrXc9nSXqVJKVWMPPgg//QQHD5oX8MfElGz+3bt3Y29vz3fffYe/vz/NmjXjo48+KjDNyy+/DJAAnLBVu62gBVEppaq5Pn1g9WpISYGuXWHLFmDTJggLg5AQ8+umTYXOGx8fz7lz54iJieHQoUN89913vPLKK/z2228AREREsGHDBjALYoWmBVEppRTt28OGDeDuDr1CM1jec6r5TKlt2+Cbb6B3b/PU1CvUrFkTgEmTJlGzZk1atWrFkCFD+OWXX8jJyeHJJ59kxowZN7o7paIFUSmlFABNm8LGD7fSNCuau9K/5b/ykDkiJ8fcfHz33au2FFu1agWAke+JxLnfnz9/noiICB544AGA1sCflyaJNwyjm7W9KTktiEoppfL4f/Uua6Q73VjHMP7LcGZfHpmWBlds7TVu3Jhu3brx5ptvkp6ezt69e1m4cCEDBgzA09OT48ePs2PHDoAo4I5Ls4UAm29Ih0pAC6JSSqnLYmLw5ByLuYcAjjGPEXzME+a4nBzYv/+qWRYsWMDhw4epU6cOd955J6+//jq9e/fGMAz8/f3x9/cHyAJOXZrlpIhk3KAeFZteh6iUUuqyZs04vf0od8n/OE5dHudTnuQTc5ydHTRrdtUs9erVY/ny5UUuWkTiAKOo6cqLbiEqpZTKE3vfOLqwgR20YTH38Wnu1iGAszOMHVt+jbOYbiEqpZQC4M8/YcCTbclyTuH3nAF0zVwNOZhbhs7O8Pzz0KlTeTfTMloQlVJK8csvMHgw+PrC8rUuNE960zyBZv9+8/TTZ56p0sUQtCAqpVS19+WX8Pjj0Lo1/PyzeY9T6FTlC+CV9BiiUkpVUyLwyiswciT87W/m3WrMYlg96RaiUkpVQ5mZ5oOCZ82CRx6Bzz4zHw1VnekWolJKVTMXLsDAgWYxnDTJ3GVa3Ysh6BaiUkpVKydPwp13wo4d8Pnn8H//V94tqji0ICqlVDWxbx/0728Wxf/9zyyM6jItiEopVQ2Eh8Ndd5mXFK5eDR06lHeLKh49hqiUUlXc99/D7bdDrVpmYdRiWLhiF0TDMGoYhrHdMIyfrGyQUkop2/noI7jnHvMaw40boXHj8m5RxVWSLcRngL1WNUQppZTt5OTAiy/CU0/BgAHwxx/g41PerarYilUQDcOoD9wJzLS2OUoppcoqIwOGDYO33zavNVyyBFxcyrtVFV9xtxCnA+Mwb/NaKMMwRhmGEWEYRsSpU6euNZlSSikLnTtnnkk6fz5MmQIffwz2evpksRRZEA3DGAAkiMjW600nIp+LSHsRae9TRbfLDcPA1dUVNzc33NzcGDlyZN64f//737Rs2RJ3d3eCgoL497//bVnWtGnTaNSoER4eHgQEBPDcc8+RlZVlSVaujIwMWrRoQf369UudU1TWK6+8goODQ944Nzc3YmNjLcsD2LZtG927d8fNzQ0/Pz9mXPE0cFtl9e/fv0C/HB0dufXWW0udVVReeno6o0ePxs/Pj9q1a3PXXXdx7NgxS7LOnj3L8OHD8fX1xdfXl1deeaUs3SI7O5uJEycSEBCAu7s7bdu25ezZs3njp02bhr+/Px4eHjz66KOkp6dbkhUZGUnfvn3x9vbGMGzzCL/r5c2dO5eQkBA8PDyoX78+48aNK/H/9bFj0L07rF0Lc+Zkc/HiROrVuzpr4cKFNG/eHE9PT3x9fRk+fDjnz5+3SR8rNRG57gt4C4gH4oATQArw1fXmCQkJkaoIkP379xc67u2335atW7dKZmamREdHS8OGDWXBggWWZB04cECSkpJERCQxMVF69eol7733niVZud544w3p1q2b1KtXr9Q5RWVNnjxZHnrooTItvyR5p06dEh8fH/nqq68kLS1Nzp8/L3v27LEk60o9evSQV199tdRZReW9/fbb0qpVKzlx4oSkpqbK0KFD5e6777Yka8SIEXLffffJxYsX5dChQ9KoUSOZNWtWqbMmTJggvXr1kri4OMnJyZHdu3dLamqqiIgsX75cfH19JTIyUs6cOSM9evSQ8ePHW5IVHR0tM2fOlO+//17MVWXZXS/v448/lrVr10p6errEx8dLu3bt5K233ir2siMjRerXF3F3F/n11+tnHTlyRE6dOiUiIsnJyfLggw/K008/bZM+XgsQIUXUm/J+lWxi6An8VNR01bEgXunpp5+Wp556yvKs06dPS+/eveWJJ56wLCs2NlZuvvlm+eWXX6pUQXzppZfk4YcfviFZ+R06dEjs7Ozk0KFDluWNHj1aXnjhhbz3P/30kzRr1sySrDp16siWLVvy3r/55psSGhpaqpwzZ86Iq6urHDhwoNDxYWFh8tJLL+W9//3338XPz8+SrFz79++3SUEsbl6u9957TwYMGFCsaVevFvH0FKlbV2T79pJlJScny9ChQ6V///7FyiqtylAQ9TrEEurevTv+/v7cc889xMXFFTqNiLBu3TqCg4Mty/r666/x8PDA29ubnTt38vjjj1uW9fTTTzNlyhRq1qxZpoziZP3444/Url2b4OBgPvnkE0vzNm3aRO3atenSpQu+vr7cddddHDlyxJKs/ObNm0e3bt0IDAwsU9b18h577DE2bNjA8ePHSUlJYf78+fTv39+SLCD3A3Pe95GRkaXK2L17N/b29nz33Xf4+/vTrFkzPvroo7zxUVFRtG7dOu9969atOXnyJImJiTbPsrWS5q1du7ZY65BFi6BPHwgIMK8xbNOmeFnr16/H09MTd3d3Fi9ezLPPPlvGHlYBVlTZSrWFGB4uMmSISLt25tfw8GtOumbNGklPT5ekpCQZM2aMBAcHS2Zm5lXTTZo0SVq1aiVpaWmWZ8XExMjEiRPlr7/+siRryZIl0q9fPxERWbVqVeFbiDbKioqKkmPHjklWVpZs2LBB/P395euvv7Ysr2nTpuLp6SlbtmyR1NRUefrpp6VLly6WZOXXuHFjmT17duELsVHe2bNn5YEHHhBAatSoIW3atJHExERLsh566CG5++675fz587J//35p1KiRODo6lipr/vz5Asijjz4qKSkpsnPnTvH29pZff/1VREQaNWoky5Yty5s+IyNDgIJb2zbKylXkFqKN80REvvzyS6lXr17ebs1rZb039pCASLduIvl/vSXJio+Pl8mTJ8u+ffuu3UcboBJsIVbvgjhpkoiLi4hhmD8KOzvz/aRJRc6alZUlLi4usmvXrgLDP/zwQwkMDJSjR49anpVrwYIFBY8P2SjrwoUL0qRJE4mJiRGRaxREC/v11ltvyT333GNZXqtWrWTEiBF540+fPi2AnD171rK+rVu3TlxdXSU5OfnqmWyY99BDD8k//vEPSUxMlLS0NHnttdekY8eOlmQlJibKgw8+KH5+fnLLLbfIhAkTpFGjRqXKWrJkiQASFxeXN+ypp56SZ599VkTM39miRYvyxuX+zk6fPm3zrFzXLYgW5C1dulR8fX2v/r/Il5WFnTzDdAGR+1pEyqVDgyXOyhUeHi5t27YtvI82UhkKYvXdZbppE7z7LqSkcFJ8EDCvZE1JMYdv2lTkIgzDMD9VXDJr1iymTp3KypUrC56NmS+L3OnLmJVfVlYWBw8etHnW/v37iYuLo1u3bnm7yv766y/8/f3NXWYW9+uqcTbOa9WqVYGzBwucSWhR3+bOncs999yDm5tbwYltnLdjxw5GjBhB7dq1cXJy4umnn2bLli2cPn3a5lm1a9dm/vz5nDhxgqioKHJycujYsWOp+tWqVau85efPyhUcHMzOnTvz3u/cuRM/Pz/q1Klj86wiWZC3fPly/u///o8ff/yx4FnI+bLSxJEHWMQMnuEZprMo7jacd5StbwXWIdWYca2VUVm0b99eIiIibL5cmwoLg0WL2CZtCGUd/pykIfmOH/n4wi235L29eDEKkUxcXW8lJyeVQ4cmcubMMtq3j8TOzoGTJ+dz8OC/aN16Fa6uLQpm7dkDpxIAOEATAJpwoNRZf/01kzp1BuLo6MvFi3vYs2cwtWr1pUmT922aZRgGmZmn86Y9d24jBw48RUjINhwcfDD27rNpv06f/h+ent2xt/ciOflPoqLuJihoCv7+wy35OSYl/cGePffSuvUqXFyCiY0dR3JyBG3brrN5FkB2dirh4f4EBy+lVq3bKcDGedHRj5CdfZ7mzWdhZ+fC0aP/5vjxj+jc+ZjNs1JTD2Jv74W9vRdnzvxKdPRQ2rRZg6trcImzAHbs6I6LSwuaNPmA1NRYdu7sQYsWC6hVqzdnziwnOnoErVv/gZNTAFFR9+Du3pFGjabaPMvcakgnNTWWiIhgunVLBQzs7JxK9TsrKs/8exxMcPBSvLy6F5gvN0uAXbTiLLV5j3/yT6aZd+u+/35YsKDALN27d6dFixZ88MEHxMbG0qNHDxYsWEDv3r2ZP38+3bp1o2HDhhw+fJhhw4ZRp04dlixZglUMw9gqIu0tC7CB6nu5ZkwMv8vt3M1S7MnGmytuJpCaWuBtRsZJ9u9/gvT0eGrUcMXDowstW/6Ut7KLi5tIVlYi27Zdvmuun9/DNGv2KaSmXL8tJcw6d24Dhw5NIDv7Ag4OPvj4DCYo6PVLy7JtlqOjf960Dg61AbvLw2yclZCwkH37HiUnJx0np/o0aDD+cjG0IK9WrdsJCprC7t13kpOTgodHKC1afG1JFkBi4vfY23vh5dWrkOXZNq9x43c5cGAsW7Y0JScnA1fXlgQHL7UkKzl5KwcPPktW1llq1mxGixbzzWJYiiyAFi0WsG/fY2zYUAdHR18CA1+nVq3eANSu3Y8GDcaxc2cvcnJS8fa+l8DAVy3JSk8/zObNQXnTrltXEyenm+jUKc6SvMOHXycr6xy7d9+RN72nZzdatVqWl2UAdfmLzmwyiyGYW6X791+VtWDBAh577DHq1KmDr68vr7/+Or17m1l79uxh/PjxJCUlUatWLe644w7eeuut6/enOrBiP2xlOIa4oPMMcSBdbmWnHKOuuf8/92VnJxIWZruwIUPMZebP0KyKnad906yKlHej+2YBKsExxGpZEGfMMHve3W6tJOF59R+Yi8t1z7grsfBwc5mF/TFrVsXM075pVkXKu9F9s4AWxAomJ0fkxRfNXt99t0jqy6+Zf0y5n7xKcKZdieWeIaZZlSdP+6ZZFSnvRvfNxrQgViCZmSKPPGL2+PHHRbKyLo3Iva4nJKTIa7HKTLMqX572TbMqUt6N7psNVYaCWC3OMk1JgQcegJ9+gldegUmTwEb36lVKKVUMepZpBZCYCHfdBZs3wyefmM8GU0oppa5UpQvi0aPQty/ExsK338I995R3i5RSSlVUVbYgRkWZxTA5GVasgB49yrtFSimlKrIqeeu2DRsgNNS8XnXdOi2GSimlilblCuIPP8Df/ga+vrBxI1y6pZ9SSil1XVWqIH75Jdx9t1kE168HGzxuTimlVDVRJQqiCLz5JowcaT4oc+VK8PEp71YppZSqTCr9STXZ2fDMM/DRRzB0qLmV6OBQ9HxKKaVUfpV6CzE9HYYMMYvhCy/AnDlaDJVSSpVOpd1CPHfOPF64ahW89x7885/l3SKllFKVWaXcQjxxAnr2hFWrDJycXJk0yQ03NzdGjhyZN82qVavo1asXnp6eBOrZNUoppYpQ6Qri/v3Qpcvl52FGRu7kwoULXLhwgZkzZ+ZN5+rqyqOPPsq///3vcmqpUkqpyqRSFcSICOja1bz7zKpV15+2Y8eODB06lEaNGt2YximllKrUKk1B/O03czepq6t5J5oOHczh3bt3x9/fn3vuuYe4uLjybKJSSqlKrFIUxAUL4M47oXFj8+4zzZqZw9esWUNcXBzR0dEEBAQwYMAAsrKyyrexSimlKqWKVxA3bYKwMAgJgbAwpj8bx4MPmscN166FunUvT9q9e3ccHR3x8vJixowZHDp0iL1795Zf25VSSlVaFeuyi8mT4d13ITUVEeGlbffzNoHc2yKKr5YH4+x8/dkNw8CKBx4rpZSq+irOFuKmTWYxTEnhojjTn2W8zXie4GMWxXXCecemApNHRUWxY8cOsrOzuXDhAv/617+oV68eLVq0ACAnJ4e0tDQyMzMREdLS0sjIyCiPnimllKoEKk5BnDEDUlMBGMT/WEE/7uRHPmIMNdJTzPH5nDx5kgceeAAPDw8aNWpEXFwcP/30Ew6XblWzdu1aatasyR133MGRI0eoWbMmffr0ueHdUkopVTkYVuxibN++vURERJRsppAQ2LYNgNPUpj/LiaADE3md15iEERJiXnehlFKq0jEMY6uItC/vdlxPxdlCbNYM7MzmeHOGcDrzGDN5g//HKL4gq8nN5dxApZRSVVnFKYjPPEP+s2bsyeYL/o8JvMFMRnLv8Q9y96gqpZRSNldxCmKnTvD88+DikrelaNjZ8YbLW3zY72d+XF+bPn0gKamc26mUUqpKqjgFEeDVV82n+95/v3lM8f77YeVKnlp2JwsXwpYt0K0bxMeXd0OVUkpVNRXrOkQwtxQ7dbpq8P33g7c3/OMf5kX6K1bApSsslFJKqTKrWFuIRbj9dlizBjIyIDQUwsPLu0VKKaWqikpVEAHatjXvZ1qrFvTuDT//XN4tUkopVRVUuoII0KiR+cSLFi1g0CCYM6e8W6SUUqqyq5QFEcDPD1avhl694JFH4O23QW9jqpRSqrQqbUEEcHc3d5kOGQIvvgjPPQc5OeXdKqWUUpVRxTvLtIQcHWH+fHOLccYMSEgwd6E6OpZ3y5RSSlUmlb4ggnkd/7Rp5rMSX3wRTp2CJUvMLUillFKqOCr1LtP8DAPGj4fZs2HVKvPY4smT5d0qpZRSlUWVKYi5RoyA//0P9uyBrl3h4MHybpFSSqnKoMiCaBiGs2EYWwzD2GkYRpRhGK/eiIaVxZ13mneAS0oy72qzfXt5t0gppVRFV5wtxHTgdhFpDbQB+hmGcfW91SqYzp1h/XpwcoIePeCPP8q+TMMwcHV1xc3NDTc3N0aOHJk3TkQYP348derUoU6dOowfPx5bPGty3rx5GIbBzJkz84adPXuW4cOH4+vri6+vL6+88kqZc66VlZ6ezujRo/Hz86N27drcddddHDt2zJKs/v375/1s3dzccHR05NZbby1z1rXyALZt20b37t1xc3PDz8+PGVc8iNpWWa+88goODg4F+hcbG1vmrGvl5crIyKBFixbUr1/fsqxp06bRqFEjPDw8CAgI4LnnniMrK8uSrH//+9+0bNkSd3d3goKC+Pe//13mnGtlrVq1il69euHp6UlgYKBNcq6XZ8t1yOnTp+natSt16tTBy8uLzp07s2HDhrzx6enpPPfccwQEBFCrVi2efPJJMjMzy9yvSk9Eiv0CXIBtwG3Xmy4kJEQqiqNHRYKDRRwcRBYtKtuyANm/f3+h4z799FNp1qyZHD16VOLj46VFixbyySeflCnvzJkz0rx5cwkODpYvvvgib/iIESPkvvvuk4sXL8qhQ4ekUaNGMmvWLEuy3n77bWnVqpWcOHFCUlNTZejQoXL33XdbknWlHj16yKuvvlqmrOvlnTp1Snx8fOSrr76StLQ0OX/+vOzZs8eSrMmTJ8tDDz1UpmWXJC/XG2+8Id26dZN69epZlnXgwAFJSkoSEZHExETp1auXvPfee5Zkvf3227J161bJzMyU6OhoadiwoSxYsMCSrM2bN8u8efPks88+k5tuuqlMGcXJs+U6JDU1VaKjoyU7O1tycnJk6dKlUqtWLcnMzBQRkVdeeUVCQ0MlMTFREhIS5LbbbpNJkybZpH/XAkRICepNebyKdQzRMIwahmHsABKA30RkcyHTjDIMI8IwjIhTp07ZrGCXVf36sG4d3Habeb3ihx9akzN37lz+9a9/Ub9+ferVq8e//vUv5pTxFjovvfQSY8eOxdvbu8DwH3/8kXHjxuHi4kJgYCCPPfYYs2bNsiTr0KFD9O3bFz8/P5ydnXnggQeIioqyJCu/uLg41q1bx7Bhw8qUdb28999/n759+/LQQw/h5OSEu7s7Lcp4x/ji9M2Wrpd36NAhvvrqK1566SVLsxo3boyXlxdgfsC2s7PjwIEDlmSNGzeOdu3aYW9vT/PmzRk0aFCBLR9bZnXs2JGhQ4fSqFGjMi2/uHm2XIc4OzvTvHlz7OzsEBFq1KhBUlISZ86cAcx1yNixY6lduzY+Pj6MHTu2zOuQqqBYBVFEskWkDVAf6GgYRstCpvlcRNqLSHsfHx8bN7NsatWCX3+FgQNh7FiYMKH0d7Xp3r07/v7+3HPPPcTFxeUNj4qKonXr1nnvW7duXabCsWXLFiIiIhg9enSh4yVfB0SEyMhIS7Iee+wxNmzYwPHjx0lJSWH+/Pn079/fkqz85s2bR7du3cq8q+p6eZs2baJ27dp06dIFX19f7rrrLo4cOWJJFpgrodq1axMcHMwnn3xS6pzi5j399NNMmTKFmjVrWp719ddf4+Hhgbe3Nzt37uTxxx+3LCuXiLBu3TqCg4Mtz7KV6+XZeh0C0KpVK5ydnRk4cCAjR47E19c3b9yV65D4+HjOnTtXprzKrkRnmYrIWWAV0M+S1lioZk347jv4v/+DKVNg5EjIygI2bYKwMPP5i2Fh5vtrWLNmDXFxcURHRxMQEMCAAQPyjpVcuHABT0/PvGk9PT25cOFCwWMAxczKzs7mySef5D//+Q92dlf/ivr168fUqVNJTk7mwIEDzJo1i5SUlIIT2SiradOmNGjQgHr16uHh4cHevXuZNGmSJVn5zZs3jxEjRhQ+0kZ58fHxzJ07lxkzZnDkyBGCgoIICwuzJOv+++9n7969nDp1ii+++ILXXnuNBQsWWNa3pUuXkp2dzd13313o/LbMAnjwwQc5f/48MTExececrcrK9corr5CTk8MjjzxiedZ12SjPluuQXLt27eL8+fN8/fXXhIaG5g3v168fM2bM4NSpU5w4cYIPPvgA4Or1SHVT1D5VwAfwuvR9TWAdMOB681SkY4hXyskR+X//TwRE7mq2Vy7WrCNiGOYAOzsRFxeRYuxLz8rKEhcXF9m1a5eIiHh4eMjmzZvzxkdERIibm9vlGSZNMpddjKwPPvhAHnnkkbz3PXr0KHCsITExUR588EHx8/OTW265RSZMmCCNGjWyJOuhhx6Sf/zjH5KYmChpaWny2muvSceOHS3JyrVu3TpxdXWV5OTkq8bZMq9Vq1YyYsSIvPenT58WQM6ePWtZ33K99dZbcs8991jStwsXLkiTJk0kJiZGRERWrVp19TFEC/u2YMGCgseZLcj68MMPJTAwUI4ePWp5v3777bdrH0O0YZ4t1yGFufnmm2XHjh0iIpKSkiJjxoyRgIAACQoKkilTpoiDg4NkZ2cXa1mlQSU4hlicgtgK2A7sAiKBSUXNU5ELYq6Pno8Vg2zpwnpJpJb5o8h9ubiIhIdfd/6srCxxdXWVnTt3iohI586d5fPPP88b/+WXX8ptt91mvgkPN5eZP+M6WYMGDRIvLy/x8/MTPz8/cXBwEA8PDxkzZkyhbXnppZdkyJAhlmQFBwfL999/nzd9UlKSAHLq1CnL+jVy5EgZOnTo1R21cd7DDz9cYAWVmJh4uSBa/DubOnVqwaJhw7zt27eLvb193rhatWqJnZ2d+Pn5yaFDhyzv23//+19p1aqVJb8zEfN/q169enLw4MGCwRb165oF0cZ5tlyHFKZx48ayZMmSQsd99tln0qlTpyKXURaVoSAaZjttq3379hIREWHz5dpUWBjfLcziIb7CjQs0JQZn0i+P9/GFW27Je3vxYhQimbi63kpOTiqHDk3kzJlltG8fiZ2dA8ePf8qxYzNo1ep3wGDXrr9Tr97TBASMNu8ScCoBgAM0AaAJB66ZlZV1lpyctLz3UVH34O19H3XrPoa9vSepqQext/fC3t6LM2d+JTp6KG3arMHVNdjmWdHRj5CdfZ7mzWdhZ+fC0aP/5vjxj+jc+ZjNswCys1MJD/cnOHgptWrdXvB3ZuO8pKQ/2LPnXlq3XoWLSzCxseNITo6gbdt1Ns86ffp/eHp2x97ei+TkP4mKupugoCn4+w+3ed9q1HAlM/N03rhz5zZy4MBThIRsw8HBB2PvPpv27a+/ZlKnzkAcHX25eHEPe/YMplatvjRp8r7Nf44nT87n4MF/0br1KlxdrzgBysZZIjmIZJCUtIr9+0fTseM+wA47O0dL8oq7DkmiFo2IZSn3mAuys4P774d8u+A3bdpEVlYWHTt2JDs7mw8++IA33niDffv2ERAQwLFjxzAMg7p167J582YGDx7Ml19+SZ8+fbCKYRhbRaS9ZQE2UCXuZVoqMTHcxzbqcJp+LOcv6hJE3OXxqakFJs/IOMn+/U+Qnh5PjRqueHh0oWXLn7CzcwCgbt3HSU2NJSLCvG7O338kdeteOrEgtYj98ldk2dt7FXhvGI7Y23vkFY3k5K0cPPgsWVlnqVmzGS1azDeLoQVZjRu/y4EDY9mypSk5ORm4urYkOHipJVkAiYnfY2/vhZdXr0KWZ9u8WrVuJyhoCrt330lOTgoeHqG0aPG1JVkJCQvZt+9RcnLScXKqT4MG4y8XQwvyHB3988Y5ONQG7C4Ps3HWuXMbOHRoAtnZF3Bw8MHHZzBBQa9bkhUXN5GsrES2beuQN42f38M0a/apBf1ay86dl/8O162riadnD9q0WW1J34q7DokjkN20ZD4P8hBfm4/42b+/wLLT09MZO3YssbGxODg4cOutt/Lzzz8TEBAAwMGDBxk2bBgJCQk0aNCAqVOnWloMKw0rNjsrwy5TGTLE3AcPsp/GkoXd5V0QdnYiYWGWZF310qyKmad906yKlJcv6ywe0pM/BETe5Z/W9M0CVIJdptW3INpgn7xm3cCsG52nfdOsipR3RVYqTnIf3wiIPG8/TbI32LhvFtCCWNHlnrWV+ymvhGdtadYNzrrRedo3zapIeVdkZRn2Msb+EwGRhx8WyciwfaQtaUGsDMLDzd0RISHmV1t/itSsyp2nfdOsipR3RVbOxnB5/XVzTd6vn0hhVypVFJWhIFbfs0yVUqqKmDkTHn8c2reHn3+GG3TnwBKpDGeZVrnnISqlVHUzciQsWQK7dpnPgc13V0lVAloQlVKqChg0CH77DRISzOfA7tpV3i2qfLQgKqVUFREaaj7dx84OuneHNWvKu0WVixZEpZSqQlq2hI0boW5d6NvX3JWqikcLolJKVTENG8L69dC2LQweDJ9+Wt4tqhy0ICqlVBVUpw78/jv07w9PPAGvvmpe1a+uTQuiUkpVUa6usHQpDB8Or7xiFsbs7PJuVcVVfW/urZRS1YCDA8yebR5TnDoVTp2C+fPB2bm8W1bx6BaiUkpVcYYBb70F06aZJ9n07Qtnz5Z3qyoeLYhKKVVNPPssfP01hIebl2UcP17eLapYtCAqpVQ1EhZm3t7t0CHzAv59+8q7RRWHFkSllKpm/v53WL0aUlLMW71t3lz6ZZ0+fZquXbtSp04dvLy86Ny5Mxs2bMgbLyJMnDgRoJVhGOcMw1htGEZwWftgBS2ISilVDYWEmBfwe3rC7bfDsmWlW46bmxuzZs3i1KlTJCUlMX78eO666y6ysrIA+Pbbb5k1axZANFAbCAf+a5te2JYWRKWUqqaaNIENG6BZMxg4EObNK/kynJ2dad68OXZ2dogINWrUICkpiTNnzgBw6NAhQkNDATJEJBv4CrjFht2wGS2ISilVjfn7m/c87d7dvF7x3XdLt5xWrVrh7OzMwIEDGTlyJL6+vgAMGTKEgwcPAjgZhuEADAeW26j5NqXXISqlVDXn4QG//ALDhsELL8Bff8G/792E3YczICbG3IR85hno1Omay9i1axdpaWksXbqUjIyMvOF169YlNDSUbdu2tQRSgaPA7ZZ3qhS0ICqllMLJCRYsAF9feP99ODkjjlnZS3AkA3bsgB9+gOefN+8Bdw3Ozs6EhYXRokUL2rRpQ+vWrXnttdf4888/AXYBIcDDwB+GYQSLSMoN6Vwx6S5TpZRSgPnYqA8e3MSbDpOZnz2Eu/iBC7hCTo55Suq778KmTUUuJzMzk9jYWAB27NjBAw88AJApIlkiMgeoRQU8jqgFUSmlVB7jgxm8nPU6M3mM3/kb9TnKARqZI9PSYMaMAtNv2rSJ9evXk5GRQWpqKm+//TYnT57ktttuA6BDhw58++23APaGYdgZhjEUcAAO3Mh+FYfuMlVKKXVZTAyI0JJIXLlIMh7spQVNiDW3FPfvLzB5eno6Y8eOJTY2FgcHB2699VZ+/vlnAgICABg/fjwJCQls2LDhFuAsZiG8V0TO3uCeFckQC54H0r59e4mIiLD5cpVSSlksLIxli85zn3yDPyf4kQHcQrQ5zs4OHnjAvP9bCRmGsVVE2tu4tTalW4hKKaXyzGv6Oo9KIK3YxTL640fC5ZHOzjB2bPk1zmJ6DFEppRQi8M47MPz1JvQMOszqmnfgZ3faHGlnBy4u5lmm17n0orLTLUSllKrmcnLgX/+C6dPh/vth3rzGOG3/3jyBZv9+aNq0yOsQqwItiEopVY1lZMCIEeY1iGPHms9MtLPDLH5VvABeSQuiUkpVU8nJcO+98Ntv5gOEx483HyZcXWlBVEqpaighAe64w7wJzaxZ8Mgj5d2i8qcFUSmlqpnYWOjbF44dg++/hwEDyrtFFYMWRKWUqkZ27IB+/cxjhytXQufO5d2iikMvu1BKqWpi1SrzMU8ODrB+vRbDK2lBVEqpauDbb80twwYNIDwcbqlwt9Yuf1oQlVKqivvoI/OOax06wLp1UL9+ebeoYtKCqJRSVZQI/L//B089ZZ448+uvULt2ebeq4tKTapRSqgrKyoInnoCZM+Gxx+DTT8Fe1/jXpVuISilVxaSmmhfcz5wJEybAF19oMSwO/REppVQVkpQEAwfChg3w4Yfm7lJVPEVuIRqG0cAwjFWGYewxDCPKMIxnbkTDKpqYmBgGDRqEj48PtWvXpm/fvuzbt6/ANLGxsQwYMAB3d3e8vb0ZN26cJVmjR4/Gzc0t7+Xk5IS7u7slWSLCxIkTqVevHp6envTs2ZOoqChLstLT03nuuecICAigVq1aPPnkk2RmZpYqC+D06dN07dqVOnXq4OXlRefOndmwYUOBaaZNm4a/vz8eHh48+uijpKenW5IVGRlJ37598fb2xrDBvbGKyps7dy4hISF4eHhQv359xo0bR1ZWliVZCxcupHnz5nh6euLr68vw4cM5f/68JVn59e7dG8MwLOvXnDlzqFGjRoH/tdWrV5cqqzh5UPZ1SHw8dOsGmzefpmnTrkyeXHiWLdchVYqIXPcF1AXaXfreHYgBbrnePCEhIVLVbN68WWbOnCmJiYmSkZEhEydOlObNm+eNT09Pl0aNGsl7770nFy5ckNTUVNm5c6clWVcaPny4PPLII5ZkLVq0SOrWrSsHDx6UrKwsefHFF6Vt27aWZL3yyisSGhoqiYmJkpCQILfddptMmjSpVFkiIqmpqRIdHS3Z2dmSk5MjS5culVq1aklmZqaIiCxfvlx8fX0lMjJSzpw5Iz169JDx48dbkhUdHS0zZ86U77//Xsx/u7IpKu/jjz+WtWvXSnp6usTHx0u7du3krbfesiTryJEjcurUKRERSU5OlgcffFCefvppS7JyffXVV9KtWzcBrhpnq6zZs2dL165dS7Xs0uSVdR2yZ49IgwYi7u4iy5YV7+eYqyzrkOICIqSIelPer5LPAP8D/n69aapiQbxSYmKiAHL69GkREfnss88kNDT0hmTld+HCBXFzc5PVq1dbkjV16lQZPHhw3vjIyEhxcnKyJCskJES++eabvPHz58+X+vXr2yQrOztbfvjhBwHk5MmTIiISFhYmL730Ut40v//+u/j5+VmSlWv//v02KYjFzcv13nvvyYABAyzPSk5OlqFDh0r//v0tyzp79qw0bdpUwsPDy1QQi8qydUEsKq8s65CNG0Vq1xbx8xPZtq3orPxsvQ65lipXEIFA4AjgUci4UUAEENGwYUMb/hgrpqVLl4q/v3/e+0ceeUQefvhh6devn9SpU0d69Oghu3btsiQrv7lz50pQUJDk5ORYkhUXFyft2rWTffv2SUZGhrzwwgsyaNAgS7JCQkJk0aJFee+/+uorAeTs2bNlyrn11lvFwcFBABk5cmTe8FatWsnChQvz3p86deqaHzzKmpXL1gWxqLxcgwYNKvXWb3Gy1q1bJx4eHgKIi4uLrFixwrKsJ598Ut5//305dOiQTQritbJmz54tLi4uUqdOHWnatKm89tprNim+18or7Trkxx9FatYUadJE5ODB4mXlZ+t1yLVUqYIIuAFbgXuKmrZSbSGGh4sMGSLSrp35NTy8yFmOHj0qAQEB8vXXX+cN+/vf/y729vbyyy+/SHp6urzzzjsSFBQk6enpNs/K7/bbb5fJkydb1q/09HQZO3asAFKjRg0JDAyU2NhYS7ImTJggXbp0kYSEBPnrr7+kY8eOAsjx48fLnJeamipff/21zJkzJ29Yo0aNZNmyZXnvMzIyBJBDhw7ZPCtXkQXRxnkiIl9++aXUq1cvb7emlVnx8fEyefJk2bdvnyVZf/75p7Ru3VoyMzOvXRBtlHXw4EGJjY2V7Oxs2bVrl7Ro0UKmTJly9cw2yivNOmTWhANSo4ZISIjINXYOFPk7u+Y6xMaqTEEEHIAVwD+LM32lKYiTJom4uIgYhvmjsLMz31/nuFVCQoK0aNFC3njjjQLDBw4cKD179sx7n5OTIx4eHrJjxw6bZ+U6fPiw2NnZycErPxbaMGvChAnSuXNnOXr0qGRmZsrs2bMlMDBQLl68aPOslJQUGTNmjAQEBEhQUJBMmTJFHBwcJDs7u0x9y+/mm2/O+520atWqwBbp6dOnC24h2jAr13ULogV5S5cuFV9f36u3NCzIyhUeHl7wOLONsrKzs6VDhw55u/YKLYgW9mvBggXSrl27ggNtmFeSdUgOyFvGiwIif2+0X86fL13frrkOsUCVKIiAAcwDphd3oZWiIIaHm39cIKk4mT+K3JeLS6Gf8s6cOSNt2rQpdNfTxIkTpVevXnnvC/wx58u66lWKrFxvvPGGdOvW7Zr9skXWnXfeKdOnTy8wzNPTU/7880/L+pXrs88+k06dOpWpb1dq3LixLFmyRETMY4gvv/xy3riVK1dePoZo46xc1yyIFuQtW7ZMvL29ZfPmzZZn5Ze7+9TWWUlJSWIYhvj5+Ymfn594e3sLIH5+frJ27VrL+7Vw4cKChd7GecVdh2RjyFimC4iEMV/Sa3qWum+FrkMsUhkKomG289oMwwgF1gG7gZxLg18WkV+uNU/79u0lIiLiusstd2FhsGgRh6UBbdmOD6eoy1+Xx/v4Frj7bVbWeXbt+hvu7h1p2vQ/Vy0uJWUfW7e2pWXLH/Dy6sWxYx9w7Nh/6NBhL3bRB+BUAgAHaAJAEw6UOivXli3NadBgPHXrPnp54J49Ns2Ki3uVpKTfCA5ejIODDwkJ84mJGU3nzsewjzlu06z09GOAgaNjXZKTN7Nnz2CaNfuS2rX7lKpv589vQiQLd/eOiGRz7NgHHDnyBh067MPJKYAzZ5YTHT2C1q3/wMkpgKioe3B370ijRlNtnmX+w6WTmhpLREQw3bqlAgZ2dk6W9C0p6Q/27BlMcPBSvLy6F/xB2zjr5Mn5eHp2w9m5IWlph4mOHoaDQx2Cg5fYNMvRsS6ZmSfzpk1LO8r27R3p1CkeBwefEv+fFdWvxMRluLu3w9HRj5SUaKKi7sPHZzCBgZMt+TkWZx0iQDQtSMCPZ5nGe/wLOzsD7r8fFizIy9q0aRNZWVl07NiR7OxsPvjgA9544w327dtHQEBA3nTNmzdn/PjxPPpovnWIRQzD2Coi7S0PKoMiL8wXkfWYW4lVS0wMuyWYfiznIq7cxOGC41NTC7w9fXopycl/cvFiFCdOzMkb3qHDHpydG+Li0pybb/6KmJjRZGYm4ObWjpYtf8DOzhFSU67flhJmAZw7F056ejw+PoOvWJZtsxo2HE9mZgJbt7YhO/siNWs2ITh4Mfb2XpB6gOsqYVZq6kGio4eRmZmAk1MDgoKmXi6GpehbTk46Bw6MJS0tFsNwwNX1Vlq2/BknJ3OFULt2Pxo0GMfOnb3IyUnF2/teAgNftSQrPf0wmzcH5U2/bl1NnJxuolOnOEvyDh9+naysc+zefUfePJ6e3WjVapnNs1JS9hAbO56srCTs7WtRp84dBAW9ZUm/HB39802bdmmYH4Zhb/Oss2dXsm/fCLKzL+Do6Iev78M0bPhyvuXZNq846xADcCeZpsTwPv80V8w5Avv3F8hKT09n7NixxMbG4uDgwK233srPP/9coBiGh4cTHx/P4MFXrEOqMys2OyvDLtO1t08WT5IkgHjZRcuCuzvs7ETCwmwXNmSIuczCdq1oVsXM075pVkXKu9F9swCVYJdptSyIS5eKODlmS3MjWuJoePUfWDH3/xebDY41VPusG52nfdOsipR3o/tmAS2IFdBnn5kfqG67TeTU81PNP6bcT14lPEOsRHLPENOsypOnfdOsipR3o/tmY1oQK5CcHJFXXzV73L+/yIULl0bkXtcTElLsa4hKTbMqX572TbMqUt6N7psNVYaCWORZpqVR0c4yzc427/j+6acwbJj5SBQHh/JulVJKVR+V4SzTKv88xLQ084zkTz+FceNgzhwthkoppa5WpZ+HePYs/OMfsGYNTJsGzz5bzg1SSilVYVXZgnj8OPTvD3v3wvz58OCD5d0ipZRSFVmVLIgxMdCnD5w+DT/9ZH6vlFJKXU+VK4hbtsCdd4JhwOrV0L5CH8JVSilVUVSpk2pWrIDbbwd3d9iwQYuhUkqp4qsyBfGrr2DAAGjSBDZuhKZNy7tFSimlKpMqURDfew+GDoXQUPOMUn//oudRSiml8qvUBTEnB154AZ5/Hu67D5YvB0/P8m6VUkqpyqjSnlSTmQmPPmruKh0zBmbMgBo1yrtVSimlKqtKWRAvXIDBg80twtdfhwkTzLNKlVJKqdKqdLtMT5+G3r1hxYoYWrcexIwZPtSpU5u+ffuyb9++vOnmzJlDjRo1cHNzy3utXr26/BqulFKqQqtUBTEuDrp2hV274O23z/L00wPZt28fJ0+epGPHjgwaNKjA9J07d+bChQt5r549e5ZLu5VSSlV8lWaX6a5d0K8fpKbCb79BaGhHoGPe+Oeee4433niDxMRE6tSpU34NVUopVSlVii3ENWugWzews4N168zLK660du1a/P39CxTD7du34+3tTbNmzXj99dfJysq6ga1WSilVmVS8LcRNm8xTRmNioFkzlrR+hQdfaU5QkHknmoYNr54lPj6eMWPG8P777+cN6969O5GRkdx0001ERUXxwAMPYG9vz0svvXQDO6OUUqqyqFhbiJMnm2fMLFoE27bx6aJa3PdSU9p6H2X9+sKL4alTp+jTpw9PPvkkYWFhecMbNWpEUFAQdnZ23HrrrUyaNInvvvvuBnZGKaVUZVJxCuKmTfDuu5CSQo4IT/MBT8jH3MEvrDzTljr7N101S1JSEn369GHgwIFMmDDhuos3DAMRsar1SimlKrmKUxBnzDDPmAEG8iP/4Wlu53eWcjcu6Unm+HzOnz9P37596dq1K1OnTr1qccuWLePkyZMAREdH8/rrr191FqpSSimVq+IUxJgYuLQF9w4vUJ8jrKIXMxlp3qNt//4Cky9dupQ///yT2bNnF7jW8MiRIwCsXLmSVq1a4erqyh133ME999zDyy+/fMO7pZRSqnIwrNiN2L59e4mIiCjZTGFh8M03ZvEDLuLCEBbyE3fxEm/x5pDdGAu+tnlblVJKWc8wjK0iUqEfyldxthCfeQacnfPeupLCUu5mFJ/xFi8x/OwMMjLKsX1KKaWqtIpTEDt1Mh9b4eJiXnAI2NsJn9b8J2/0Wsl/l/tw551w/nw5t1MppVSVVHEKIsCrr8LKlXD//RASAvffj/HHSib80Zs5c2D1avMC/ePHy7uhSimlqpqKd2F+p07m6wrDh0PdunDvvebo5cvhllvKoX1KKaWqpIq1hViEPn1g7VrzWYhdu5rfK6WUUrZQqQoiQNu2EB4O/v7w97/Dt9+Wd4uUUkpVBZWuIAIEBsKGDdChAzzwAEyfXt4tUkopVdlVyoIIULu2+Riou++G556Df/4z7xJGpZRSqsQqbUEEqFnTvJZ/7FiYNs28tj8trbxbpZRSqjKqeGeZllCNGuYu0wYN4IUX4MQJ+P57qFWrvFumlFKqMqnUW4i5DMO8pn/BAvOhGaGhcOmWpkoppVSxVImCmGvIEPMhwseOQefOsHNnebdIKaVUZVGlCiJAz56wfr1597du3cwb3yillFJFqXIFEaBlS/NaxcBA6N8f5s8v7xYppZSq6KpkQQSoXx/WrTOPJz78MEydmve4xVKJiYlh0KBB+Pj4ULt2bfr27cu+ffsKnbZ3794YhkFWVpYlWQsXLqR58+Z4enri6+vL8OHDOV/Ku54XlTV37lxCQkLw8PCgfv36jBs3zrJ+RUZG0rdvX7y9vTEMo1QZJckDmDZtGv7+/nh4ePDoo4+Snp5e6rxRo0bRvHlz7OzsmDNnToFx6enpPPfccwQEBFCrVi2efPJJMjMzS51VVJ6IMHHiROrVq4enpyc9e/YkKirKkqzRo0cXeCapk5MT7u7ulmQBxMbGMmDAANzd3fH29mbcuHGWZM2ZM4caNWoU6Nvq1atLnVVUXn5lXYcUlWXLdUhVUmULIoCnJyxbZl6O8dJL8NRTkJ1dumWdPXuWgQMHsm/fPk6ePEnHjh0ZNGjQVdPNnz+/zCu6orK6du3Khg0bOHfuHLGxsWRlZTFx4kRLslJSUpg+fTqnT59m8+bNrFy5knfffdeSLAcHB+6//36+/PLLUi2/pHkrVqxg6tSprFy5ksOHDxMbG8vkyZNLnde6dWs+/vhj2rVrd9W4qVOnEhERQWRkJDExMWzbto033nij1FlF5X377bfMmjWLdevWcebMGTp37szQoUMtyfr000+5cOFC3issLIzBgwdbkpWRkcHf//53br/9dk6cOEF8fDwPP/ywJVkAnTt3LtC3nj17ljqrOHlgm3VIUVm2XIdUKSJi81dISIhUJNnZIuPGiYDIP/4hkpJS9mUmJiYKIKdPn84bdvbsWWnatKmEh4cLIJmZmWUPukZWruTkZBk6dKj079/f8iwRkffee08GDBhgadb+/fvF/NO0rSvzwsLC5KWXXsob//vvv4ufn1+Zc7p27SqzZ88uMCwkJES++eabvPfz58+X+vXrlznrWnlTp06VwYMH572PjIwUJycnS7Lyu3Dhgri5ucnq1astyfrss88kNDS0zMsuTtbs2bOla9euNs+6Vp6INeuQon5ntl6HXAsQIRbUG1u+itxCNAxjlmEYCYZhRFpYly1lZwdvvw0ffgj/+x/07g2nT5dtmWvXrsXf3586derkDXv55Zd54okn8Pf3L2OLi85av349np6euLu7s3jxYp599lnLsq4cHxwcfEOybO3KvKioKFq3bp03vnXr1pw8eZLExERL8iXfPnsRIT4+nnPnzlmSNWTIEA4ePEhMTAyZmZnMnTuXfv36WZKV3+LFi/Hx8aF79+6WLH/Tpk0EBgbSv39/vL296dmzJ7t377YkC2D79u14e3vTrFkzXn/99TLtwiwOq9YhhbFqHVKZFWeX6RzA+v+kG+Cpp+C772D7dvNpGbGxmBcuhoWZz18MCzPfFyE+Pp4xY8bw/vvv5w2LiIhgw4YNPP3009ee0UZZAKGhoZw7d474+HheeOEFAgMDLcvKNWvWLCIiInj++ectz7ouG+VduHABT0/PvPe53ycnJ5cpqzD9+vVjxowZnDp1ihMnTvDBBx8A5i7psvatMHXr1iU0NJTmzZtTs2ZNvv32W6ZNm2ZJVn5z585l2LBhVx8DtlFWfHw8CxcuZOzYsRw/fpw777yTQYMGkZGRYfOs7t27ExkZSUJCAosXL2bBggX8+9//vnpCG+VZtQ65liLXIdVRcTYjgUAgsribnRVtl+mV1q8XqV1bxNc1Wf506ipiGOb+VDs7ERcXkUmTrjlvQkKCtGjRQt544428YdnZ2dKhQ4e83USHDh26enfHpEnmssuYVZjw8HBp27atpVlLly4VX19f2bVrV8ERFmRdd5epDfNatWolixYtynt/+vTpgrtwS5ElUvguqpSUFBkzZowEBARIUFCQTJkyRRwcHCQ7O7tMfbtW3oQJE6Rz585y9OhRyczMlNmzZ0tgYKBcvHjR5lm5Dh8+LHZ2dnLw4MGCI2yYNXDgQOnZs2fe+5ycHPHw8JAdO3ZY1q9cCxYskHbt2lnSN6vWIcXt21XrEAtQCXaZ2qwgAqOACCCiYcOGtvspWmTvgu0SaBwSV5LlF/qZP4rcl4uLSHj4VfOcOXNG2rRpI+PHjy8wPCkpSQzDED8/P/Hz8xNvb28BxM/PT9auXWsuy8WlYEYpswqzbt068fDwMN9YkLVs2TLx9vaWzZs3FxxhUb+uWRBtnBcWFiYvv/xy3vuVK1dePoZYiqxcxVkBffbZZ9KpU6cy9e16eXfeeadMnz69wDBPT0/5888/LevbG2+8Id26dSs40MZZEydOlF69euW9L1AQLf6dLVy4sGDRsGFeSdYhWdhJNoZN+1ZgHWKRylAQDbOd12cYRiDwk4i0LM5WZ/v27SUiIqL4m6nlISyMEwtXcyc/sZ22NGMf/py8PN7HF265Je9tVtZ5du36G+7uHWna9D8FFiUiZGZenjct7Sjbt3ekU6d4HBx8sIs+AKcSADhAEwCacKBUWQAnT87H07Mbzs4NSUs7THT0MBwc6hAcvAT27LFpVlLSH+zZM5jg4KV4eV1xXMjGWeYfZTqpqbFERATTrVsqYGBn52RJ3pkzy4mOHkHr1n/g5BRAVNQ9uLt3pFGjqSXOAsjJyQBy2LmzN/7+I/DzG4phOGIYdqSnHwMMHB3rkpy8mT17BtOs2ZfUrt2nVH0rKi8u7lWSkn4jOHgxDg4+JCTMJyZmNJ07H8M+5rhNs3Jt2dKcBg3GU7fuo5dntHG/UlL2sXVrW1q2/AEvr14cO/YBx479hw4d9pb4/6yorMTEZbi7t8PR0Y+UlGiiou7Dx2cwgYGTbd43MIq9DomhGZ6cYxetcCDLPEni/vvNe1fmk5GRQU5ODr1792bEiBEMHToUR0dH7OzsmD9/Pt26daNhw4YcPnyYYcOGUadOHZYsWYJVDMPYKiLtLQuwgUp/c+9Si4nBnxOspidt2IETV1x/lppa4O3p00tJTv6TixejOHFiTt7wDh324OzcEEfHywfBc3LMR244OvphGPaQesVxoiuVMCslZQ+xsePJykrC3r4WdercQVDQW5eWZdusw4dfJyvrHLt335E3ztOzG61aLbN5Vnr6YTZvDsobvm5dTZycbqJTpzhL+la7dj8aNBjHzp29yMlJxdv7XgIDXy1VFsCuXX04d24NAOfPbyQmZhStW6/Cy6snqakHiY4eRmZmAk5ODQgKmnq5GFqQ17DheDIzE9i6tQ3Z2RepWbMJwcGLsbf3gtQDVy2rLFkA586Fk54ej4/PFZdb2LhfLi7Nufnmr4iJGU1mZgJubu1o2fIH7OwcbZ519uxK9u0bQXb2BRwd/fD1fZiGDV+2rG/FXYc4kU40LRjID3zLYNxyLsL+/Vdl9enThzVrzKyNGzcyatQoVq1aRc+ePdmzZw/jx48nKSmJWrVqcccdd/DWW29dvz/VQXE2I6lixxBFRGTIEHMffGG7O+zsRMLCNKsiZd3oPO2bZlWkvCuyvuAxsSNLOrJJThk+tu+bBagEu0yLUwwXAH8BmUA88FhR81SKgliG/f+aVQ5ZNzpP+6ZZFSmvkKzvGSjOpEgzY58cWrLNdlkWqRIFsTSvSlEQRS6ftZX7yauYZ21pVjll3eg87ZtmVaS8QrLWOfUWL+cUqVtXZOdO20fakhbEyiA83NwdERJifrX1p0jNqtx52jfNqkh5hWTt3i1Sr56Ip6eIDW4QZJnKUBCLdZZpSVWKs0yVUqqKOHIE+vaFQ4fg66/hnnvKu0VXqwxnmVbpm3srpVR10LCh+RzYtm1h8GD49NPyblHlpAVRKaWqgDp14PffzWfAPvEEvPqqefaNKj4tiEopVUW4usLSpTB8OLzyilkYS/vIu+qo+l6Yr5RSVZCDA8yeDXXrmg9GT0gwjys6O5d3yyo+3UJUSqkqxjDgrbdg2jRzi7FPHzh7trxbVfFpQVRKqSrq2WfNW5xu2gTdu8Px4+XdoopNC6JSSlVhQ4bAL7+Yl2R06QL79pV3iyouLYhKKVXF/e1vsHq1eb/xrl1h8+byblHFpAVRKaWqgZAQ2LABPD3h9tth2bLyblHFowVRKaWqiSZNzKLYrBkMHAjz5pV3iyoWLYhKKVWN+PvDmjXmSTbDh8O775Z3iyoOLYhKKVXNeHiYJ9rcfz+88AL861+Qk1P65Y0aNYrmzZtjZ2fHnDlzCoybO3cuISEhAG0Nw4g3DOMdwzAq5DXwWhCVUqoacnIyL8l46il4/30YNgwyMkq3rNatW/Pxxx/Trl27q8alpKQwffp0gB3AbUBv4PnStttKFbJKK6WUsp6dHXzwgXlXmwkT4NQpWLwY3NxKtpwxY8YA4FzI7XCeeOKJ3G9FRI4ZhjEf6FWmhltEtxCVUqoaMwx4+WWYOdO8Ofjtt5uF0ULdgShLE0pJC6JSSikee8y8zdvu3ea1ioeWbIewMPN6jbAw83Y3ZWQYxqNAe6BCnsqjBVEppRRgXorx++9w+mgKXe6ty86Fe2HbNvjmG+jdGyZPLsvivYC3gP4ictomDbYxLYhKKaXydK2xiXV0x55MurOGRQw2T0FNSTGv0SjFluLy5csBbgLuEpHdtm6zrWhBVEopddmMGQSnb2MDXXAmjSEsYhYjzHFpaTBjxlWzZGRkkJaWhoiQmZlJWloaOZeu4/jjjz946KGHAA6KyJYb1o9S0IKolFLqspgYcgTe518k4EcL9vIAi8xxOTmwf/9Vs/Tp04eaNWuyceNGRo0aRc2aNVm7di0Ar7/+OufOnQNoahjGhUuvCnnjOL3sQimlVJ6Mxi0Yse15FhDGM0znff6JHWKOtLMz7/t2hdWrV19zeatWrQLAMIztItLeijbbihZEpZRSACQnwz1x/+F3vJjKeMbxDkb+CZydYezY8mqe5XSXqVJKKRISoFcvWLXNi9kDlzLe5T8YdpdKhJ0duLjA889Dp07l21AL6RaiUkpVc7Gx0LcvHDsG//sf3Hnn3bBppXkCzf790LQpPPNMlS6GoAVRKaWqte3boX9/yMyElSuhc+dLIzp1qvIF8Eq6y1QppaqpP/6AHj3A0RHWr89XDKspLYhKKVUNffONuWXYsCFs3AgtWpR3i8qfFkSllKpm/vMfGDIEOnSAdeugfv3yblHFoAVRKaWqCRGYOBGefhruugt++w1q1SrvVlUcelKNUkpVA1lZMHo0fPkljBwJn3wC9loBCtAtRKWUquJSUuDee81iOHEifP65FsPC6I9EKaWqsDNnzN2j4eHmscNLD7dXhdCCqJRSVdTRo9CvHxw4AIsWweDB5d2iik0LolJKVUF79ph3nzl/HpYvN2/Lpq5PjyEqpVQVs3EjhIaaJ9KsWaPFsLi0IJbAjh07CAkJwcXFhZCQEHbs2GFZ1qhRo2jevDl2dnbMmTPHspyYmBgGDRqEj48PtWvXpm/fvuzbt8+SrNOnT9O1a1fq1KmDl5cXnTt3ZsOGDZZkXWnevHkYhsHMmTMtyzAMA1dXV9zc3HBzc2PkyJGWZQFkZ2czceJEAgICcHd3p23btpw9e9bmOevWrcvrU+7LMAwWL15s8ywwHyjbrl07PDw8aNSoEZ9//rklOQA//vgjLVu2xM3NjS5durBnzx7LsqDo/+tp06bh7++Ph4cHjz76KOnp6SXO+PFH+NvfIDt7FDVrNqddu6uzIiMj6du3L97e3hiGUfiCqiMRsfkrJCREqpr09HRp2LChvP/++5KWliYzZsyQhg0bSnp6uiV5//nPf+T333+XkJAQmT17tiUZIiKbN2+WmTNnSmJiomRkZMjEiROlefPmlmSlpqZKdHS0ZGdnS05OjixdulRq1aolmZmZluTlOnPmjDRv3lyCg4Pliy++sCwHkP3791u2/CtNmDBBevXqJXFxcZKTkyO7d++W1NRUy3NXrVolbm5ucuHCBZsvOyMjQzw8POTTTz+VnJwc2bJli7i6usqOHTtsnhUTEyPu7u6ybt06yczMlClTpkjjxo0t/Xu83v/18uXLxdfXVyIjI+XMmTPSo0cPGT9+fImWP2uWSI0aIu3bi7z11rWzoqOjZebMmfL999+LWQasB0SIBfXGli8tiMW0YsUKCQgIkJycnLxhDRo0kGXLllma27VrV0sL4pUSExMFkNOnT1uak52dLT/88IMAcvLkSUuzHn/8cfnoo4+kR48eVaYgnjlzRlxdXeXAgQM3JC+/ESNGyIgRIyxZ9okTJwSQixcv5g1r3769fP311zbP+vDDD+WOO+7Ie5+dnS3Ozs7y+++/2zzrSoX9X4eFhclLL72U9/73338XPz+/Yi0vJ0dkyhRzjf73v4ucP3/9rFz79+/XgpjvpbtMiykqKopWrVoV2L3QqlUroqKiyrFVtrd27Vr8/f2pU6eOZRmtWrXC2dmZgQMHMnLkSHx9fS3L2rJlCxEREYwePdqyjPy6d++Ov78/99xzD3FxcZbl7N69G3t7e7777jv8/f1p1qwZH330kWV5uS5evMh3333H8OHDLVm+n58fYWFhzJ49m+zsbMLDwzl8+DChoaGW5Jnr6cvfiwiRkZGWZBUlKiqK1q1b571v3bo1J0+eJDEx8brz5eTAs8/Cyy/Dgw/CTz+Bu7vFja2itCAW04ULF/D09CwwzNPTk+Tk5HJqke3Fx8czZswY3n//fUtzdu3axfnz5/n6668tW9GBeYztySef5D//+Q92dtb/qa9Zs4a4uDiio6MJCAhgwIABZGVlWZIVHx/PuXPniImJ4dChQ3z33Xe88sor/Pbbb5bk5VqyZAne3t706NHDsoywsDBee+01nJyc6NatG2+++SYNGjSwec7f/vY31qxZw+rVq8nIyGDKlClkZGSQkpJi86ziuHIdk/v99dYx6elmEfzgA3juOfjvf80nV6jSKdZawjCMfoZh7DMM44BhGC9a3agbatMmCAuDkBDz66ZNhU7m5ubG+fPnCww7f/487iX5KFbMLJsoYdapU6fo06cPTz75JGFhYZZmATg7OxMWFsbUqVPZuXOnJXkff/wxrVq1olNZnulWgr51794dR0dHvLy8mDFjBocOHWLv3r2W5NWsWROASZMmUbNmTVq1asWQIUP45ZdfbJ6V39y5cxk2bFjJT8QoZlZ0dDRDhgxh3rx5ZGRkEBUVxTvvvMPPP/9s86ybb76ZuXPn8tRTT1G3bl1Onz7NLbfcQv2S3unaRv/XV65jcr8vsI7Jl3X+vke5M/QcixbBO+/Ae++ZD7ZXZVDUPlWgBnAQaAQ4AjuBW643T6U5hjhpkoiLi4hhmDvf7ezM95MmXTXpihUrpF69egWOITZs2LD4xxBLkJVfqY4hljDrzJkz0qZNmxIfwC9N1pUaN24sS5YssSRv0KBB4uXlJX5+fuLn5ycODg7i4eEhY8aMsbxvWVlZ4urqKjt37rSkbwcOHBBADh8+nDfs6aeflmeffdbmWbmOHDkiNWrUKPlxyxJkffvtt9KmTZsCw5555pkb8jtLSkoSV1dX2bt3b/GyypB3rWOIL7/8ct77lStXFjyGmC/rBL7Slq1Sg0yZO2hxibNy6THEEp5UA3QGVuR7/xLw0vXmqRQFMTzc/OMybwBf8OXiYo7PJ/cs0+nTp0taWpp8+OGHxT/LtIRZuXmpqanSpUsX+fzzzyU1NVWys7NtnnXu3Dnp0KFD8Vc4ZcgKDw+XdevWSXp6uqSkpMjUqVPFzc1Njh07ZkleUlKS/PXXX3mvzp07y3vvvSdnz561eVZkZKRs375dsrKyJDk5WZ555hlp1qyZZGRkWNI3EZFu3brJqFGjJC0tTfbs2SM+Pj7FOyGkFFkiIm+++aZ069ateP0pZdaBAwfE1dVVVq5cKTk5OXLgwAFp3LixfPbZZ5b0KyIiQrKysiQhIUEGDx4sYWFhlvVN5Pr/18uWLRM/Pz+JioqSpKQk6dWr1+UPqfmyDtBIGrNfXLggP9O/VFk5OTmSmpoqUVFRAkhqaqqkpaUVv++lUBkKomG289oMw7gP6CciIy+9HwrcJiJPXWue9u3bS0RERBm2W2+AsDDzXkYiPMs0dtCm4HgfX7jllgKDkpO3ExMzkpSUPbi4tKBZsy9xd29bdNaePXAqAYADNAGgCQeum7VjR0/OnVtTYFjr1qvw8upp06wTJ+ayb98I7OxcgMu7wTp02IOzc0ObZp09u4YDB8aSlhaLYTjg6norgYGv4+XV/fo5pcy70o4dPfHze5i6dYtxfWAJs5KS/mD//idIT4+nRg1XPDy60KjRv3FxaWpZ39LTj7Fv32OcO7ceR0dfGjQYT0DA45ZkAWzZcjMNGrxA3bqPFa9PpcxKSPiGw4dfIz39MDVqeOLn9xBBQW9hGEXsDyxF1vbtoVy8uBPDcMDHZzCNG79PjRqulvWtqP/ro0ff5+jRt8nJScXb+16aNfsUOzunvCwBttOOTBxYRS86sdncT3r//bBgQYHl9uzZkzVrCmatWrWKnj17EhcXR1BQUIFxN910k6UnghmGsVVE2lsWYAM2u3WbYRijgFEADRsWsSKtCGJizM9y15KaetUgd/e2hIRsLXlWahEH6QvJatNmdclzSpHl7z8cf/9SnjFYwiwvrx60b1/C44VlyLtSiX6mJcyqVet2OnYsww0NStE3J6d6tGq1/IZkAXTsGH1Dsnx978fX9/4bktW27fqS55Qhr6i/wQYN/kmDBv+8ZpYBNCeaFuw1iyGYp5nu33/VLKtXXzsrMDCQojaGqqWiNiGpqrtMhwwx9/cXtrvDzk6kJLtONMv6rBudp33TrIqUd6P7ZgEqwS7T4hREeyAWCOLySTXB15unUhTEUh5H0axyyrrRedo3zapIeTe6bxaoEgXR7Ad3ADGYZ5tOKGr6SlEQRS6ftZX7yauEZ0hq1g3OutF52jfNqkh5N7pvNlZlCmJJX5WmIIqYn6yGDBEJCTG/WvlJS7MqX572TbMqUt6N7psNVYaCWORZpqVRKc4yVUopdcNUhrNM9b4GSimlFFoQlVJKKUALolJKKQVoQVRKKaUALYhKKaUUoAVRKaWUArQgKqWUUoAWRKWUUgrQgqiUUkoBWhCVUkopQAuiUkopBWDNvUwNwzgFHC7jYryB0zZoTkVWHfoI1aOf2seqQftonZtExKcccovNkoJoC4ZhRFT0G8GWVXXoI1SPfmofqwbtY/Wmu0yVUkoptCAqpZRSQMUuiJ+XdwNugOrQR6ge/dQ+Vg3ax2qswh5DVEoppW6kiryFqJRSSt0wWhCVUkopKmhBNAyjn2EY+wzDOGAYxovl3R5bMwxjlmEYCYZhRJZ3W6xiGEYDwzBWGYaxxzCMKMMwninvNtmaYRjOhmFsMQxj56U+vlrebbKKYRg1DMPYbhjGT+XdFisYhhFnGMZuwzB2GIYRUd7tsYJhGF6GYXxnGEa0YRh7DcPoXN5tqmgq3DFEwzBqADHA34F44E8gTET2lGvDbMgwjO7ABWCeiLQs7/ZYwTCMukBdEdlmGIY7sBX4RxX7PRqAq4hcMAzDAVgPPCMim8q5aTZnGMY/gfaAh4gMKO/22JphGHFAexGpshflG4YxF1gnIjMNw3AEXETkbDk3q0KpiFuIHYEDIhIrIhnAQmBQObfJpkRkLXCmvNthJRH5S0S2Xfo+GdgL1CvfVtmWmC5ceutw6VWxPmHagGEY9YE7gZnl3RZVOoZheALdgS8BRCRDi+HVKmJBrAcczfc+niq2Iq1uDMMIBNoCm8u5KTZ3aVfiDiAB+E1EqlwfgenAOCCnnNthJQF+NQxjq2EYo8q7MRYIAk4Bsy/t+p5pGIZreTeqoqmIBVFVIYZhuAGLgWdF5Hx5t8fWRCRbRNoA9YGOhmFUqV3ghmEMABJEZGt5t8VioSLSDugPjLl0WKMqsQfaAZ+ISFvgIlDlzs8oq4pYEI8BDfK9r39pmKpkLh1XWwzMF5El5d0eK13a/bQK6FfOTbG1rsDAS8fYFgK3G4bxVfk2yfZE5NilrwnAUsxDN1VJPBCfbw/Gd5gFUuVTEQvin0BTwzCCLh34HQL8UM5tUiV06YSTL4G9IvJ+ebfHCoZh+BiG4XXp+5qYJ4JFl2ujbExEXhKR+iISiPm/+IeIPFzOzbIpwzBcL534xaXdiH2AKnUGuIicAI4ahtH80qDe/7+9+3WtOgrjOP7+zIGGFWEgJkGDMxlsWmxGRTCJQVZdM1kEk3+BQVAwqKDBJrOoYNCwoIxFZ9m6wag8hnuUOYZM/N77vT/er3Thci5P+3zP957zPMDUHHDrynzfBexWVd+T3ABeAQeAh1W10XNZnUryFDgPLCbZAm5X1YN+q+rcOeAasN7+YwO4VVUv+yupc0eBR+1k9BzwrKqm8lrClDsCvBg8wzEPPKmq1X5LGooV4HHbaGwC13uuZ+yM3bULSZL6MI6vTCVJGjkDUZIkDERJkgADUZIkwECUpJnW9bCBJD9ak/SPSSbqypynTCVphnU9bCDJt6pa+P/KRs8doiTNsL2GDSQ5kWS19XZ9l2Spp/JGykCUJO12H1ipqjPATeDeP6w9lGQtyYckl4ZS3ZCMXacaSVJ/WkP+s8Dz1r0H4GD77jJwZ49l21V1oX0+VlXbSY4Dr5OsV9XnYdfdBQNRkrTTHPC1TXH5Q2vS/9dG/TsapW8mectg9NtEBKKvTCVJv7UxbV+SXIFBo/4kp/ezNsnhJL92k4sMehpPTBNxA1GSZlgbNvAeOJlkK8kycBVYTvIJ2AAu7vPnTgFrbd0b4G5VTUwgeu1CkiTcIUqSBBiIkiQBBqIkSYCBKEkSYCBKkgQYiJIkAQaiJEkA/AQP59VzlvkqlAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T13:35:26.515Z', endedAt='2023-01-29T13:36:03.638Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0,\n", + " 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0]))])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/6d7afdb4-9263-47c4-929a-96477b27ed25\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 34.9571\n", + "Average post-processed IS size: 33.1852\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEKCAYAAAAB0GKPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZDUlEQVR4nO3df7hdVX3n8feHCGhLRZT4iwCBEUfQKowRsY44KkIoClSxRKuDrQ7jD7SKv2LtYI1jJ0ofbR2pQiWCigINqCnEYaiAYhVNAAVBg4EGCMoQDUUZEAx8+8fekcP13tx9cs85ubm8X8+zn5y99o+1dnJzPvesdfbaqSokSZrMNlu6AZKkrYOBIUnqxMCQJHViYEiSOjEwJEmdPGxLN2BYdt5555o7d+6WboYkbVUuv/zyn1XV7PG2zdjAmDt3LitXrtzSzZCkrUqSGyfaZpeUJKkTA0OS1ImBIUnqxMCQJHViYEiSOjEwJEmdGBiSpE4MDElSJwaGJKmTGXunt2auuQvPH+j51iw+bKDnk2YqP2FIkjoxMCRJnRgYkqRORhoYSeYnWZVkdZKF42w/Psm1Sa5K8rUku/dsuy/J99pl2SjbLUka4aB3klnAScCLgbXAiiTLqurant2uBOZV1V1J3gh8BDi63XZ3Ve07qvZKkh5slJ8w9gdWV9UNVXUvcCZwRO8OVXVxVd3Vrl4GzBlh+yRJmzDKwNgFuLlnfW1bNpHXAV/tWX94kpVJLkty5HgHJDm23WflunXrptxgSdIDpuV9GEleDcwDnt9TvHtV3ZJkT+CiJFdX1fW9x1XVKcApAPPmzauRNViSHgJG+QnjFmDXnvU5bdmDJDkIeB9weFXds7G8qm5p/7wBuATYb5iNlSQ92CgDYwWwV5I9kmwHLAAe9G2nJPsBJ9OExW095Tsl2b59vTPwXKB3sFySNGQj65Kqqg1JjgMuAGYBS6rqmiSLgJVVtQw4EdgB+MckADdV1eHA3sDJSe6nCbnFY75dJUkaspGOYVTVcmD5mLITel4fNMFx3wJ+f7itkyRtind6S5I6MTAkSZ0YGJKkTgwMSVInBoYkqRMDQ5LUiYEhSerEwJAkdWJgSJI6MTAkSZ0YGJKkTgwMSVInBoYkqRMDQ5LUiYEhSerEwJAkdTLSByhJW5O5C88f6PnWLD5soOeTRs1PGJKkTgwMSVInBoYkqRMDQ5LUiYEhSerEwJAkdWJgSJI6MTAkSZ0YGJKkTgwMSVInBoYkqRMDQ5LUiYEhSerEwJAkdTLSwEgyP8mqJKuTLBxn+/FJrk1yVZKvJdm9Z9sxSX7cLseMst2SpBEGRpJZwEnAocA+wCuT7DNmtyuBeVX1dGAp8JH22EcD7weeDewPvD/JTqNquyRptJ8w9gdWV9UNVXUvcCZwRO8OVXVxVd3Vrl4GzGlfHwJcWFXrq+p24EJg/ojaLUlitIGxC3Bzz/ratmwirwO+2s+xSY5NsjLJynXr1k2xuZKkXtNy0DvJq4F5wIn9HFdVp1TVvKqaN3v27OE0TpIeokYZGLcAu/asz2nLHiTJQcD7gMOr6p5+jpUkDc8oA2MFsFeSPZJsBywAlvXukGQ/4GSasLitZ9MFwMFJdmoHuw9uyyRJI/KwUVVUVRuSHEfzRj8LWFJV1yRZBKysqmU0XVA7AP+YBOCmqjq8qtYn+SBN6AAsqqr1o2q7JGmEgQFQVcuB5WPKTuh5fdAmjl0CLBle6yRJmzItB70lSdOPgSFJ6sTAkCR1YmBIkjoxMCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFJ6sTAkCR10jkwkrytfVSqJOkhqJ9PGG8HfpLk7CQHD6tBkqTpqZ/AmEvzDO77ga8kuTHJoiRzh9EwSdL00jkwqnFBVS2geZ723wAvAVYnuTDJgiSzhtVQSdKWtVmD3u3Diy4HrgQ2AHsAJwFrkrxocM2TJE0XfQVGkscleXeSHwL/DGwPzK+qJ9F86vgsPuRIkmakfr4l9U/AzcBrgE8Cu1TVq6vqEoCq+hXwd8CuQ2inJGkL6+cRrbcBB1bVZZvYZx1N95QkaYbpp0vq6zRjFg+SZLsk/xV+MzB+46AaJ0maPvoJjM8AO45T/nvtNknSDNZPYASoccp3A+4YTHMkSdPVpGMYSa6mCYoCvp5kQ8/mWcDuwPLhNE+SNF10GfRe2v75NOB84M6ebfcCa4BzBtssSdJ0M2lgVNUHAJKsAc5qvz4rSXqI6fy12qo6fZgNkSRNb5sMjCS/APasqp8l+SXjD3oDUFWPHHTjJEnTx2SfMN4C/LLn9YSBIUma2TYZGL3dUFV12tBbI0matnxEqySpk8nGMDY5btHLMQxJmtkmG8M4bpCVJZlPM6PtLODTVbV4zPYDgb8Fng4sqKqlPdvuA65uV2+qqsMH2TZJ0qZ1HsOYqvZpfCcBLwbWAiuSLKuqa3t2uwl4LfDOcU5xd1XtO6j2SJL608/05lO1P7C6qm4ASHImzTPCfxMYVbWm3Xb/CNslSepgk4PeSX6RZOf29S/b9XGXDnXtQvMApo3WtmVdPTzJyiSXJTlygvYe2+6zct26dX2cWpI0mX7uwxjoeMZm2L2qbkmyJ3BRkqur6vreHarqFOAUgHnz5nnPiCQNUD/3YUx1POMWHvz41jltWSdVdUv75w1JLgH2A67f5EGSpIHpewwjyQuBfdrVa6vqoo6HrgD2SrIHTVAsAF7Vsc6dgLuq6p62i+y5wEf6a7kkaSo6B0b7Rn8OzVdef9IWP7F9XsbLNw5mT6SqNiQ5DriA5mu1S6rqmiSLgJVVtSzJs4AvATsBL03ygap6KrA3cHI7GL4NsHjMt6skSUPWzyeMU2nGM/asqpsAkuwGnA58GnjhZCeoquWMedhSVZ3Q83oFTVfV2OO+Bfx+H22VJA1YP4HxHOCAjWEBUFU3JXk78O2Bt0ySNK30M5fUTcAjxil/OA/+uqwkaQbqJzDeAXw8yQFJZiXZJskBNFN5vGMorZMkTRv9Tj74cOBfgI13Ym8D3AecATj5oCTNYCOdfFCStPUa2eSDkqSt22ZNPpjk8cB2vWW9356SJM08/dy4tyPwceCPGRMWrVmDapQkafrp51tSfwM8AzgS+BXNtB7vopl19uiBt0ySNK300yV1KPDKqrq0ffrd5VV1VpKfAv8dWLrpwyVJW7N+PmE8CrixfX0H8Jj29beBPxhgmyRJ01A/gXE9sGf7+ofAgiQBXgasH3TDJEnTSz+BcRrNTLUAi2m6oe4FTgQ+PNhmSZKmm85jGFX1sZ7XFyXZG3gm8OOqunoYjZMkTR+bdR8GQFXdyANjGpKkGa6fLimSHJnkG0l+1i6XJvmjYTVOkjR9dA6MJO8AzgJWAe9ulx8BX0jyzuE0T5I0XfTTJfVO4Liq+oeesiVJvgssormxT5I0Q/XTJbUDcPE45Re32yRJM1g/gfFl4Khxyl8OLBtIayRJ09ZkD1A6vmd1NbAwyQt44BneB7TLR4fTPEnSdDHZGMZbxqzfDjy5XXrLXkszjiFJmqEme4DSHqNqiCRpeuvrPoyNkuyQ5HcH3RhJ0vTV7417b05yE81stb9IcmOSNw2naZKk6aSfJ+79BfBemvstvtkWPw9YnOSRVbV4CO2b0eYuPH/g51yz+LCBn7OrmXY9kh6snxv33gAcW1Vf7Cn7WpIfA39NM4OtJGmG6qdL6rHAinHKvws8bjDNkSRNV/0ExnU0z/Ee61U080tJkmawfrqk/go4O8mBwL+0Zc8Fng+8YsDtkiRNM50/YVTVucD+wK3AS9rlVmD/qvryUFonSZo2OgVGkm2TnAXcUVWvrqpntsurq+rKrpUlmZ9kVZLVSRaOs/3AJFck2ZDkqDHbjkny43Y5pmudkqTB6BQYVfVr4GCgNreiJLOAk4BDgX2AVybZZ8xuN9FMM/KFMcc+Gng/8GyaTznvT7LT5rZFktS/fga9zwVeNoW69gdWV9UNVXUvcCZwRO8OVbWmqq4C7h9z7CHAhVW1vqpuBy4E5k+hLZKkPvUz6H0T8JdJngesBP5/78aqmmzG2l2Am3vW19J8YuhivGN3GbtTkmOBYwF22223jqeWJHXRT2C8lmZm2qe3S69iGkxxXlWnAKcAzJs3b7O7zyRJv61zYPTOXJtkh7bszj7qugXYtWd9TlvW9dj/MubYS/qoW5I0Rf1OPvi2nskH70hyc5K3J0mHw1cAeyXZI8l2wAK6P6nvAuDgJDu1g90Ht2WSpBHpZ/LBj9CMD5zIA0/cew5wAvAE4N2bOr6qNiQ5juaNfhawpKquSbIIWFlVy5I8C/gSsBPw0iQfqKqnVtX6JB/kgalJFlXV+u6XKUmaqn7GMF4PvL6qlvaUXZRkFXAykwQGQFUtB5aPKTuh5/UKmu6m8Y5dAizpo72SpAHq9wFKV01QtlkPYpIkbT36eaP/LPDmccrfCHxuMM2RJE1X/XRJbQ+8KskhwGVt2bOBJwJnJPn4xh2r6q2Da6IkaTroJzCeAlzRvt69/fPWdtm7Zz/vf5CkGaif+zBeMMyGSJKmNwerJUmdGBiSpE4MDElSJwaGJKkTA0OS1ImBIUnqxMCQJHViYEiSOjEwJEmdGBiSpE76mUtKW6m5C88f+DnXLD5s4Od8KPLfRlsTP2FIkjoxMCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFJ6sTAkCR1YmBIkjoxMCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFJ6mSkgZFkfpJVSVYnWTjO9u2TnNVu/06SuW353CR3J/leu3xqlO2WJI3wAUpJZgEnAS8G1gIrkiyrqmt7dnsdcHtVPSnJAuDDwNHttuurat9RtVeS9GCj/ISxP7C6qm6oqnuBM4EjxuxzBHB6+3op8KIkGWEbJUkTGGVg7ALc3LO+ti0bd5+q2gDcATym3bZHkiuTfD3J88arIMmxSVYmWblu3brBtl6SHuK2lkHvnwK7VdV+wPHAF5I8cuxOVXVKVc2rqnmzZ88eeSMlaSYbZWDcAuzasz6nLRt3nyQPA3YEfl5V91TVzwGq6nLgeuDJQ2+xJOk3RhkYK4C9kuyRZDtgAbBszD7LgGPa10cBF1VVJZndDpqTZE9gL+CGEbVbksQIvyVVVRuSHAdcAMwCllTVNUkWASurahlwKvC5JKuB9TShAnAgsCjJr4H7gTdU1fpRtV2SNMLAAKiq5cDyMWUn9Lz+FfCKcY47Bzhn6A2UJE1oaxn0liRtYQaGJKkTA0OS1ImBIUnqZKSD3luTuQvPH+j51iw+bKDnk/ox6J9n2LI/0zPp/+fW9G/jJwxJUicGhiSpEwNDktSJgSFJ6sTAkCR1YmBIkjoxMCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFJ6sTAkCR1YmBIkjoxMCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFJ6sTAkCR1YmBIkjoxMCRJnRgYkqRODAxJUicGhiSpk5EGRpL5SVYlWZ1k4Tjbt09yVrv9O0nm9mx7b1u+Kskho2y3JGmEgZFkFnAScCiwD/DKJPuM2e11wO1V9STgY8CH22P3ARYATwXmA3/fnk+SNCKj/ISxP7C6qm6oqnuBM4EjxuxzBHB6+3op8KIkacvPrKp7qupfgdXt+SRJI5KqGk1FyVHA/Kp6fbv+GuDZVXVczz4/aPdZ265fDzwb+Cvgsqr6fFt+KvDVqlo6po5jgWPb1f8IrBrqRTV2Bn5mPdOuDuuZ/vWMwky6FhjN9exeVbPH2/CwIVc8UlV1CnDKKOtMsrKq5lnP9KrDeqZ/PaMwk64Ftvz1jLJL6hZg1571OW3ZuPskeRiwI/DzjsdKkoZolIGxAtgryR5JtqMZxF42Zp9lwDHt66OAi6rpM1sGLGi/RbUHsBfw3RG1W5LECLukqmpDkuOAC4BZwJKquibJImBlVS0DTgU+l2Q1sJ4mVGj3Oxu4FtgAvLmq7htV2ycxqi6wmVTPTLoW65neZtK1wBa+npENekuStm7e6S1J6sTAkCR1YmB0lGTXJBcnuTbJNUn+vC1/RpJvJ7k6yT8leeQU63l4ku8m+X5bzwfa8j3a6VJWt9OnbDekeo5r66gkO0+ljknqOaOd5uUHSZYk2XZI9Zzall2VZGmSHQZdR8/2jye5cyrXMcm1nJbkX5N8r132HVI9SfKhJNcl+WGSt071mkZhE9fzoiRXtH9n30zypC3d1q6SzEpyZZLz2vWBvg/0rapcOizAE4D/1L7+PeA6milOVgDPb8v/DPjgFOsJsEP7elvgO8ABwNnAgrb8U8Abh1TPfsBcYA2w8wD+3iaq5w/bbQG+OMTreWTPPh8FFg66jnZ9HvA54M4h/p2dBhw1wJ/pier5U+CzwDbttscOqs5hLpu4nuuAvdvyNwGnbem29nFNxwNfAM5r1wf6PtDv4ieMjqrqp1V1Rfv6l8APgV2AJwPfaHe7EHj5FOupqtr4W+q27VLAC2mmS4Fm+pQjh1FPVV1ZVWumcu6O9SxvtxXNV6TnDKmeX0DzWzPwCJq/y4HWkWZesxOBd2/uubvUM4hzd6znjcCiqrq/3e+2Qdc9DJu4ngI2fvLfEfjJFmhe35LMAQ4DPt2uhwG/D/TLwNgMaWbR3Y/mN5hreGBOrFfw4BsMN/f8s5J8D7iNJoSuB/6tqja0u6ylCauB1lNV35nqOfutp+2Keg3wf4ZVT5LPALcCTwH+9xDqOA5YVlU/ncq5O9QD8KG2e+1jSbYfUj3/ATg6ycokX02y11TrGZUJruf1wPIka2l+1hZvwSb2429pfgm5v11/DEN4H+iHgdGntg/8HOBt7W+vfwa8KcnlNF1V9061jqq6r6r2pfmte3+aN7qBG1tPkqdtgXr+HvhGVV06rHqq6k+BJ9J8Kjx6wHUcSPOLwpSCqEM9TwPeS/Oz8Czg0cB7hlTP9sCvqpmC4h+AJVOtZ1QmuJ63A39YVXOAz9B0TU5rSV4C3FZVl2/ptvQyMPrQ/jZ8DnBGVZ0LUFU/qqqDq+qZNH3x1w+qvqr6N+Bi4DnAo9JMlwIDnhqlp575gzpnl3qSvB+YTdNPO7R62rL7aGZInlKX4Th1vAB4ErA6yRrgd9LceDoQvdfSdotWVd1D88Y3sBmbx/ydrQXObTd9CXj6oOoZlZ7rORR4Rs8ntLOAP9hS7erDc4HD25+pM2m6ov6OIb4PdGFgdNT2H54K/LCqPtpT/tj2z22Av6QZiJpKPbOTPKp9/QjgxTS/GV9MM10KNNOnfGUI9fxoKufsp54krwcOAV65sa98CPWs2viNmPbf73CmcI0T1HF5VT2+quZW1Vzgrmqe5zLoa/lRkif0XMuRwA+GUQ/wZZogBHg+zaDxtLeJ/zs7Jnlyu9vGsmmtqt5bVXPan6kFNNMk/QkDfh/o14yarXbInkvT/3l120cK8Bc082O9uV0/l+Y3v6l4AnB6O5C6DXB2VZ2X5FrgzCT/E7iSJryGUc9bafpNHw9clWR5tVPSD7ieDcCNwLeb9z/OrapFg6wHOB+4NM1XnQN8n2ZAd2B1VNV5UzhfX/UkuSjJbJpr+R7whiHV803gjCRvB+6kGQPYGkx0Pf8NOCfJ/cDtNN3IW6v3MNj3gb44NYgkqRO7pCRJnRgYkqRODAxJUicGhiSpEwNDktSJgSFtAUkuSfKJLd0OqR9+rVYaI8lpNDP1vqRd/x2amzL/mObu2juBVcAnquqLm1nHo4FfVzORpbRV8MY9aXKforlx889p7q7eiWba7Edv7gmrav1gmiaNjl1S0uQOB/5XVZ1XVWvaKeA/WVUnTXRAkm3TPFDpJ0nuSXJzksU923/TJZXktWkeWDV2Oa1n/5cmuTzJr9I8ROlD6Xl4TpKXtbPY3p1kfZKvJ3nccP469FBlYEiTuxWYn2THPo55K/BHNPMA7UUzS+6qCfY9i2Zai43LITSzHn8dIMkhwBnAJ4Cn0kxtcRTw1+32x9NMUHc6sDdwIM3DnKSBsktKmtyxNG/YP0tyNfAt4CtVdeEmjtmdZtK+S9uHRN3UHvdbqupu4G74zWSWpwCfrKqN85K9DzixZ/36JO8BPp/kXTRTt28LLK2qG9t9pjQxoTQeP2FIk6iqbwB70kwxfTbNUxb/b5KTN3HYacC+wHVJTkpyWDuj8YTaLqZzaWZTfUfPpmcC70ty58aF5rGdv0szSeT3gX8GfpDknCRvbCcplAbKwJA6qKpfV9WlVbW4qg4G/gdwbJqnL463/xU0z0Z/L83/s9OBCycJjZNpBtSPbp/fsdE2wAdoAmjj8nSarq517b4Ht8tVwOuAHyd5xuZcqzQRu6SkzXNt++cOE+3QfmV2KbC0HcC+jOZhS7/1fIkk7wReAuy/8TnkPa4AnlJVEz6Yqe32+jbNdPGLaB4dfDTNpw9pIAwMaRJJLqF5muJK4OfAPjQDzj9igofxJDke+CnNcyt+DbwK+AXN0+zG7ntQe74/Ae5uB7EB7q6qO4BFwHlJbqTpEtsAPI0mXN6d5ADgIOAC4P/RPG9+Vx4INWkgDAxpchfQPDzrQzSfKG4FLgQWjek66vVL4F003UZF87CbQ6vqrnH2/c80g9Znjyk/HXhtVV2Q5DCabrB30gTGdTTjJAB30Nwn8hbgUcDNwAer6vP9Xqi0Kd7pLUnqxEFvSVInBoYkqRMDQ5LUiYEhSerEwJAkdWJgSJI6MTAkSZ0YGJKkTv4dgujTtOwWk+EAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/team_solutions/q/99_qubits_random.ipynb b/team_solutions/q/99_qubits_random.ipynb new file mode 100644 index 00000000..e0fcd5eb --- /dev/null +++ b/team_solutions/q/99_qubits_random.ipynb @@ -0,0 +1,1311 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5b0ab25d-cf12-4270-8612-4bd372f0f7bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c2e85850-c5a4-4552-a562-60fbedf1a23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "47db7e7f-a003-4037-88ad-0ec688b47041", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "99\n", + "GRAPH: [(0, 1), (0, 4), (0, 14), (0, 21), (0, 32), (0, 53), (1, 4), (1, 21), (1, 37), (1, 38), (1, 53), (1, 62), (2, 6), (2, 10), (2, 20), (2, 34), (2, 43), (2, 49), (2, 63), (3, 8), (3, 59), (3, 75), (3, 85), (3, 93), (4, 21), (4, 38), (4, 62), (4, 95), (4, 98), (5, 81), (6, 20), (6, 31), (6, 41), (6, 43), (6, 70), (6, 89), (6, 91), (7, 55), (7, 79), (7, 88), (8, 35), (8, 54), (8, 75), (8, 85), (8, 93), (9, 26), (9, 33), (9, 48), (10, 16), (10, 29), (10, 43), (10, 49), (10, 57), (10, 63), (11, 26), (11, 48), (11, 67), (12, 13), (12, 15), (12, 32), (12, 80), (13, 32), (13, 51), (13, 53), (13, 80), (13, 94), (14, 21), (14, 27), (14, 73), (14, 98), (15, 40), (15, 80), (16, 28), (16, 29), (16, 63), (17, 19), (17, 52), (18, 69), (18, 87), (19, 52), (19, 65), (20, 34), (20, 39), (20, 43), (20, 49), (20, 70), (20, 91), (21, 95), (21, 98), (22, 92), (23, 35), (23, 51), (23, 54), (23, 92), (23, 94), (24, 61), (24, 66), (24, 84), (24, 96), (25, 36), (25, 38), (25, 42), (25, 78), (25, 79), (25, 83), (26, 33), (26, 48), (27, 33), (27, 48), (27, 68), (27, 73), (28, 29), (28, 57), (28, 65), (28, 77), (29, 57), (29, 63), (29, 77), (30, 48), (30, 67), (30, 68), (30, 86), (31, 40), (31, 41), (31, 43), (31, 89), (31, 91), (32, 51), (32, 53), (32, 80), (33, 48), (33, 68), (34, 39), (34, 49), (34, 70), (35, 54), (35, 75), (35, 85), (35, 92), (35, 94), (36, 83), (36, 88), (37, 62), (37, 74), (37, 82), (38, 62), (38, 78), (38, 82), (38, 95), (39, 70), (39, 76), (40, 41), (40, 89), (41, 44), (41, 86), (41, 91), (42, 78), (42, 82), (42, 83), (43, 89), (44, 70), (44, 72), (44, 76), (44, 91), (45, 46), (45, 56), (45, 57), (45, 64), (45, 77), (45, 97), (46, 60), (46, 89), (46, 97), (47, 58), (48, 68), (49, 63), (50, 55), (50, 95), (50, 98), (51, 53), (51, 94), (52, 65), (54, 85), (54, 94), (55, 79), (56, 60), (56, 64), (56, 81), (56, 97), (57, 64), (57, 77), (58, 59), (60, 90), (60, 97), (61, 66), (61, 67), (61, 84), (62, 74), (62, 78), (62, 82), (64, 77), (64, 97), (65, 77), (66, 67), (66, 72), (66, 84), (67, 72), (68, 73), (68, 86), (69, 87), (70, 76), (70, 91), (71, 85), (71, 87), (71, 90), (71, 93), (72, 76), (72, 84), (74, 82), (76, 91), (78, 82), (78, 83), (79, 88), (79, 95), (81, 87), (81, 90), (84, 96), (85, 93), (95, 98)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import visualize_graph\n", + "\n", + "def kings_graph(numx,numy,filling=0.7,seed=None):\n", + " '''\n", + " Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed\n", + " numx - number of grid points in the X direction\n", + " numy - number of grid points in the Y direction\n", + " filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling)\n", + " \n", + " Returns\n", + " pos - [N x 2] array of points on a square grid\n", + " graph - networkx connectivity graph\n", + " '''\n", + " xx,yy = np.meshgrid(range(numx),range(numy))\n", + " num_points = int(numx*numy*filling)\n", + " rand = np.random.default_rng(seed=seed)\n", + " # Generate points\n", + " points = np.array([xx.flatten(),yy.flatten()]).T\n", + " points = points[rand.permutation(numx*numy)[0:num_points],:]\n", + " #for point in points:\n", + " #print('point: ', point)\n", + " #for x in point:\n", + " #print(\"coordinates: \", x)\n", + " \n", + " #points=np.array([[1,2],[1,3],[0,1]])\n", + "\n", + " \n", + "# points=[]\n", + "\n", + "# 100 qubit sssssnakee---------------------------\n", + "# points.append([1,0])\n", + "# points.append([2,0])\n", + "# points.append([3,0])\n", + "# points.append([4,0])\n", + "# points.append([5,0])\n", + "# points.append([6,0])\n", + "# points.append([7,0])\n", + "# points.append([8,0])\n", + "# points.append([9,0])\n", + "# points.append([10,0])\n", + "# points.append([11,0])\n", + "# points.append([12,0])\n", + "# points.append([13,1])\n", + "# points.append([12,2])\n", + "# points.append([11,2])\n", + "# points.append([10,2])\n", + "# points.append([9,2])\n", + "# points.append([8,2])\n", + "# points.append([7,2])\n", + "# points.append([6,2])\n", + "# points.append([5,2])\n", + "# points.append([4,2])\n", + "# points.append([3,2])\n", + "# points.append([2,2])\n", + "# points.append([1,2])\n", + "# points.append([0,3])\n", + "# points.append([1,4])\n", + "# ##\n", + "# points.append([2,4])\n", + "# points.append([3,4])\n", + "# points.append([4,4])\n", + "# points.append([5,4])\n", + "# points.append([6,4])\n", + "# points.append([7,4])\n", + "# points.append([8,4])\n", + "# points.append([9,4])\n", + "# points.append([10,4])\n", + "# points.append([11,4])\n", + "# points.append([12,4])\n", + "# points.append([13,5])\n", + "# points.append([12,6])\n", + "# points.append([11,6])\n", + "# points.append([10,6])\n", + "# points.append([9,6])\n", + "# points.append([8,6])\n", + "# points.append([7,6])\n", + "# points.append([6,6])\n", + "# points.append([5,6])\n", + "# points.append([4,6])\n", + "# points.append([3,6])\n", + "# points.append([2,6])\n", + "# points.append([1,6])\n", + "# points.append([0,7])\n", + "# points.append([1,8])\n", + "# ##\n", + "# points.append([2,8])\n", + "# points.append([3,8])\n", + "# points.append([4,8])\n", + "# points.append([5,8])\n", + "# points.append([6,8])\n", + "# points.append([7,8])\n", + "# points.append([8,8])\n", + "# points.append([9,8])\n", + "# points.append([10,8])\n", + "# points.append([11,8])\n", + "# points.append([12,8])\n", + "# points.append([13,9])\n", + "# points.append([12,10])\n", + "# points.append([11,10])\n", + "# points.append([10,10])\n", + "# points.append([9,10])\n", + "# points.append([8,10])\n", + "# points.append([7,10])\n", + "# points.append([6,10])\n", + "# points.append([5,10])\n", + "# points.append([4,10])\n", + "# points.append([3,10])\n", + "# points.append([2,10])\n", + "# points.append([1,10])\n", + "# points.append([0,11])\n", + "# points.append([1,12])\n", + "# ##\n", + "# points.append([2,12])\n", + "# points.append([3,12])\n", + "# points.append([4,12])\n", + "# points.append([5,12])\n", + "# points.append([6,12])\n", + "# points.append([7,12])\n", + "# points.append([8,12])\n", + "# points.append([9,12])\n", + "# points.append([10,12])\n", + "# points.append([11,12])\n", + "# points.append([12,12])\n", + "# points.append([13,13])\n", + "# points.append([12,14])\n", + "# points.append([11,14])\n", + "# points.append([10,14])\n", + "# points.append([9,14])\n", + "# points.append([8,14])\n", + "# points.append([7,14])\n", + "# points.append([6,14])\n", + "# points.append([5,14])\n", + "# points.append([4,14])\n", + " #points.append([3,14])\n", + " #points.append([2,14])\n", + " #points.append([1,14])\n", + " #points.append([0,15])\n", + " #points.append([1,16])\n", + " ##\n", + "\n", + "\n", + " \n", + " \n", + " print(len(points))\n", + " #points2 = points.tolist()\n", + " #print(\"POINTS 2:\", points2)\n", + " #points=np.array(points)\n", + " #print(\"test: \" , points[:0])\n", + " # Generate a unit disk graph by thresholding distances between points.\n", + " distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2)\n", + " graph = nx.Graph(distances<=np.sqrt(2))#+1E-10)\n", + " \n", + " graph.remove_edges_from(nx.selfloop_edges(graph))\n", + " print(\"GRAPH: \", graph.edges)\n", + " return points, graph\n", + "\n", + "# Make a small king's graph\n", + "pos,small_G = kings_graph(13,13,0.59,seed = 1)\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "385e0886-b252-4adf-b6e0-b7b1bf2333b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def find_UDG_radius(position, graph):\n", + " '''\n", + " Computes the optimal unit disk radius for a particular set of positions and graph.\n", + " position - [N x 2] array of points\n", + " graph - network connectivity graph. This should be a unit disk graph.\n", + " \n", + " returns\n", + " radius - Optimal unit disk radius of the graph\n", + " rmin - Minimum distance\n", + " rmax - Maximum distance\n", + " '''\n", + " \n", + " dists = np.sqrt((position[:,0,None] - position[:,0])**2\n", + " + (position[:,1,None] - position[:,1])**2)\n", + " rmin = 0\n", + " rmax = np.inf\n", + " for i in range(position.shape[0]):\n", + " for j in range(i+1,position.shape[0]):\n", + " if (i,j) in graph.edges:\n", + " if rmindists[i,j]:\n", + " rmax = dists[i,j]\n", + " \n", + " if rmin>rmax:\n", + " print(rmin,rmax)\n", + " raise BaseException(\"Graph is not a unit disk graph!\")\n", + " \n", + " return np.sqrt(rmin*rmax),rmin,rmax\n", + "\n", + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "\n", + "\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 316, + "id": "10ac48c7-e642-4108-9fea-b4c845426899", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAG2CAYAAADhtfbVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd1hURxfG37tL7yJN7CWiYgU1diwptmjUGFGTaKIxGhM1TRM1mqgxJl9iNFWNPbHFFrsmKgIqFoyKHbGg2BEsICyw+35/DLsssMCy7NK8v+fZR7llzszcuXPuzJw5RyIJGRkZGRmZpx1FSWdARkZGRkamNCArRBkZGRkZGcgKUUZGRkZGBoCsEGVkZGRkZADIClFGRkZGRgYAYFXSGZCRkZGRKRmOHTvmZWVltRBAQ5T/AZIGwOmMjIzhgYGBdw1dICtEGRkZmacUKyurhT4+PvU9PT0TFQpFud6Dp9FopHv37jW4ffv2QgC9DF1T3r8IZGRkZGTypqGnp+ej8q4MAUChUNDT0/MhxGjY8DXFmB8ZGRkZmdKF4mlQhloyy5qn3rOYQpQkabEkSXclSTptpvTUkiSdyPxtNkeaMjIyMjIyWiw5QlwKoKsZ00sh2TTzZ3D+V0ZGRkbGguzZ44iXXqoJf//6eOmlmtizx9Ecyc6YMcOrVq1a/i4uLk0nTpzoAwAffvih75QpU7wBoF+/fjWWLFlSwdj0Lly4YPPMM8/4FzYfFjOqIRkmSVIN/WOSJNUG8AsATwBPALxN8ryl8iAjIyMjYyY++MAX8+Z5Q6VSgATOnbPH7t1uGDnyDn744WZRkl60aJHn7t27o2vXrp1uruyaQnGvIS4A8D7JQAAfA/i1EPfaSZIUKUnSIUmSXrZI7mRkZGRkcrNnjyPmzfNGaqpQhgBASkhNVWDePO+ijBQHDRpULS4uzrZbt27PfPnll15vvPFGtfyuDw8Pd2jRooWfv79//Xbt2j0TGxtrrT3u5+fXwM/Pr8Hs2bO9TMlLsSlESZKcALQBsFaSpBMA5gOolHmuryRJpw38duklUZ1kcwCDAMzJHG3KyMjIyFiaOXO8oFIZ1hcqlYQ5c0xSQACwcuXKa15eXumhoaHRFSpUUOd3rUqlksaMGVNt06ZNl86cOXNuyJAh8R9//HFlABg2bFiNOXPmXLtw4cJZU/NSnPsQFQAekGya8wTJDQA25HczyRuZ/16WJGkfgGYALpk/mzIyMjIy2bh82Q55hQokJVy5Ylcc2YiKirK9ePGifefOnesCgEajgaenZ3p8fLzy8ePHym7duiUBwFtvvXV/7969roVNv9gUIslHkiRdkSSpP8m1kiRJABqTPFnQvZIkVQDwhKRKkiQPAG0BfGvpPMvIyMjIAKhVKxXnztmDlHKdkySiZs3U4sgGSalOnTopJ06cyGZ7Eh8frzRH+pbcdrEKQAQAP0mS4iRJGgZgMIBhkiSdBHAGQG8jk6sPIDLzvhAAs0iaPCyWkZGRkSkE48bdha2t4SGirS0xbpxBV2jmpnHjxqkJCQlWu3fvdgTEFGpkZKSdh4eH2tnZWb1r1y4nAFi6dKm7Kelb0sp0YB6nCr0Vg+RBAI2KliMZGRkZGZPo0iUZI0feybQylUBKkCTC1pYYOfIOunRJLo5s2NnZcfXq1ZfGjBlT7fHjx0q1Wi2NGjXqTvPmzVMXLVp0dfjw4TUkSULHjh0fmZK+xLzmhfUvkiQ3AFoHsATwFskIUwTKyMjIyJQOTp48ebVJkybxRt+wZ48j5szxwpUrdqhZMxXjxt0tLmVoLk6ePOnRpEmTGobOGasQlwEIJ7lQkiQbAA4kH+R1vYeHB2vUMChPRkZGRqaU8O2338LHx6dYZKlUqoxmzZoVaDNiafJTiAVOmUqS5AqgA4ChAEAyDUBafvfUqFEDkZGRhc6ojIyMjEzxce7cOdSvX79YZJ0+fTpfvVEaMMaopiaAewCWSJJ0XJKkhZIk5dqEKUnSiMyN85H37t0ze0ZlZGRkZMyPMbOE5QWNRiNBxEU0iDEK0QpAAIDfSDYDkAzg05wXkVxAsjnJ5p6enqbmV0ZGRkammLCzs8P9+/efCqWYGQ/RFUCeASeMsTKNAxBH8nDm3+tgQCHKyMjIyJQtqlSpgri4OBTHrN7t27et1Gq1h8UF5Y0GwOmMjIzheV1QoEIkeVuSpOuSJPmRvACgCwB5D6CMjIxMGcfa2ho1a9YsFlkNGjQ4lel+s9Ri7D7E9wGsyLQwvQzgTctlSUZGRkZGpvgxSiGSPAGgVGt2GRkZGRmZolDc4Z9kZGRkZGRKJbJClJGRkZGRgawQC018fDzatm2LihUrws3NDa1bt8aBAweyXXP58mX07NkTzs7O8PDwwPjx480ie+/evQgICICLiwtq1aqFBQsW6M6FhISgUaNGcHNzQ8WKFdGnTx/cuHHDLHIBYPny5ZAkCQsXLtQd+9///oeGDRvC2dkZNWvWxP/+9z+zyZORkSl7GOonunXrBicnJwBoJklSkiRJaZIknSqxTOYHSbP/AgMDWV5JSUnh+fPnqVarqdFouHHjRlaoUIHp6ekkSZVKxVq1avH7779nUlISU1JSePLkySLLTUtLo4uLC+fNm0eNRsMjR47Q0dGRJ06cIEnevn2bN27cIEmmpqbyk08+4UsvvVRkuSSZkJBAPz8/+vv78/fff9cd/+abb3js2DGmp6fz/PnzrFatGletWmUWmTIyMmWLvPoJLQAixT/YB2AKLaB7ivqTR4iFxM7ODn5+flAoFCAJpVKJxMREJCQkAACWLl0KX19ffPjhh3B0dISdnR0aN25cZLkJCQl49OgRXn/9dUiShBYtWqB+/fo4e1bsgPH29oavr6/ueqVSiZiYmCLLBYDPPvsMY8aMgYdH9i1E48ePR0BAAKysrODn54fevXvnGi3LyMg8HeTVT+gjSVINAO0BLC+ufBUGWSGaSOPGjWFnZ4devXph+PDh8PLyAgAcOnQINWrUQLdu3eDh4YGOHTvi1Kmizw54e3tj4MCBWLJkCdRqNSIiIhAbG4t27drprrl27Rrc3Nxgb2+P7777zixTtUeOHEFkZCRGjhyZ73UkER4eDn9//yLLlJGRKVsY208AeAMiUMRVy+eq8MgKUcuhQ8DAgUBgoPj30KF8L4+KisKjR4+wcuXKbEopLi4Oq1evxpgxY3Dz5k306NEDvXv3RlpaHn5tCyF34MCBmDZtGmxtbdG+fXt89dVXqFq1qu58tWrV8ODBA8THx2PGjBmoV69ekWSq1Wq8++67+Pnnn6FQ5N9UvvjiC2g0Grz5prxFVUamXGCBfgJCIS41c07NhyXmYcvcGuKUKaSDAylJJEAqFOLvKVOMur1evXq6tbxevXqxY8eOunMajYYuLi6686bKPXfuHB0cHLhz506q1WqeP3+ederU4datWw3m6datW/Ty8tKtbZoi88cff+Sbb76p+zsoKMjg2sBPP/3EGjVq8Pr16wbzIiMjU8awQD8B4DyAJABOLAXrhYZ+skKMiBAPGuARNGco2olqAcTxiIgCk6hduzY3bNhAkpw8eTI7deqkO5enQtSTewgtqYJ1vnLXrl3Lpk2bZjs2duxYjh492mCerl+/TgC8f/++QZl/YBDvwT1fmb1796abmxu9vb3p7e1Na2truri4ZJO5aNEiVq5cmZcuXSqwnmRkZMoAev1Erp+J/QRJQkRNWs5SoPjy+hkVILiwNG/enGUmHuLAgcCaNYhlFdTGZWigQHMchQNSxHlPL6BBA93ljx4dApkBZ+eWINW4ceNHXLs2Ay1aXICtrS+ePLmAY8eaoWHDzXBz64QbN37EjRs/o0WLc1AobLLknj0L3LuLVNjiMFpBiQy0wUEoQINyU1IuITKyiS7d1NTLiIp6EVWrjoev7wjcu7cBjo7+sLd/Bunp9xETMxopKTEIDPwvl8z7qIjTaAgrpCMR7nBCMqBQAK++Cqxapbv8wYMHSE1N1f3dt29fvPLKKxg2bBhcXV2xYsUKfPTRRwgJCSm2mGoyMjIWJrNPBIlx+AEAMAcfiHMm9BMAkJKSAgcHBzWAF0juLbayFBJjfZmWX6KjcYXV0QkhUEADgDiJpmiCE0IppqRku1yjUSEmZgxSUy9Dkqzh6NgIDRtug62tsPB0cPBDvXp/Ijp6JNLT78LJKQANG27OrgwBIOUJAMAOKiiRATWscRb+aIAzQinmkGtvXxt+fosREzMGKlUslEpXeHsPRqVKwnF7WtoNXL78EdLS7kKpdIabW0f4+2/MJfMBXHEWDSCByIA1umIntqM7XDSPgYsXs13u5uaW7W8bGxu4uLjoGvnkyZNx//59tGjRQnfNa6+9hnnz5hld/TIyMqWM6GgxHgRwAk2zn9NoCt1PAMDff/8NAGoAIebOrlmxxLCzLE2ZRvcYxyq4RnfEMxIBPAV/euMWvXGLp6WG5MCBlhEcHCzm5QEGIYR1cIEA2Qt/UyXZWkRuSKcv6YAkNsBptsZ+NsBpWiGNzyKCiVIFy5VVRkam7JCjbwpCSNaUqUJhcj+BzH2Ipfn3VFuZnjsHBB3+Bqmww150RiD+Q0OcwT50hAIadORenOxmodCPY8cCdna6PyvjJn7Bu9iM3nhFsR6qkWPNKi4kBOh+cBJqSLHYi86wQTo8cQ/r8Ar+QwCek3YjYcgHZpUpIyNTBsnRN2XDzg4YM6Z481OMPLUK8fRpoGNHQKO0wb6Ra9DEIUbMjwOop7iIULuusHOxQaexjXHsmAUy0KoV8PHHgIOD7tC7ivn41Xostqh74JX/PQuVyjyi9u4FevQAatVRIuTDrfB2SNKd663Yir9tg3FaaoRO41ugGOKEysjIlGYM9E1QKMTfH38szpdXLDHsLO1Tpv/9R1asSPr6kufPZx6MiBBTBYGB4t+ICF6+TNaoQbq6GmVsahoREQzyPMMgp0id3N9+E7MTPXqQqalFS373btLOjmzYkLxzJ2+Zu3aJ6xo0IG/dKnKpZGRkyjoG+omigDIwZfrUWZkePQq88ALg7CxGTnXq5H/9tWtA587A3bvA9u2A3h58s9Gxo/h3376sYwsWAO+8A3TvDqxfn/cMRn7s3g289BLwzDPAnj2Ap2f+MkNCgJ49gSpVRN1Urlx4mTIyMuUHQ/2EqUiSdIxkqY6r+1RNmUZEAM89B1SoAISFFawMAaBaNSA0FPD1Bbp2NU/DMIYRI4D584US7tsX0LNqNop//81bGeZFp07Arl3ArVtAUJD4GJCRkZF5WnhqFGJYmBgZenkJBVejhvH3Vq4sFGH16mLE9u+/lspldkaMECPFHTuAPn2MV4r//COUYd26YqRnjDLU0q6duD8+XijFK1dMy7uMjIxMWeOpUIh79gDduompwNBQQM/9p9H4+AilWLeuUDbbt5s9mwZ5+21g4UIxcnv55YKV4q5dQK9eQL16otz5OJ7Pk1atxL0PHwIdOuTadiQjIyNTLin3CnHXLrEuVquWUGh6EZIKjaenGHE1bCiUk9hranmGDRNK8Z9/gN69c+3Z17Fzpzhfv77pylBLYKBYU0xNFSPFc+dMT0tGRkamLFCuFeLWrVmjpZAQwNu76Gm6uwtjlYAAoH9/YO3aoqdpDG+9BSxaJKZrDSnFHTvE8QYNRP4qViy6zCZNxEeERiMW10+fLnqaMjIyMqWVcqsQN24UxiiNGxd9tJQTNzcxWmvVCggOBlauNF/a+fHmm8DixULh9eoFPBHe37B9uxix+vubTxlq8fcX08xWVkIpnjhhvrRlZGRkShPlUiGuWSNGb82bCwXh7m5+GS4uYlQWFAS89hqwdKn5ZRhi6FBgyRKh5Hv1Elsy+vQR07iWKqufn1CKDg5iC0op3VEjIyMjUyTKnUL84w9g0CCgTRuxfqjnX9bsODmJadnnnhOjtwULLCdLnyFDhALeu1cofu3I0BLKUEudOsJS19UV6NJFbGGRkZGRKU+UK4W4eLFQFh07itGbs7PlZTo4AJs3i+0Y77wD/Pyz5WUCYi+lQiE87jo5ATY2Bd9TVGrUEErRy0tsYQkLs7xMGRkZmeKi3CjE334T1pgvvCBGbY6OxSfbzg7YsEEYtbz/PvD995aVt3kz0K+fMOyZPx84cEBY0iYnW1YuILashIaKLSzduompWxkZGZnyQLlQiHPnAu++K5TC338D9vbFnwdbW2Fx2r+/8H/79deWkbNpE/DKK0CzZsKwZ8QIMU0cFiYceBeHUvT1FdanNWuKOt+1y/IyZWRkZCxNmVeI//sfMG6cMCwx1eenubC2FhangwcDEycCX36pi7NpFv7+O7sy1MblHDRIKMXwcDF1m5SUXyrmwdtbbGXx8xPGPVu3Wl6mjIyMjCUp0wpxxgxg/HhgwABhWVoc62gFYWUFLFsmrEG/+AKYNMk8SnHjRjH6DAwUyjCnsdCgQcCKFcD+/cWnFLWOCho3FltcNm60vEwZGRkZS1EmFSIJTJkCfP458PrrwJ9/itFZaUGpFJvoR4wQU6cff1w0pbh+PfDqq2IbiSFlqEW7J/LgQbG+9/ix6TKNReuoIDBQKOw1aywvU0ZGRsYSlDmFSAKffgpMnw507boXp08HwN3dBbVq1cKCHPsefvrpJ9SsWRMuLi5o3rw59u/fX2z5VCiAefOA994DZs8WQaY1msKns369GAE3bBgNd/feqF3bE+7u7njxxRdx4cIF3XVLly6FUqnEsGFOsLJywv79TmjTZl+RlGJ4eDicnJyy/SRJwvr16wGIWJqTJ09GgwaVcfasKxwdO2LgwDP44w/TZQLA3r17ERAQABeX3M9127ZtaNeuHdzc3ODj44Phw4fjsRk0f0Fl1adLly6QJAkZGRlFlltSREdHo3fv3vD0NNyeli1bhsDAQLi4uKBKlSoYP358mS6vjGWRJAmOjo66d2f48OG6cyqVCiNHjgSAJpIkJUiStEWSpNIZXM4SQRYtFSBYoyHHjRPBc99+O40uLi6cN28eNRoNjxw5QkdHR544cYIkeejQITo4ODAyMpIajYa//vorPTw8mJGRYZG85Zfnjz4SeR4xglSrc18TFCR+OfnrL1KpJNu0IffuPcyFCxfy/v37TEtL4+TJk+nn56e7dsmSJWzbtq3Bex8+NF5mfoSEhNDJyYlJSUkkyTVr1rBSpUq8dOkSMzIy+NFHn9LJqRkliVy0qHBpa0lLy/+5rlixgjt27GBycjITEhLYtWtXvvPOO6YJy4ecZdXy559/sn379gTA9PR0s8stLg4fzr89/frrrwwLC6NKpWJcXBwDAgL49ddfl2COZUoCY/sJALx48aLBc9988w0bN25MACcA2AFYDmADS0FA4Jy/MqMQ1Wry3XdFjseMIW/duk0ATE5O1l3TvHlzrly5kiS5evVqtmjRQncuKSmJAHjz5k2z560gNBrys89E3ocOJXPqZEONbs0aodDatiUfPcqd5v379wmA8fHxJHMrRJJcu1ak0bp1bqVoikIcOnQohw4dqvt71qxZ7N+/v+7v06dP09bWli+8IMr622+FS58kb9/O/7nmZP369WzYsGHhBRVAzrKS5IMHD/jMM88wIiKizCvEnORsTzn5/vvv2bNnz2LOlUxJYw6FOHLkSH7yyScEECkuRQ8AF1gKFGDOX5mYMtVoxKb3X38FPvkEmDMH8PHxxsCBA7FkyRKo1WpEREQgNjYW7TJD2nfr1g1qtRqHDx+GWq3G4sWL0bRpU/j4+BR7/iUJ+OorYWSzdCnwxhtAfrNPa9YII5nWrfN2MBAWFgYfHx9U1HNcevz4cXh4eKBu3bqYPn06Xn45A2vWAEePiuDGjx6ZXobk5GSsW7cOQ4YM0R0LDg7GpUuXEB0djfT0dCxbtgxdu3bFpk1iC8ioUcCPPxZOjrd3/s81J2FhYfD39ze9YAYwVFYAmDhxIkaNGlUibcjSGGpPOc+bu55lyhcdOnSAj48P+vbti6tXr+qODxs2DAcOHAAAa0mSHAAMBrCjZHJZAJbQsuYcIWZkkG+8IUYckyeL0ZaWzZs308vLi0qlkkqlkgsWLNCd02g0/Oqrr2hlZUWlUsmKFSvyyJEjZsuXqcycKcrSvz+ZliaO6X+FrVolRnXt2xseGZLk9evX6evrm23UdOnSJV6+fJlqtZpRUVGsX78+Z86cSZJcv560siJbtSIfPMgt0xiWL1/OGjVqUKP3AFQqFceMGUMAVCqVrFGjBi9fvpx5juzTR5T122+Nl0Pm/1z1+eeff+jm5sYLFy4UTkABGCrr0aNH2aRJE6anp/PKlSvlaoRoqD3ps2jRIlauXJn37t0r5pzJlDTG9hOhoaFUqVRMTEzk6NGj6e/vr3s/Hjx4wAEDBhAAAWQAOA7AnaVgRJjzV/oUYkQEGRxMBgQw7dXBDH7+HgFy2rTsl507d44ODg7cuXMn1Wo1z58/zzp16nDr1q0kyd9//5116tThhQsXqFaruWPHDnp5efHGjRum581MfPedqPnevcnU0EMM8jzDIKejXNn6RyoUGnboQD5+bPjeu3fvsn79+pwxY0a+MlatWsWAgADd3xs2CKX47LPkg3+P6GQyOFjUeQF06dKFU6ZMyXZs0qRJbN26Na9fv8709HQuWbKENWrU0E13pqWRr74qyjp9xDXdc81PZkHPVUtERAQ9PDy4e/fu/DOu155MLatarWaLFi24b98+kizdCrGQ5S2oPW3cuJFeXl6MioqyRG5lSjMREYXuJ0gyIyODDg4OujYzePBgvvzyy8xUhLYAPgdwmKVAAeb8lS6FOGUK6eBAShJVsGY/rCNAzuryT65L165dy6ZNm2Y7NnbsWI4ePZokOXr0aI4bNy7b+SZNmnDt2rWm5c3M/PijqP3uih1sj1DWxxkqkMEOijA+/tRw55SQkMCmTZtywoQJBaa/evVqNmvWLNuxjRtJK0UGWyqOsC3CGYQQUqEQdZ5D2elz7do1KpVKxsTEZDveo0cPzpkzJ9sxV1dXHj16VPd3ejr5WqMTBMjPMY0aIF+ZBT1Xkvzvv//o6enJzZs3518Jeu2JBcjNr6yJiYmUJIne3t709vamh4cHAdDb25thYWH556E4KWR5C2pPO3bsoIeHBw8fPmzJXMuURjLbUhBCjO4ntGRkZNDR0ZEnT54kSfr7+/Pvv//WX0N0yxwterAUKEH9X+lRiBERosIBPoQTWyKCADkb48TxHF8nMTExdHR05J49e6jRaBgTE8PatWtz/vz5JMmlS5fymWee4aVLl6jRaPjPP//Q3t6e586dK3zeLEFEBOfbjCZAWkNFQMMghDAJDgbL+/DhQ7Zo0SKbYtBn+/btvH37NkkxyvL39+cXX3yRS+bfNv1pDRXtkcRncUA0AcCgTC1fffUV27dvn+v4F198wbZt2/L27dtUq9Vcvnw5HRwcmJiYmE1mhr0T38QiAmQrHGBGPjILeq6nTp2il5cXV69enV/tZmtP91GBoWhvclk1Gg1v3bql+x05coQAGBcXR5VKlX8+igu98ub6mdCe9uzZQ3d3d4aGhhZH7mVKE3ptqQNC6I+ofNvS6dOnefz4cWZkZPDx48ccO3Ys69aty7TMNaGhQ4eyb9++2hGiNYCJAG6wFCjAnL/SoxCDg3VftlURS4AMxkrqvnSDg3PdsmbNGvr7+9PJyYmVK1fm+PHjqc7c16DRaPj555+zatWqdHJyYr169bh8+fLC58tSZJa3BzYR0BDQsA32677IgjzP6Obvg4JIP7+lBECFwoEKhaPu9+yzsQwKIqtU+YjW1l5UKBxoZ1eT1ap9zvbt07KlEeR5hkEIYT2c0cnUjhQNydT+7O39WLfuwlzH27dPoa/vu7Sx8aFS6Uwnp2Zs1GiHQZkdEEIJagKkMx7kK7N+/TV0cPCnUulEG5vKrFp1PDt0UDMoiPT2HkpAylYHDg4Ncuc7U24b7KcVVFQinYlwzbc9kaSfnx8XLlyY76MrlVOmeu/PWPzAsfghqxMzUN6lS0V7cnBwoKOjo+4XGxtLkuzYsSOVSmW2c127di2BgskUO5ltKR1KeuE2AXI/2uTZlvbs2cO6devSwcGBnp6e7N27N6Ojo3Xn4+PjOWjQIAJIB/AAwH4ALVkKFGDOn0Sa0dlmJs2bN2dkYaPIBgYC//0HAGiHMEShCR7DBXMxBmPwkzhfniLTBgZi4X/NMAILoIAaaljBDQ/QEKeghAZwchZlNifHInU+3ULRHoACjkhCE0TBGukWlXkBdXEbvgA0ABTwxQ08g4uWkZkpNy0pDSfRBE/ggIqIRzy8ss6Xw/akfX86IgQAsA+dsp8vT+WVsRyBgUj/LwqDsQJr8Sra4AAOoF2286a0JUmSjpFsbsacmh2rks6Ajrp1gRMnAI0GVlCjKY7DA/cxFj9CJdnhk7pxJZ1Ds/KLNBrv4S10w3ZsQF+swysYgmWwghpbpV5wfOkl4YfNnAz8HvjrL0CjQUeEIAEVcBF18RCu2CM9D++XOpldpnrAbLz1V1eEoiOq4Spq4ipa4Ci+wyfojh2Y3zMEilUrzCoTAG70Xowum8cAABrjJCrgQdZJhUK0t/KE3vuTi/JYXhmLoardAMH/fY6/8TK+w0f4CLOzTpb3tmSJYWdR1xC102lpsOIArMqyUiwnzJ4tZh96KbcwFTa6qa0VGEgFMhikCGXSXgsYMhio4z3oRAcksZ50jjc2R5pVXFoas6yEMVknUwNwEqYTIId0v5vLUUFRiY0la1dOoRMeMQztsgwDjFhDLLMYeLblurwyFiElhezeJoEA+SPey2pDZmhLyDSqKc2/0qMQSYOWTen2zny98XFhpfh59n2IZZFZs0St9+tHqiZ9KRqYQkHt/PwKm6FUSOp8t14UCQN1HGb7HJ1sUlmnDnnNTN8dKpUoI0B+02WXQYu1aR33ECAHDhTWqObg8mWyRg3S1ZWMeGuByZZyZZIiWAbKyCQnk88/L97Z+T025eqbitqWZIVoCrq9L5G6vS8ZGeRbb4ncTphQdpXitGnMrQC0+8YCA3XlXbVKtL/27S2kFA3U8cGDpIsLWbMmeeVK0ZJPTSVfekmU9Ycf8pZJZn0gvPJKlqMCU7l4kaxalaxQgYzUDnbzkFtuedrKK2MWkpLITp2EXdbixZkHDfRNRUFWiCZiyDuCWk2OGiVyPG5c2VKKGg05aZLI+5AhuX2ZGmL1auGxpl27vD3WFAVDdXz0qFAmVasK5WIKT56QXbuKsv76a8EySb0p5F5CmZrCuXNkpUqkhweZ6Qe8QLnllaetvDJF4+FD0c8oFOSff1pOTllQiGXClykg1nJ/+QUYO1b4Mn3vPdPCKRU3JDBhgvBlOnw4sHixiJdYEAMGCPuWiIjii23YvLkI+PvkCRAUBJw/X7j7k5OBl14Cdu0CFi4UvkyN4YMPgJ9/BjZvBvr0AVJSCif39GmRX40G2LcPaNKkcPfLyDytPHgAvPCC6GdWrwYGDy7pHJUsZUYhAsJJ9g8/CAffv/4qHH6XZqVIis7+f/8D3n0XmD9fKHZjefVVYNUq4NCh4lOKTZsKpZKRAXTsKJSNMTx+DHTvDoSECAfmw4YVTu7o0cCCBcDOnUCvXkIpG8OJEyKfSqXIt+x/WkbGOBISgOeeE7t11q0TAb6fdsqUQgSEUvzmG2DyZDEKefNNQK0u6VzlRqMRSnDu3KwRUGGUoZb+/cWX26FDRY9YYSwNGwKhoSK/nToBJ0/mf/3Dh8CLLwIHDgArVohoHqbw9tvAkiVilNq9u27LZJ5ERgKdOwMODkBYGFCvnmlyZWSeNu7dE+/O6dPAxo3Ayy+XdI5KB2VOIQJCKU6fDkybBixfDrz+ev7hlIobtVp07vPmAZ9+Cnz/vcizqbzyiggJdeRI8SnFevWEUrSzE0rx2DHD1yUmAs8/L0JMrVkDBAcXTe6QIcCffwL79+df1kOHgC5dAFdXoQzr1CmaXBmZp4Xbt8U7feGCWKbo0aOkc1R6KJMKUcvnn4vR4qpVoiNOSyvpHAnFPHSoWCucOhWYObNoylBLv37QxTZ88UUxKrM0zzwjlI2rq1A+hw5lPx8fL46fPAls2CDyaA4GDhRlPXxYKNvExOznw8PFcS8vkb8aNcwjV0amvHPjhlhiuHIF2L5drB/KZFGmFSIAjB8v1hXXrxcjKZWq5PKSng689poY4cyYIQICm0MZaunbVziaiYwsPqVYs6YYKXp4CCW0f784fveumHI5exbYtEkY05iTfv3EMz1+XCjd+/fF8b17xcixcmWRr6pVzStXRqa8cu2aMD67cUMYvnXqVPA9TxtGKURJkq5KknRKkqQTkiSVOoeI48YJC9QtW8RceGGtFM1BWpqwDF2zRhjRTJpkGTl9+gBr14opzBdeEFZilqZaNaF8KlcWinjdOvGVGRMDbNsmFJQl6NVLKNuzZ8XLu2aNmN7RKmlfX8vIlZEpb1y5IpRhfDzw779Au3YF3/M0UpgRYieSTVlKnbO++y7w++/iy+ell4y3UjQHqaliRLNxozCi+fhjy8p7+WWhlI4fLz6lWLmysOKsUkVYv16+DOzYIUZvlqRbN2DrVrHeMXAgUKuWsGT19rasXBmZ8kJMDNChg5hR2rMHaNWqpHNUeinzU6b6DB8uTP5DQoyzUjQHKSlA796i0543DxgzxvIyASFz/Xqx7cDQOpslUKnET5LElpLkZMvLBMSWDo1GyFWpSsdasYxMWeD8eaEMU1NFv2iJwDLlCWMVIgH8I0nSMUmSRhi6QJKkEZIkRUqSFHnv3j3z5bCQvPGGMP3fv9/y62zJyUDPnmIKYvFisS+yOHnpJWHMEhVleaV46VLWV+auXUCjRmKk+vfflpMJiDXT/v2F04Dt28XaZYcOQGysZeXKyJR1ZIcVhcdYhdiOZACAbgBGS5LUIecFJBeQbE6yuaenp1kzWViCg7O2KVhKUTx+LKbz9u0TWz/efNP8MoyhZ0+hFE+dslxZL1wQL1ZSkjBqee45YPduICBAKKu1a80vExDGSQMHAq1bA//8Iz5wdu8WBjYdOohpWxkZmdxoHVZYWYn1dtlhhXEYpRBJ3sj89y6AjQBaWjJT5kBrpXjypFjnio83X9rajegHDwr3aq+9Zr60TaFHD7F+eeqUUFYJCeZL++xZoQzT0oTyb9ZMHHdzE0qqVSvxAbLCzCENFy8Wo/2gIOG9xtlZHG/ZUijlpCShFKOjzStXRqaso++wIjQU8PMr6RyVHQpUiJIkOUqS5Kz9P4AXABjp0Ktk0bdS7NxZTLcVFa27o8hIMTIaMKDoaZqD7t3F9OWZM+ZTilFR4itTkoQybNQo+3kXF2FYExQknCMsXVp0mYBwcTdsmBjxbt0KODpmPx8QINZD0tKE7HPnzCNXRqasExEhO6woCsaMEL0B7Jck6SSAIwC2kdxp2WyZj65dxdaAmBjRud+6ZXpa2o3oUVFimrJPH7Nl0yx06yaU4tmz2ffumcJ//4mtDjY24iuzQQPD1zk5CaX13HNi2njBAtNlAsBPPwEjR4pR76ZN4ivXEI0bCyUNCKV46lTR5MrIlHXCw4XVueywwnQKVIgkL5NskvnzJ/lVcWSsIMLDw+Hk5JTtJ0kS1q9fn+vaLl3ESEa7MTUurvDy7twRCuLs2XAoFE4IDjYsV6VS4YMPPoCvry8qVKiAd999F+np6UUtrtF07SoUyblzpk8VHzki7nVwiIe3d1u0bl0Rbm5uaN26NQ4cOKC7jiQmT56MZ56pjMOHXeHu3hHvvHMGP/9sWt6/+05Y6b78shqNGk1GrVq+cHZ2RrNmzfAgc2/JsmXLEBgYCBcXF7zwQhX06DEe1tYZ6NRJbEMxlfj4eLRt2xYVKxou68iRI7O1NVtbWzhr53HLKFu2bEHDhg3h5OSENm3a4OzZs7pz+vVcpUoVjB8/HhmlyT+ikRTUTyxduhRKpTLb+X3aL60yhNZhRZUqQEyMhHr1HHXlGT58uO66Bw8eYMiQIfDy8oKXlxe++OKLkst0acQSMaUsEQ+xIEJCQujk5MSkpKQ8rzlwQATBrVWLvHrV+LRv3CDr1RMBo/fsyV/uF198wXbt2vH+/fu8e/cun332WU4pgYjlu3aRdnZk48bkvXu5z+dVx/v3k87Ooo7On0/h+fPnqVarqdFouHHjRlaoUIHpmdGN16xZw0qVKvHSpUvMyMjgJ598SlfXZgTI774zXiZJzpghYiIOGEB++ukkdurUiVevXqVGo+GpU6eYkpJCkvz1118ZFhZGlUrFuLg4BgQE8OOPv2a1aqSbG3n4cOHkaklJyb+sORkyZAjffPPN/BMtIYwpb3R0NJ2dnRkeHs709HTOnDmTtWvX1pXXUD1//fXXFs+7pcn5vi5ZsoRt27Yt4VwVjZ07xbvesCF5+zYJgBfzCGg6dOhQvvLKK0xOTuaVK1dYq1YtLtZFBLYsKAPxEMuNQhw6dCiHDh1a4HWHD4uOs1o1Miam4HSvXSPr1CGdnMiwsILlBgYG8q+//tL9vWLFClapUsWoMpibf/7JWykaquOQENLRkaxbl4yLy35OrVZz8+bNBMA7d+6QJGfNmsX+/fvrrjl9+jRtbW3Zv79oWV99VbBMjYacMkVc/9pr5N27CXR0dGSMMQ+H5Pfff8+ePXvy6lWyZk2hzA8cKFhufhgqqz5JSUl0cnLivn37jE+0GDGmvD/99BO7d++u+1utVtPOzo67d+82eL22nss6Od/Xsq4Qt2whbWzIpk2z3vH8FGLFihV55MgR3d9fffUV27VrVxxZLRMKsVxszE9OTsa6deswZMiQAq9t2VJ4a0hKEtOn+VkpXr0qrrl7V1hUtm9vnFzx7LP+HxcXh4fF4Xg0B88/L9zZRUcLo6L8tofu3i0Mc6pXF2tzlStnnWvcuDHs7OzQq1cvDB8+HF5eXgCA4OBgXLp0CdHR0UhPT8eyZcvQtWtXrFwpAo1OmiT8uepVRzZIYOJEEbXkzTeFUc65c6dgZWWFdevWwcfHB3Xr1sUvv/ySZ77DwsLg7++P6tXFuomPj1hHCQsrdHXlW1Z91q9fD09PT3TokGv3UZkiZzslidN5BMDU1nNZJq/39fjx4/Dw8EDdunUxffr0MjM1vHGj8G/cuLHo0zw8ss516NABPj4+6Nu3L65evZrtvpzPPa9n/lRiCS1bpBFiRASDPM8wyOkoGRxMRkQUeMvy5ctZo0YNajQao8VERZGenqSPD3nmjJDL4GAyIIAMDmbM2v9YtSpZoQJ59KjxcidNmsQ2bdrw7t27vHXrFlu2bEkAvHnzptF5Mze7d5P29mJK5c4d5qrj7bPP0daWbNQo87wBUlJSuHLlSi5dulR3TKVSccyYMQRApVLJGjVq8PLlyyTJjAxy6FAx8vvsM1JzMLtMzcEIfvCBOD9yJKlWizRXrFhBAHzrrbf45MkTnjx5kh4eHvznn39y5WnRokWsXLky7+kNf2/eJOvXF+XdvTt3WY1pT4bKqk/nzp05derUAtMpEYws77lz5+jg4MCQkBCqVCpOmzaNkiRx5syZua41VM8lTo731dR+4tKlS7x8+TLVajWjoqJYv359g3VQ4uQo75rpF6hUkq1akQ8eZL80NDSUKpWKiYmJHD16NP39/XVT4YMHD2afPn346NEjXrx4kbVq1aKNjU2xFAFlYIRYuhTilCmkgwODEMIghJAKhVi4K2ANrkuXLiat0505IxSip8NjnrRrSUoSCfC8VI++0g16OCTx+PHCyX3y5AlHjx5NX19f1qxZkzNnzqS1tTXV2h6/hNizRygJf8/bvGNfXVfHm6TetEEqAyrdYHx8wenUq1ePJ06cICmUf+vWrXn9+nWmp6dzyZIlrFGjBpOTk0kKJffOO6KVfWg1VydTLSk52uo3AuSYMWLaVMuGDRsIgFf1Fnnfe+89jhs3Lls+Nm7cSC8vL0ZFReXK4507QrnbWaVxh23vQrcnQ2XVEhsbS4VCwUuXLhmVRrFSyPdn7dq19Pf3p7u7O8eMGUN/f38uX7482zX51XOJkVlO7ftqzn5i1apVDAgIMGdui06O8v4hvU4FMti+2hU+epT/rRkZGXRwcNA9v/v373PQoEH09vZmgwYNOGnSJNaqVasYCiErxMIRESEeOpD1QotZNXE8jy/Aa9euUalUGr3mlJMLa46zshRHd8TzGJrxNBrQG7fojVs8Zde8yHLnz5/PVq1amZQ3c7PnpzO0RzIb4DRbYz8b4DStkMaWOMRE+0pGfWXXrl2bGzZsIEn26NGDc+bMyXbe1dWVR/WG1JqDEXzf6hcCpC+uswNCOBwLCJCfWM2m5mB2mTExMQTA2NhY3bH3338/m0LcsWMHPTw8eNiQBU0m8TuPspl0nDZIpT+ijG5PeZVVy4wZM9i+ffsC7y12THx/tCQmJtLR0ZHnzp3THTOmnosdvXLm+pmhn1i9ejWbNWtmiZybRo7yLsKblKBmZ+xmkr1Hgc81IyODjo6OPHnypMHzn332GYODgy2R81yUBYVoVXKTtTmYO1cXtykSgUiHDToiRJx7AqCXC2BgL1xs7B9wcmqDYcNqmyb3rA0q8zpOoima4ygUUMML8diLzqiXdlHky4B7+D/++ANt2rRB7drZ5d64cQOSJKFSpUo4fPgwpk+fjkWLFpmWNzPT+cB0bMdt9MBWPIE9AAkueARrpOHllJW56vjRo0MgM+Ds3BKkGjdu/Ihr1+7g22+fxdy5wNWrLRAevhZr1gTD2toTd++uwOPH6Rg3rg6stC3rrAuY0QBVcB1xqIqbqIwwdEQ1xOJwRjN06p3zudaGq2t7tGr1FerU+REpKZdx8uRq1K+/Ch07AomJe3H27GD4+2/E+PH5OEw66wB7JsAWKpxBQzjhcda51NRcz/XQoUPIyMhAy5YtoVar8eOPP+LOnTt49tlnsyW7fPlyTJgwwcQnYEEy3x8COInGcIBeuBcD5QWAY8eOoWnTpkhISMDo0aPRq1cv1KtXDwCwd+9eDB48GBs3bkTLlqXIMZVePzEC83AIrRCFpuJcHuUE8n5fd+zYgYCAAHh7e+P8+fOYPn06+vfvb+lSGI9eed/GfCzECLyAXfgbL8NelZarvGfOnEF6ejoaNWqElJQUTJ48GZUrV0b9+vUBAJcuXYKbmxvc3Nzwzz//YMGCBQgNDS2RopVGSo9RTXR03tYXQJ5BDu/cWQ5v74KNafJO9wnskYraiAahgBrW+A4foh4uCK+4Fy8avG358uUGjXguXbqENm3awNHREUOGDMGsWbPwQmkJSx0djY7YhzewFICIXFwP52AFtTifo441GhUuXhyNgwcr4tChykhI2I6GDbfB1lYEIqxWbQKcnJrg2LGmOHDADXFxP8Dffz2srNyyEkl5AglATVyG8BEvwRWJqIkrIgcGnmv9+quQmhqLAwcq4vTpHqhRYzoqVBBxpmJjpyMj4yFOneqO8HAnhIc7ISqqW+6ypjyBNTLgh/MAiCQ4IxbVtAXL9VxVKhVGjx6NihUronLlyti+fTu2bdsGX72gixEREYiLiytdHaaWzPcnHO3xAO5IQEWoYCPO5dGOx44dCzc3N/j5+aFChQr4/fffdeemT5+Ohw8fonv37rr9bN26Gajn4iaznElwxB94A6fQBGMwV5wz4X3ds2cPGjduDEdHR3Tv3h19+/bFxIkTLVmCwpFZ3i/xORZiBGojBpvQG/ZINVjeO3fuYMCAAXBxcUGtWrVw9epVbN26FdbW1gDER1CjRo3g7OyMzz77DCtWrCjzxlJmxRLDTpOmTIODxVqAoSkfhYIcOLDwaRop95DUiq5IpCdusRJu0BGPGYr2lpVbEgQH69YfbPGEQDrrIJrXUMVyZQ0OZppkw35YS4B0x91ie65XpJqsgct0xgMuwRvFI7ek0Ht/6uACAbIbtjEFtuWrvMHBfCw5sz1CCWjoikQC5GRMo0YqR+XUEhzM76SPCJAdEMLHcCiz7RhlYMq09CjEIq6BmEr4vNN0xkPWxkXGoipvwocNcJr2SOZu2+4Wk1sSLJ9yUbf+0A6hbIZjdMED1sQlXrGrZ5GypoYeYi/lFgJkbVwstud68a//WFW6xgq4z6MIzJJpYbklRo73py7OU4Kaz+EfJttXLDflfbT7MNsp9lOJdNbHaXZACIfhdwLkeKvvc61Jl3W+eidWOKzAKqbBqky3Y1khFhYTrUxNRbsR3a/iXcbZ1dZ9Yd+RvNlIOiWsFHdYRHSxs3SpMFLrUjOGyfYVdXV8RGpJNySwmmuiUY4KCsOTJ2S3bqKV/WI9ttie67lzpK8vhZWwXSvdc7W03BInx/uzVBpKBTLYsfplPn5c0pkrOo8ekW3bkkopg3/ZDM5mtTzKaj4BcuzY7FbLZRWNhpw6VTTb1xqdYLq9c5lvx7JCNAXdPqpIo/cXmcI//4htCA0akLduMWufT2AgGRwsrBSbCS8QmzdbJAvFxpIlQhk+9xyZnMxcdfzf0pOsWFEokfPnzSMzOVnIkyTy999zy7TUcz11ivT2Jr28xP9zPtey9EVtEjnqecUX0VQqhSJ5+LCkM2c6Dx+SbdqQSiX511/MVU7NwQiOHSt6tFGjsva1lkU0GvLTT0VZ3nxT7OktD+1YVogmYorrtsKwbRtpaytcmt29m/d1CQlky5aklRW5bp3l8mNJFi8WSun558WITUvOOo6KEkrE25s8fbpoMh8/FmkrFGJkmpdMc3PiBOnhQVaqJEaJTys563ntWtGGW7YUbbqs8fAh2bp17vcwZzk1GnL8eNGrDRuWqUjKGBoNDTqsKA+UBYVYeqxMi4lNm4CXXxYRpPfuBTw98762QgXg33+Fu7cBA4DVq4stm2Zh8eKsuIKbNgH29nlf26iRcNmmUIgwWSdPmibz0SMRPHn/fhHx3ghvembh2DERjcTOToSrytw9IAPglVeAdetENJDnnitaWLDi5tEjEcXh6FFgzRoR+DsvJAmYNQv4/HNg0SLhDlCtLr68FhWNBnj/feCHH0TUl19/Fe+jTDFiCS1bWkeIf/0lvjKffZZMTDT+vsePyQ4dxIhn2TLz58sSLFwovjJffDH7yFBLXnUcHU1WqUK6u5PHjhVOZkEjaks914gI0tWVrFGDzPQc91STVz1v3541M5KXi77SxIMHwjWZlRWZwz8Cyfzb0/Tpov0HB5NpaZbMpXlQq8m33xZ5/vjj8rEOmhOUgRHiU6MQV6wQCs3UtZSkJLJLFzH9uHChefNmbn7/XTzZrl3JzKhJucivji9fJqtXF0rm0CHjZMbHk82akdbW5KZNhZdpKuHhIhJJ7dqknnObp5r86vnff7PWzkvQvW6BPHggPlzzUoZkwe3pm2/Ee9C3L6lSWSKX5iEjgxwyROR10qTyqQxJWSGajLk7Tq1RSceOLJK13ZMnQskA5C+/mC17ZmX+fJG/bt3yVoZkwXV89aqIiejsLJROfmh9h9railGIqTILy969wtjOzy93uKqnmYLqOb8wX6WBxEQx02BtTf79d97XGdOefvhBvA8vvUSmppovj+YiPZ0cNEjkcdq0ks6NZZEVoomYs+PUKojnn8+0sCwiqalkr14izR9+KHp65mTePJGv7t3zV4akcXUcFyc6TUdH0YkaQj+6xL//Fl2msWgDIOushGV0GFPP+oGgCxMs29IkJpItWuQ/06DF2Pb066/Md/mgpEhLI195ReRt1qySzo3lkRWiiZir4/zpJ+MVRGFQqch+/UTa33xjvnSLwm+/ifz06GHcl7CxdXzrllA69vZiq4o+16+TzzwjFKYxsXLN9Vy3bhXbYZo0yd9K+GnF2Ho+dEhMi1evTpaG4B0JCWTz5kIZGrPVqTDtaeFCMUvUubNY/ihpUlPJ3r3FOzt7dknnpniQFaKJmKPj/P57UbrevS0zVZKeLhbsS8NUh/YLuGdP48tamDq+e1cYYtjaii0rZPYp1f37zS8zLzZuFB1mYCB5/37R0iqvFKaejx0TBlRVqgiDqpIiIUE8U2OVIVn49rR8ubAj6NCBBYZNsiQpKeIjHSB//rnk8lHcyArRRIracc6cKUrWv79lLcwyMsg3Ml1kTp5cMovhP/9Mk9ZIClvH8fEiNqm1tZiarVZNjC4KExmoqM/VVCvhp43C1vPJk2L/po8PefaspXKVN/fvi7ZlY0Nu2WL8faa0p1WrxOb+1q1zB9YtDvQdVixYUPzySxJZIZqIqR2nRkN+8YUo1aBBYhRnadRqcvhwIfOTT4pXKZqqDEnT6jgxURjPAMKys7DbMoqiEP/8U3zdt2tXtj2uFAem1PPp08Ipg6encNJQXNy/T51HKO3sg7GY2p7WrRMfVi1aFK+jgsePhWFfTocVTwtlQSGWm22fJDBpEvDFF8DQocDy5ciKyWdBFApg/nzg3XeB//0P+OCD/KNYmYuffgLeew/o3Vtsura1tbzMmzeBu3cBa2sgORk4f97yMgFgyRLg9deBoCBgxw7AxaV45D5N+PsLhwbW1sLBwfHjlpeZkCAcBZw5A2zcCHTvbnmZgNjcv2GDcD7RuTMQH295mVoHA+HhwB9/FJ/DCpnCUS4UIgl88gnw9dfAiBHCS4VSWXzyFQrg55+BceNEvM7Ro4XXCUvx44/Ck8XLLwN//QXY2FhOlpZTp4QHG0kCDh4Uyum114Blyywrd8EC4K23RMe5dSvg5GRZeU8zfn5AWBjg6CgUxdGjlpN1/z7QpQtw9izw99/Fpwy1vPSS8N50/rz4ALh713KyHjwQ3qIOHxbergYNspwsmSJiiWFncU6ZajTk+++Labz33ivZTa0aDTlhAi3qS3HOHJF+nz5F22xcmDr+7z+yYkWycmXywgVxzJS1kMJOcVnKSri8U9S12itXyJo1SRcX8sABM2VKj3v3hIWwrS2LFE3GHEZau3cLC+r69S3jqEB/7T2/PZVPAygDU6ZlWiGq1eSIEaIUH35YOjw8aDQiKgtAvv66edcxZ8+mzvNGUY2FjK3jw4dJNzdhRJMzPFRKSlZ4J2Os5QrTgX33HS1qJVyeMYeiuHYta0tNaKg5ciW4dy/LYnnnzqKlZa5tPPv2iXI+84zYSmQu7tzJKmt+DiueFmSFaCLGNPSMDHLoUFGCzz4rHcpQH60vxQEDzGPpqt1G0q+fedIzpo4PHBDbKmrWzHvztv5+qu+/L7pMkvzqKxaLlXB5xVyK4uZNsl49MYLavbvo6WmVoZ2dcKxQVMzp6OHAATEirllTjJCLys2bWft3C3JY8bQgK0QTKaih67s7+uKL0qcMtXz7Lc0yvakdLb3yivkUREF1XJivZn2PGzNnmi5TPyjq4MHFYyVcHjGnorh9m2zYUCixokxv3r0rLJTt7HI7eDAVc7sCPHIk79mQwmCMh6enkbKgEMucUU16uliUXrkSACR8+60jnJ2d4OTkhOHDh+uu++KLL2BtbQ0nJyfd7/Lly8Wa108+AebMERZ0/foBqamFT+O774CPPwb69wcGDdqCZs0awsnJCW3atMHZs2d11y1duhRKpTJbefft22dSvnfvBrp1A6pWFZaHVaoAy5cvhyRJWLhwYa7rra2BVavEc5k4Efjyy8Jb2pJZ99atOwJHj/rBxkaBpUuXmlQGmfyJjo5G79694enpCXd3d7z44ou4cOGC7vzq1avh5+eHunVdcfu2F+zth6BXr0fYsqXwsu7eFUY60dHxqFWrLYKDK8LNzQ2tW7fGgQMHdNeZsw3rs3fvXgQEBMDFxQW1atXCggULDF7XooUICZeUBHToAOhVh9HExop7b9wQZe3Xz3BZZUopltCylhoh6k/PiVETePHiRYNpTJ06lYMHDy5SPsyFqb4Utd76X32VPHs2ms7OzgwPD2d6ejpnzpzJ2rVrMz1zGLVkyRK2bdvW6LTzquMdO8SaR8OGYnRAkgkJCfTz86O/vz9///33PNPU99o/cWLukXteMjUasQYMiDXhn376mbt372ZgYCCXLFlidJlkBMaMnA4fPsyFCxfy/v37TEtL4+TJk+nn56c7f+3aNd67d48k+fjxY77yyiB6eb1f6GDZd+6Q/v5i6nD79hSeP3+earWaGo2GGzduZIUKFczehvVJS0uji4sL582bR41GwyNHjtDR0ZEnTpzI856oKLEf09ubPHPG6Ozw0qWsKDGhofmX9WkE8gjRfKSmAn37ClPpH38EPvqopHNkPKNGAQsXAv/8A/TsKfbwFcQ33wATJojAxCtWAHv27EL79u3Rrl07WFlZYcKECbhx4wZCQ0PNls8tW8S+xvr1gZAQwNtbHP/ss88wZswYeHh45Hu/UimCEr/9NjBzphghFzRS1GjEFpLZs8W+ynnzgPfeG40uXbrAzs7OTCWTyUnLli0xbNgwuLu7w9raGh988AEuXLiA+5nRg6tWrZrtedvbK9GkSQxatDA+WPadO2JLw+XLYstMt2528PPzg0KhAEkolUokJiYiISHBUsVEQkICHj16hNdffx2SJKFFixaoX79+ttmVnGiDZUuS2GoUFVWwnIsXxVakx4+BPXuADh2Kv6wyRadMKMQnT4BevYDt28Um+PffzzrXoUMH+Pj4oG/fvrh69Wq2+7Zs2QJ3d3f4+/vjt99+K95M52DYMLFnb98+MR35+HHe186aBXz6KRAcLKLOax0MUE+7aL9oTp8+rTt2/PhxeHh4oG7dupg+fToyMjKMzt/69eKDo0kTMW2k7QuPHDmCyMhIjBw50qh0FAqh1EaPBr7/Hhg7Nm+lqNEAI0eKPZwffSQ+dCTJ6CzLmJGwsDD4+PigYsWKumP79++Hq6srnJ2dsX79enz88Tjs2gW0bQsMHiycX+TFnTtimvTKFWDbNvF/LY0bN4adnR169eqF4cOHw8vLS3euKG3YEN7e3hg4cCCWLFkCtVqNiIgIxMbGol27dvne16CBWC6wsRFK/b//8r723DkxTZqaKt6dwEDjyipTCrHEsLNIU6YREQzyPMMgp6NkcDAf7znMjh3FfrfFi7NfGhoaSpVKxcTERI4ePZr+/v66KYkzZ87wxo0bzMjI4IEDB+jj48OVK1eani8zsXp1Dl+KERHCS3hAABkczK/eiSVADhyY3ajk3LlzdHBwYEhICFUqFadNm0ZJkjgz04rl0qVLvHz5MtVqNaOioli/fn3duVzkqOOVX0ZTqSTbtMnu3zEjI4OBgYGMiIggSQYFBeU7ZapPzmlQ9YHsMjP2R+Q7vUqSbdu2ladMC0uOZ8vMZ5cf169fp6+vb57vR1xcHKdOncoLmZtQk5JE1AhdsOwcbfjW1kjWry9iVeZlVJKSksKVK1dyqZ4Ps6K04fzKuXnzZnp5eVGpVFKpVHJBIZyI6k+DHjqUu6xRf5zQTa+ePm18WZ9GUAamTEuXQpwyhXRwYBBCGIQQPpRc2VZxgApJzT//zP/WjIwMOjg4MCoPR4xff/01+/bta1q+zMz69cKXYnPfON63ryx6FoAzpEnCD2vDkwYtLNeuXUt/f3+6u7tzzJgx9Pf35/Llyw3KWLVqFQMCAnKfyFHHS6WhVCCDHapdyRUB4Mcff+Sbb76p+7swCpEUSu7TT0UrG6pczg7YxyCEMF2y5iDl6gKthGWFWEhyPFsqFEIrTZmS5y13795l/fr1OWPGjHyTjoiIYLNmzXR/P3ki1sQB8hfrsbo2fEuqxHrSOTpYq4wKCVavXr081/OMbcP5lVP7Iblz506q1WqeP3+ederU4datWwvOXCa6yC42KQy37aIr639SACviHn2dH/L8+aKV9WlAVoiFISJCNGqAQQhhW4TzWURQiXSusXmtwC/djIwMOjo68uTJkwbPz5o1i3369Cl8vizE5m/P0QapbIr/eA8VOR1CGQ7GH8ywdyqwvImJiXR0dOS5c+cMnl+9enW2Doxkrjqui/OUoGZn7GaSvUcumb1796abmxu9vb3p7e1Na2truri4cPTo0UaXU3MwglOtZhAgvXCb7RHKV/CX2KJhPSXfcsoKsRDkeLZBCBGvNyCOG6jnhIQENm3alBMmTCgw+fDwcLq4uGQ7lrLvEHsqtolg2RjLm/BhPZylA5K4z/YFo0antWvX5oYNGwyeM6YNF1TOtWvXsmnTptmOjR07tlBtmCSvbzrGutIFOuIxQxDEI2hONySwKmJ50a5hkcv6NFAWFGIxuL82krlzgZQUAMAT2CEKTaGBAuvwCl7O2ALMzQBatdJdfubMGaSnp6NRo0ZISUnB5MmTUblyZdSvXx8AsGnTJnTo0AFubm44evQofvzxR8ycObNEimaIl/77EpvwAH2wAV64C0IBb9zGdVRBl5QtQC8XoEH2ex4/PgYnp6ZIT09ATMxoODr2wsiR9QAA9+/vgLNzAGxsvPHkyXmcOTMdnp790bGjXgJnXYAn2wAAoegAQIEKuI80WKNHytpcMjMylqJ+/ay9IikpfeHh8QpOnBiWPd38OOsCZLRFDVzGVdTCXXgBkPA9PsSH6rnA3OhszxUA0tLSoNFoQBLp6elITU2FjY0NFIoyseRdMmS+P2mwwn60gxJqdESIOPcEBp7tI0RFvQhn57Y4dGhWrud5584KuLq2h51dNaSmxuL8+UmwsemSoz05Q6NJhQfu4QPMwQeYDQWIRojCVNVnuWQ+enQIZAacnVuCVOPGjR9x7dodfPvts5g7t/BtOAztQCjQASHCGMJAOVNSmiEq6iKaNNkLN7dOSE29jKiorahadbzxbRgAztrBnfGIQ2V0QggADWoiFnvRGTXSrov612vHhw4dQkZGBlq2bAm1Wo0ff/wRd+7cwbPPPlsIoTLFTelRiNHROuuLu/CGCnbojb/RG5sADYQZlx537tzBqFGjEBcXB0dHR7Rp0wZbt26FtbU1ALGP6q233oJKpUKVKlUwYcIEDClNLuajo/Ei/kM7hGE3XgRA1MBl6GxKMj8O9ImJGYvk5JOQJGt4evZH7dqzdecePNiDCxeGQq1Ogo2NN7y8XkO1ahOzJ5DyBABwBTUg7KmI2rgEJTQGZVpZuWX7W5JsYGXlAisrV+PLmSmzCuJwNVOuN27jXfwqrGpyPFcAeOGFF3TWswcPHsSIESMQEhKCjoXqwZ4yoqORTiW6YzvUsIIaCmRACSuoxfkczzY+fiMePz6K5OQzuH17qe54ixZnYWdXDU+enMXlyxOQkZEIK6sKqFixO2rW/Dq7zJQnUICoiUuIhwcABdxwF254aFCmRqNCTMwYpKZehiRZw9GxERo23AZbW18AhWvD6bAGoQQg4QLqoR7Oi3cnh0x7+9rw81uMmJgxUKlioVS6wtt7MCpVGo5CkfIEtkhDdVzBOfgDUOBfdEENxBrsn1QqFcaMGYPLly/D2toajRo1wrZt2+Dr61s4uTLFiyWGnSZNmQYHi7UAgBmQOBjLCZDDsYAZkpWwMilHaAYEcwzmitiCeEgF0vkMLvA6Kot6sER5g4P5rfQJAdIZD6iEit64xVPwt6jMR5ILgxBCQEMXJBAgn8cuJklO5e65lhQp/V9nL2zSTU0DGrbEISbAzaLPNlqqy6qIpRLpdMRDAuTn+JIayXIyb0s+bIgoAhmsiLvCmT5+t2w/ERzMbVIP2uEJ7ZHMRjiRNVVrqfotZ6AMTJmWHoWotzZAgBqAkzFNGJkoVzM9vOA5+rJCRgY5vNdtAuQH+J5BCGEzHKMLHrAmLvGKXT2j1iQKy/QR14R/Vaxie+xjCxymL+LojnhG2rWxiMyEXUf4rOIwlUhnfZwRhjx4gwpksJ1iPx/uPmJ2mU8bycnk8y0ThYELRjEIIfRHFG2QyiY4zjv21S3ybE+vOEEf3KIH7jIAR9kBIRyG3wmQ462+p+ag+WXe2BwpjHaQxCY4zg4I4RR8ISyzlWuYFn7I7DJJct3MC7SGigGIZBvsN2qNViY7skIsLJnWY9qRIhUKfm39OQHy5ZfLR9SDtDTxMQmQn7cPocY+y1ruiNSSbkhgNdfEIvlSzIlGQ37+uZD5euPjTLd31sm8JNVmDekKXWxTGB5uPpmk8FLSpAlpo0zn3zb9s1kF/mUzmFaKDDZvLkLkyJjGw4dk+/aZUdh7r89mffmP9ALtkcx6HncZF2deuZGRIiRYJaeHPGvXTCdTLSk5ymo+AXLcOPP6Gb52jaxTh3SySWWo7fPZ2tM31pN00VHMHSps+XJRv22qxPKBvU+hrHhlspAVoilo9/kEBur2F/34I3Wuz5KTTU+6pNF3PTdrVuZB3X6qSDI4mP8tPamLPWiMKXdB6MdofOutzBiNOWRe33SMdeuKd9tcnvnj4rIiJezalVsmIyK4dWuWm7hbt8wj92ni/n2yeXOxhWfNmsyDOeo57LfTuoglly+bR+7+/SIyRPXqmU6wc8jUHIzg2LGizb37rgjTVlT0YzQePJhbJiMi+MsvQubzz5uvn/jtN5Fmly5i/6UhuTLGIStEM7Jokfgg69CBufbLlQWSk8kXXqDB2IE5fTJGRZFeXoX3pZgTjUZ8pQPkqFHZO6acMm/fzordtnmz6TJJ0fHWrClCR4WF5S2TJPfsyYqqce1a0eQ+Tdy+LaJH2NqSW7ZkP5ezno8eJd3dxUdWHrt0jGb3bvHhVLdu9ueVU6ZGQ44fL9re8OFFU4oxMSIChZubiEiRl0ySXLpU9BPt24vRc1HQRpnp2TP7qNPcUTaeFmSFaGZWrxZfwy1biq/jsoL+tJahbXWGXrCzZ8lKlYST4Ty2VuaLWi2+zgFy7FjjHG3fv0+2aCHqePXqwsskxai2cmWyQoXsnVdeMsmsWHS6EYdMvly7Rt2I3lCcQkP1rP3IMrU9kULx5nT8np9MjYacPFm0wTfeyJydKCTnz5O+vmJ69r//CpZJitGylZUYPZvST2g0wmGE1rF+zpBrskI0DVkhWoBNm0gbGzGauXPHYmLMhjFKJq8XLDqarFJFfN0fO2a8TLVafJUD5CefGF7HyUumvvLO6SqvIE6eFJ2ul5fhTje/juTYscw1qUpFGxWXd2JixIeDi4uYujREXvV84YJoTxUqkIcPF07uX39lKRlDa775Pdtp00RbDA4uXIzLM2fELImXl1DohZGpVd6NGuVW3vmh0Yh3BhAByA0pcVkhmoasEC3EP/+Ir2M/P5rdWMCc6E9r5TcNmd8LlsuXYgFkZIivcUB8nedl1JCfzPymd/PiyBHR0VapkvfaZ0EdyenTpI8P6eGRezQgI2YNtKOlyMi8r8uvnq9cEW7InJzI0FDj5C5ZIj6Q2rXLexqyoGerDWXWr59xwbJPnhSj2UqVRLlNkZnX9G5eqNViaQEgR4/Oe5pXVoimIStECxIeTrMbC5iT69dptKFKQS+Yzpeic96jAlJ8fQcHi6c6bVrRZBo0AMqD0FCRt1q1RIdrqkySvHhRrBe5umYaT8iQJI8fFx8KPj7kqVP5X1tQPd+4QdavLwyedu7MPy19Q5WkJNNlkuQPP4i0Xnopf4vxY8fErEiVKmKWpCgycxkA5UF6etaH5Pjx+VvHygrRNGSFaGHMaSxgTi5dImvUEC+iMVsZjHnB4uKEgnV0NBxBQKUSX9+A+Bo3h0z9LSJ5jTZ37RIda716BY/Wje1IYmOFeb2jI7l3b8HXl3ciIoRBSdWq+SsILcbU8927ZNOmYvlh40bD12hHdb16FbyVwdhnq1WwXbsaDpZ96JD4GKpeveAPXWNlareI+PoaHm2qVOQrr4h8TZ9e8FYRWSGahqwQi4GoKLHO4OlJlgZH8tppLXf3/Ke19DH2Bbt1i2zQQCgg/VFnaqr46gbEV7g5ZWZkZK1HfvBB9s5i40bRoTZtatx6bmE6kps3RaR1Ozty2zbj7imPhISID4M6dcRMgTEYW8+JiWSrViIc2YoVWcf1960GB+c2KimKTJL8/XcRMEK3lSET7axPrVrGlbUwMk+dypqOP3486/iTJ2T37qKss2cbl5asEE1DVojFhNZYwM3NuHU2S3H8OHWx0Qqa1tKnMC/Y3btZ2yO2bRMvdNeu4kn+8otlZGo01O0re/ttoSRXrhQd6bPPkgkJ5pdJkvfuibBz1tbkunXG31de2L5dfBA0aCA+EIylMPX86BF18UZ//z17HEvdvlUzyyTJZcuyb6PSKv66dY23CyiszOhoMcp2cxOj7sePs+I6zp9vfDqyQjQNWSEWI6YYC5iTQ4cKN62lT2FfsPj4LEXRuHFWZ2ZJmRqNCOQLCCUoSeL+wuwJNaUjefBABC5WKITHkKeF9evF823WTHwYFIbC1vOTJ2S3buLZtm4t/h0zpnB7B015tqtWiY+qBg2yFH9hHDSYIvPq1azp+AYNhPw//ihcGrJCNI2yoBDLTTydGjWA8HCgalWga1dg167ik71vH/Dcc0DFiiIPzzxjWXkVKwJ//w3Y2QFRUcDo0cDwQjrvLyySBHz1FdCjB3D4MODlBWzcCDg7W1auqyvwzz9Ap07AG28A8+ZZVl5p4M8/gVdfBVq0APbuBTw8LCvP3h5Ytw6oVg2IiAA6dADmzAEsHW0rOBiYMAE4e1a0r7//Bnx8LCuzenXRbtVqIffTT4HXXrOsTJmyg9FNXpIkpSRJxyVJ2mrJDBUFX18gNBTw8wNeekk0fEuzcyfQrZvoTMLDxQtnaR4+FJ1JcrIo62+/AStXWl7uzJnAtm1A48bAnTvAoEHAkyeWl+voCGzdCvTsCYwaBXz/veVllhTz5wvFHxQkPurc3CwvU6UCXn8duHYNaNoUCAsDJk7URWOzGJs2Af/7H1CrllBQAwYA8fGWlXnzppBDAnXqAN9+C6xfb1mZMmWHwnwDjgVwzlIZMReenkBICBAYCPTvb1lFsXEj0KsXUL++GCVWqmQ5WVoSE4HnnweOHAH++guIjATatxdfucuWWUYmKTrISZOEnGPHgIULRYfdvTvw+LFl5OpjZwds2CBGTh9/DHz5peU77OLmhx+AkSNFnW7dCjg5WV5mSgrw8suibufMEc925Ehg1ixg7FgRstISrFsHvPIK0KyZkLlpkxixde4M3L1rGZmxsWL0e+2aaLuRkWIU/uqrwB9/WEamTBnDmHlVAFUA7AHQGcDWgq4viTXEnOgbCyxYYP70//hDrD+0bi2s9YqCsWsS9+6JNSUbm+wb/ZOTxT6xwpTVWJlqtVhPAsgRI7KvKxXWsMYcay8ZGcKDSH5eeMoaGk2WN5f+/Y3buJ4fxtZzToMa/fwU1rCmMM92xQrRbtq2zb7Rf/duYUFdv75xRkSFkZnToEaLvmHNvHnGpSWvIZoGysAaorEKcR2AQAAd81KIAEYAiAQQWa1aNXPWo8nom1Qbux3BGObPFy9Qp07ihSoqxrxgd+5keb3ZsSP3+ZSUrLIa413GGJkZGeSwYTS45ULL338LBd2kScFbL8zVkajVwpOIIaflZQ19J9hDhhTOtVleGFPPCQniQ0apFB82hvI1darI14ABBW+9MPbZLl0q3p2OHQ2/O/v2ZTl7v37dPDJPncramqW/5UJLSgrZo4co6/ffF5yerBBNo1woRAA9Afya+f88FaL+rzSMELXob1ifMaPo6c2eLdLq3t3wxmJTKOgFu3kzy7OIIWfOWvS9yxS0p6ogmdniNn6e/0jM2M355uxI9BXJG2+YR5EUN5ZS7AXVsy5OpY34oMmPb7+lzrtMfpvzjXm2CxYIZfjcc/mHZzpwwLj9iMbIjIwUe4Lz2pSvRaUSo3OA/PJL2VONJSgvCvFrAHEArgK4DeAJgD/zu6c0KURSdJavvy5K++mnpk2zaTTCiwUgvFoUdVpLn/xesOvXxdeyo6P4ei6ItLQsrxtff22azJSULMVqjNcbUoR5KsiVnrk7Ev2pRnM/E0uTnm65qd/86lk/TmVBbtu0aL3LPPdc3u7bCnq2P/8s0ujWzbgAvocPi+nNatXydrlWkMzwcOEtqkYN4T2qINLTxSi9oGciK0TTKBcKMdvFZXCEqEWtJkeOFCV+//3CfY3rB9kV/g5BBwcHOjo60tHRkcOGDdO7VsPx48fT3d2d7u7uHD9+PDUF9HZ5vWBaH6YuLuKrefPmzfT396ejoyNbt27NM3phITQaDSdNmkRfX1+6uLjQyyuIwOk8v3bzkqldjxQjwwvs1asXPTw8WKFCBb7wwgs8r+e5+9SpU3zhhRdYsWJFAtA5+M4ruLGxHcnx48cZEBBAe3t7BgQE8LiheS49vv+eZhm15/dcZ8+ezZo1a9LZ2ZmVKlXiuHHjmG7isDTnaCQ/uXv37mXHjh3p4uLC6tWrG5V+XvWsH6cyNDT/9qRP586dCYCSlM62bcXeUGNlklmzKuIjK++yalGpVKxXrx69vCrrXDNeuFA4mf/+m+XYe9WqPWzWrBmdnZ1Zs2ZNztfbhR8SEkJJknT5cXR0ZOfOS5lfcGNj23F+9btq1SrWrVuXLi4u9PT05BtvvMGHRQ3gWMqRFWIpQ99Y4M03jTMW0J/WGjlS/A2AFy9eNHj9vHnzWLduXV6/fp1xcXGsX78+f/vtt3xlGHrBcgZFjY6OprOzM8PDw5mens6ZM2eydu3auk55zZo1rFSpEi9dusSMjAyOH/8p3d2bERAb6o2Jh5gzbuPhw4e5cOFC3r9/n2lpaZw8eTL9/Px0158/f54LFy7k33//TWGflX8IKGM6EpVKxWrVqnH27NlMTU3l3LlzWa1aNaoKGP5p13U7dzZ9XTe/5xoTE8PETOup+/fvs1OnTvzemAWnHKSkiICzgAhAW5Dcw4cPc/ny5Zw/f36RFOL589lDPxXUnrT8+eefbN++PQFw1ar0PENA5fVsv/6auhF8Wlr+ZdUyY8YMtm/fnpUrV2ZUlFj78/HJHRYsL5mbN2eFfrp+PY0uLi6cN28eNRoNjxw5QkdHR57I9PMYEhLCypUrZ7tfPwSUoXVdY9pxQfV77do13sv0uPD48WMOGjSI77//fv6JlnHKnUI09ldaFSJZOGMBfYvGjz/OUir5vdStW7fO9gW6cOFCPvvss/nmKecLpg2y6+6eFQbpp59+Yvfu3XXXqNVq2tnZcXfmouKsWbPYv39/3fnTp0/T1taWb78t8v/RR9mVYk6Z9++Ljs7KSgRYNcT9+/cJgPE5esOLFy/qFKI2/4bi7hnTkezatYu+vr7ZRtVVq1blDkOWRDn44w+hzE21/DWmsybJ+Ph4dunShaNGjSpU+voWjfrfSMbI/ffff01WiIY+UgpqTyT54MEDPvPMM4yIiCAApqenZwsSrO9VJqdMjUY7+iUHDcpSKgWV9fLly6xXrx63b9+uU1RnzgiFmDO4saH2pA0i3qKFaNO3b98mACbrLVo2b96cKzMtiQwpxJz5z2n5a0w7NqZ+tTx+/Jivv/46u3Xrln+iZZyyoBDLjacaY5Ek4IsvxIbcNWuAfv2A1NTc16Wni43nS5dmXS9JWec7dOgAHx8f9O3bF1evXtUdP3PmDJo0aaL7u0mTJjhz5ozR+Tt7FujYEUhLE3sbmzXLOifaVNb/SeL06dMAgODgYFy6dAnR0dFIT0/HsmXL0LVrV8ybJzzZfP+92Feml4SOO3eEzFOnxN7KV181nLewsDD4+PigYsWK+ZbBz084KahQQXjwCQszuvg4c+YMGjduDEmvshs3bmxUHb72GrB2rdhf1rmzaZu883quALBy5Uq4uLjAw8MDJ0+exDvvvGN0ug8fAi++KJ7psmVir5+xcovC0aPi2Vpbi+fQuHHWufzaEwBMnDgRo0aNgo+e+5iePYVzhitXxJ6+69dzyySByZOBqVOBIUOA5csBKyvjyvr+++9j5syZsLe31x1r0EA43LCxER6L/vvPcFmXLBHvbOvWwO7dgLs74O3tjYEDB2LJkiVQq9WIiIhAbGws2rVrp7vv7t278Pb2Rs2aNfHBBx8gOTkZkgRMmQJ8951oU337Gu4n8qOg+t2/fz9cXV3h7OyM9evXY9y4cYUTIGN+LKFlS/MIUZ9sxgJ7DwvX/gEBTOn/Ol9qd58A+b//5b4vNDSUKpWKiYmJHD16NP39/XVTIQqFguf0YlFFR0cTQN7riBERDPI8wyCnozzZdTw9K6QZnB46d+4cHRwcGBISQpVKxWnTplGSJM6cOZOkmGocM2YMAVCpVLJGjRq8nGndoj9V/M47pPpAlsxrL73LutWeFBi38fr16/T19dV9WeuTc4SoJZsBxw9ndTIZHJx9M5ge06ZN44ABA7IdGzRoEKdOnZp35nKg7xT7xuZI3XPNTy6Z/3PVJzo6mpMnT+at/BxvRkTo5N7r8zYD/B7n6aTcGLlGjxD12lNo5y/o7JBu0NCpoPZ09OhRNmnShOnp6bxy5YpuhKjlwIGsOIMX//pPJ1MzIJgfD7pBrSP4nGtw+ZV1w4YN7Nq1K0nDIzf9ZYTDC6OytaefPrxMQAS2zmnBunnzZnp5eVGpVFKpVHKB3mbdW7du8cyZM1Sr1bx8+TLbt2/PESNGZLt/3jy96fg9h41qxwXVrz5xcXGcOnUqLxhaKC1HoAyMEJ9qhUiKfVEKSc22igN8AFcmwYFd8C8B8tfuWwq8PyMjgw4ODoyKiiJJuri48LDePGFkZCSdnJwM3zxlCungwCCEMBBH6Y54VpbieGH0XIOXr127lv7+/nR3d+eYMWPo7+/P5ZkerydNmsTWrVvz+vXrTE9P55IlS1ijRg3dVJFGQ372mXjibyqXsQNC2BIRrI4rdMED7h+at3fwu3fvsn79+pyRx76VvBQiKUz8m/rcpA1S6Y9TDEKImNd0cBDlz8Hs2bNzTR317NmT32kX3IwkJIR0skllbSmGV1FdFDwfuTnJ+VxzsmrVKvbp08fwzZnPlZLEm/ChP07RDk+4bWDBXqTzkmuUQtRrT41wgvZIZj3pHOPGGfiqY97tSa1Ws0WLFtyXadZsSCGSIpBvRfskVpJusgUOMwghHIO5BMjRLQ4VaLimX9akpCTWqVOH0Zme8fOayrx6laxV4T6d8ZBNcYxBCOEsaYIw2vE7myvwsFYx7dy5k2q1mufPn2edOnW4detWg3mKiIhgxYoVcx1fvlz0E20UB9kW4QW24/zqNy+5zZo1y6e2yj6yQiwLRETwL5vBtEIam+IYn0UEFcjgMrwuGns+IwpSvNSOjo48mbm40bp162xfoIsWLTK8hhgRIdIH6I9TVCKN1XGFl1DTKLmJiYl0dHTUjUZ79OjBOXPmZLvG1dWVR48e1f2tORjBL6ynEyDdcY/WSKU74hmJgDxlJiQksGnTppwwYUKeeclPITIiggn2vnwWEQQ0rIYrotkBBmXu2rWLlStXzjairlatmlFriDnlRtgG0Q0JrIJYhqBDvnJzkvO55uSPP/5g48aNDcrVPtdDaMFauEhHPOZedCyS3AIVop7cZ3CBEtRsguO8A89Ct6fExERKkkRvb296e3vTw8ODAOjt7c2wsLBsMk/bBdIHN2kFFT1whwD5Ib6jxr5wZT1+/DitrKx0MitUqECFQkFvb29euXIlm8zrdnVYF+cpIYPumTIHYgXT7F1yyVy7di2bNm2a7djYsWM5evRog3k6dOgQK1SoYLB+19kMpDVUdMIjtsH+QrWnnO9rTsLDw+ni4pJvGmWdsqAQJZFP89K8eXNGRkaaPV2LMHAgsGYNtrA7emELAKABzsIT98R5Ty+xiJFJcvIZkOlwdGwEjSYFV65MRkLCDjRvfhoKhTVu3pyHGzfmonHj3QAkREU9j8qV34evb45Fo7NngXt38RAuOAGxUPgsDsMOqQblAsDjx8fg5NQU6ekJiIkZDUmyQv36wlnr1atfIjHxX/j7r4e1tSfu3l2B6OiRaN36Bqys3LLJvIKauIbqAIjmiIQjkg3KzMh4hKio5+Ds3BLPPPNzrqoTjUiFlJTLiIz0R/v2KQAkKBS2ucqphhL70RaABA/Ewx9nDMrUaNJw5MgzqFLlQ/j6jsStW7/j+vX/oWXLi1AobPJ9lIbqNwlOOIZAAEAz/AcXPDYot6DneuvWQlSs2As2Nl5ITj6Ls2f7o0KFF1GnzmyDcpPhgEi0yJR7HC54ZJJcUgMyDYmJIbh4cSRatrwAQJG7LjLlxqI6rqIGAKItDsIKGQblAnm3J5JIT7+juy419TqOH2+JVq3iYG3tmSU7U2YK7HEELQFI8EUcnkFMocsqSRLS07MWfR8+PIiYmPcQGPgfrK09IUnKbDLTYIMItAYgwQUP0BQnIBmQmZJyCZGRTdCw4Wa4uXVCauplREW9iKpVx8PXdwQSE0Ngb18LtrbVoFLF4fz5N2BnVwP16i0xWL8JcMcpNIICGqTBBkpoRFiQV18FVq3KdsuxY8fQtGlTJCQkYPTo0bCyssLKTOfKK1asQPv27VGtWjXExsbijTfeQMWKFbFhwwaUVyRJOkayeUnnIz+sCr6knBMdDZB4CdvQFvsRh6pZyhAQ3o/1SEu7g4sXR0GlioNS6QgXlzZo2HArFAprAEClSu9kKohGAAAfn+GoVMmA8UWKCBPhikdQQA0NrHAN1VAX0QblAkBMzFgkJ5+EJFnD07M/atfO6oyrVZuA9PS7OHasKdTqZNjb14G///osZagnsyau4BqqQgKzlKEBmfHxG/H48VEkJ5/B7dtLdcdbtDgLO7tqUKlicfhwTd3x8HB72NpWR6tWV3PJvAUfCF/yRDw8cRO+8MXNXDIVChv4+/+N6OjhuHLlUzg41Ie//9+FU4Z6cp2QBCukIwPWOI1GaIKTosyFfK4PHx7AlSuToFYnwdraE56e/VGz5nSDcp/AHlEQhlVWyMhShoAJcsNw8mQn3fXh4fZwdQ1C06b7csm9A29cRQ1IIOzxJEsZGpAL5N2eJEmCjU2WIY1GIz7SbGy8IUl6XUZmHdsjBfZIQRpsspShCWXVl2lt7Q5Ake2YvkwbpMEOKUiFPR7DBYlwhzsScsm0t68NP7/FiIkZA5UqFkqlK7y9B6NSJREvLSnpOM6ffw0ZGYmwtq4ID48+qFHjq1x1pZXrjgRYIR1KqIUyFBUEXLyY65axY8fi5MmTsLa2Rv/+/TF7dtb7evbsWUyYMAGJiYmoUKECunfvjq+//jq3XJnixRLDzjI1ZRocLNYCtNMf+j+FQvgvs7BcDcDP8JUwRMB8qiWlZeTqyQxCiFgHsXRZg4P5rfQJAbIv1vEhnNgDWwiQc6UxxVK/QQhhSxxiZVynO+J5TAq0mNwz3T6iD27SE3cYiCPFU8ckF7WcRwlqdsZuJsGheNpxSbw7OWTGw53NcIw2SOUmqXextafieq7lCZSBKVNZIeqtveT6GbE2YC65GoCTINb3hisXU33AAnL1ZOZ6qS1U1ukjrhEgg7GSabAiAapgzT5YL6x437tqdpkkDZb1EmqyOq7QDQk8vNCwsUxROHmSwkoYt3gG9Yutjn/7TST/ouIfPoFd8bXjknh3DMhMgBtb4hCtkMZ1My1kqVkC7055Q1aIZQWtVaD2y7MQ1ojmlKuRFJxs9TUBEWXCIlEc9CwRjbGUMxWNRjgFB8jXGx9nhr1TtvpNs3fhAP8oAuZxum4QA2W9aucnrBSdyf37zSfq2DFmuRkbPbdY6pgk584VVdqzJ5kycVrxt+OSeHcMyHxo7802VWLzjN5hTrnF8VzLI7JCLEto940FBha4X82ScjUHI3SK5K23LKQUdXvVIi1SVv1IFMOGZbrIM1C/+k7Xp0yxUGxDA2WNixM+Lh0dxfaMoqJ1RF29up4TaQvXMZkViaJvXz1PKiXRjkuJzMePhQcZhUJsp7KUXEs/1/KKrBBlTEbrXu7NNy2jFC3lsV+jIceOFXk3JqRRRoZQ/IBwoG4JpWiorLduiY379vb5OyQoiP378w5VZMmoCNrIK8bEKnyaSE4WjjZyBj02J3K0C9MoCwpRtjItpXzxhfj3yy/FQsXChYBSWaJZKhCNBnjvPeC334SbuB9+yO7uzhBKJfD778It1zffACoVMHt2wfcVFR8fICREuJbr2RPYsAHo3r1waezbJ+6tXBnYsweoUsUiWc0GKVyiTZ8OvP46sHhxdrdoTzsODsDmzcLV2ttvi/Y0enRJ50qmrCC/SqWYL77I8r2q0YjOr7QqRY0GGDECWLQIGD8emDXLeKWmUAC//iqU4pw5wo/rTz+J45bEy0soxRdeAF5+Wfis7N3buHt37wZ69QJq1hT/r1TJolkFIJThZ5+JD4e33gIWLCi97aEksbcH/v5bbA187z3Rnj74oKRzJVMWkBViKWfqVKEYpkwRHeKSJaWvE1SrRQe9fDnw+ediVFvYEZ4kCWVoawv873+iE5s/3/JKsWJFMbp78UXglVfE3upXXsn/nh07gD59gLp1hTL08rJsHgHx7D/8UNTRqFHAzz9bvm7KMra24gNn0CBRb2lpwIQJJZ0rmdKOrBDLAJ9/LhTG55+LjnHp0tKjFNPTgTfeAFavFtN4kyebnpYkidGPrS0wY4ZIe9Eiy5fVzQ34918xZRocLBT7oEGGr928GejfH2jYEPjnH6FQLY1GA7z/vhhFGzsVLSNmHFavFu3z00+FUvz885LOlUxpRlaIZYTJk0UnOHmyUIrLlpW8UkxLE57vNmwQimz8+KKnKUlCsdrYiFFxWlru8EGWwMUF2LlTrAm+9ppQxkOGZL9m3TpR3oAAYNcuoUgtjUYDvPOOWEP+5BNRz7IyNB4rK+CPP0T4qylTxJri9OlyHcoYRlaIZYhJk8Q02cSJWUqxpAwqVCoxUtqyRYxYzB3K7fPPhVLUftmvXCn+tiROTsD27WId8c03hdy33xbnVq4UI41nnxVTpi4uls0LkH0qevJkYNo0uSM3BaVSLDXY2ABffSXabs74pjIygKwQyxyffSZe5M8+E0qxOEZPOUlJEVZ8O3eKabxRoywjZ8IE0Yl9+KFQvn/9JaZTLYmDg1DyffsKI6G0NKEo33oLaN8e2LpV/G1pMjKEFenq1UIRylN9RUOhEGvSNjYi6G9amliPlZWijD6yQiyDfPqpeJE//VQoxT/+KD6lmJwsRlB794ppvGHDLCvvgw+EEhw9WhiyrF8vrAgtiZ0dsHEjMGCAsFKUJKBLF2DTJqEwLU1amljDXL/efFPRMkIp/vyzaE8//CDq+ZdfZOMkmSxkhVhGmTBBvMjjxwul+OeflleKjx+LNbb9+8V07euvW1aelnffFV/2I0aIrQ7FoZhsbYHOnYUsEujQoXiUoaWnop92JAn4/nvxfGfNEkpR3r4io0VWiGWYTz4RL/gnnwjjixUrhPGAJXj4EOjWDThyRMgJDraMnLwYPlwoxTffFNaglp66/OEHMVX70ktCEWq3vWgtfi2B/lT0L7+IDwEZ8yNJwMyZoj1NmyaU4pIlsoMDGVkhlnk+/li84B9/LDrslSvNrxQTE8U+vePHgTVrgH79zJu+sbzxhijb66+L/GzfDri6ml/OrFlijbZfP1GfSqWYRp06VYzgZswwv1LUn4r+/XfxASBjOSRJ7Je1sREGS2lpYpbFUh+UMmUDWSGWAz76SEyffvihUIqrVpnvxY6PB55/XgQM37BBjJhKkoEDRScWHCw8zOzcCVSoYL70p00Tim/gwOwGS4sXC7kzZ4rO05xWivpT0UuXCsUvUzxMmiSmTz/5RGy1Wb3a8tbMMqUXeTm5nPDBB8IH6Pr1Qlmkpxc9zbt3xTra+fNiLa2klaGWfv1EOU+cEMYu9+8XPU1SjBSmThX7D3MaKikUwLx5wrjnu+/E2h5ZdLkPHwJduwIHDoipaFkZFj8ffwzMnSsMqfr1A1JTSzpHMiWFrBDLER98IEzJN2wQFpJpaaandesW0LEjEBMj1uu6djVXLs2D1rjm7FmgUyehvE2FFMZJX30l9h3m5TNWoRA+Vj/8EPjxR7HdRKMxXW5iohh9HzkipqKLe11WJosxY8QHz9atYuo6JaWkcyRTEsgKsZwxdmzW166pSjEuDggKAq5dE1OSXbqYP5/moGtX0YHFxAjlfetW4dMgxWjvu+/E6G/evPzN8CVJXPvpp2Jf2/DhYgN9YYmPF/V68qT4gCmpdVmZLN55R7gK/PdfoEcPsa4r83QhK8RyyJgxYgSj9fhfGKV49arYYnDnjvDV+eefI+Dn5weFQoGlS5fmeV+XLl0gSRIyMjKKmv1C8dxzwnPMtWtCicfFGX+vRiNGeT/+CIwcGY/jx9vC07Mi3Nzc0Lp1axw4cEB37bJlyxAYGAgXFxdUrVoFGRnj8fnnGViyREyxFqbY2qnos2fFKHfLlrzrePXq1fDz84Orqyu8vLwwZMgQPHr0yHhhMoVC6xkoNFRYVT9+bFo64eHhcHJyyvaTJAnr168HAJw+fRovvvgiPDw8IJUD7wAjRuTdhklisnBy3FiSpIeSJO2TJMm/JPJZELJCLKe8/77YhLxpk9jXZoxSvHRJKJXERBHFoU0boEmTJvj1118REBCQ530rVqxAujkWLU0kKEj4Fr19W/w/Nrbge9RqMbqbP1+M9mbPdsLixYtx7949JCYmYsKECXjppZd0Cv7JkyeYM2cO4uPjcfjwYezduwcODt/hq6/E2t/gwcat2+pPRW/bJka5+dVx27ZtceDAATx8+BCXL19GRkaGtnORsRCvvSasiw8eFIZbDx8WPo327dsjKSlJ99u6dSucnJzQNXPtwdraGq+++ioWLVpk5tyXDPm14bVr12Lx4sUAcB6AO4AIAH8Ubw6NQ7YyLceMHi2m+EaPFiGN1q7N2/XZhQtiCi81VZj+N2umTUNEV7WzszN438OHD/Hll19i+fLlaN26tSWKYRRt2wol/uKLYoQbEgLUqmX42owMsZ/xzz+FEc3UqYAk2cHPzw8AoNFooFQqkZiYiISEBHh5eWGUnn+6ypUrY/DgwQgJCcGWLaJOP/64YCvFuDgxMrx5U4xqg4LE8fzquGrVqtn+ViqViImJKWTtyBSWAQPEcxwwQMxC7NoFuLubnt6yZcvwyiuvwNHREQDg5+cHPz+/cvMs82vDV65cQbt27bB27do0kmpJkv4EUCojVMojxHLOu+8Kf6NbtgilqFLlvubsWdE5p6cLRaJVhsYwceJEjBo1Cj4+PubLtIm0bCliGyYlCaUYHZ37mvR0MZr7809hRKMNwqylcePGsLOzQ69evTB8+HB45RHsMCwsDP7+Ytbno4/EtOvGjWJjvSErxdhYUcfaqWitMjSG/fv3w9XVFc7Ozli/fj3Gye5rioU+fcT6blSU+FiMjzctneTkZKxbtw5DcoZPeUoIDg7GpUuXAMBWkiRrAEMA7CzZXBlGVohPAaNGAb/9JgxQ+vUDVGGHhRY8FomobhPQsV06FApg3z6gUSPj042MjMSBAwfw/vvvWyzvhSUgQJQjLU0onbOrTurKmvbqaxjwfAL++ksYxkycmPv+qKgoPHr0CCtXrkS7du0Myli8eDEiIyPx8ccf6469/76Yft22TVgpPtl3RCf3Us+x6NBKhYSErKnowtCuXTs8fPgQcXFx+OSTT1CjRo3CJSBjMj17io/J8+fFVPed7cd0zxUDBwKHDhWYxoYNG+Dh4YGgwnwFlQYOHRJlDAw0uqyGqFSpkvZdagggBUB/lNIRIkia/RcYGEiZ0sf8+SRAdlfsYHuEMhBH6Y54VpGuM3r0nHzvbdu2LZcsWaL7W61Ws0WLFty3bx9J8sqVKwTA9PR0SxbBaM6cIX2cHtETd9kcR9geoeyBrQTIH7tuMyqNevXq8cSJE9mObdy4kV5eXoyKijJ4z+LFpAQ1Oyn2sR1C2QKHWBnX6Y54/vf2r/nKy1nHhoiIiGCzZs2Myr+M+dizh3SwVrGedI6tcYBBCCEVCtLBgZwyJd97u3Tpwil5XHPx4kWKbriUMWWKKJskiU7DyLIaasOTJk1i69atCeAkxDLdUABXADjQAvqnKD9ZIT5NRERwvs1oAqQjHlFCOqvjCi+hpmjsERF53pqzoScmJlKSJHp7e9Pb25seHh4EQG9vb4aFhRVDYQogIoIX7BqzMq5TiTQ64BEBch5GFFhWLbVr1+aGDRt0f+/YsYMeHh48fPhwvnL/sHmLCmTQAY9pDRU9cYdRaFjoOjZEeHg4XVxcCsy7jJmJiGCY7XN0wiPaIoX+iBLdJ5Dvc7127RqVSiVjYmIMni+VCjEiQpQJoAbgUQQaVVbScBvu0aMH58yZQwCR1Coe4AGA5rSA/inKTzaqeZqYOxcj0tfgLGpjLj4AQIQiCNVxDUhViA2MrVpluyUtLQ0ajQYkkZ6ejtTUVNjY2MDV1RU3b97UXXf9+nW0bNkSx44dg6enZzEXzABz56Ku6hRCEYQ6iMETOKEKrmEVBmLVk4FALxegQdbljx4dApkBZ+eWINW4ceNHXLt2B99++yzmzgUSE/fi7NnB8PffiPHjW+Yt96wLkPY6quEqrkJY9exDRzTAuULXsUKhwIoVK9C+fXtUq1YNsbGxmDRpErqU1o2h5Zm5c9E+bQ9WYCB6YwvOoCGiURt1cUksGht4rgDwxx9/oE2bNqhdu3a24yShUqmQlmn+nZqaCkmSYGvpgJ/GMHcukJICAmiOo/gPgdiPdmiLg3mWNb823KJFC6xduxYArCRJUgAYDMAaQOmzKLKElpVHiKWUgAAeRCs64yElqOmOu1lffgBp4LkFBQURQLZfSEhIrutK25QpAwJ05bLFEwIaKpHOpjjGIIQwyCmSQUHU/Zo02UdHx8ZUKp1oZVWBrq4d2KRJqO68q2tHAkoqFI66X4UKXbOlERREBjkdZSCO0gppBDS0QUqR6njixImsXLkyHRwcWLlyZb799tuMj48vnjqUySIggNdRmc/gApVIpxJprIpYXkTtPJ8rSfr5+XHhwoW5jmvfF/1f9erVLVwIIwkIoAbgGMwhQPoijmpIJrfhlJQUvvvuuwSQBuARgP8AdGUpGBHm/MkK8SniwHOf0wmP+AwusJV2HUTbyBUKcuDAks6i+QgOFmUCGIQQtsJB1sV5OuIx90kdLVbWw89PohsSWA1X2RIR5buOnyKuvvQeayGGLnjAA2jN42hCD9ylL+J4Tqpfrp6resBAvoN5BMgquMYOZmrD0JsyLa0/2cr0KeHAAeDFg1NRSbqNEHSCLXLs1LezEy5uygtjx4oyZWILFfahI6rhGrpxG3a3Mv/m9oMHgecOfIEK0gOEoQPskWP/RXmr46eES5eADke/QwLc8S+eRxtEoClOIgSdkAErdGQIzvScUNLZNAtqNTA8aQ7m4x18iq9RC5eQzY9OOW/DskJ8Cti/X3hE8a2ixL5xm1DZ4UHWSYVCRMD9+GODayBlllatRJn0wtxXUtzFPvvuqOP1CD3HN8BOM+6ECgsTXk18KlshbOwGVHfQ27RWXuv4KSA6WmzfSUqzxZ6316Clwxmds9uGinMItesKhZM9Oo5tgpMnSzizRSQjQ7ghXLLNC1M7hGCm/YwsZfi0tGFLDDvlKdPSQ1gY6ehI+vmRN25kHoyIYJDnGQY5RYqpRSMsLsssBsoaH082a0ba2JCbNxddxO7dpL09Wb8+efNm3nJlyhZnzpA+PqSnJ6nbZRMRIZ5nYKDuuUZHk1WqkBUqkJGRJZplk0lLI199VcyKfvVV5kEzt2GUgSlTWSGWY0JDhTKsV0+vo85EawTyNGCorAkJZMuWpJUVuW6d6Wnv2EHa2ZGNGpF37hQsV6ZscPKkUIQ+PkIxFsTly2SNGqSra9n79lGpyD59hDb47rvs58zZhsuCQpSnTMspYWFA9+5A1arCHVulSiWdo9JFhQrChVrLlsJf5apVhU9jyxbhlaZ+fVHHeXh5kylj/PefiLFpYyOiXjRoUPA9NWuKaz08xNT5/v2Wz6c5SE0V7gY3bhTuBz/6qKRzVLLICrEcog1dU62a6KhLgZvRUomrq4j32LatiHCwfLnx965fLzqSJk2E/9SKFS2XT5ni48gR4bfUyUm8R3XrGn9vtWriHl9fsWa/b5/FsmkWUlLEB922bSIOaCnywFhiyAqxnLFvnxgZ1qghK0NjcHYGtm8XI4KhQ0WA2IJYvVqMKlu2FMFkK1SweDZlioGDB0VkC3d3McOSYy+9UVSuLN7B6tXFe/jvv2bPpllIThZBkP/9F1i8WARHlpEVYrkiJCRLGe7dC3h7l3SOygaOjmL688UXRYzEX3/N+9rly0W0jLZtxejS1bX48iljOUJDxVRnpUri/9Wrm56Wj49QinXrAi+9JD64ShOPH4sZpNBQ0Z7ffLOkc1R6kBViOWHvXvHFV6uWUIyyMiwc9vbA338DvXqJ+JFz5uS+ZtEiMYrs1El0cs7OxZxJGYuwe7dQENWrC0VWpUrR0/T0FO9kw4bAyy+LQN2lgQcPhOI/eFCsm7/2WknnqHQhK8RywJ49QhnWri1eQtm4wzRsbUUQ5X79gA8+AL75Juvcr7+K0eOLL4rRZGacV5kyzo4dIsRTnTrmNz5zdxfKNiAgK0B3SZKQIKaEjx0TeXn11ZLNT2lEdu5dxtm9W0zLPPOMUIylwa92WcbGRqwRvv468OmnIq6is7NQkC+9JDqS0uB/WabobN4M9O8P+PuLtTRLGEa5uQlr5h49gOBgEaB60CDzyymI+HihDM+dE0GPe/Ys/jyUBWSFWIb5918xxScrQ/NiZQX8+adQjlOmiGN9+4opJhubks2bjHlYv14oqIAAsRZsScMoFxcxEu3VS0xRpqWJqffi4s4dYTl76ZKY3XjhheKTXdaQp0zLKP/8I0YsdeuKaVJZGZoXpVKsx2qpWROwti65/MiYj1Writ9K2MkJ2LpVjNLefBNYsMDyMgHg5k2gY0fgyhWxvUJWhvkjjxDLILt2if1D9erJe+AsASlGhjNmiC96Z2fg+++Fr8cffgAkqeA0ZEony5YBb70FtGsnFISTU/HJdnAQ07T9+oltDunpwoDLUly/DnTuDNy+LUbB7dtbTlZ5QVaIZYydO4XVWv36Yv1QVobmhRRrh99+CwwbBsyfL/wa29oKy9O0NODnn3X+nWXKEAsXAiNGCCWxaVPJGEbZ2Yk1vAEDgPfeA1Qq4MMPzS/n6lVhDZ2QIGaTWrc2v4zyiKwQyxA7dgB9+ghXUpYyAniaIYXxzNy5wKhR2RXf7NlCKX7zjVCK8+eLaVWZssGvv4rRWNeuQiHZ25dcXrTWzIMHC1dpKhXw2WfmSz8mRij9pCQxg9S8ufnSLu8UqBAlSbIDEAbANvP6dSSnWjpjMtnZvl0oQ39/MTJ0dy/pHJUvNBrxxf7bb8C4cUIB6k+NShLw9deiM5s2TSjFxYuFAY5M6WbOHPGh06sX8NdfpcNK2NoaWLlSGGlNnCja05QpRZ+OP39eGNCkpQnbgqZNzZLdpwZjXmcVgM4kkyRJsgawX5KkHSQPWThvMpls2yasHBs2FCNDWRmaF7VarOksWgSMHw/MmmW4Y5Ik4MsvRWf2+eei0/njD9nYpjTzzTdiCrxfvywFVFqwshJrmtbWwBdfiPY0Y4bpSvH0aWG0Q4o9lQ0bmjW7TwUFroRkRu5IyvzTOvNHi+bKSLZs2YKGDRvCyckJbdq0wdmzZy0uMz4+Hm3btkXFihXh5uaG1q1b48CBA7rzq1evhp+fH1xdXeHl5YUhQ4bg0aNHJsvbulUow2eeiYa3d2/4+XnC3d0dL774Ii5cuKC7buTIkXByctL9bG1t4VxEVyrh4eHZ0nRycoIkSVi/fr1FyloSZGQIq79Fi4BmzUbg77/9oFQqsHTp0mzXLVu2DIGBgXBxccG8eVUQFDQea9ZkYMAA0ZEVhb179yIgIAAuLi6oVasWFuQwQVy5ciWqV68OR0dHvPzyy0hISCiawKeE6dOFMmzffgvOn28Id3fD/cQPP/wAHx8fuLi44K233oJKpSq2PCqVou2NGAHMnAl88olQaIXl5EmxZqhQAN98sxdvvGG4Pc2cOTPb+2xvbw+FQoH4+Ph8Ui8YtVqNyZMnw9fXF87OzmjWrBkePHgAAFCpVPjggw8AoLEkSYmSJP2aObgqfRgTIwqAEsAJAEkAvsnjmhEAIgFEVqtWzRzhs/IlOjqazs7ODA8PZ3p6OmfOnMnatWszPT3donJTUlJ4/vx5qtVqajQabty4kRUqVNDJvXbtGu/du0eSfPz4MQcNGsT333/fJFmbN5PW1mTz5uS//x7mwoULef/+faalpXHy5Mn08/PL894hQ4bwzTffzPO8KXHOQkJC6OTkxKSkJJLmLaslyausaWki7ilATp9O/vzzz9y9ezcDAwO5ZMmSbNf++uuvDAsLo0qlYlxcHAMCAtiz59cEyJ49ydRU4+Vmz0MaXVxcOG/ePGo0Gh45coSOjo48ceIESfL06dN0cnJiaGgoHz9+zIEDB3LAgAEm1MLTg0ZDTp4snuvLL+ffT+zcuZNeXl48ffo0ExISGBQUxAkTJpRInt97T+T5/ffF38YSGSmCE1epQp45k397ysnUqVPZqVOnPNM2tp+YNGkSO3XqxKtXr1Kj0fDUqVNMSUkhSX7xxRds164dARwH4AngEIAvWQriH+b8Fe5iwA1ACICG+V1XHAGCf/rpJ3bv3l33t1qtpp2dHXfv3m1x2foyN2/eTAC8kzM6LIWSeP3119mtW7dCp71pk1CGLVqQiYm5z9+/f58AGB8fn+tcUlISnZycuG/fvjzTN0UhDh06lEOHDjV4rihltTSGyqpSkX37ijfg22+zn2vbtm0uhZiT77//nj179uRvv4k0XnyRfPKkYLk5uX37NgEwOTlZd6x58+ZcuXIlSfKzzz7jwIEDdediYmJobW3NR48e5Z/wU4pGQ37yiXgmw4eTP/6Yfz8xcOBAfvbZZ7rzu3fvpre3d7HnmxR5/+gjkfd33iHV6oLviYgQQYlr1BBBigtqT9nlaVizZk0uXbo0z/SNacMJCQl0dHRkTEyMwfOBgYH866+/dAGCAQwCcJ2lQAHm/BXKeJzkg0yF2NX0Man5oN7cgrZAp0+fLhbZjRs3hp2dHXr16oXhw4fDS8+B6P79++Hq6gpnZ2esX78e48aNK1TamzYJ34fNmgmTaTe33NeEhYXBx8cHFQ2Ymq5fvx6enp7o0KFDIUuVN8nJyVi3bh2GDBmS7XhRy1oSqFSifjdsEAYXn3xS+DTCwsLg7++PkSPFlNc//wh3WMnJhUvH29sbAwcOxJIlS6BWqxEREYHY2Fi0a9cOAHDmzBk0adJEd33t2rVhY2OD6Ojowme6nKO1Ev7f/4B33xWWwJKUfz+Rs36bNGmCO3fu4P79+8Wef0kSeZ84UeR9+HCxvp0X+/cDzz8vghKHhgrnEQW1J33Cw8Nx9+5d9OvXr0j5PnXqFKysrLBu3Tr4+Pigbt26+OWXX7Jdo/8MAEgAqkiSVPpixRSkMSGGuG6Z/7cHEA6gZ373FMcI8dy5c3RwcGBISAhVKhWnTZtGSZI4c+ZMi8vWkpKSwpUrV+b5hRUXF8epU6fywoULRqe5cSNpZUU++yz54IHha65fv05fX1+DX30k2blzZ06dOjVfOYUdIS5fvpw1atSgJo+5HFPKWlzol/XJEzGaA8hffzV8fUEjxEWLFrFy5cq66WKS/OMPUqEg27cntYM3Y+t48+bN9PLyolKppFKp5IIFC3TnOnfuzN9++y3b9b6+vgwJCSk44acItZocOVI813HjsqYcC+onatWqxR07dujSSUtLIwBeuXKlBEoh0GjIL74QZRk8mDS0CrR3L+ngQPr5kXFx2c/l1570eeuttzhkyJB882JMG16xYgUB8K233uKTJ0948uRJenh48J9//iEpplPbtGlDiGU3HwCHIexQKrEUjAr1f8YoxMYQc79RAE4DmFLQPUVSiBERYmEnIED8GxGR56Vr166lv78/3d3dOWbMGPr7+3P58uUWl5uTevXq5TlHHxERwWbNmhkld0O772ilVLNVq7yV4d27d1m/fn3OmDHD4PnY2FgqFApeunQpX5lBnmcY5HTU6LJ26dKFU6ZMyfeaAstaEuiVNemVIewc+ICSRC5cmPct+SnEjRs30svLi1FRUbnOrV5NKpVk69bkg3+PGFXH2g57586dVKvVPH/+POvUqcOtW7eSJHv16sVvvvkm2z1OTk6MjIw0rvzlFb33JuPVgXyr5x0C5IQJudff8usnGjduzDVr1uiujY+Pz3MporiZOVP00K++SqaFH9KVd1fQV7SzUbNBA/LWrez3FNSetCQnJ9PZ2Zl79+7NOwNG9hMbNmwgAF69elV37L333uO4ceNIkk+ePOHo0aMJIA3AZQCfZf5fwVKgBPV/FknUZIU4ZYr47JEkkTWFQvxdQEdMkomJiXR0dOS5c+eKVS5J1q5dmxs2bDB4Ljw8nC4uLgXKXY8+tEIaWykO8eGErwxenpCQwKZNm+a76D9jxgy2b98+78xmygxCCIMQYlRZr127RqVSmecagZZ8y1oS6JW1HcLYAfuoQAaXv7wu39vyUog7duygh4cHDx8+nOe969eT1op0tlAcZRuEF1jHa9euZdOmTbMdGzt2LEePHk1SrCEOGjRId+7SpUvyGqLee5MOJV/HcgLklA4hBRqj5OwnBg4cyIkTJ+rO79mzp8TWEA3x/feiS+qj/Jsq2HAbutEWKWwineTdj2blur6g9qTlzz//ZPXq1fOc8SlMPxETE0MAjI2N1R17//33dQpRC7LWEEcAiGApUIA5f6VHIUZEiAoHmAYr7kVHkT1AHDfwdRIZGcmMjAzevXuX/fv3z2Z8YIrccLTlTjyfr9yIiAiGh4dTpVLxyZMnnDVrFp2cnHjjxg2SoqFpG8bVq1fZoUMH9unTJ1+50zCZSqSxNQ7wIZwNyn348CFbtGiRq2HnpG7duly0aFGBZW2KY2yLsALrmCS/+uorg0rW6LKWBHplbYswuuABlUjnaryaZ1lVKhVTUlLYpk0bLliwgCkpKVRnWjbs2bOH7u7uDA0NLVDuFtu+tEEq7ZHM5jiUbx3HxMTQ0dGRe/bsoUajYUxMDGvXrs358+eTFFamzs7ODAsLY1JSEgcPHvx0W5nqPdcHcGJTHCNAzsBEk/qJHTt20Nvbm2fOnGFiYiI7depUIlameRIRwZ+sPyBA1sVZKqFiII7yPiqY1J60PP/88/z888/zlKmtY51CLKCfaN++PUeMGMHU1FSePXuWnp6eOsOluLg43rhxgxC7EFoBuA7gBZYCBZjzJ5Hm31LYvHlzRkZGFu6mgQOBNWsAEpVwA7dRCX64AB/cFuc9vYTPMj2OH2+H5OSTkCRreHr2R+3as6FUFtJB4dmzwL27eAI7HMWzIv84Ckc8MSj3wYNQxMSMQWrqZUiSNRwdG6FGjelwcxMGLFeuTMLt28uQkZEIK6sKqFixO2rW/BrW1hUNyr0BX8TgGQBEOxyAEmqDcm/fXoYLF4ZCoXCAWJMWtGhxFnZ21QAADx9GICrqObRufRtWVgb2IGbKTEAFnEJjOCAZyci8TqEQEUNXrcp1W7169fDJJ59g2LBh2Y5PmjQJy5YtQ2JiIipUqIDu3bvj66+/NmjoU+zotSdrpCEDVvDHGXggc7+VgfZ04kRHPHwYmu1YkyYhcHPriBMnOuHhw3AoFHa6c66u7dG48Y7scjPr+Doq4zLqQAEN1Fr/F3nU8V9//YVp06YhNjYWrq6uGDx4ML7++msoMv3GrVy5Ep9++inu37+P5557DkuWLIH70+qdIfO5plOJKriOu/DBC9iBXeieZ/22a9cOJ0+ehLW1Nfr374/Zs2fDUc+R6ezZs/HNN98gJSUF/fr1w7x582BbGtzZALryDuYfWInBUCADrXEIVsgQ5w2047t3/0Js7DSoVLFQKl3h7T0YNWt+DUkS7UmluoFDh6qjZcvzsLevk1tmZhsGgBNoCickIQ5Vxbk86vjGjRsYNmwY9u/fDy8vL0yYMAHvvPMOAGGA9sYbbyA2NlYDIAbANJIrzFZHZqT0KMTAQOC//wAAvojDPXghA9Z4Bhfgi1uAk7O4xtwci8STJDVOoinSINxYWCMdTXASjki2qNw7SY44j3oACGukow0iss5bQu6xSCQkWeM0GkGJDNTDeZxCloUdAgOBwj630opee3LEY6TBBm1xMOu8BZ/rgyQlTqMRCKA2LiEa9bLnq7zUcUkQGIj0/6IQjNXYgH7wxQ3cRGX8hpEYifnlr34DA7HyPz+8jj/ggCeoh7NwRErWeQv1E0gSvlhiUAeeuIfjCMiWJ1PqWJKkYyRLt2dVSww7TZoyDQ4W89SZw/T2CGV3bCVA/iS9R5oyHWoEZ7p9RB/cpCfusDmOsAUO0RdxrIh7PC41s5jcRS3nUYKanbGb7RCafVpCobCI3J1BM8X6A47zHipmybOgzBIjR3sqjvolyT2dptMBSayHs7yBSuW7jksAVf/B7IMNBMg5GMMU2LIHthAg50pjyl39Ln32V0pQsxP28DEci6c96b07uX5FkInMNcTS/Cs9CtHAvHUqbNgbGwmQ34+5Uvg0C+DkSdKzQhp9cItnUF8nNwa1WA1XWQH3eXRxbmvCoqLbzK34h09gZ/Q8fVHYsYO0tVGzqXSC8XDP3dAtILNEMWEdpKjs3Ena2ajZUDrN2/Aq/3VczKhU5Msd7gvlh/d19aqCNftgPQHyf+9dLelsmo0FC0hJ0vB5xW4mw7742pPeu2NOmbJCLCwGLJvS7F3Yv8EpAsIM2VwcO0a6u5OVK5MXRs/NJfeqnR9rut2niwt58KD55M6dK2q9Z08yZeK0Qlt8msL27aSNDdmsGRn/8ddChvYL0EIySwUmWNSaypYtoo6bNiXvfTzr6anjYkKlInv3FtX5Y9dtueo3zd6FA/yjhIGN4R1JZYqffxZF69Ejq58o1vakteQ1o0xZIZqCbu9LpG7vS3q62KAKiA2rhfHzZ4jDh0k3N7J6dVK3Xc+A3OvXyWeeIZ2cyIKMC43h229FGfr2FS94XnLNybZtWcrw/v0smQwOJgMDLSKzVGHh+iXJDRuyfM4+lXVsYVQqslcv8e78/HPmQQP1m55Ovv66uG7KlKL3EyWFdqvFyy9n7yeKvT2ZWaasEE3EkHeEjAxy6FCR488+M72x799POjuTtWqRevtI85R78yZZr574OCqKm9QZM0TeBwwQTqULkmsOtm4VyjAgQK+jfgqxVP2SOTbjP7CMjKeZ1FTypZfEu/PLLwVfn5FBvvUW89ykX9rRbsbv3z93P1HWkRWiieTVganV5IgRItcffVT4xr5vH+noSNatS16/brzc27fJhg1JOzuxTlQYNBrxtQqIr1dDbpgs0WFv2SJGLYGBZEKCedMua1hKIRpy1yZjPlJTxdJCfm72DKHvxu2DD8qGUjTGXVtZR1aIJpJfB2ZqmJR//yXt7ckGDcSor7By790T60M2NkLZGINGI75SAfHVmpFReLmmoB826mlXhqRlFOKiRcKxUefOZGY0LBkzkpoq1s8AYYRWWDQacswYcf/o0cZFjigpNBpy4kSR16FD8+4nyjqyQjSRgjow/TApI0YU3Ni3bydtbclGjUgDUZqMlpuQIMIxWVuLdaP80GiEk2GAHDUq/zyas8MuKGzU04i5FWJ+IZ9kik5KCtm9u6jjefNMTydnKKjSqBQL25eVZWSFaCLGdGDGflVt2pS1jlaQv15j5D54INaLlEqxfmQItZp8912Rt7FjCx7FmqvD/vtvoQxbtpSVoT7mVIjZrIRTzJOmTBYpKWS3bqKOc3gbMwn9YMFDhpSu0ZdGI2a5ADHrVRamdouCrBBNxNgOTH/efdCg3PPua9eKUErGKghj5T56RHboINaPcgbXUKvF1yggvk6NaeTm6LCNCRv1tGIuhai1Eu7TR8/6T8ZspKSQXbuKOs4jYpHJTJsm0h04sHSszxXVHqIsIitEEylsB2bIMmvFCjGKa9OGfPjQ/HKTksT6kSSJ9SRSfH0OGSLyMnmy8Y28qB32hg1CGeYXNuppxhwKcfp05mklLFN0UlLEFHRBobmKwqxZ4hn261eyHzT6FvMTJz4dypCUFaLJmNKBaffu9O5N/v67GL0FBZGPH1tO7pMnWV+0P/8svj4B8TVaGIrSYa9bl6UMjVX8TxtFqV+Nhvz8c+ZrJSxTNJ48IV94IfvHpaWYPVs8y169hOFOcZOeLmazAPLLL58eZUjKCtFkTO3AfvqJOg9DnTuTycmWl6tvDQeQOWK5WkwuKZShdg+crAzzxtT6NdZKWMZ0njwhn39eKMPFi4tH5i+/iGfarVvxGkWlpYlZLHN73SorlAWFqCgRj+IWQpIKvsbScosrD2vXAgMGAM8+C+zaBbi4FI/cpwUS/2/vvMOjKrow/t5N75SQhKYhoRqk9wAJHamCIEFEEJAi1U8FFcQCIqJYEFR6kSpVREABQxFC7zWEDgIBkgApbLK77/fHZDe7yW6yu9lNvb/nyQN725mZOzPnzsyZc/C//wFffQWMGAHMnw84OOR3qooWyclAt27Azp3AokXAm2/mjdy33xbvc/t2IT852f4ylUoRNWntWmDmTODDD+0vU8ZyioxC/O47YNQoUcHnzQMiI4HOnXVRTOxCSgrQowewZQswaxYQEQGMHw9MnWo/mQDw228iTFqTJqJRexkJfShjPRqNqEvffw+MHQvMmSPCwMnYDq0y3LULWLwYGDgwb+UPGQIsWQL88w/QqZN9+4lnz4CePYFNm4AffxQfWjIFFHsMO/N6yvTLL5llsXz5crGOGBpqH6OapCSybVsx1TN/vjimUmX4Uvz4Y/sY1WhdhTVvLntHMRdLytcaK2EZy0hKyjBIW7o0f9OycmWG8Z09DNKSkjKmhG2xjaQwg0IwZVroFeJnn9GkOfVvv2VsRbDltounT8V1CkXWBq1SkYMH0yJfiubKXbVKNN4WLSwzFirumFu+KhX5xhu02EpYxnwSE8lWrUTb+fXX/E6NQGuY1qiRbT07PX1KhocLZbh4se2eW1iRFaKVmLsxf+JE5rjhVrtZvX79nB1cmyP38WPxNengIBSUMdRq4Z0GEN5qbLExf+VK0Ym0bCkrQ0sxp3zT0qy3EpYxj8REoSAUCjGDU5DQOvCoWzdnBx7m8PixmMUpiHnNL2SFaCXmuG577z2R+rfeytnd0Z9/CtdttWqRsbHWy42LE1+Rjo7iqzI7NBrhpQYQXmty47ptxQrrtpHICHIqX6VSTLdbayUskzP6ynDFivxOjXG2bTPPxWNOxMeLWSlHRzFLJSMoDAqx0JkKkMC4ccA330QjMLA7Nm4sA1/fUujQoQMuXbpkcO3Vq1fRpUsX9OnjBRcXX5w7Nx7h4cC9e5bLffQIaNMGOHkS2LABeOUVYNmyZZAkCQsWLNBdp1QqMXz4cAQE+GPZslIIDu6Kn366g2HDhLGGpaxYAfTvD7RsCWzerMb06ZNQrlw5eHl5oW7dukhISEgvF2LSpEkoX748fHx8EB4ejnPnzlkusJihVAK9egHr1wNNmgzFwoXVoFAosGTJEoPrlixZAgcHB3h6eur+du/enS9pLmwkJgrDlb17gaVL1Th/3ngdBoDvvvsOAQEB8Pb2xqBBg6BUKvMsnR07CgO5mBggPBy4e9fyZ8TFAW3bAsePA5Mn/4Mvv6wHb29vBAUFYd68ebrr7t69i27duqFcuXKQJAnXr1+3WT5kcoE9tKw9wz8NG8b0NcNDnD9/AR89esTU1FROmjSJ1apV012rVCoZFBTEmTNnMjExkSkpKZw//xTd3UX4p9u3zZd7/774anRxEV+RJBkXF8dq1aoxJCSE87VWNSS/+uor1qpVi/fu3WNKSgr79+/PatV6EBDrU8amdk3J1YYXatVKfGFPnDiRrVq14vXr16nRaHjmzBmmpDvUXLNmDcuWLcsrV65QpVLxgw8+YN26dU2UcPHCVPnqO1aYM4ecPXs2d+7cyfr163NxpkWfxYsXMzQ0NC+SW6R4+lSseSsUYokhuzq8fft2+vn58ezZs4yLi2NYWBgnTJiQ52nWhomrUsV4mDhTxMaKWSgXF/L331Pp7e3NX375hRqNhocPH6aHhwdPnjxJkrx37x7nzJnDAwcOEACvXbtmn8wUIFAIRoiFRiGqVOSbb4oUf/BB1nW5R48eEQAfpi8AzJ07l82bN8/y7H37RIDg4GDyxo2c5f73H1mjhggdpR8geNiwYZwzZw7DwsIMFOLw4cP5/vvv635v2bKFVatW1flSjIjIavxjTO6yZRnhhZKShAL28PBgTExMljyR5PTp09m7d2/d77Nnz9LFxcXotcUNY+WblES2aWNoJawlNDRUVog2QKsMtY7wc6rDffv25Ycffqj7vXPnTvr7++dVcg3ILpC4Me7eFaHlXF3Jv/8WCg8Ak/S8gzRo0IArV640uC8tLU1WiAXor1BMmapUYp/S4sXAJ58A06Zl3QC/d+9eBAQEoHTp0gCAgwcPIjAwEC+99BJ8fX0RHh6OM2fOoHlzYMcO4OFDICwMuHbNtNzbt8U1N28C27aJKVMAOHz4MI4ePYrhw4dnuWfw4MHYv38//vvvPyQnJ2PFihV46aWX8PHHYpP36tViv2Jqqmm5S5cCAwYArVsDf/wBuLsDZ86cgaOjI9atW4eAgABUrVoVc+bM0d0TERGBK1euIDo6GmlpaVi6dCk6duxobhEXK7RTeJGRYi/akCHm3XfixAn4+vqiatWqmDJlClQqlV3TWZh5+hR46SXgwAFg5UrhRCKnOnzu3DnUrl1b97t27dq4f/8+Hj16lOfpDw0VDgPi4sRyxdWrpq+9c0dMsV6/DmzdCrRrB/j7+6Nv375YvHgx1Go1oqKicOPGDTRv3jyvsiBjDfbQsrkaIUZFMazMOYZ5HiEjIpi67yBffVWMrr74wvgtt27dYrly5Qy+vtq1a0dHR0du3bqVSqWSM2bMYKVKlahM36h49ChZqhRZoQIZHZ1V7vUNxxgURHp7k/v3Z8hSqVSsX78+o6KiSDLLCDEhIYF9+vQhADo4OLBOnTp8pGfe+t13Ii9du6b7Uswkd/GkGEqS2OOo73puxYoVBMBBgwYxOTmZp06doq+vL//++2+SYop4zJgxOrmBgYG8evWq9e+hqJCpfBN2HM7RStjYCPHKlSu8evUq1Wo1T58+zRo1anBacfS/ZYyoKDH1Ua8eGRHBJzsPMTRUlLG+UUlOdTgoKIjbtGsSJFNTU/N99HTsmOgnypcnL11ilrze2HiMwcFiNLlvn+G9mzdvpp+fHx0cHOjg4MB5RkJ4yCPEgvVXsBTi5MmkuzvDEMkwRFIpubCHwyYC5NdfG78lNjaWNWrU4NSpUw2Od+vWjeHh4brfGo2G3t7eujl8kjx5kvT1Jct6PuZ517o6uVekYD4n3WAJ12QeOmQob9asWXzzzTd1vzMrxH79+vHll1/mo0eP+OzZM37++eds1KiRwTN++kmUfMfgaCa7ldLJXSQNogQ12wVdzuJjccOGDQTA63rzN6NGjeK4ceNIirWZpk2b8tatW0xLS+PixYsZGBhoMGVT7MhUn+KkUmyoOEJHhSpbK2FjCjEzq1atYr169Wyb3sJIehlTkkiAjyUfNlMcoIOk4tq1hpfmVIdr1arFNWvW6M49fPjQYBkkvzh1iixThgzwfMJzrvV0eb0qBTFQukYfl2QePGh4z4ULF+ju7s7t27dTrVbz4sWLrFy5Mrds2WJwnawQC9ZfwZkyPXgQ+OYbnWNBDRToyXXYqO6OH5zew3vND2a5JT4+Hu3bt0e3bt0wceJEg3O1atWClINj0dq1gd0/nIImMQXhz7YhCR5IgRtacjcS6YFdaItGGkO5u3btwsaNGxEQEICAgAAcOHAA7777LkaNGgUAOHnyJAYOHIhSpUrBxcUFo0ePxuHDh/Hw4UPdM0aMABZ8eAV/XQlG15Q1UEOBuwjAYM5HO+zA73cbw+2UodxatWoBgEGe9P9/8uRJ9OnTBxUqVICjoyMGDhyI+Ph4nD9/PtsyKLJkqk9pcEIb7sApzYtY7xiBV8pnrU+WIEmS+KIszuiXMYkn8EJHbsVhTQOsceqPXhUsq8MhISE4deqU7vepU6fg7++vWwbJL2rVEv0EEpMQ/mwbTrMmLqMyWnI3HtMbu6S2aEzDvJ49exZVq1ZFhw4doFAoUK1aNXTu3Bnbtm3Lp1zImIU9tKxVI8SICN2XlweeUIKaAFkFF8UXfplzOuOIsDAyNPQxvbwasly5kQbHtX8NG16kQuHGWrV2sGVLFYODv6WraxBbtFAaXlvmHBviEJ3xjICGgIZOULIBDpuQG8+mTe/q/ry9mzIoaCZDQxMYFkb6+w+kr29PhoYmsEWLVAYGfkFn53JZ01jmHKvjfLpMkdcO2MZkuAqTvIiILEXUokULDh06lM+ePeP58+dZpkwZ7ky39Pn0008ZGhrKe/fuUa1Wc9myZXR3d2e8OS56iiJ69SkAd+gIJV2Qwm3oYLJ8lUolU1JS2KxZM86bN48pKSlUp28g3bp1K+/du0dSfP2HhITw008/zdMsFTj0yvh1LKUHntARqVyPHlbV4W3bttHf35/nzp1jfHw8W7VqlS9WpkaJiOAlVGV53KIHntITj+mLWJ5ELaN5jYmJoYeHB3ft2kWNRsOYmBgGBwdzrp7/tpSUFCYmJhIAL168qLO2LaqgEIwQHfNbIeuIjhabDAGkwRmEhGq4iACkbxpMSTG4/OHDjXj69AiSks7h3r0luuMNG56Hq+tzcHevhurVlyM6ejjS0mLh6VkPNWtuhkLhbCg3JRnuSEZlXMJ5vAgAqIzL8ECSUbmOjiUMfkuSMxwdveHo6AMACA7+BjExY3D4cBVoNKnw8KiJkJCNWfObkgx/JCIFrriBQADEr3gdbngGaABcvpzlllWrVmHw4MEoXbo0/Pz8MGXKFLRJt/SZMGECYmNjUadOHSQlJaFy5cpYv349SpQokeU5xQK9+vQYPlDDEdvRDm3wj8nybd++Pfbs2QMAOHDgAIYOHYrIyEiEh4dj165dGDhwIBITE+Hv74/XX38dH330UV7mqOCRXsbxKIGV6AcNFHgTi9ATG62qwx07dsT48ePRqlUrpKSk4JVXXsFnn32Wx5kyQXQ0qiIac/EWumArAOAnDEdtnDaa1+DgYCxatAhjxozBjRs34OPjg379+mGIngWXm5ub7v/Vq1cHAHnWIb+xh5a1eoSoUJAAW2A3a+EEdUEGFQrhV8seRETwuFSPpfGAJfGAvoilNxIYhcZ2l6vNrz/+I6BhM/zLx/Cyr9zigl75hmIf6+JY3tSn4kREBB9KvqyLYwTUdEUSJai5CAOLXhlHRPCEVDe9n3jI0rhPLzzmfjQtenm1EygEI8SCs4Y4dizg6goAUIAoiYSMc66uwJgxdhF7uO1HaM2d8EASjqAxjqMe/BCLdtiBfU6t7SZXP7/VcQkv4BwOoxE6YjueuJSxn9zigl75OkIFbzzJOGfH+lSciO3/LlohEufxAl7EWTTEUbTFTgzGQixyHFqkyvhoe9FPuCMZh9EYJ1EPZXEX7fE39ji1LVJ5Lc4UHIXYpAnw3nti050WhUL8fu89cd7GHDgAtH3nRZQsQex17YBgxXVUxG3skVqhgnQHHTV/4p9k28sFkCW/ZfAQa6S+OIKG6Fj6MJ68YCe5xYV8qE/Fibt3gfD3GiDGoSq2uPRCKcRBAQ1+l3qgvWIXhqTOwaLzRaOMo6KANuNehE8JCXtdO6Cy4hoq4A52S63xnHQLL6n/wK6kopHXYo89hp222Yd4VEx7pe/3szV79mRyz6TdX1S/PhkRwXt/HmXNmsLzxF9/2SUJgkz53fDlRTo6kk2a2Cc+W7Ejj+pTceLWLdFuPDyEm7PMZZyy+yA7dBCz05m9ABU29u4lPT3JypXJmzeZpZ+4/+cRvvii6Cf0tlDKGAGFYMq04ClEWh4g2FJ27hSu2GrUEK7ZTPHgAVmnjggLk2n7kE3JnN+NGzPiOMpKMffYuz4VJ65fF+7MvLyEezMtmcs4JSXDT6yR/eiFgl27xBbL6tXJO3dMX/fwoQgb5exMbt6cd+krbBQGhVhwpkzziO3bgS5dgMqVgd27gbJlTV/r6wvs2iX2IfXoAWw0YixqD15+GVi3TnjMb98e0AsGICOTb1y9KtyYxcUJt2ahoaavdXUV7aVTJ2DoUEAv0EOh4K+/gM6dgaAg0U+UK2f62tKlRT9Rpw7Qs6eInCJTOClWCvGPP4Du3YEaNYQfSz+/nO8pVUo0/vr1gd69gd9+s386AZHOdeuAEydkpSiT/0RHC2WYmCg6/0aNcr7H1VWESuvUCRg2DJg71/7ptAVbtgDdugHVq4t+wt8/53tKlgT+/luUS58+wmexTOGj2CjE9evF11vt2qJBW+L8wsdHVPZmzYC+fYHly+2XTn26dRPpPnlSOAyOj88buTIy+ly4IJzcp6YKBVGvnvn3urgIpdi5MzB8OPDLL/ZLpy3YuFH0E7VqiX7C19f8e318xAxUaCjQrx+wbJn90iljH4qFQly9Wny1NWokIl2ULGn5M7y8RMSL8HDgjTdE5I28oGtX0aGcPi0rRZm858wZoQwBMXWY7n3NIlxcxIddly7CbeFPP9k0iTbjt9/ELFD9+mJWqFQpy5/h5SUiXrRqJSL0LFxo82TK2JEirxCXLRNfa6Gh4uvNx8f6Z3l4iOmUdu2AQYPybgqoSxehFM+cEdG44+LyRq5M8ebECdGxOzsDe/YAL7xg/bNcXMQSQNeuwMiRgF7UpwLB8uVi9qdZMzEblNt+4o8/gA4dRGixgvoBIJOVIq0QFy4UX2mtWomvNi+v3D/TzQ34/feMKaAff8z9M82hc2cxnXP2rKwUZezP4cMiHqeHh1CGVavm/plapditGzBqVMFRiosWiVmf8HAxC2SrfmLTJpHXkSOB77/P/TNl7E+RVYg//SS+zjp0EF9rHh62e7bWWKBHD+Gg4ptvbPfs7OjUSTSy8+dlpShjPw4cEPWrZElg714gONh2z3Z2BtauFUZjo0bl3QelKX75BRg8WMz6bNli237CxUXk9ZVXgHfeAWbMsN2zZexDkVSI338vvsq6dhUKRM+Hrs1wdgbWrBFrk++/D0ybZnsZxnjppQyl2KYNkA/BxGWKMHv3CqvmgADx/+eft70MZ2exXvfyy+KDctYs28swh1mzxJpm585i1sde/cTq1UBEBDBhAjBliu1lyNiOghPtwkbMmCEq3iuvACtXigppL5ycxNqDkxMwcaKwwvvkEyCHMIy5pmNH0YC7dxdKcedOy6zhZGSMsWuX+IgMDBT/z26Pbm7RKsU+fYTbWVL8m1d88434kO3RQygse/YTjo6in3B2BiZPFv3E55/bv5+QsZwipRCnTBEVLiIC+PVXURHtjaMjsGSJUIqffQYolWK0aO/K3qEDsHlzhlK01ERcRkaf7duFcqhSRXxgmbNHN7c4OYlZlogIYNw4QKMRU4v25osvgEmThDL+9VeRDnvj4CAs052dgalThVKcPl1WigWNIqEQSaEIp04F+vcXFc/BIe/kOzgACxaINYPp04VSnDnT/pW9fXuhFLt1k5WijPX88QfQqxcQEiK2JeVlgHonJzFC69sX+N//RFv+3//sI4sEPv1UjM5ef130E3nx0axFoRCW6c7OYiZLqQS++05WigWJQq8QSeCDD0QFGzxYVLi8VIZaFAphyOPsLCp5aqpYo1DYeZW2XTvRoXXtKqwCd+0CypSxr0yZosP69WKEVreucFdmzR7d3OLkBKxaBbz2GvDuu6JNv/uubWWQwEcfiQ/WN98E5s/Pv35i9mzRT3z/vegnZs+2fz8hYx6FWiGSYorlhx/E4nh+VyxJEpXc2VmsUaSmCis2e6epbVthIaevFPNiykumcLN6tRgpNW4stiXlZu9dbnFyEmv+kiSic5HiX1ugVbDffSe2Ss2Zk//9xLffihmlr74S/UR+fcjLGFJoFaJGI8y2f/5ZrD98+23BmHqQJDFadXERaxWpqWI/pL0re5s2Qil26SKU4j//yEpRxjTLlomRUvPmot7YYu9dbtFXiu+/LxTZ++/n7pkajbBknTNH/Pv99wWnn/jyS9FPfP656CfyeqlHJiuFUiGq1cJZ8MKFwPjxBW9xWpLEeqaLi1jbTEsDli61/3pF69YZSrFVK6EUzXFMLFO8WLgQeOstUV9+/922e+9yi6MjsGKFGMGNHy8U2oQJ1j1LoxH9xIIFYrQ5Y0bB6yc++0x8CHz8segnli3LGyMfGePkOHEgSVJFSZIiJUk6L0nSOUmS8tA4OisqlfiyXbgQqFt3KDZtqgYHBwWWLFlicN3Zs2fRoUMH+Pr6QsqnVvDxx0JZr1wpjAbS0qx/1sOHDxEaGorSpUujRIkSaNq0Kfbv329wzXfffYfXXguAJHnj0qVBCA9X4v793OXhn3/+Qb169eDt7Y2goCDMyxTH58GDB3jttdfg4+ODkiVLol+/frkTWABYtmwZJEnCggULdMdIYsKECShdujRKly6NCRMmiICihQxjDiuM5RcAjh8/jpYtW8LT0xP+/v744Ycfci3/jz/+QM2aNeHp6YlmzZrh/PnzunPDhw+Hp6cnSpTwxB9/eEKhcMEHH3hh+nTL5ajVwr2iyJKEn37ygJeXJzw9PTFkyBCDa+2RT0uYNEkoa+1+xdTU3D1PkiR4eHjA09N4fmWyIaeAiQDKAqiX/n8vANEAXsjuHnsFCE5NFcGqAXLKFHL27NncuXMn69evz8WLFxtce/HiRS5YsICbNm2iyGb+8e23Is3du5PPnmU9b04A25SUFF68eJFqtZoajYYbN25kyZIlmZaWRpLcvn07/fz8ePbsWcbFxbF27TA6Ok5gjRrk3bvWpTs1NZXe3t785ZdfqNFoePjwYXp4ePDkyZO6a5o3b8533nmHCQkJTE1N5fHjx60TZkcsCRAcFxfHatWqMSQkhPP1wr3/8ssvrFq1Km/dusXbt2+zRo0a/Pnnn+2SXnvx3XeiHnbtmlEPTeX3wYMHLFOmDJcvX85nz57xyZMnPH/+vMlnm1PG0dHR9PLy4r59+5iWlsZp06YxODhYV4cz07//AAYFvUmAnDbN/HympZF9+4q8fv45CYCXL182eq2l+bQn33+f9f1YQ3b5zU9QCAIEW34D8DuAdtldYw+FqFSSPXuKFM+YYXguNDQ0i0LUcvny5XxXiCQ5e7ZIe6dOIpq4PpZGdFer1dy8eTMB8P79+yTJvn378sMPP9Rds3PnTpYs6a+L+G2NUrx37x4BMCkpSXesQYMGXLlyJUnyr7/+4vPPP0+VSmX5w/MQS8p32LBhnDNnDsPCwgwURNOmTTl37lzd7wULFrBx48a2Tagd+eorUf9eeUW0JS2m8vvhhx/y9ddfN/v55pTxjz/+yE6dOul+q9Vqurq6cufOnVmuTUxMpKenJ3ft2s3XXhNp/+KLnNORmkr26iWunz5dHMtOQViaT3vz888i7R07ksnJ1j1DVojW/1lkayVJUiCAugAOGTk3VJKko5IkHX3w4IEVY1XTKJVin9SGDWJRPLcL7fnByJEiavi2bcIaNDnZuufUqlULrq6u6NatG4YMGQK/dMuZc+fOoXbt2rrrateujfj4+1i9+hFu3RJrinfvWibL398fffv2xeLFi6FWqxEVFYUbN26gefPmAICDBw+iWrVqGDBgAEqXLo2GDRtiz5491mWsAHD48GEcPXoUw4cPz3LOWPmeO3cuL5NnNVOmiHW4iAhDryzZ5ffgwYMoVaoUmjVrBj8/P3Tt2hU3b97MdVpEv5jxf5I4e/ZsluvWr1+PMmXKoFWrlli2TFjDTpwo1uZNoe0n1q0TRnb6a48tW7ZEQEAAevbsievXr9s9n9YyfLhYDvrrL9FPJCVZ9xxT+ZXJAXM1JwBPAMcA9Mzp2lyNEKOiGFbmHMM8j5AREUyOPMgOHcRX008/Gb+lMIwQtSxZQkoSGR5OPn3KLPllVFSOz0hJSeHKlSu5ZMkS3bGgoCBu27ZN9zs1NZUAeO3aNe7dS3p4kNWqkf/9J2QyIoKsVy9HmZs3b6afnx8dHBzo4ODAefPm6c699dZbBMAFCxYwNTWVq1atoo+PDx88eGBV2dgFM8tXpVKxfv36jEo/n3nEpFAoeOHCBd3v6OhoAqBGo7Fv+i1F791q+kRw0sBbBMj+/Un9gXxO+a1SpQp9fHx4+PBhpqSkcPTo0WzWrJlJmeaU8YULF+ju7s7IyEgqlUp+/vnnlCSJ04zMh7Zu3ZqffPKJXnpFHrTToJnrcHLkQb70kjg/e7bhs/bs2UOlUsn4+HiOHDmSISEhumlai/KZh/z6K6lQkC1bkk+e0KI2m11+8xMUghGiucrQCcBfAP5nzvVWK8TJk0l3d4YhkmGIZKLkydaKSEpQc8EC07cVJoVIkitWkA4OZGjF63zs5q/LLxUK0t1dlIMZVK9eXbeeV6tWLa5Zs0Z37uHDhwTAhw8fkiT37SM9PcmqpR/wjmuQ0MpAtjK1Hdj27dupVqt58eJFVq5cmVu2bCFJjhkzhoGBgQb31KxZk5s2bbKmWGxPpvqUXV5nzZrFN998U/c7s4Lw9vbmoUOHdL+PHj1KT09PuybfYtLzS0miBuB4fEWAHFz3KDPPaueU31q1anHgwIG639r6lJCQYFSmuXV47dq1DAkJYalSpThmzBiGhIRw2bJlBtfcuHGDCoWCV65cMTiuUpFvvCGq7WdOn+vqcJLkwbaKXZSgpt73mlFUKhXd3d15+vRpy/KZD6xeLfqJphVuMMEtwKw2m5nM+c1PioRCBCABWAbge3MfapVCjIoSLxlgGCIZir1sid1UQMVlzoOz/SIqbAqRJNd+cYmOSGVjRDEU+0RnIrZeiXIwY6QYHBzMDRs2kBRriB999JHu3K5du+jv729w/b+/nKEnnrAKLvE2ymXIMyFz7dq1rFOnjsGxsWPHcuTIkSTFOlqlSpUMzr/44osFQyFmqk85lW/37t1ZokQJ+vv709/fn05OTvT29tbltWnTpgaj44ULFxasNUS9/GoAjsV3BMgRmEO1m4fF+X399dcNFOajR4+yKgoLyzgz8fHx9PDwMBh5k+TUqVPZokULo/eo/o3iAIdfCZCfYjKfwoPh+IcKqLjE+a0cZapUKnp4ePDUqVPm5zMfWf/lRTpByYY4xDiUyLHNZiZzfvOToqIQmwMggNMATqb/dcruHqsUYkSE7guoMfbTFUl0QBpX41XxRRQRkeUWpVLJlJQUNmvWjPPmzWNKSgrVajVJUqPRMCUlhefOnSMApqSk8FluTLdsTUQEN6E7naCkA9Lohce6TiUMkWIKKizDWKFu3SjWqbOPLVoo2bx5MitVmk4HB082aXKHYWHkiy9uo5OTPxs0OMfQ0HiWKNGKFStOMHhGWJlzrINjdEAanfGMEVie0biMlHFMTAw9PDy4a9cuajQaxsTEMDg4WGdc8ujRI5YoUYJLliyhSqXi2rVrWbJkyYIxZapXn3xxn554km1e4+PjeffuXd1f06ZNOXPmTF3H+PPPP7N69eq8ffs279y5wxdeeKFgWZmm51cJB/ogjgBZHjdN1qfQ0Hg2bXpX9+ft3ZRBQTMZGprAsDCyVq1ddHQswfr1T7BFi1SWLz+O3t7Ns9Qn7fMlpFGCKts6HBZG1qt3lC1bqti0aSzLlOlNP7++Wa5xc6vKqlUXZjmuldkSu+mP/wiQDkijA9K4EhFG3+vZs2d54sQJqlQqPn36lGPHjmXVqlWZmppKUnw4lihRgidOnGBqairHjRvH5s2b2/ttmU9EBP9AFzrjGeviGB+gdLb1OKf85ieFQSHmaFRD8l+SEslaJOuk/23N5dJlVqKjxWsGcBfl8Azu6IGNeBW/iR22ly9nuaV9+/Zwc3PDgQMHMHToULi5uWHv3r0AgBs3bsDNzQ0hISEAADc3N1SrVs3mybaa6Gh0x+94DSuhhiOUcDE8n5Ji8FOjUeLy5ZE4cKA0Dh4sj7i4rahZ80+4uJQDAJQq1REVK47HqVOtcPDgc3BxeR6BgZ9lemYyfPAEL+AcUuGMDeiFm6ioFZCljIODg7Fo0SKMGTMG3t7eCAsLwyuvvKLb11SqVCls3rwZ33zzDXx8fDB9+nT8/vvv8C0IHsbT69NVVMIj+CIRnvgJI8Q5I3ktUaIEAgICdH/Ozs7w9vaGT7o/s2HDhqFr16548cUXUbNmTXTu3BnDhg3L61yZJjoaakoIw148Rkk4IhVBuJZxPlN9cnQsAWfnAN2fJDnD0dEbjo4ivyVLtkalStNw5kxnREX5ISUlBjVqrDSUmZJhGUYoQDjgNiqYlAkAMTFjsX9/CRw5Ug2OjiVRtep8g/OPH0dBqbyNMmV6G89nSjIkEJVxBQChhgPexwz0xWqj7/X+/fvo06ePbh/t9evXsWXLFjil735v3bo1pk2bhs6dO8PPzw8xMTFYuXKlEcH5RHQ0umALNqMbLqAGZkLPyasV+ZXJAXtoWatHiAoFCTAVDuyODQTI9/EVNZJCbCwqQmj6RPBT6RNhYo0/mQwXwy8/e+RXr4x/RT96I56BuMqrCLSfzPwiIoLRUlVWwE06IJVeSCBAzsVbRS+vJNNefY39sYwA2Rx7CKjZGjuZCPc8qU8tsJu+iCVAfotxdpWZIJVgY0QRULM8btq/3eQnemV8HHWYCsdCm18UghFiwVGIeusRBKiGxBGYQ4Ac6zibmgM5r6kVFjQa8qMBtwmQA7GIKigyKrkFa4gWk6mMj6IeS+IRK+AmL7vWtI/MfOL8qhMsK/1HX8SyPg6zBfawE7YQIH90eqdI5TU1lYxo90A4rMBEEuAyvE4FVGyBPXzi5mf3+hSGSLbAbvbCbwTImU4T7CIz/u/DbKQ4TCcoGYLTVq29Fyoytdk86SfshKwQLUVrJZf+RaSRFBzn+KMwDhhBpi8PFmo0GvLdd0XJD613RBg8pOfXUitTq8hUxielOvRFLMt6PmYm24ZCy5kzpJ8f6e/xhGdd6+vWtJ5JruzusFl02DPzO5W2wcBhRdu/DN7taimCDkgTVooJdkpAJivTVMmZvR3WESC/+ca2ouLjyYYNSSdFGn937mW1dXahI1ObLaz5lRWiNWj329SvT0ZEUHMgihMmiJQOHsws5uOFCY2GHD1a5GXUKPE7c37z5Isvk8yzK07S318okTNn7C/enhw/TpYuTZYrR168SL09ckfJiAim7jvI3r3FO7DEHVhB5Nkz4eYLEG6/SGZ5t+u/vEgnJ6FI4uLslJBsyjizVylriYsjGzQgnZzIzZuzyixMIyWryI9+wsbICtFGaDTiY0i7wbgA7DG1GLWaHDpU5OHdd9OVYQHi4kWhREqXJk+cyO/UWMfhw2SJEuRzz5ExMRnHM7sVS0sj+/UT7+LTTwveuzCH5GTqHFbkZOz6xx+kszNZpw5pLwNgY2Xcp49I31df5e7ZcXFCDzg7i7yYkilTsJEVoo2ZMkWkuE8fsW5SWFCpyIEDRdo//LDgdsCXL5MVK5IlS5JHjuR3aixj/37S25usVIm8ds3wnLGOs7C8E2MkJpKtW4tdJQsXmnfP9u2kqytZsyZ5757t02SsjNPSMpzxa/2KWoq+Mkz3B5GtTJmCi6wQ7cCMGSLVPXsaOikuqBS20ci1a2RgoFAuBw7kd2rMY88e4YWnShXy5s2s5011nAV91G6MJ0/IFi3EMlImBy85snMn6eYmnL3/959t02WqjPUjT3z5pWXPfPRIeCpzdib//NN8mTIFE1kh2glbhUmxN6mpLJTrVTdvkpUrCyWzd29+pyZ7du6kLqKHqU4+u45ToxHruYBY3y3ISjEhgWzaVLjzWr3aumfofzzcumW7tGVXxmlptChiBSmUYd26pIsLuXWr5TJlCh6yQrQj2jApHTpYHybFnjx7Rr78MgutReOdO0LJuLuTu3bld2qMY+40YE4dp4Hl79CCac0cF5duYelErl+fu2cdOGB6etlacipjlSpjpmTq1Oyf9fChWO90cSH1/NVbLFOmYCErRDuzcKFYR2ndWqyrFBRSUsjOnUXp/vhjfqfGeu7dE8rG1VUon4LE5s3mG4qY03FqNORHH4l3NnBgwbJmfvBA5DOzUUluMGWAZC3mlLFKRb7+uijjKVOMX/PgAVm7tlCGOdU5WSEWLmSFmAdow6S0aJEeJiWfSUoi27cXJasXT7bQYo/OOLesX086Opq/lcDcjlOjEeu8gJjiKwjWzPb8KMmyRSUXmFvG+mGcPvvM8NyDB2StWiKvf/1lO5kyBQNZIeYRujApTWm/DchmkJhItmolRq2LFuVfOmzNo0cZe8DSg2vkG6tWWf6uLe04p00TLaN37/y1ZtZOW7u5ibVSe3D6dLoTA3/y7Fnrn2NJGatU5IAB1BmakYbK8O+/bS9TJv+RFWIesn696LAbNLDjBuRsePyYbN5cjFaXL897+fYmIYFs0iR3Bh25ZdmyTEFTzcSajnPmTNE6unfPH8MtfcOmPXvsK+v8ebJsWdLXl0wPr2kxlpax/raX994jX3xRKMMdO+wnUyZ/kRViHpMXG5CNER9PNm4spvF++y3v5OY1+ib/v/6at7Jzs15sbcf544+ihXTqJNaF84pr14TBS15ufYmOJitUIEuVIo8ds/x+a8pYpcrYp+jgYP7IMDcyZfKPwqAQcwz/VJjo0gXYvBm4eBFo1Qq4f9/+MuPigLZtgePHgXXrgN4motYUBby8gG3bgPBw4I03gEWL8kbuzz8DgwcDHToAW7YAHh55I3fUKGDuXJHnbt2A5OSc78ktV64AYWFAfDywcyfQtKn9ZQJAlSrA3r3iHbduDRw6ZH+Zjx4Bp08DDg6AWg3s26eLACcjky8UKYUIiE7zzz+Bq1dFx/3ff/aT9eCB6DzOngU2bQK6d7efrIKCh4dQSu3aCSX1yy/2lffDD8DbbwNdu4oydnOzr7zMDB0qFP/OnUDnzkBiov1kXboEtGwJJCUB//wDNGxoP1nGqFRJKMXSpcX7/fdf+8mKjRVt59o1YPt2UZemTAEmT5aVokw+Yo9hZ35Nmeqj3YBcubJx7yW55e5dMiTEfIu4oob+1pIffrCPjK++ok28Etliam35cjFVHBoq1ottzdmz1DlYP33a9s+3hNu3yapVSQ8PMjLSvHssKeN798gXXhDGQv/8I46p1eSQIeJ9T5xonoMEecq0cIFCMGVaZBUiaZ8NyKToMKpVE5vWtQ26OKJUkj16iFr09de2fbbWb21ERO4tPW3Vcf72m1gnbtxYrBvbipMnhUFL2bLCwKUgcPduhtIyZ23P3DK+e5esUUO0nczKVq0m33qLZvuXlRVi4UJWiAUAW29AvnGDDA4mvbzIffty/7zCTmpqRlSDnDyQmINGQ378MXWRTWyxQd6WHeemTcKauX59sR0ltxw7JgxZKlQQhi0FidhYsRXCxcW4L1F9zCnju3czvB/t3m38GrWaHDZMvP8PPsheKcoKsXAhK8QCwokTttmAfPWqcHzt40MePGir1BV+0tIyNltPnmy9P1CNhhw/njaPfWnrjvPPP4WSqFVLKA1rOXhQ1KXnnxd1qyDy8KFwsO3kJD4GTJFTGf/3n1CGHh45byNRq8nhw0U9mDDBdH2SFWLhQlaIBQhdFHUrNyDrh0Y6dEjFiRMnsmzZsvT09GSdOnUYnz6HNmzYMHp4eOj+nJ2d6enpadvMFEBUKnLQoJw7MVNoNOTYseL+ESNEp7h06VIC4Pz583XX/fPPPwwPD6e3tzeff/55s55tTsf54MEDNmvWjKVKlaKPjw+bNGnCf//9V3f+zJkzbN++PUuXLk0A/PtvsX78wgti5GMp+/aJWYagIHLlyl2sW7cuvby8WKlSJc7Vc3Gk0Wg4depUVqxYkV5eXuzTpw8f22MRMxvM2VaUXRn/959YYvDwyHAWb+zdfvLJJ3R0dNS1HUdHDwJX+P77xuuT+d5xTLdXfVq3bk0ATCsILoqKILJCLGBYuwH5wgXD+yZOnMhWrVrx+vXr1Gg0PHPmDFNMbFQbMGAA33zzTRvloGCj/2U/bpz5SlGtFkoQEEpRoyHj4uJYrVo1hoSEGHSahw4d4rJlyzh37lybKsSUlBRevHiRarWaGo2GGzduZMmSJXWd48WLF7lgwQJu2rSJwhZNrB+7uwsDlNu3zcsrKdbOPDzEfdeupdLb25u//PILNRoNDx8+TA8PD55Mr6BLlixhtWrVePPmTT59+pTdunXjG2+8Yb4wG/H4sTAoUijIFSuynjdVxnfuiHx6emYsMZh6t5988gn79eun+63RkG+/Td3m/cz1yVyFaE57Xb58OVu0aCErRDsiK8QCiHYDcsmS5NGjOV+feWQZFxdHDw8PxpixIJmYmEhPT0/uNrVgUgTRaMgxY0TNevvtnCNHqNViehQQ06XaTm/YsGGcM2cOw8LCDDpNLTt27LCpQjRMk5qbN28mAN6/f9/g3OXLl3UKkcwY6QUHi/XlnPj7b2Gooh1Z3rt3jwCYlJSku6ZBgwZcuXIlSfKVV17hjBkzdOf2799PFxcXg+vziqdPyfBw4SBhyRLDc8bK+PZtEWbK05PUG2ybfLeZFSIp6sPIkTQas9Kc92pOe01ISGCVKlUYFRUlK0Q7UhgUYpHbh5gT2g3I3t5AmzbZb0A+eVLsZXR0BPbsAUJCgDNnzsDR0RHr1q1DQEAAqlatijlz5hi9f/369ShTpgxatmxpl7wURCQJ+P574P33gZ9+AoYNAzQa49eq1cCbbwILFwIffwxMny7uP3z4MI4ePYrhw4fnadoBoFatWnB1dUW3bt0wZMgQ+Pn5ZXt98+bAjh3Aw4diQ/21a6av3bpV7KesUgXYvRsICAD8/f3Rt29fLF68GGq1GlFRUbhx4waaN2+uu0/0JRn/VyqVuHz5cm6zajGenmKPb9u24r3Nn2/62jt3hHOMu3fFPsPQUHE8p3f7xx9/oFSpUggJCcHPP/8MSQJ+/FE4SZg5E3j3Xcv2KZrTXj/66COMGDECAQEB5j9YpmhiDy1bkEeIWrJYi0ZFCRv/evXIiAgeWXSaJUuKdcPLlzPuW7FiBQFw0KBBTE5O5qlTp+jr68u/jdimt27dmp988kme5akgodGQkyaJL/sBA0jVv4blm7rvoM5tl34oIJVKxfr16zMqKookcz9CjIpiWJlzDPM8IuSnPzc7UlJSuHLlSi7JPAxi1hGilqNHM1mLZqpPm766SCcn8fPhQ8N7N2/eTD8/Pzo4ONDBwYHz5s3TnZs/fz6rVKnCa9euMSEhgV27diUAHsgrn25GSEkR7uwAcvZsZinjW78fY+XKom3t359xX07v9ty5c7xz5w5VKhX379/PgIAA3UhZf+Zh3DhSc8C895pTez1y5Ahr167NtLQ0Xrt2TR4h2hEUghFisVWIpN4GZKdnjHTpIOaCAEZJTemNBAaWiMuyf3HDhg0EwOvXr+uOjRo1iuPGjTO47saNG1QoFLxy5Uoe5KTg8vnnopb1dVjDNDiSAJWSC3s6bCQgNt/rM2vWLIM111wpxMmTSXd3hiGSYYgUC2Du7uK4GVSvXl23lqfFlEIk9fYTej7mede6uvr0m/QqHZHKxuVvZtm/eOHCBbq7u3P79u1Uq9W8ePEiK1euzC1btpAU07eTJ0/m888/z/Lly/Pbb78lAN60h7cJC3j2TDg+B8iZThN0ZXxLqshgKYZezilZ/LCa+261fPnll+zZs6fut77h1VjH2WxpxnvNrr2q1Wo2bNhQt6QhK0T7IivEQsDdLUf5gnSObkji32jLvWhOTzxhZUTzpmuVLF+eMTExBMAbegtGo0ePzqIQp06dyhYtWuRJHgo0UVGc7jSJAPkK1vIJPNgVvxMgv3N6P0v5du/enSVKlKC/vz/9/f3p5OREb29vjhw50uC6HBViVJToJIEMhShm28RxM0aKwcHB3JAp3lV2CpEkz644SX/cox/u8QxCuAJ9qYCKodjHx27+WeSuXbuWderUMTg2duzYLPnV8tdff7F8+fJU57Q4mwek7jvIXg7rCZCVcIVNcIDBuExvJDDKJczqd6tl+vTp7NGjh8ExzYEojnP8kQBZHrfYMof3ml17jY+PpyRJuvT4+voSAP39/blXaw4rYzMKg0KURDptS4MGDXj06FGbP9cu9O2LB6t3oS124DRqAgCqIxq70AblFPeBV18FVq0yuKVly5aoUaMGZs2ahatXryIsLAyrVq1CmzZtdNdUq1YNEyZMwKBBg/I0OwWOvn2BNWvwHcfif/gOAAFIqIJolMN/QBk/4IUXdJerVAnQaJ7pfp871xO+vr1QtuxgODr6gNSATEV8fCQuXx6ORo0uAVBAoXA2lHv+PPAgFgCwFy1ASAjD3ozzmeQ+eXIQpApeXo1AqnHnzizcvDkVDRtegotLufQGo0RKylUcPRqCFi1SAEhQKFyyyE1+8BSnUAepcAIgIRy78Qe6wlORkqU+XblyBbVr18bmzZvRqlUrXL16FR06dMD48eMxdOhQxMXFIT4+HkFBQbhw4QJeffVVjBkzBkOHDs3de7EFfftCtXodBmAJVqIfAEIBNWrjFLzx1OJ3+/Dh7/DxaQlHxxJ4+vQIzp3rgUqVpiEgYECGzPPnwQexuIJg3EFFKKBCGpyEMYRCYVF7bd26Ne7rRQC4desWGjVqhNu3b6NMmTJwds5Up2RyhSRJx0g2yO90ZIdjficg34mORhk8wHh8idchGtI7mIlyuAtoABgxXli1ahUGDx6M0qVLw8/PD1OmTDFQhlFRUbh9+zZ6F+XQF+YSHQ2QGIIFeBffgHCAE5QIwD1xPiXF4HJHxxIGvyXJGY6O3nB09AEAPH68F6dOtdKd37fPDT4+YahTZ7eh3BQRmiIRHhC2YxJu4Hk8jxtG5Wo0SsTEjMGzZ1chSU7w8HgRNWv+CReXcgAApfIGDh2qZCDXxeV5NGlyPYtcd6TAH3dxC4EANPgTneGOFKP1KTg4GIsWLcKYMWNw48YN+Pj4oF+/fhgyZAgA4OHDh+jatStu3bqFMmXKYOzYsQVDGQJAdDQcocIyvIGV6AtAgdJ4BC88FectfLexsatx6dIgaDRKuLhUQMWKEwyVIQCkJEMCUBG3cAcVoIEDtqMjOmG7sN6ysL3qG9I8eyaUtb+/Pxwd5a6xWGKPYWdhmjJlRATXSr3pBCXd8JQeeEoFVFyG18XaRN+++Z3Cwk1EBOOlkmyCAwQ0LIWHVEDFFtjDx5KP/co3IoIHpSYsgTg6I4Ul8VB40sGn1Eh2fK8REfxaeo8A6Y14NsW/GVN6Ra0+RUSIPAFsgUiWwgOxPQJf26+MIyJ4W6rAqrhICSpWx/miW75FDBSCKdNi/xm0rMoUvMlKaIKDkKCBBMAZqRiApUh2KIFhY/rldxILNQ/eeBft13yAc6iBEJyDLx5iBH7G61iOttJObB9AlLKD3D0tJqHL6ufgh1hUwwO44BmCcRWf4xMkOpTEN6MbQbKxTBL4zONrfMYK6IPVuIuykKC3JOHqCowZY2Op+cjYsSIAaXIyFABq4ixq4Qxm4j2kOrjjh9H1bF7GN/u8j9ZrpiIWZVAbp+CDJxkni1r5yuQ99tCyhWWE+NNP4sOyTaUYJrr56owvUiQ3dlZsFRZ0M/M7lYWXO3dEZANXx1Ruc+luYO35u3MvOjuk8cUXRTggW7Jtm3CrVsP3Pu+4BunkqiUHjnacQ0A4kLalXYpGIzaOA+SbdY5R5eZptXVroSKTJa9GUvB/jj8QIIcOtW0ZX7ki/L76uCTzoEvL4lG+RQgUghFisVWI33wjct+li9hXlbGX6igZEUHl3oPs3Vtc89ln1jusLq5cuyb8dHp6pkc2yFS+jIrijh2iH6tWjbx1yzZyN2wQjqjr1El3vJ1JruZAFD/4gLpoGrawsNd3WTdqVLoSMJLfIouRMv7wQ1EeAwfaxkm71sNUqVLpHqaKU/kWEWSFWADRaMhPPxU5f/VVw1h7mV1BpaWJTeUATToYlsnKpUui8ypRwjAqiDFXW/v2iZiVgYFiBJAbli8nHRzIJk0M4xUakzt1qnivr7ySu+DD+pE+Mjs1L07RGDLnVb+d9euXuw8PUz6Ii1P5FgUKg0IsVmuIJDB+PPDNN8DAgcCCBYCDg+nrHR2BRYsADw/g66+BpCThRkpR7Bzemc+ZM0C7dsLgb/duoHbt7K9v3hzYtQvo0AFo0UL8v3p1y+XOny/cxIWHi2UtT8/sr584UbzXd94BXn4ZWL8ecHOzTGZqKvDaa+LeqVOBjz4SrudkRDl88gng7CzKJTUVWLECcHKy7DlnzwoXi5Ik6lNIiF2SKyMDAMXHl6lGA4wcKZThyJHCf2Z2ylCLQgHMnp3hm3PQIEClsn96CyNHjwqF5OAg/MXmpAy1NGggOju1GmjZUviQtYTvvweGDgVeekn42sxJGWoZNw6YN0/42uzUCXj61HyZKSlAjx5CGX73nVCwsjLMyocfija3dq3YIqhUmn/viRNZfQnLyNiTYqEQVSrhjPjnn8UI0dJRniQBX30FfPYZsHSpGBWkptovvYWRf/8FWrcWTtP37bN8lPfii0KJuroKp9DZOV3XQoqR2TvvAK+8AmzcaPko7623gF9/FWlu3x6Ij8/5nqdPgc6dgW3bgLlzhWKVMc277wKzZgGbNon39OxZjrfgyBFRn9zdhTKsVs3uyZSRKfoKMTVVOEtZtgyYMiUjooKlSBIweXLG127PnuY17OLAjh1CmZQrJxRLUJB1z6laVdxfurSIqLBnj+lrSTEV9/HHQP/+wOrVYnrOGvr1E+/0+HHRCT94YPrahASR1717hSItKHvkCzqjR4uPhz//BLp3B5KTTV8bFSXef8mSopwrV867dMoUb4q0QtROa61bB3z7LTBpUu6ntd59F/jlFxHKp3NnIDHRNmktrPzxB9CliwhptGcPUKFC7p73/POiE3zuOaBjRzGdmRmNRmw3mz4dGD4cWLJETKvlhh49xNrjxYsijNN//2W95sEDMXo9dkwo0H7yFlWLGDpUrMnv2CHqTFJS1mv27hUfHP7+oj4FBuZ5MmWKMUVWISYmGk5rvfOO7Z49bJiYOt29WxiDJCTY7tmFiTVrxEi5Th0gMlJ0YragXDlRtjVqAN26ialQLWo1MGSIWNd9912xrmsrI6cOHYQCvnVLGPhcv55x7r//hKK8eFEozh49bCOzuPHmm2JkvWeP+OB5orevftcusQ5coYI4X7Fi/qVTpnhSJBWi/rTWsmX2mdbq3x/47Tex1tGmjQgQW5xYtEhMRTdrJr74S9nY3UyZMsA//wiDm969hYViWpoYlS1eLCwYv/7a9oYsYWGiY46LE0oxOlooxhYthKLcvl105DLW06+fmOKOihLtNCEB+OsvMWoMChIfQ2XL5ncqZYojRU4hPnwo1oGOHhUK6/XX7SfrlVeEocD588Ia7u5d+8kqSMyeDQweLLZXbNsmDGnsQYkSwN9/C8vT118XynHNGqEIP/3UfladjRqJTlmpFJHemzQRCnLnTqEwZXJP795iKeP4cfFeu3UThli2nGmQkbGUIqUQtdNaFy6Iaa2ePe0vs1MnsZ54/brouG/csL/M/GT6dGEg8fLLoozd3e0rz9NTfNiULg2cPi0+Qt57z74yAbFlZMECoQhjY4E5c4DGje0vtzjx8stiO9OVK2Krzpo1gK9vfqdKpjhTZBTijRtCId28mffTWq1aidHDgwdias1IBJpCDymMkj78UGw7+e03wMUl5/tyy+PHouOMjxcjCe0meNo+jKcBR4+K9S5fX6B8eWG88++/9pVZ3FizRmxnqlFDGEr17Ancu5ffqZIpzhQJhXj5slBEjx6J9az8mNZq0kRM96SkCMV87lzep8FekMD//gd88YUwaFm2zHKPI9bw6JFYnz10SHSeUVHAG2+IrRYffmg/pai/pzIqSvyVKyfWu3bssI/M4savv4oPq2bNxPvdtg24dk0sPdy5k9+pkymuFHqFePasUIbPngmF1KRJ/qWlbl1hHSdJQikfO5Z/abEVarWwqv3+exHtZ9488zz85JZ790TnePasWKft1UtsrVi8WIzWvvpKbL3QaGwrd+dOYW2qv6eyQgVhoFWlijD82LzZtjKLG4sWAQMGiPe7bRvg5SVmWbZvF8owLEzM9MjI5DWFWiEeOyYaj4ODUER16uR3ioAXXhAdqaenGGXs35/fKbIelUqMyObPF67Jvvsub9yT3bwpRtnXrmXs99SiUIitFu+9l2Hco1bbRu4ffwhZlStn3VPp5yc+uOrUEVN7q1fbRmZx45dfxDtr3x7YskX4k9XSooUYgT98KNr1tWv5l06Z4kmhVYj79xu6CqtRI79TlEFwsEiTv79o+Lt25XeKLEepFL4nV64Epk0T63Z5oQxjYkTHGBsrLExbt856jSQBM2YIS9MlS8TUW1pa7uRq91TWrm3a0rFUKdFhh4YKmYsW5U5mcWPWLGDECDHK3rTJuJu9Jk1Ee3n8WCjFmJg8T6ZMMaZQKsRdu4SiCQgQU1nWugqzJxUrZqStc2fhsqqwkJwsDFk2bhSd2Icf5o3c8+fFyDApSexBbNbM9LXaaArffCMMfMz1kWmMxYsz1rN27sx+T6W3t5jma99ejHRmz7ZOZnHj66/FlHvPnsIwytXV9LX16xuux1+8mHfplCneFDqFqJ3WCg4GIiPVmDt3EsqVKwcvLy/UrVsXCeluY86ePYsOHTrA19cXko2HNmq1GpMmGZcLAFevXkWXLl1QpYoX/vvPFyVKjMfLLwt3X9ayb98+eHp6GvxJkoT169cDAJYuXYr69evD29sbFSpUwPjx46GyIizH06diK8lff4mIIKNHi+PLli2DJElYsGBBlntSU1NRo0YNVMiF37bjxzOMoT777A+88UZNeHp6olmzZjh//rzuuszv9d13hdN2rQs5Y+7AsmP2bBHBpG1bYMsWNWbMMP1etbi7A7//Lj4aRo8WW1FsgbEy/u677xAUFARvb2+UK1cO77zzjlXvNT+ZOlU41e/TB9iwQULJkh66OjxkyBDddS+99JLueGioJxISnPHgwYsICxNrydaQU7sZPny4wTkXFxd4eXnZItv5hiRJ8PAwXsZff/01atasCS8vL1SqVAlff/21TWQOHToU1apVg0KhwJIlSwzOacsYQF1JkhIlSVJKkmRBbJk8xB5BFu0VIHjNGtLRkWzYkHz0iJw4cSJbtWrF69evU6PR8MyZM0xJSSFJXrx4kQsWLOCmTZsospkz5gYczU6uUqlkUFAQZ86cycTERKakpHD//lNs3pxUKMglS6zMfCYiIyPp6enJxMREkuRPP/3EvXv3UqlU8vbt26xXrx6//PJLi54ZF0c2aiTKeNUq/eNxrFatGkNCQjh//vws902dOpUtWrRg+fLls32+qfI9cID08SGfe47csSOaXl5e3LdvH9PS0jht2jQGBwczLT3CrKn3unSpKN/QUDIhwTy506eLALYvv0w+e5b9ezVGair52mviGRMnZg0gbUkAW1NlHBMTw/j0aMePHj1iq1atOHPmTPMemocYy6tGQ378sSif/v1FkGAAvHz5spnPDOOoUZ+xbFmydGnyxImcZeZE5naTmQEDBvDNN9+07KEFjOzK+KuvvuKxY8eYlpbGixcv8rnnnuMq/cZuJbNnz+bOnTtZv359Ll682FS6jop/sATAIhaAgMCZ/3K+AFgEIBbAWXMfag+FuHix6PBatCAfPxYdiIeHB2NiYrK97/LlyzZViDnJnTt3Lps3b57leGIi2a6dKPE5c8xKTrYMHDiQAwcONHl+5syZ7NKli9nPu3+frF2bdHYmf//d8NywYcM4Z84choWFZVGIV69eZfXq1bl161arFOI//5AeHmSVKuSNG+SPP/7ITp066c6r1Wq6urpy586dBvcZe69r15JOTmT9+uTDh6blajTkpEniXbz2mlBs5tanzKhU5FtviWeNG2eoFC3psLMrYy0PHz5kmzZtOGLECIvSmBcYK+MJE0S5DBokyok0XyFeu3aNCoWC165d4+XLZMWKZMmS5JEjpmWaQ3btJjExkZ6enty9e7dlDy1gWPLRMXr0aI4aNcpmskNDQ7NViAA8ADwFEMYCoAAz/5kzZboEQL56b5wzR2ySbttWmGZ7ewNnzpyBo6Mj1q1bh4CAAFStWhVz5syxe1pyknvw4EEEBgbipZdegq+vL8LDw3HmzBl4eAhz/W7dRIDi3MxUJCUlYd26dRgwYIDJa/bu3YsQMyOqak3do6OF5V+3bhnnDh8+jKNHj2L48OFG7x09ejSmTZsGN0sDEUJYkHbqBFSqlBHhAoD2Q0z3f5I4a8acWa9ewljj7Flh0m9skzcpnIJPnWq4p9La+uTgIJzHjx0rtqYMG2a51WtOZbxy5Up4e3vD19cXp06dwrBhwywTkMcwfd/qV18JI5r58w236rRs2RIBAQHo2bMnrut7UNdj2bJlaNGiBQIDA1G5sqgfPj5iX+rBg9alK6d2s379epQpUwYtW7a0TkABwpwyJol9+/aZ3U/YiFcAPACwNy+Fmo05WhNAIPJqhBgVRUZEkPXqkRER/GrkdQJk9+5iWkvLihUrCICDBg1icnIyT506RV9fX/79998GjzN7hBgVxbAy5xjmeUTIj4oyellOctu1a0dHR0du3bqVSqWSM2bMYKVKlahUKkmK0UhEhPhynjyZ1BwwzK8pufosW7aMgYGB1GSeo0tn4cKFLF++PB88eGAyr1qZV7uMZqVyKfTyIvfuNbxMpVKxfv36jEpPU+bRy4YNG9ixY0eSYioq2xFipvJd+8Ulo6O5Cxcu0N3dnZGRkVQqlfz8888pSRKnTZtm8Ljs3qt21Fm5Mnlj4zGdXNWrfflW93sEyLFjDUdz5tYnU2QedabtM68+5VTG+kRHR3PSpEm8e/euWWnKM/TerbpPX77d867RMibJPXv2UKlUMj4+niNHjmRISIhuOlyf4ODgLCONmzfJ4GDS05Pc+/NZs8pXn5zaTevWrfnJJ5+Ymek8Jsr8fsLcMp48eTJr1arFZ/odq5UytZgxQtwF4FMWgNGgsT+bKUQAQ9MzfPS5557LseCMMnky6e5OShI1AD/G5wTIvjVPMTXV8NINGzYQAK9fv647NmrUKI4bN87gOrMUYrrcMEQyDJFibtbdXRzPRE5yu3XrxvDwcN05jUZDb29vnjx5UndMpRLTSAD5ruP31EASP7KRq0+bNm042cQ1GzdupJ+fH0+fPp1tXilJvIiqLI9bLIWHPDLklyyXzpo1y2A9Rb+zTkxMZOXKlRkdHU0yB4WYqXyXSgOogIqhFa9nWe8jybVr1zIkJISlSpXimDFjGBISwmXLlhlck9N7PXCA9HFJ5nPSDTbCQbbEbvbDcrHe13x3lo7a3PqUE19+KV5lD4dNbIE9Odan7MrYGKtWrWKPHj0sSpNd0Xu3LRHJIZhPgHy/6b4sZZwZlUpFd3f3LHV137599PDw4NOnT7Pcc+cOWa10LN2RyNo4kWP56pNdu7lx4wYVCgWvXLmSfaLzA702a0k/QZou4x9//JGBgYG8deuWTWXmoBBPA1ADCGIBUH7G/mymEPX/rBohRkWJAgeogsT+WEKAHIz5VLl5Zvk6iYmJIQDeuHFDd2z06NGWK0Q9uc2wj02xXxQLII5bKHfSpEls1aqV7pwxhUiS6v1RHO04hwDZAX8yBU7ZytVy8+ZNOjg4GF3r2rZtG319fXno0KEc87oJXVkG9+iHezyNmkZldu/enSVKlKC/vz/9/f3p5OREb29vjhw5kidOnKCjo6PuXMmSJalQKOjv789r164ZlRmGSJbFbQJkW/zNRDffHL864+Pj6eHhwQsXLhgcN+e9HndtSl/E0hHP6IknBMhp+MCq92o2UVGc5fQ/AqQXHrMxDmT7XrMrY2P8+uuvrFWrlmVpshd677YFdrME4giQk/A5NW6m67AWlUpFDw8Pnjp1yuD4kCFD2L9/f5My77kFMgRnCKj4PK7mut2QGYZhBQ69Mj6HGlRBYVZ+tRgrY+0MkknlryeTAM8gxGyZOSjE2wD2sgAoPlN/kkhn9kiSFAhgC8ma5kzDNmjQgEePHjXn0gz69hW7o0l4IwFP4YPSeIgQnIUEAGX8hBsYPU6ebAl39xqoXHkWUlKu4tSpMNSosQolS7ZJz6ASKSlXcfRoCFq0SAEgQaHI5JH6/HngQSzS4IQDEBvfwrAn47yFcpOTL+HYsbqoWXMzSpRohTt3ZuHOndlo2PACFApnA7l8EIuzCEEcykCCGi2wD1I2cgHgxo1piI/fjjp1DKfg4+P/wfnzvRESshElSphYA0nPawrccBiNAAANcAQeSDYqU6VKgEaTsbnv3Lme8PXthbJlB8PBwQNpaRlBIB8/PoCYmFGoX/84nJzKQJIcDGQCwB60BKCAC1LQCEeggMZoPp8+PQZPzzpIS4tDTMxISJIjatRYCQAWv9dEeOIY6gOQUBZ3UBWXTZZvdu/VbNLlXsPzuIlAkR94wRNJws3Oq68Cq1bpLk9ISMAzvQ2UPXv2RK9evTB48GD4+PhgwYIF6NatG/z8/HD+/Hn07t0bHTp0wLfffmt+muxFeptVUQEnpAJQoAzu4wVcEOczlXFS0jmQafDweBEaTQquXZuEuLhtaNDgLBQK4RxXrU5BVFQAQkI2omRJI14ZjLTXyfgMn+Ezo+WrZdq0adi+fTv27jW+dFWtWjVMmDABgwYNyl2Z2Jr0Mt7NlmiDXfBAEurheMZ5C8v4/v0VuHLlXdSuHQkPDxPeTPTa7HUE4gaewwGEoikOmizj1NRUaDQatGnTBgMHDkT//v3h7OwMhV70bkmSlADeJllgXVo45ncCdERH67w1uyEZifBCHErhEUrDF4/ELt1M1KixCpcuDcb+/aXh7OyHwMApus5LqbyBQ4cq6a7dt88NLi7Po0mT64YPSUlGKpxxCrUBABIyOce0UK67ezVUr74c0dHDkZYWC0/PeqhZc7OhMkyXG4+SSEApSNCAcMAlVEc1XBRK0YhcALh/fxkqVnw/y/EbN6ZApXqMM2c66Y75+LRArVrbDGQCgBtSoIAGGjjgKoIRgnNCOWWS6ehYwuC3JDnD0dEbjo4+AABn5wDdOSenUgAUBsf0Zd7EcxDbXgkl3PAfyqECbhvNZ0zMWCQlnYIkOaFMmd4IDs7o/C15r2oocAXB6QeIB/BDWdyDF55a/F7NJiUZSfDAXZTXHeqAv7AVneCjeZIlFEqJEiUMfjs7O8Pb2xs+PqKM9+/fj4kTJyIxMRFlypRB7969MWXKFMvSZC+io5FKR7yGldC+20fwxWP4wAePs5Rxaup9XL48AkrlbTg4eMDbuxlq1tyiU4YA8OjRJjg6lkCJEq2My0yvT9cRCEACQHyJj1AHp9BDs8lkqJlly5bh/fezthsAiIqKwu3bt9G7d2+Lsp8nREdjJ1ujGzaLNopMAxgLy/j69UlQqR7h+PGGunv8/V9H1aq/6D1TlPFVBOEWnkMIzqIRDotzGo3RMm7fvj327BEDiQMHDmDo0KGIjIxEeHg4AFHGAJwA5GI3dh6Q0xASwCoAdwGkQQx5B+d0j1VTphERYp46fWotFPvYGFF0RCp/k14l+/a1/JlmcKvb26yCS/TAU9bGcbEmoZ0eUCjsJvePFl/RGc9YB8f5AKX5GT4W+7WwlCrJ0T5yM5VxVVykBDXb4m8mSR52kanpE8FPpU8IkH64xxbYzV74jQD5pfSB3cr3ySsD2RK7qYCK1XGejRHFQFylNxJ4QGpmN7knOkxgaTxgOdxmQxzkCzhDR6SyIQ4xTiplN7n5wbPer7MrNhMgg3GZTbGf1XCBHnjKPVKYXfKq7tOXw/EzAbICbrAZ9rIJDtABaVwj9SlS5UuSf7acTheksBZOsin+zZP+SdMngmPxPQFyBOZQrbVxyKVMpO9DLMh/dnlobtcQtcYXj+HFUOyjAiqu+DTa8mfmwPXrZFD5FHrhMf9FswyjGgvm6K1hwwbSyVHNBoqjfISSOnlTMJEA+brDSqr+tb1cY2W8BG9QARXDFHv4dJeJtUcr0WjIjwaINcOBWMSW6TLT4MC+WEGA/GzITZvKJMXG/KY1n9ABaVyFPrq83kQFVkY0PfGEe38+a3O5R46QJb3SWFG6ycsI1sn9HV3pjGesK53gw+1Hcn5QISA5mezYJF7sq8UIXV7/QwCr47xQij/ZtozVanLYy8JKeAK+1NWnJ/Bkc+ylAir++ol5++8KA5s2iX6innScD1EqT/ontZocobUSxnfUaGXZQKasEC3FiLXnU7cyDH/+KiXJdl5eSPLKFeEZpUQJ8tDguWZbmeaWNWtIBweySRMyYfwXQk76qI0KBac6fZJhup/VUjr3GCnjlc4D6CCpGBoqnB7YAo2GfPddka2h9Y5Q7eZhIFPl5skBtY/TlJcXa4mLE56MHB3Jdb1XZcnrHdcgVveNpbs7uWuXbWSSoo/w9iYDA8lrY77NInebS3e6OKTyxReFE4TCTFIS2batMECc32VTlrzedaukK2Nb7XFXq8mhQ0V9+iB0LzVuhjIT3XzZKvAKJYlctMg2MvOTtWtFHW7cmIwfPy1P+ie1mhwyRJTx+Gb7hGGUXt+UW5myQrQG3Z6mo7q9L0lJwsuLJJHz5ln/aC2XLpHly5OlSpHHjpmWa2t+/TXD286TJxlyGREhNuSly/3iC/Fm+va1k1I0ktd160QDbNRIKJXcoNGQo0eLPIwala7sjMhUqzO8vLz3Xu6V4oMHZN26wtvO5s2m83rvHlmzJunqSm7fnjuZpNi/6ekp9j3e1A54jcjduZN0cyNr1CD/+y/3cvODp0+FdxiFQrjLI2k0r3fviny6u5ORkbmTqV9PPvzQdH1KSiLbtxfX/ZJ1F1GhYcUK8dFs8IFq5/5JpSLfeEOU3ccfZ5Rx5r4pN8gK0UqMuWRKSSE7dRIpnj3b+mefO0cGBJBlypCZrL2tcgVlLosWCYXeqpVw45YT2v1sERH2UYrG8vr778L1Wd26hpvlLUH/S/5//8vZlZlaTY4cKa4fM8Z6pXj/Pvnii6SLC7ltm+E5Y3IfPCDr1BHK848/rJNJilGmuztZrZrYI5eT3N27M1zVmdoCVlBJSCCbNROd9cqVhueM5fXePfKFF8RHwD//WCdTf9Ty0Uc516eUFLJzZ3H9rFnWycxPliwR/UR4uPj40Mde/ZO+s5DPP7f987XICtFKTL34Z8+ExxqA/PZby597+rRQhAEBQjGaKze3/PKLSHP79mK6yVy0zqftoRRN5XXrVqFUrJnaU6nIgQNp+CVvhkyNhnznHXHf8OGiE7SE//4ToxE3NzKTy9Ns5T56RDZoID4CNmywTCZJ/vWXGGWGhIjO31y5//5LenmRQUFiHbswoO/4fd26rOdN5VVfKVo6Ra1Wk4MHi3oxaZL59UmpFA7bAfKbbyyTmZ/MmyeUYbt2xvsJe/RPSiX5yiuirL76yrbPzoysEK0kuxefmkr26iVSbkkwh+PHhcf88uXFlKmlcq1l1iyR1s6dxderpXz1lbj/1VdtqxSzy+uOHaIDe+EF86f20tLIfv1EWj/91PhILzuZGg35wQfifn1n0Dlx65YYbXl4mF6vyk5uQoJYz3VwEOu75rJlixhd1q5NxsZaLvfQIbF+/dxzYj27IPPwYcZUdGbH71qyy+v9++KjwdQHizHU6gxvTropPAtkpqaKNgOQX3xhnsz8ZPZskdZOnUz3E7bun549I7t2FXK/+852zzWFrBCtJKcXn5aWEXbns89ynmbT73yyC2Zg6wr39dcijT16iC+x3D6nd29mcWFnLTnlVTu1V7Uqeft29s9KTRVpA8hMLkctkqnRkJ98Ip7z+us5fwBcvy5GWd7e5P791st98kSs6yoUYp03JzZsEKPKBg3EKNNauceOiXXs7D7S8pvspqL1ySmv9+9nrNvu2JG9TP2ZhsmTTbdvc/qJ118Xz/nkE9sZbtmab78VaczsrzkztuyfkpPJjh2F3J9+ss0zc0JWiFZizovXbzSZ1xb02b/f/OkpW1Y4rWFMnz62UWLffCOe16uXbZ5nTl7Nmdp79ixjeiqnMH3mlq+27F591XReY2IyrIQPH8693MREsnVrMWW1cKHp6wyshBNyLzenafz8JKepaH3MyWtsrFCurq6kKZ/pKhU5YECGEsutTJWKfPNN8bwPPih4SlFrK2BOu7ZV/5SYSLZpI+r6ggW5f565yArRSsx98frWZ+++m7WyW2rAYIsKZ+koxxJmzhTPfeWV3CtFc/N66FBG8N7MU3v6hk4//mg7mWT2o+uLFzOshI8ft53c5OQMK8Wff856Xmsl3Ly5npWwDeRmZ+iVX5gzFa2PuXnVV4p//WV4Tt/S8dNPbSdTrSaHDRPPfeedgqEUNRoxu2XJFitb9E9PnpAtW4p6nMlfvt2RFaKVWPLi9a0UR4/OqOzWmLjntsLpr4O9+ab562CWoJ1e6dkzd0rRkrzqT+2lB7fQbYUByLlzbS+TJH/4gVnWX/WVh6mAHrmRq2+l+MMPGccttRK2VK7RrUD5hHYq2stLzBKYgyV5ffCArFVLTMNqlaJKRfbvT90yiK1l6m8FGjnScsMtW6LRiL23gJjlMrefyG3/lJBANm0qZjhWrbL+OdYiK0QrsfTFazTCxB8QX4J//im+QC21lMxNhcutpaQlfPcdc702aWleT53KmNo7elQoBks3QVtTvvoWuocOWTe9aKlcpVKULSBGqtZaCVsqV38a2FTAEntj4LDCgjRYmteHD4VBkouLaK/atb4pU+wnU6MR+10BMbOUH0oxN2nITf9k4LBinXXPyC2yQrQSa168RiNM/bVOFerUsXwvnbUVzlZ76SxBO3p6+WXrlKI1eT13jvTzE41KoSCXL7e/TDJjdOboSJYta7kBijVyU1PF+q/WY5U1VsLWyNUfnWVnKGQPcjNKtSavWqWodYYydar9ZeqPzgYMsM8sTnayx4yh1aNUa9uPUYcV+UBhUIgKFBEkCahXT/yr0QBVqgDpAQPsikYDDB8OzJkDvPce8P33Ig32ZswYYNYsYNMmEY0lNdX+MsuVA8qWBVQqwN3daHQquxASAri5CbkVKog02BsnJ1GftNSpA7i4mLzcZjz/PLBnDxAQALRvL/6fF5w/D4SFiXoUGWmYd3vh4wNUrizakIND3siUJGDqVOCzz4ClS4E33hD1yt5oNMCIEaLN/u9/wI8/ikhK9iY2FmjdWrzf338Huna1v8zCTJFRiKtXAxERQNOmwMcfA2vXAv36AWlp9pOpVgODBgHz5wMTJwIzZuSNMtQyerRoWL//DvTubV+lGBcHtG0rGtbPPwOlSomGduSI/WQCwP79Qm5AgMjr8eNCUTx+bF+506YBEyaIch0wAPjiC+Cjj8R40d5UqCAU4XPPAS+9BOzaZV95Z84A6VF6sHs3UKuWfeUBQgm98Qawfj0waZKQ+fLLwNat9pcNAJMnA19+CaxcKUIO2rufGDIEmDsX+PBD4Jtv8qafuHtXvNeYGODPP4GOHe0vs9Bjj2FnXk+ZLl0qpl1atsyw/tNuU7Bknc0Sufp7Ie3p7sgctJt6u3bNfh+TPpbkNTY2Y71nyxZx7Pp1slKlnPcAWiuTNNwLqbUSNncPoLVyjVkJq9ViXdhSK8XcGkFo9wC6uma/BzA3mOOwwhwsbTtaV2HTp4tjjx6R9epZ5krPFlaX5u4BtBZb7oW0JL+WWgnnBSgEU6aFXiEuWCDWl9q0yWr9Z6mXGHPl6nvL0Tbo/Oann0R6unQxr2Gbm9e7d4WXEWNm8vqNbs8e28kks/eW88cfouOsU0esj9hKbnZWwtas/9iiw9b3EmPr9R9zHVaYg7l5TUvLWJvN7CosLk74kXZyMk8p2qJ8SfO8xFiDrb3lmJtfcx1W5DWyQrQSc1/8nDkiBx07ij1kxrDEQtAcubn1p2pPfv454wMgJ6VoTl5v3xZOq93dTTtn/u8/snp1223eJs3zp7p9e/Z+RC2Vq28lPGyYcYWnbyE4ZEjOStFWHbY9LAS1DisqVbKNP1Vz8pqWlqEgZswwfk1cXIZ/2Zw+AGxVvmSGH9G2bS2zJDaFvqWyrfypmpPfgmCpbApZIVqJOS9eu/XAnGlCc/eQ5STXVhE37In2AyCnr92c8nrjBhkcLMIa7d2bvUz9cEq5ce9FCl+Zzs7mRdzQRpqoXj1rpAlL5Jray2oMS6wUbdlhZxdpwlLsEXEjp7zqu/fLSUHEx4sPACcn075TzZFpKYsXm440YQn2iriRU371HVbk915WY8gK0UpyevFah9evvGL++qA5Xkayk6sfFNUWMRntydy5onxeesk6R8FXr4pAtz4+5odA0w+nZOrLPqf3ak1MRqOxCC2Qa21Mxs8/F/dkF7PS1h22vpcRXSxCC7FXTMbs8pqamhFRISf3flri40U9cHISkeMtlWktRmMRWoC+tyNbx2TMLr/WOKzIawqDQix0VqZTpgjrv06dopGa2h3ly5dBqVKl0KFDB1y6dMnoPW3atEH//hKWL1chKkpYKSYkmC8zMRHo3Bn45x9g8WIgOPgf1KtXD97e3ggKCsK8efOM3jdo0CBIkoSYmBgrcmo9Q4cC8+YB27YBPXoAz56Zf29MjDC/f/wY+OabfWjb1hOenhl/kiRh/fr1uuuvXr2KLl26oFIlL9y86YtSpcajZ09gwwbL0rxqFdCnD1C9+j6cO+eJihVNy/zuu+8QEBAAb29vLF48CFu2KBEbK9J9/br5MvWthIcPj0Z0dHf4+ZmuT/pyr10bhKlTlVi1KndWitHR0ejevTvKlMm5Hnt5CSvMVq2AgQOBhQstk7V9O9Cli9jqsHs38MknQ1GtWjUoFAosWbIky/X6+R00aBCUSqXF+UtLE+Wzfj3wwQfR2LPHdF6VSiXeeecdlCtXDpUqlcSLL76NOnXS0KuX2F5kDTmVL0lMmjQJ5cuXh4+PD+bNC8fXX5/DoUOW9xNJSaKf2LEDWLQIGDJEjUmTJqFcuXLw8vJC3bp1kZD+wCVLlsDBwcGgbe3evduqPJ4+bWgl/OOPpt+rfhmXLFkSb7/9NtLsaWJb2LCHlrXHCFGjETHRAOHv8MCBQ1ywYAEfPXrE1NRUTpo0idWqVcvyrOXLl7NFixYEwLS0NG7cKL4669fPaqVoTO7jx+JrUTtVlZqaSm9vb/7yyy/UaDQ8fPgwPTw8ePLkSYP79u3bx5YtWxIAL1++nKvysBatwVGHDllHisbyeuGC2Pju60tmyg5JMjIykp6enkxMn3dWKpUMCgrizJkzmZiYyJSUFP777ynd1F5m91CmvnCXLBGjnrCwrFNVmWVu376dfn5+PHv2LOPi4hgWFsYJEybwyBGyZEmyYkUyc3Ebk5vZSvjQoezrkym5WivFbt2yTt2bM4LJSa4x9CMVzJmT/fO1bN6cdSp69uzZ3LlzJ+vXr8/FixcbXG8qv6YwltfUVOFiUBteKKe8fvrpp2zevDkfPXrE2NhYNm7cmOPHT2aTJmLmIHPMSluU75o1a1i2bFleuXKFKpWKH3zwAevWrctNm0Q/Ua+eeQ4+jEVMmThxIlu1asXr169To9HwzJkzTElviIsXL2ZoaGjOD84hv8YipmT3Xo2V8eTJky1Kh7WgEIwQC4VC1GjI999ntsYMjx49IgA+1Ku9CQkJrFKlCqOionQKkTQdyy6z3Ph4snFj0RjXrhXH7t27RwBM0lt5b9CgAVfqLeykpaWxTp06PHXqVL4qRFJEbpAkMY2jb3iUOa9nzggvNP7+5Nmzxp81cOBADhw4UPd77ty5bN68eZbrTE3tGWvQ8+dnb8yQWWbfvn354Ycf6n7v3LmT/v7+JMkTJ8QWgnLlhHI3JdecmJqZ61N2crVWii+9lH0Zm4OxemwMS2LZaaeiGzY0PhUdGhqapePMLr/GyJxXfaOS7783fk/mvNavX5+//fab7vyKFStYoUIFPn5MnVJcv960THPILHP69Ons3bu37vzZs2fp4uJCUriUc3ERflezcwEZH581pmZcXBw9PDwYY8J81xYKMaeYmsbeq6kyzgsKg0Is8FOmJPDOO8DXXwtPD3PnGvfwsHfvXgQEBKB06dK6Yx999BFGjBiBgIAAg2s7dwb++AO4dElMP92/n/V5cXFAmzZiI/i6dUCvXuK4v78/+vbti8WLF0OtViMqKgo3btxA8+bNdfd+9913aNmyJWrlxQ7nHBg0SEyt7dgBdO8OpKRkvebkSTHl4uAgplxCQrJek5SUhHXr1mHAgAG6YwcPHkRgYCBeeukl+Pr6Ijw8HGfOnNFN7YWHZz+199NPwFtvAR06AJs3C+83Ock8d+4cateurftdu3Zt3L9/H48ePUKdOiL9KpWQfe5cVplKpdhsv24d8O23wAcfGE9b5vqUndyRI8UU9fbtQLduQHKy8Weag7F6bAwXF5GHV14R7WPGDOPXrV4tpqIbNRJ1oGRJ89KRXX5zIjVVeE/auBH44Qdg7Fjj1xnLq+g3M/5/+/ZtkI/x119Aw4biuXqz5xaTWWZERASuXLmC6OhopKWlYenSpeiYvoO9UyfRT1y+LPqJe/eyPi8uDmjXDjh2TDgDefVVcfzMmTNwdHTEunXrEBAQgKpVq2LOnDkG9544cQK+vr6oWrUqpkyZApUFLnO0DitKlQL27gWCgswvA2Nl/Njeni4KC/bQsrkaIUZFMazMOYZ5HqG6T1+O6HmXADlunGmDh1u3brFcuXIGo7QjR46wdu3aTEtL47Vr1wxGiFoMrBQ3H9XJjX35LdaqnEgXF7EFIDObN2+mn58fHRwc6ODgwHl6VjY3b95kcHAwE9KD5SGfR4hatBZ0bduSSZGHdHk90v4jlvRKMzrVqM+yZcsYGBhIjd5LaNeuHR0dHbl161YqlUrOmDGDlSpVojLd0skgCOn7V3UyGRHB78ZeMznVmJ3MoKAgbtMzZU1NTSUAXrt2TXfMYOp32Smd3JTe/dmpWVyOVsLG6pM5crVTv+Hh5NNdhwzya451kjG5OaG/yf3zzynkRESQ9epxaeM5VCg0Bg4rjGFsJGFOfnXotVll737s3vIRcwoJZiyvEydOZLNmzRgbG8u7d++yUaNGBMD/0q1/Hj/OsLRd+8Ulm5SvUqnkmDFjCIAODg4MDAzk1atXDe6LjNQLlv37UV35PujxFutUSTTqTGDFihUEwEGDBjE5OZmnTp2ir68v/04PBHnlyhVevXqVarWap0+fZo0aNTgtu+jaemW8u/Vn9HBTGTisMIax95pTGdsTFIIRYsFSiJMnk+7uDEMkWyKSg7GAADmh2V6TyjA2NpY1atTgVD3PwGq1mg0bNuTudBcNphQimW6l6PyMlaXLbIIDbIr9fAFn6YYk7nh9SZbrL1y4QHd3d27fvp1qtZoXL15k5cqVuSXdhUvPnj25VG+esKAoRFJ02BLUbKP4h82xh3VxjN5IYKB0jdfGZL+psk2bNlnWGrp168bw8HDdb41GQ29vb4P11GfPyK5VLxAgg3GZYYjkdGmCsBKucTZbK2FjMmvVqsU12nkpkg8fPjQ6xRgdTVbwTmBJPGI9HGFz7GFb7KAENed1MW3Lb6w+WSJ35UrSQVIxVLGfzbGXYYgUWtLdXdRvC+Wag0qVEUdwkuOX1EDiAgzSvevED7IPIWGs4zQ3v/pttgV2sys2iw+Ol7ZYnNfk5GSOHDmS5cqVY6VKlTht2jQ6OTlRrbdG8uQJGVrxOh2QxhdwNtflO3HiRDZt2pS3bt1iWloaFy9ezMDAQIMlETI9WLZzCoOlGN7Ac7wHP4bgDF2RzL/6ZTX53bBhAwHwut4mz1GjRnHcuHFG07dq1SrWq1fPeOL1yrgWTtINSXxBOsf/3jGxmTMdY+/VnDK2F7JCtISoKFGpAbbAbpbEQwLkx/iMGjd3o1+AcXFxrFOnTpbF/vj4eEqSRH9/f/r7+9PX15cA6O/vz72ZN9VFRTHKJYzeSKAzkumKZHrgKXejpUhPJrlr165lnTp1DI6NHTuWI0eOJEn6+PjQz89PJxsAfX19uWLFCsvLxNZERXGp8xBKUNMNiVQgjcG4zJuoYDSvWm7evEkHB4cs6yGTJk1iq1atdL+NKURGRVHp5sOeWEeA9MRjsV0BK5jm5mWxzL59+/Kjjz7S/d61a5fxta2oKF51rcHncY0OSKMLkihBzSV4w2ReTdUnS+WudX6NjkilK5JYH4dFMwOskmsu6v1RHOKwiABZDeeFwwpsZTJcs323pOk1xBzzq9dmQ7GH3ogXhj4YYZO8zp07l02aNMki84mbH5tjLwENA3E1V+XbuXNnfp9pkdPHx4dHjhzJIvegS0v6IJ4VcJNBuEx3JHIXWhmVGxMTQwC8ceOG7tjo0aNNKsTVq1ezbt26WU/olfGLOEUJar6IU7yPMla918wYLWM7URgUoiTSaVsaNGjAo0ePWnZT377AmjUACRekIBWu8EUsQnBenC/jZxBeQaV6gtOn28LLqxGqVJlt8CiSSEvLWBh89uwWTpxohCZNbsPJqQwUCueMi8+fBx7E4gm8cALC3f5etEAL7BeLla++KvYEpHPlyhXUrl0bmzdvRqtWrXD16lV06NAB48ePx9ChQxEbGwuNRqO7vmzZsoiKikLt2rXh5uZmWZnYmvQy/prvYDy+AQA0xGG4I31hMVMZa7lxYxri47ejTp29BseTky/h2LG6qFlzM0qUaIU7d2bhzp3ZaNjwQkYZp5cvIWEvWgKQ4IJkNMZhSFbIjIvbjosXB6J27X/g4lIO5871hJdXIwQFTTd8QLrcJLjjKBoCAMrjNirjitG8ZlefrJF7AxVwHcEAgGbYDyeorJJrNufPgw9icQiNoIQ7AKIF9kIBGpULABpNKgANTp1qg4CAgfD37w9JcoYkKczLb3peNVBgH1oAkBCIK3get6zKq1J5B4AEZ+eyePr0EM6f742qVReiVKn2WWSmwQEHINbta+IMSiPOKpnXr3+G+PgdCAlZDyenMoiNXYHo6OFo2vQOHB1LZJH7BJ44gfoAgFo4iZJ4bLJ8T55sCXf3GqhceRZSUq7i1Kkw1KixCiVLtsGjR9vg5VUPzs7+SE6+iHPneqFMmd4IDPzEMIHpcpVwwUE0gRPScBdlRX6N9E8AkJqaCo1GgzZt2mDgwIHo378/nJ2doVAocOfOHUiShLJly+LQoUPo3bs3Fi5ciPbt28PeSJJ0jGQDuwvKBY75nQAd0dG6UAKVcRnRqI6HKIN78EcA7mexBnn4cCOePj2CpKRzuHdvie54w4bn4er6HJydMwxpNBqxEc/Z2R+SlCnLKcICwhtP4QgVHKAWylDcKFbU9QgODsaiRYswZswY3LhxAz4+PujXrx+GDBkCAPDz88uSNV9f3/xXhoCujN/Ht5iCj/EUPriE6qiF03CA2rjFDYD795ehYsX3sxx3d6+G6tWXIzp6ONLSYuHpWQ81a242/OBIL18JhAJqaOAAJdxxHYEIxHVIFsosVaojKlYcj1OnWkGjSYGv7ysIDPws6wNSkqGCIy6huu7QXZSDLx6hBBIsrk+WyH0CL9xCoO7QKdRBLZyCM9Islms2Kcm4hYo6ZQhIedoJUAAAHVtJREFUuILKqIL0+muknE+fbo/Hj0V8qSdPDiA6eihq145EiRLh5uU3JRlqKHAONdMPaDKUoRGZOeU1JeUKLl58A2lpsXBxqYhKlaYbKsN0mYSEGFQFIMEBaRnK0AqZzz03AWlpsTh2rA7U6iS4uVVGSMh6Q2WYLhcAvJGIkoiDBlKGMjRRvjVqrMKlS4Oxf39pODv7ITBwCkqWbAMASEjYhUuXBkKtToSzsz/8/F7Hc899lOUZWrkuUKIk4lAedzLya6R/AoD27dtjT3rcsAMHDmDo0KGIjIxEeHg4rly5gjfeeAOxsbGoWLEipk+fnifKsNBgj2GnVVOmEREZkUIBJsKdbdLXfBZIQ4RLEHugJzcMkWJNQjsFo1DYT25+kKmMf0MvOiKVjRHFeKmkffKaqXzF2vB8AuR4fEVNhH3K92GPIayHo3SCkiE4bbA2/LfU3m7vdV+bT+iFxwyGWJN+Ubvmg7O8K5W1m9zPa64hQEZgJVtiNyviBgFyMOZTJTnaRe7TVwYwHP9QgprVcCFP2k7aq68xAqvElhlMyJBn7/aaqe0Uebl2AIVgyrTgKES9uXLtXzJc2RFbxbrEe1dzfoY16MnNohBzmKMvdBgp403oRicoWV9xjI+2H7arTG35qiFxBOYQIMe++l+uQuIY4/59CithpHArOurkxsKXtXGCLkjhnzMv5PwgC4mMJD3cVKwmXeRtlNPJjUQYPfCUVaVLwkrRhhg4rHBYThUUOrmT8SkBsr/DCqbts209fvyYDK31mA5I4wr0zZO2k5ZGRrR7QID8Cu9nVRD2bK9G2k6RlmsHZIVoKenWVLovIoWCz9xKsFu6lWJOG5CtRs+Ky1yrtUKLkTL+06UHXRxSWauWoaMCW8vUL1+NmzvHNT5AgBwxwrxwSubw338iZJSbG4WVcCa5j9zKs37Z23RyIjdutI1Mkvz774xwVXf/NyOL3H9dWgsrxWDhON0WZHFY8fEnWeROdfqEgAi5lJpqG7kGDit6rc6TtmMQKaPtX1nqcJ60VyNtp0jLtTGyQrQG7T6q+vV1+4uUygznwHaLP6jb53PU7H1NhRYjZfz33yJaxQsviBiI9pCZuXw1GnL8ePFeBw/OPnKEOdy+LfaKGQRFNSJXv0PXc9phNfoeTXQfFEbkHjwoHKY//7xxzyKWoNGQY8eKsnv7bb0PCiNyZ8wQ11kSLNsUDx8Kd2YGTrft3Hb0I2V8/XWGzMx1OE8obnJtiKwQbUiWDch2wB7e8wsT//wjPjyrVhXKxdaY8lH78cfivfbvb71S1AZF9fISe8Zykvv4sYh8olCQy5dbJ5Nktj4vjck9elT4nqxQQeyVtAa1WoyqAeMOK4zJ/f57cb25AaSNERsrlL6Li/gIyEmmLdB3s2dupAyZgomsEG2MwQbkSeaH6jGX4q4QSXLfPqFUbDm1pyW78p0yRbzXiAjLp/auXBGjLh8f8uBB8+U+fSpiZEqS8ORjKb/9JkaZjRuLaURz5Z48KbzolC1Lnj9vmUyVSoymAXLCBONtwJRcbQDpDh1MB9Q2xd27GVPR6c5WzJKZG/TDRhW0YNwyliMrRDugVov1EkCsn9hSKcoKUaCd2gsMFLERbUVO5aud2uvZ0/ypvehoMdrKLihqdnKTksh27YTcuXPNk0mKuHna+Jqm4uZlJ/fsWeFI3c9POFY3h7Q0MYoGxPKRqbqfnVyts/fWrbMPlq2P/lR0ZKTlMq1BP1KGrAyLBrJCtBNqtVg3AcQ6iq2UoqwQM7DF1F5mzClf7dRe1645T+2dP58RFPXUKevl6kc4z87/phatX9hWrbKPrJ6T3IsXRWSO0qXJ48ezl5maKgxjADIn7245ydUGy27RInsfp6SYJQgONj4VbYlMSzAnUoZM4UNWiHZEoxHrJwA5fLhtrBRlhWhIbqb2jGFu+f70E3Oc2jt9WihCf38RLTy3cpVK8uWXhdxvvjF93dy54pp27YyHq7JUbkyMCN9TogR52MSuF30FMSN795Vmy129WjjJbtqUTPdDn4WcpqItlWkO+u/hhx9y/zyZgoOsEO2MRiPWUQBy0KDcWynKCjEr1kztmcKS8tUGNzY2tXf8eEbcw4sXbSdX35rRWOCBH38U5zp1yhpwOTdyr10jK1Uivb3JAwcMzz17JgxhLBktmSt3/XphENSgQdY4ifpT0UfN2Dppi7ajVJLdu4u8zpqVu2fJFDxkhZgHaDRiPUVrpWgkoIXZyArROPpTeydOWP8cS8t32TIxtacfvujw4YygqCZir+ZKbloa2a+fqE+ffpoxHT9zpjjWvbv5VpqWyL15k6xShfT0JPfsEceSk8UoGRAGMeZiidw//hDBsuvUIR88EMfOn9cLn3XS9jKNoVSKUGBA9qG5ZAovhUEhFhxfplYiScBnnwHOzsCkSSI46a+/Ak5O+Z2yokO1asCePUDr1uLv77+BBnngord/f/Fe+/UTQYQ//VQE9y1dGoiMBJ5/3vYyHR2BpUtF/fn0UxFQ2NMTmDhRyF6xwj51q2LFjDJ+6SXh5/6770Q+Fy4UgZ7tQZcuIjjzyy+LILg//igCCkuS6WDRtkYbtPmPP4A5c4C337a/TBkZYxR6hahl4kQRRfz994VSXL1adKYytqFyZRGZu3VroE0bER2+aVP7y+3TRyigPn2EoggMFIqjQgX7yXRwEErI2Rn48ktx7LXXhKJ0tGOLKVtWKKFWrYBu3YRSWrYMeP11+8kExMfGn38CnTuLKOxlyoh0VKtmX7mAUIa9egFbtgA//QSMGGF/mTIyplDkdwJsyXvvAT/8AGzcCLzyCvDsWX6nqGihVUZ+fkD79kJB5gU+PiLSDQm4uQGurvaXKUlAqVIZv0uWFGmwN66uYkRKijT4+NhfJgB4eQllr9GID0t3d/vLVCpFO92yBfj5Z1kZyuQ/RUohAsCYMaJxbdkCdO9uMqKRjJVop/YqVBAjtl277Ctv+3YxrVe1qpiuvHJFjKDu38/5XmshxcfV9OnAW28B//ufmMobPlwoDHsRFydGaCdPAkuWAHXrAj17Ahs22E8mABw4kDEyXLcOiI8HwsKA69ftJ/PZM5G3P/8E5s4VZSsjk98UOYUIiMa1cCGwY4foTJOS8jtFRYty5cSUWlCQKN+//rKPnD/+EB811auLtbS+fcWHzpUrQHg4cPeu7WWS4qPq22+BUaNEZ/3NN8BHHwHz5wODBwNqte3lPnwopqJPnxYKcMAAYOdOoGFDEQN2zRrbywTEKL9DB8DfX3zo9Owp5MbHAy1birK2NVpluHWrKN+hQ20vQ0bGKuxhqZOXVqbZYckGZFK2MrWUBw+EdaKzs7BWzAlLynf9euEWrWHDrFsC9uwR1phVqpC3btlOrlpNDh0qLB3ffdfQ4YNGQ372mTj32mvmWTObK/fePbJmTeFcfft2w3NPnggrW4VCWN2ag7lyd+4UvmurVxdRQvQ5ccI+W1tSUsiOHUU5zpuX8/UyRQcUAivTIq0QSfM2IGuRFaLlPHok9rE5OZEbNmR/rbnlu2qVeGfNmpl+ZwcOiH17lSqJfXy5latSkQMHihbx0UemvR99+aW4pnfvnH2umiP3zh2hkNzdyV27jF+TmCj2Y0qScL2WE+bI3b5dKOCaNYVCNsaZM2L/qb+/2I+aW5kpKWIbiSSJfaYyxQtZIRYQNmzI2ID86JHp62SFaB0JCeKDw8FBfICYwpzyXbo0695DU5i7JzEnuWlpYtSXee+hKczdk5iT3Js3ycqVxWh3797sZervSfzpp+yvzUnu5s1Z9x6a4sIF8/Yk5iQzOZls3958pS5T9CgMCrFIriFmpkcPsS5z+rRYp3n4MHfP++OPP1CzZk14enqiWbNmOH/+vMH5q1evokuXLvDy8oKvry/Gjx+fO4EFHB8fsY7YrJnYnvDrr9Y9Z+FCYMCAh/DyCsXZs6VRsWIJNG3aFPv379ddo1Qq8c4776BcuXJo374k2rV7G4mJaWjZErh0yXKZaWkizStXPsRzz4Vi1qzSKFkyq1x9/vyzDQAJv/+uQs+e1lkzX78uDFdiY8W+zhYtgGXLlkGSJCxYsEB3XUJCAgYMGIDnn/fD8eN+qFLlU7z9trCmtoYNG8T6Xa1awN9/q/H995NQrlw5eHl5oW7dukhISAAArF69GtWqVUPjxj5QKv2QnDwA4eFPcOyY5TJTUsRa8I4dQIsWQ/HVV9WgUCiwZMmSLNcWt7YjU8Cwh5YtaCNELTlNE5kzgomOjqaXlxf37dvHtLQ0Tps2jcHBwUxLX1RSKpUMCgrizJkzmZiYyJSUFJ7KzvN0ESKnqb3sylfrv7RduxSePHmRarWaGo2GGzduZMmSJXXl++mnn7J58+Z89OgRY2Nj2bhxYw4bNlk3tWfMr6kpuc+eZbgKmz49hRcvmparZfny5WzRogUB8Kef0ihJpv2ampIbE0NWrGjovzQuLo7VqlVjSEgI58+fr7t24MCB7NWrF5OSknjt2jVWqhTEevUWZevX1JTczMsHEydOZKtWrXj9+nVqNBqeOXOGKek+6W7evMkH6cPHp0+fslu31+jlNdriEFtJSWTbthkhtmbPns2dO3eyfv36XJwp5lZxbjvFARSCEWKxUoikWKfRGhLcuWN4zhyF+OOPP7JTp06632q1mq6urty5cydJcu7cuWzevLltE12IyM7dmKnyNRXhQq1Wc/PmzQTA+/fvkyTr16/P3/TC3K9YsYIVKlTQuRszFvnCmNyUFOGT1FiEC2NySTIhIYFVqlRhVFQUATAtLU0X+SI8PGvkC2NyTbnBGzZsGOfMmcOwsDADhVi6dGke1vP6/cUXXzA0tLkuWPaUKVmK06jczG7w4uLi6OHhwRgz/N89ffqU/fv3Z3j4S7rIF/v25SwzKYls00aUz5IlhudCQ0OzKMTi3naKOoVBIRaLKVN9WrcWe9tu3xZTVrduWf4M8W4z/k8SZ8+eBQAcPHgQgYGBeOmll+Dr64vw8HCcOXPGVskv8Li5AZs2ie0YI0YAs2Zlf/2MGcC4cWKD9rp1YlM4ANSqVQuurq7o1q0bhgwZAj8/P909mcv/9u3bKFfuMfbsEfe3agUcP25aZnKy8ASzbZsw+x81KuNcdnI/+ugjjBgxAgEBAbpjAwcCy5cD+/YBHTsCT56YlnvunKhzKpXYtlKnjjh++PBhHD16FMNNbMbLnN9z585i+XLh2u7jj4HJk8V2EVMsWiS2cYSHi60OXl7AmTNn4OjoiHXr1iEgIABVq1bFnDlzDO77999/4ePjAy8vL6xfvx4ffjgOe/aIbTcdO4o8mCI5GejaFfjnH7GncsAA09dqKe5tR6YAYA8tW5BHiFqMWSmaM0K8cOEC3d3dGRkZSaVSyc8//5ySJHFaeniEdu3a0dHRkVu3bqVSqeSMGTNYqVIlKs2NeFtEMBayKHP5fv65OB8RYXwbQ0pKCleuXMklesOLiRMnslmzZoyNjeXdu3fZqFEjAuB/6fsGrl7NGrJIX+7Tp2I0p53CM4YxuUeOHGHt2rWZlpbGa9eu6UaIWn77TWwTadyYjI/PKlc/lNaFCxmyVCoV69evz6ioqPR7DEeI/fr1Y48ePfjkyRNevnyZQUFBdHZ2Tr+XHDxYlOH48RnGQPpyTYXSWrFiBQFw0KBBTE5O5qlTp+jr68u///47S3ncvn2bn3zyCS9dukSSvHuXfOEF0s2N1F6uLzMxUcSKVCjE1idjGBshym2naINCMEI07yKgI4BLAGIAfJDT9YVBIZIZVooVK5KXfzvOsDLnGOZ5RPTQ6R2UMdauXcuQkBCWKlWKY8aMYUhICJelbxLr1q0bw8PDdddqNBp6e3vzpLlhA4oQ+kFtpwy9qStfTZ8IThp4SxehJKewXdWrV9eVX3JyMkeOHMly5cqxUqVKnDZtGp2cnKjWC4h5/ToZFJQ+tffLWZ3cx6+8ydBaj6lQkMuX55x+rVy1Ws2GDRty9+7dJGlUIZLkpk3CmrlePfLh9iM6uUfbf8iSXmlGgy3PmjWLb775pu53ZoX46NEjvvbaa/T39+cLL7zAiRMnMigoSHderSZHjGBGsOwDUTq539ddQkCEj8ocrmrDhg0EwOvXr+uOjRo1iuPGjTNaFlFRUaxbt67ud2wsWasW6eJC/jnzgk5mYq8BDK+XkGMZG1OIctsp2hQJhQjAAcAVAEEAnAGcAvBCdvcUFoVIpm9AdktkOekOG+IQwxApPm3d3UVcqRyIj4+nh4cHL6R/9k+aNImtWrXSnS/ujTotjexf6wQB8jlcY0tEcjy+IkAOrnvUrBiWwcHB3GBik+PcuXPZpEmTLMdv3yarln5ADzxlbZxgKPaxMaLoiFT+1iubvSFG5MbHx1OSJPr7+9Pf35++vr4EQH9/f+7NtF/izz9JF4dU1pJOsyn+ZV0cpQ/i+bx0nVdHf5tFRvfu3VmiRAnds52cnOjt7c2RI0caTdOHH37IiIgIg2MajVCGADnCcS7DEMkgxBAgezpspHLiZ1meExMTQwC8ceOG7tjo0aNNKsR9+/bR29vb4NjDh2S9snfoBCVDcIbNsYdhiKQCKq7osdboc7QYU4hy2ynaFBWF2BTAX3q/PwTwYXb3FCaFyKgonnFtQD/coxOUbIBDolgAoRSNjBSPHj1KlUrF2NhY9u7dm3379tWdu3jxIt3c3Lhjxw6qVCp+++23DAoKKr7TPlFRVLl5chAWECA98Vh03JhDtZtHlvKNiorivn37qFQqmZyczOnTp9PT05N30i2gbt++zTt37lCj0TAqKooVKlTgX3/9ZVTuXbdKfAFnqYCKrkiiE5TchG5G32t2cjUaDe/evav7O3z4MAHw9u3bWd9rVBT/dulCNyTRFclUII3BuMwbqGhUbnx8vMGzmzZtypkzZzIh3SNBTEwMHz58SJVKxa1bt7J06dI8a2SXvOZAFMc7zjQo4wisZCocTdbjFi1acOjQoXz27BnPnz/PMmXK6IzDli9frlOW169fZ8uWLdmjR48seY13K8vGiCKgpjsShTJEX5MylUolU1JS2KxZM86bN48pKSm60b3cdoo2hUEhSiKdppEkqReAjiSHpP/uD6AxyVGm7mnQoAGPHj1q4WpmPtG3L7BmDS6yKmrjFByhwlN4QQGK8AavvgqsWmVwS/PmzXHq1Ck4OTmhd+/e+Pbbb+Hh4aE7v2HDBowfPx6xsbGoV68e5syZg5C8CCxXEEkvXw0BdyRDCVeUwgO8iHPifBk/4IUXdJcnJOxBTMwYPHt2FZLkBA+PFxEYOAUlSrRMP78XFy++gbS0WLi4VMTzz0+Gv3+/rHLPnwcexCIVTohCMwDACziHMnholVx9nj27jkOHKqFlyzRIUqZ4UOly41ASZ1ALANAEUXBBqlG5mTl5Mhz+/q+jbNkhAIDY2N9w5co4qFQJcHOriqCgr1CqVAeT+b2I6riPAEjQoAX2QtKeNyJXqbyDS5cG4/Hjf+Hs7IeKFSegXLlhAIBr1ybi3r2lUKni4ehYEqVLd0KlSl/Cyal0FplqOGA/QkFImIO38TZ+Mdl2wsPDsWfPHoNjkZGRCA8PByC3naKMJEnHSOZBJFXrsZlClCRpKIChAPDcc8/Vv3Hjhn1SbGvq19eZJA7EYqjggOV4w/B8YVHuBRG98q2D47iCYNTD8YyO2tNLXGNrjh0FEhMBAIfRAGo4oikOZpzPA7lRaAIHqNEIR/JU7gE0hTNS0QB6u+jtIVdP5iVUhQTgP5TPOC+3HRk9CoNCNCfc6R0AFfV+V0g/ZgDJeQDmAWKEaJPU5QVVq4p4OxoNluBNw3MKhTgvYz165XsS9QzPKRRA1z7AypW2l9t3JvDbb8bjNcly80am3HZkChnm7EM8AqCKJEmVJElyBhABYLN9k5WHjB1rOuKsq6uIBSRjPflVvrJc+8uV245MESNHhUhSBWAUgL8AXADwG8lz9k5YntGkiYgG6+6eERJdoRC/33tPnJexnvwqX1mu/eXKbUemiJHjGqI1FCqjGi0HDwqPyZcvA1WqiK9fuUHbjvwqX1mu/eXKbUfGDArDGqKsEGVkZGRk7E5hUIjFzpepjIyMjIyMMWSFKCMjIyMjA1khysjIyMjIAJAVooyMjIyMDABZIcrIyMjIyACQFaKMjIyMjAwAWSHKyMjIyMgAkBWijIyMjIwMAFkhysjIyMjIAJAVooyMjIyMDABZIcrIyMjIyACwky9TSZIeAMhthGBfQBvevFgh57t4Iee7eFGc8+1Bskx+JyQ77KIQbYEkSUcLuiNYeyDnu3gh57t4Iee7YCNPmcrIyMjIyEBWiDIyMjIyMgAKtkKcl98JyCfkfBcv5HwXL+R8F2AK7BqijIyMjIxMXlKQR4gyMjIyMjJ5hqwQZWRkZGRkUEAVoiRJHSVJuiRJUowkSR/kd3ryAkmSFkmSFCtJ0tn8TkteIklSRUmSIiVJOi9J0jlJksbmd5ryAkmSXCVJOixJ0qn0fH+W32nKKyRJcpAk6YQkSVvyOy15hSRJ1yVJOiNJ0klJko7md3ryCkmSSkiStE6SpIuSJF2QJKlpfqcpOwrcGqIkSQ4AogG0A3AbwBEAfUmez9eE2RlJkloCSASwjGTN/E5PXiFJUlkAZUkelyTJC8AxAC8Xg/ctQWxUTpQkyQnAvwDGkjyYz0mzO5Ik/Q9AAwDeJLvkd3ryAkmSrgNoQLJYbcqXJGkpgH0kF0iS5AzAnWRCPifLJAVxhNgIQAzJqyRTAawG0D2f02R3SO4FEJff6chrSN4leTz9/08BXABQPn9TZX8oSEz/6ZT+V7C+Tu2AJEkVAHQGsCC/0yJjXyRJ8gHQEsBCACCZWpCVIVAwFWJ5ALf0ft9GMeggZQBJkgIB1AVwKJ+TkiekTx2eBBALYAfJ4pDv7wGMB6DJ53TkNQTwtyRJxyRJGprfickjKgF4AGBx+hT5AkmSPPI7UdlREBWiTDFEkiRPAOsBjCP5JL/TkxeQVJOsA6ACgEaSJBXpqXJJkroAiCV5LL/Tkg80J1kPwEsARqYvkRR1HAHUA/AzyboAkgAUaJuQgqgQ7wCoqPe7QvoxmSJK+hraegArSG7I7/TkNenTSJEAOuZzUuxNKIBu6etpqwG0liRpef4mKW8geSf931gAGyGWhoo6twHc1pv5WAehIAssBVEhHgFQRZKkSumLsBEANudzmmTsRLpxyUIAF0h+m9/pySskSSojSVKJ9P+7QRiRXczXRNkZkh+SrEAyEKJd/0Py9XxOlt2RJMkj3WAM6VOG7QEUeWtykvcA3JIkqVr6oTYACrSxnGN+JyAzJFWSJI0C8BcABwCLSJ7L52TZHUmSVgEIB+ArSdJtAJ+QXJi/qcoTQgH0B3AmfT0NAD4iuTX/kpQnlAWwNN2qWgHgN5LFZhtCMcMfwEbx7QdHACtJbs/fJOUZowGsSB/cXAXwZj6nJ1sK3LYLGRkZGRmZ/KAgTpnKyMjIyMjkObJClJGRkZGRgawQZWRkZGRkAMgKUUZGRkZGBoCsEGVkZGSKNbYOLCBJkjrdiflJSZIK1ZY52cpURkZGphhj68ACkiQlkvTMfcryHnmEKCMjI1OMMRZYQJKkYEmStqf7Xt0nSVL1fEpeniIrRBkZGRmZzMwDMJpkfQDvAfjJgntdJUk6KknSQUmSXrZL6uxEgfNUIyMjIyOTf6Q72m8GYG26dx0AcEk/1xPA50Zuu0OyQ/r/nyd5R5KkIAD/SJJ0huQVe6fbFsgKUUZGRkZGHwWAhPRILAakO9/P1gG/niPzq5Ik7YYI6VYoFKI8ZSojIyMjoyM9/No1SZJ6A8IBvyRJtc25V5KkkpIkaUeTvhC+igu0Q299ZIUoIyMjU4xJDywQBaCaJEm3JUkaDKAfgMGSJJ0CcA5AdzMfVwPA0fT7IgFMJ1loFKK87UJGRkZGRgbyCFFGRkZGRgaArBBlZGRkZGQAyApRRkZGRkYGgKwQZWRkZGRkAMgKUUZGRkZGBoCsEGVkZGRkZADIClFGRkZGRgYA8H8ICKSX4DTiUgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from iquhack_utils import get_blockade_radius,C6\n", + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "#blockade_radius = 7.5e-6\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 320, + "id": "f6640a71-1756-420e-a7cf-e543136fb2ad", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Define a set of time points\n", + "time_points = [0, 0.6e-6, 3.4e-6, 4e-6]\n", + "\n", + "# Define the strength of the transverse field Ω\n", + "amplitude_min = 0\n", + "amplitude_max = 10e6 # rad / sec\n", + "\n", + "# Define the strength of the detuning Δ\n", + "Delta_initial = -20e6 # rad / sec\n", + "Delta_final = Delta_final # Defined above\n", + "\n", + "# Define the total drive\n", + "from quera_ahs_utils.plotting import show_global_drive\n", + "from quera_ahs_utils.drive import get_drive \n", + "\n", + "amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piecewise linear\n", + "detuning_values = [Delta_initial, Delta_initial, Delta_final, Delta_final] # piecewise linear\n", + "phase_values = [0, 0, 0, 0] # piecewise constant\n", + "\n", + "\n", + "# Define the drive\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);" + ] + }, + { + "cell_type": "code", + "execution_count": 321, + "id": "ab0f6485-56db-47dc-ac15-50f842678fa7", + "metadata": {}, + "outputs": [], + "source": [ + "from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 322, + "id": "f23da4e6-fe03-42e5-aa25-bd0a2c7728c2", + "metadata": {}, + "outputs": [], + "source": [ + "#from braket.devices import LocalSimulator\n", + "#device = LocalSimulator(\"braket_ahs\")\n", + "#small_ahs_run = device.run(small_ahs_program, shots=50)\n", + "\n", + "\n", + "def save_result_json(json_file,result):\n", + " '''\n", + " Helper function to save results locally\n", + " '''\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " with open(json_file,\"w\") as io:\n", + " json.dump(result_dict,io,indent=2)\n", + " \n", + "def open_json(json_file):\n", + " '''\n", + " Helper function to load and open json data\n", + " '''\n", + " with open(json_file,\"r\") as io:\n", + " return json.load(io) \n", + "\n", + " \n", + "# Results are loaded and saved to file\n", + "#result = small_ahs_run.result()\n", + "#save_result_json(\"classical_results/small_kings_graph_mis_trial_5.json\",result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 323, + "id": "4f9aaaac-4035-4a19-80f1-1fc123be6765", + "metadata": {}, + "outputs": [], + "source": [ + "def postprocess_MIS(G,results):\n", + " '''\n", + " Removes vertices that violate the independent set condition\n", + " G - networkx graph\n", + " results - an AWS AnalogHamiltonianSimulationQuantumTaskResult\n", + " \n", + " returns\n", + " data_out - a list of bitstrings which are valid independent sets of G\n", + " '''\n", + " data_out = []\n", + " for measurement in results[\"measurements\"]: # For each measurement...\n", + " pre_sequence = np.array(measurement[\"pre_sequence\"])\n", + " post_sequence = np.array(measurement[\"post_sequence\"])\n", + " if np.any(pre_sequence==0): continue # skip anyshots with defects\n", + " \n", + " bitstring = post_sequence\n", + " inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices\n", + " if len(inds) == 0: continue\n", + " subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges.\n", + " inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph.\n", + " payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s)\n", + " payload[inds2] = 0\n", + " data_out.append(payload)\n", + " \n", + " if len(data_out) == 0: \n", + " raise ValueError(\"no independent sets found! increase number of shots.\")\n", + " \n", + " return np.asarray(data_out)\n", + "\n", + "def analysis_MIS(graph,result_json):\n", + " '''\n", + " Helper function to analyze a MIS result and plot data\n", + " '''\n", + "\n", + " post_bitstrings = np.array([q[\"post_sequence\"] for q in result_json[\"measurements\"]])\n", + " pp_bitstrings = postprocess_MIS(graph, result_json)\n", + "\n", + "\n", + " IS_sizes = np.sum(1-pp_bitstrings,axis=1)\n", + " unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True)\n", + "\n", + "\n", + " avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() )\n", + " avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean())\n", + " print(avg_no_pp)\n", + " print(avg_pp)\n", + " plt.bar(unique_IS_sizes,counts/counts.sum())\n", + " plt.xticks(unique_IS_sizes)\n", + " plt.xlabel(\"IS sizes\",fontsize=14)\n", + " plt.ylabel(\"probability\",fontsize=14)\n", + " plt.show()\n", + " \n", + " return IS_sizes,pp_bitstrings\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "8dee86cf-1e13-416f-a670-c038f54fdf7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c')\n" + ] + } + ], + "source": [ + "from braket.aws import AwsDevice\n", + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "nshots = 70\n", + "task = qpu.run(small_ahs_program, shots=nshots)\n", + "print(task)\n", + "\n", + "save_result_json(\"BIGBIGSNAKEYWOHOO.json\",task.result())" + ] + }, + { + "cell_type": "code", + "execution_count": 325, + "id": "fcd45af0-ee2a-4397-ba58-e4f02e7036d6", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'G' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[325], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m color_lookup \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m0\u001b[39m:\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m1\u001b[39m:\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m'\u001b[39m}\n\u001b[1;32m 10\u001b[0m seqs_color \u001b[38;5;241m=\u001b[39m [color_lookup[seqs[i][j]] \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(seqs[i]))]\n\u001b[0;32m---> 11\u001b[0m visualize_graph(ax,\u001b[43mG\u001b[49m,pos,node_colors \u001b[38;5;241m=\u001b[39m seqs_color)\n\u001b[1;32m 12\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mNameError\u001b[0m: name 'G' is not defined" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "nmeas = len(result_json[\"measurements\"])\n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,G,pos,node_colors = seqs_color)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "id": "fef2363a-11c0-4b19-a343-a86160efb89f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AnalogHamiltonianSimulationQuantumTaskResult(task_metadata=TaskMetadata(braketSchemaHeader=BraketSchemaHeader(name='braket.task_result.task_metadata', version='1'), id='arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c', shots=70, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2023-01-29T06:51:59.331Z', endedAt='2023-01-29T06:52:48.394Z', status='COMPLETED', failureReason=None), measurements=[ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0,\n", + " 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0,\n", + " 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0,\n", + " 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1,\n", + " 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0,\n", + " 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,\n", + " 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,\n", + " 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n", + " 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1,\n", + " 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,\n", + " 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0,\n", + " 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1])), ShotResult(status=, pre_sequence=array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), post_sequence=array([1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1,\n", + " 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]))])" + ] + }, + "execution_count": 326, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#EDIT THIS AFTER RUNNING JOB\n", + "from braket.aws import AwsQuantumTask\n", + "\n", + "task = AwsQuantumTask(arn=\"arn:aws:braket:us-east-1:592242689881:quantum-task/9dcb25b8-adb9-4e26-86eb-c7877f6c9d2c\")\n", + "task.result()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 327, + "id": "61a02975-4ff1-4419-a3f6-2b688692f154", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 28.5714\n", + "Average post-processed IS size: 27.0667\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_json = open_json(\"BIGBIGSNAKEYWOHOO.json\")\n", + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)\n", + "\n", + "ind, = np.where(IS_sizes==IS_sizes.max())\n", + "n_show = min(len(ind),3)\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "for i in range(n_show):\n", + " ax = plt.subplot(1,n_show,i+1)\n", + "\n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[pp_bitstrings[ind[i]][j]] for j in range(len(pp_bitstrings[ind[i]]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390cad5e-5090-4bf9-bc19-e2700f151a7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b14a427-8102-4c66-9d0f-ca41b869ffe8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/team_solutions/q/graph_tools.py b/team_solutions/q/graph_tools.py new file mode 100644 index 00000000..35f55300 --- /dev/null +++ b/team_solutions/q/graph_tools.py @@ -0,0 +1,212 @@ +import numpy as np +import networkx as nx +from matplotlib import pyplot as plt + +def kings_graph(numx,numy,filling=0.7,seed=None): + ''' + Generate a next nearest neighbor graph with a lattice constant 1, with some number of nodes removed + numx - number of grid points in the X direction + numy - number of grid points in the Y direction + filling - Fraction of vertices to be kept. Total number of vertices is int(numx*numy*filling) + + Returns + pos - [N x 2] array of points on a square grid + graph - networkx connectivity graph + ''' + xx,yy = np.meshgrid(range(numx),range(numy)) + num_points = int(numx*numy*filling) + rand = np.random.default_rng(seed=seed) + # Generate points + points = np.array([xx.flatten(),yy.flatten()]).T + points = points[rand.permutation(numx*numy)[0:num_points],:] + + distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2) + graph = nx.Graph(distances<=np.sqrt(2))#+1E-10) + + graph.remove_edges_from(nx.selfloop_edges(graph)) + print("GRAPH: ", graph.edges) + return points, graph + +def manual_snake_example(): + points=[] + + # 100 qubit sssssnakee--------------------------- + points.append([1,0]) + points.append([2,0]) + points.append([3,0]) + points.append([4,0]) + points.append([5,0]) + points.append([6,0]) + points.append([7,0]) + points.append([8,0]) + points.append([9,0]) + points.append([10,0]) + points.append([11,0]) + points.append([12,0]) + points.append([13,1]) + points.append([12,2]) + points.append([11,2]) + points.append([10,2]) + points.append([9,2]) + points.append([8,2]) + points.append([7,2]) + points.append([6,2]) + points.append([5,2]) + points.append([4,2]) + points.append([3,2]) + points.append([2,2]) + points.append([1,2]) + points.append([0,3]) + points.append([1,4]) + ## + points.append([2,4]) + points.append([3,4]) + points.append([4,4]) + points.append([5,4]) + points.append([6,4]) + points.append([7,4]) + points.append([8,4]) + points.append([9,4]) + points.append([10,4]) + points.append([11,4]) + points.append([12,4]) + points.append([13,5]) + points.append([12,6]) + points.append([11,6]) + points.append([10,6]) + points.append([9,6]) + points.append([8,6]) + points.append([7,6]) + points.append([6,6]) + points.append([5,6]) + points.append([4,6]) + points.append([3,6]) + points.append([2,6]) + points.append([1,6]) + points.append([0,7]) + points.append([1,8]) + ## + points.append([2,8]) + points.append([3,8]) + points.append([4,8]) + points.append([5,8]) + points.append([6,8]) + points.append([7,8]) + points.append([8,8]) + points.append([9,8]) + points.append([10,8]) + points.append([11,8]) + points.append([12,8]) + points.append([13,9]) + points.append([12,10]) + points.append([11,10]) + points.append([10,10]) + points.append([9,10]) + points.append([8,10]) + points.append([7,10]) + points.append([6,10]) + points.append([5,10]) + points.append([4,10]) + points.append([3,10]) + points.append([2,10]) + points.append([1,10]) + points.append([0,11]) + points.append([1,12]) + ## + points.append([2,12]) + points.append([3,12]) + points.append([4,12]) + points.append([5,12]) + points.append([6,12]) + points.append([7,12]) + points.append([8,12]) + points.append([9,12]) + points.append([10,12]) + points.append([11,12]) + points.append([12,12]) + points.append([13,13]) + points.append([12,14]) + points.append([11,14]) + points.append([10,14]) + points.append([9,14]) + points.append([8,14]) + points.append([7,14]) + points.append([6,14]) + points.append([5,14]) + points.append([4,14]) + #points.append([3,14]) + #points.append([2,14]) + #points.append([1,14]) + #points.append([0,15]) + #points.append([1,16]) + # + + #points2 = points.tolist() + #print("POINTS 2:", points2) + points=np.array(points) + #print("test: " , points[:0]) + # Generate a unit disk graph by thresholding distances between points. + distances = np.sqrt((points[:,0] - points[:,0,None])**2 + (points[:,1] - points[:,1,None])**2) + graph = nx.Graph(distances<=np.sqrt(2))#+1E-10) + + graph.remove_edges_from(nx.selfloop_edges(graph)) + print("GRAPH: ", graph.edges) + return points, graph + +def postprocess_MIS(G,results): + ''' + Removes vertices that violate the independent set condition + G - networkx graph + results - an AWS AnalogHamiltonianSimulationQuantumTaskResult + + returns + data_out - a list of bitstrings which are valid independent sets of G + ''' + data_out = [] + for measurement in results["measurements"]: # For each measurement... + pre_sequence = np.array(measurement["pre_sequence"]) + post_sequence = np.array(measurement["post_sequence"]) + if np.any(pre_sequence==0): continue # skip anyshots with defects + + bitstring = post_sequence + inds = np.nonzero(bitstring==0)[0] # Find indices of IS vertices + if len(inds) == 0: continue + subgraph = nx.subgraph(G,inds) # Generate a subgraph from those vertices. If the bitstring is an independent set, this subgraph has no edges. + inds2 = nx.maximal_independent_set(subgraph,seed=0) # Find the mIS of this subgraph. If there are no edges, it is the original bitstring. Else, it randomly chooses within each graph. + payload = np.ones(len(bitstring)) # Forge into the correct data structure (a list of 1s and 0s) + payload[inds2] = 0 + data_out.append(payload) + + if len(data_out) == 0: + raise ValueError("no independent sets found! increase number of shots.") + + return np.asarray(data_out) + +def analysis_MIS(graph,result_json, print_extra = True): + ''' + Helper function to analyze a MIS result and plot data + ''' + + post_bitstrings = np.array([q["post_sequence"] for q in result_json["measurements"]]) + pp_bitstrings = postprocess_MIS(graph, result_json) + + + IS_sizes = np.sum(1-pp_bitstrings,axis=1) + unique_IS_sizes,counts = np.unique(IS_sizes,return_counts=True) + + + if print_extra: + avg_no_pp = 'Average pre-processed size: {:0.4f}'.format( (1-post_bitstrings).sum(axis=1).mean() ) + print(avg_no_pp) + avg_pp = 'Average post-processed IS size: {:0.4f}'.format(IS_sizes.mean()) + print(avg_pp) + + if print_extra: + plt.bar(unique_IS_sizes,counts/counts.sum()) + plt.xticks(unique_IS_sizes) + plt.xlabel("IS sizes",fontsize=14) + plt.ylabel("probability",fontsize=14) + plt.show() + + return IS_sizes,pp_bitstrings + diff --git a/team_solutions/q/iQuHackDocumentation.pdf b/team_solutions/q/iQuHackDocumentation.pdf new file mode 100644 index 00000000..cf459c80 Binary files /dev/null and b/team_solutions/q/iQuHackDocumentation.pdf differ diff --git a/team_solutions/q/iQuHackPresentation.pdf b/team_solutions/q/iQuHackPresentation.pdf new file mode 100644 index 00000000..37feced8 Binary files /dev/null and b/team_solutions/q/iQuHackPresentation.pdf differ diff --git a/team_solutions/q/iquhack_utils.py b/team_solutions/q/iquhack_utils.py new file mode 100644 index 00000000..2a1c9819 --- /dev/null +++ b/team_solutions/q/iquhack_utils.py @@ -0,0 +1,279 @@ +import matplotlib.pyplot as plt +import matplotlib.gridspec as gridspec +from matplotlib.axes import Axes +import numpy as np +from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation +from braket.ahs.atom_arrangement import AtomArrangement,SiteType +import warnings +import networkx as nx +import json + +C6 = 5.42E-24 + +def is_IS(graph,node_types): + inds = np.argwhere(np.array(node_types)==0).ravel() + subgraph = nx.subgraph(graph,inds) + print(subgraph) + return subgraph.number_of_edges() == 0 + + +def find_UDG_radius(position, graph): + ''' + Computes the optimal unit disk radius for a particular set of positions and graph. + position - [N x 2] array of points + graph - network connectivity graph. This should be a unit disk graph. + + returns + radius - Optimal unit disk radius of the graph + rmin - Minimum distance + rmax - Maximum distance + ''' + + dists = np.sqrt((position[:,0,None] - position[:,0])**2 + + (position[:,1,None] - position[:,1])**2) + rmin = 0 + rmax = np.inf + for i in range(position.shape[0]): + for j in range(i+1,position.shape[0]): + if (i,j) in graph.edges: + if rmindists[i,j]: + rmax = dists[i,j] + + if rmin>rmax: + print(rmin,rmax) + raise BaseException("Graph is not a unit disk graph!") + + return np.sqrt(rmin*rmax),rmin,rmax + + return np.sqrt(rmin*rmax),rmin,rmax + + +def visualize_graph(ax,graph,pos_dict,node_colors = "#6437FF"): + """Visualize graph using networkx + + Args: + ax (matplotlib.axes.Axes): Axes object to plot graph on. + graph (networkx.Graph): Graph to be plotted + pos_dict (dict): dictionary containing the x,y coordiantes where the nodes are the keys. + node_colors (str or list, optional): Defaults to "#6437FF". The color(s) to color the nodes of the graph. + + """ + + ax.set_aspect('equal') + ax.axis('off') + + # pos_dict = {a:positions[a] for a in range(positions.shape[0])} + nx.draw_networkx_edges(graph,pos_dict,width=10/np.sqrt(len(graph.nodes)),ax=ax) + nx.draw_networkx_nodes(graph,pos_dict,node_size=1225/np.sqrt(len(graph.nodes)),node_color=node_colors,ax=ax) + + +def get_graph_from_blockade_radius(register : AtomArrangement, blockade_radius:float): + """Get graph based on blockade radius. + + Args: + register (braket.ahs.atom_arrangement.AtomArrangement): register for analog quantum simulation. + blockade_radius (float): the blockade radius calculated using (C_6/final_detuning)^(1/6). + + Returns: + networkx.Graph: The graph of the effective unit disk graph set by the blockade radius. + """ + filled_sites = [site.coordinate for site in register if site.site_type == SiteType.FILLED] + graph = nx.Graph() + + positions = {n:c for n,c in enumerate(filled_sites)} + + graph.add_nodes_from(positions.keys()) + + for n,r_1 in positions.items(): + for m,r_2 in positions.items(): + if n <= m: continue + dist = np.linalg.norm(np.array(r_1)-np.array(r_2)) + if dist < blockade_radius: + graph.add_edge(n,m) + + return graph,positions + + +def get_blockade_radius(detuning: float, rabi: float) -> float: + """calculate Blockade Radius given the detuning and rabi amplitude. + + Args: + detuning (float): detuning value. + ravi (float): rabi value + Returns: + float: blockade radius + """ + + demon = np.sqrt(detuning**2+rabi**2) + if demon > 0: + return (C6/demon)**(1/6) + else: + return np.inf + + + +def plot_task_results( + ahs_program : AnalogHamiltonianSimulation, + n_shots : int, + pre_processed_shot : list[int], + post_processed_shot : list[int], +): + """function to generate figure summarizing iQuHack task results. + + Args: + ahs_program (AnalogHamiltonianSimulation): Braket AHS program used to generate shots + n_shots (int): number of shots for Task + pre_processed_shot (list[int]): The list showing the independent set before post processing, + post_processed_shot (list[int]): The list showing the independent set after post processing + """ + + fig = plt.figure(tight_layout=True,figsize=(9,6)) + gs = gridspec.GridSpec(6, 3) + + graph_axs = [ + fig.add_subplot(gs[0:3, 2]), + fig.add_subplot(gs[3:6, 2]) + ] + + drive_axs = [ + fig.add_subplot(gs[0:2, 0:2]), + fig.add_subplot(gs[2:4, 0:2]), + fig.add_subplot(gs[4:6, 0:2]) + ] + + drive_axs[0].sharex(drive_axs[1]) + drive_axs[1].sharex(drive_axs[2]) + + + register = ahs_program.register + drive = ahs_program.hamiltonian + + data = { + 'amplitude [rad/s]': drive.amplitude.time_series, + 'detuning [rad/s]': drive.detuning.time_series, + 'phase [rad]': drive.phase.time_series, + } + + detuning_data = list(data['detuning [rad/s]'].values()) + blockade_radius = get_blockade_radius(detuning_data[-1],0) + + + + graph,positions = get_graph_from_blockade_radius(register,blockade_radius) + + + for ax, data_name in zip(drive_axs, data.keys()): + ax.tick_params('both',direction='in') + ax.tick_params('x',top=True) + ax.tick_params('y',left=True) + + if data_name == 'phase [rad]': + ax.step(data[data_name].times(), data[data_name].values(), '.-', where='post') + else: + ax.plot(data[data_name].times(), data[data_name].values(), '.-') + ax.xaxis.set_ticklabels([]) + + ax.set_ylabel(data_name) + ax.grid(ls=':') + ax.set_xlabel("time (s)") + + color = { + 0:'red', + 1:'black' + } + + pre_processed_shot = [s for s,site in zip(pre_processed_shot,register) if site.site_type == SiteType.FILLED] + post_processed_shot = [s for s,site in zip(post_processed_shot,register) if site.site_type == SiteType.FILLED] + + shots = [ + pre_processed_shot, + post_processed_shot + ] + + titles = [ + "pre-processed", + "post-processed" + ] + + if not is_IS(graph,post_processed_shot): + warnings.warn("'post_processed_shot' is not a valid independent set of the effective graph.") + + + for (ax,shot,title) in zip(graph_axs,shots,titles): + colors = [color[s] for s in shot] + visualize_graph(ax,graph,positions,colors) + ax.title.set_text(title) + + fig.tight_layout() + fig.subplots_adjust(hspace=0.25) + fig.suptitle(f'number of shots: {n_shots}') + return fig,drive_axs,graph_axs + + +def generate_test_program(Nx,Ny,lattice_spacing=6.5e-6): + from quera_ahs_utils.drive import get_drive + + + register = AtomArrangement() + for ix in range(Nx): + for iy in range(Ny): + x = ix * lattice_spacing + y = iy * lattice_spacing + register.add((x,y)) + + + time_points = [0, 2.5e-7, 2.75e-6, 3e-6] + amplitude_min = 0 + amplitude_max = 1.57e7 # rad / s + + detuning_min = -5.5e7 # rad / s + detuning_max = 5.5e7 # rad / s + + amplitude_values = [amplitude_min, amplitude_max, amplitude_max, amplitude_min] # piece-wise linear + detuning_values = [detuning_min, detuning_min, detuning_max, detuning_max] # piece-wise linear + phase_values = [0, 0, 0, 0] # piece-wise constant + + + drive = get_drive(time_points, amplitude_values, detuning_values, phase_values) + + return AnalogHamiltonianSimulation( + register=register, + hamiltonian=drive + ) + +def save_result_json(json_file,result): + ''' + Helper function to save results locally + ''' + result_dict = {"measurements":[]} + for measurement in result.measurements: + shot_result = { + "pre_sequence":[int(qubit) for qubit in measurement.pre_sequence], + "post_sequence":[int(qubit) for qubit in measurement.post_sequence] + } + result_dict["measurements"].append(shot_result) + + with open(json_file,"w") as io: + json.dump(result_dict,io,indent=2) + +def open_json(json_file): + ''' + Helper function to load and open json data + ''' + with open(json_file,"r") as io: + return json.load(io) + +if __name__ == '__main__': + L = 10 + ahs_program = generate_test_program(L,L,lattice_spacing=4e-6) + pre_processed_shot = list(np.random.randint(2,size=L*L)) + post_processed_shot = list(np.random.randint(2,size=L*L)) + + fig,drive_axs,graph_axs = plot_task_results( + ahs_program,100,pre_processed_shot,post_processed_shot + ) + + plt.show() diff --git a/team_solutions/q/qaoa.py b/team_solutions/q/qaoa.py new file mode 100644 index 00000000..12f96482 --- /dev/null +++ b/team_solutions/q/qaoa.py @@ -0,0 +1,146 @@ +import numpy as np +import json +import matplotlib.pyplot as plt +from pprint import pprint as pp +import networkx as nx +from scipy.optimize import minimize + +from braket.aws import AwsDevice +from braket.devices import LocalSimulator + +from quera_ahs_utils.plotting import show_global_drive +from quera_ahs_utils.drive import get_drive + +from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation + +qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila") + +# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice. +capabilities = qpu.properties.paradigm + +# get C6 coefficient in rad m^6/sec Pull from capabilities attribute +C6 = float(capabilities.rydberg.dict()['c6Coefficient']) + +# Some variables storing device information +max_time = float(capabilities.rydberg.dict()['rydbergGlobal']['timeMax']) +time_res = float(capabilities.rydberg.dict()['rydbergGlobal']['timeResolution']) + +max_rabi = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyRange'][1]) +rabi_res = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyResolution']) + +max_detuning = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningRange'][1]) +detuning_res = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningResolution']) + +max_slew_rate = min( + float(capabilities.rydberg.dict()['rydbergGlobal']['detuningSlewRateMax']), + float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencySlewRateMax']) +) +ramp_time = max_rabi/max_slew_rate # run = slope/rise. This is greater than time res + +def get_ham_values(params): + ''' + Generates the time-dependent values of the parameters of the Hamiltonian + params: The parameters storing the duration of each pulse + + Returns + time_points: :ist of points along the t-axis where the value of a Hamiltonian paramter changes + amplitude_values: the values of omega at key points in time + detuning_values: the values of delta at key points in time + phase_values: the value of the phase at key points in time + ''' + + # Based on device + max_rabi = 15800000.0 + max_detuning = 125000000.0 + ramp_time = max_rabi/2500000000000000.0 + + # Initialize variables + p = int(len(params)/2) + time_points = [0] + amplitude_values = [0] + detuning_values = [max_detuning] + phase_values = [0] + time_count = 0 + + # Fill in lists according to params + for i in range(0,p,2): + time_points.extend([ + time_count+ramp_time, time_count+ramp_time + params[i], + time_count+ramp_time+params[i] + ramp_time, time_count+ramp_time+params[i] + ramp_time + params[i+1] + ]) + + time_count = time_points[-1] + + amplitude_values.extend([max_rabi*(i+1)/p, max_rabi*(i+1)/p, 0, 0]) + detuning_values.extend([0, 0, max_detuning*(i+1)/p, max_detuning*(i+1)/p]) + phase_values.extend([np.pi*(i+1)/p, 0, -1*np.pi*(i+1)/p, 0]) + + return time_points, amplitude_values, detuning_values, phase_values + + +def objective(params): + ''' + The objective function that the classical optimizer minimzes the parameters of. + Runs evolution by given paramters + + params: a list of points in time, in picoseconds (so that the number is large enough for scipy to optimize). + ''' + + scaled_params = [elem*10**(-6) for elem in params] # convert to microseconds + time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_params) + # Define the drive + drive = get_drive(time_points, amplitude_values, detuning_values, phase_values) + #show_global_drive(drive); + + small_ahs_program = AnalogHamiltonianSimulation( + register=small_register, + hamiltonian=drive + ) + + # Define Device + device = LocalSimulator("braket_ahs") + small_ahs_run = device.run(small_ahs_program, shots=1000) + + # Run + result = small_ahs_run.result() + + # Store results in json string + result_dict = {"measurements":[]} + for measurement in result.measurements: + shot_result = { + "pre_sequence":[int(qubit) for qubit in measurement.pre_sequence], + "post_sequence":[int(qubit) for qubit in measurement.post_sequence] + } + result_dict["measurements"].append(shot_result) + + #json.dumps(result_dict,io,indent=2) # dumps instead of dump to avoid saving file + + IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_dict, print_extra=False) + return -1*IS_sizes.mean() # Multiply by -1 since we want to minimze rather than maximize + +# Constraint to ensure total time falls within maximum allowable time +def enforce_time_bound(x): + return 0.000004*(10**6) - (sum(x) + (15800000.0*(10**6)/250000000000000.0)*(len(x))) + +# Constraint to ensure all time durations are positive +def enforce_positive_params(x): + for elem in x: + if elem < 0: + return -1 # penalty for negative parameter + + return 1 + +# Constraint Dictionary +cons = ( + { + 'type': 'ineq', + 'fun': enforce_time_bound # sum of times must be less than max time + }, + { + 'type': 'ineq', + 'fun': enforce_positive_params + } +) + +if __name__ == '__main__': + pp(capabilities.dict()) \ No newline at end of file diff --git a/team_solutions/q/qaoa_tests.ipynb b/team_solutions/q/qaoa_tests.ipynb new file mode 100644 index 00000000..6cb0a985 --- /dev/null +++ b/team_solutions/q/qaoa_tests.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b08fdd8e-e73e-4102-a256-677d80441e87", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], + "source": [ + "!qbraid jobs enable amazon_braket\n", + "import numpy as np\n", + "import json\n", + "import matplotlib.pyplot as plt\n", + "from pprint import pprint as pp\n", + "import networkx as nx\n", + "from scipy.optimize import minimize\n", + "import json\n", + "\n", + "from braket.aws import AwsDevice\n", + "from braket.devices import LocalSimulator\n", + "\n", + "from braket.timings.time_series import TimeSeries\n", + "from braket.ahs.driving_field import DrivingField" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fa5f926e-5fde-43e8-ad45-623ae3f8874d", + "metadata": {}, + "outputs": [], + "source": [ + "from qaoa import *\n", + "from iquhack_utils import *\n", + "from graph_tools import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5c8a545-5ddb-4f7a-ab0f-afe4e46f66db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'braketSchemaHeader': {'name': 'braket.device_schema.quera.quera_ahs_paradigm_properties',\n", + " 'version': '1'},\n", + " 'lattice': {'area': {'height': Decimal('0.000076'),\n", + " 'width': Decimal('0.000075')},\n", + " 'geometry': {'numberSitesMax': 256,\n", + " 'positionResolution': Decimal('1E-7'),\n", + " 'spacingRadialMin': Decimal('0.000004'),\n", + " 'spacingVerticalMin': Decimal('0.000004')}},\n", + " 'performance': {'lattice': {'positionErrorAbs': Decimal('1E-7')},\n", + " 'rydberg': {'rydbergGlobal': {'rabiFrequencyErrorRel': Decimal('0.02')}}},\n", + " 'qubitCount': 256,\n", + " 'rydberg': {'c6Coefficient': Decimal('5.42E-24'),\n", + " 'rydbergGlobal': {'detuningRange': (Decimal('-125000000.0'),\n", + " Decimal('125000000.0')),\n", + " 'detuningResolution': Decimal('0.2'),\n", + " 'detuningSlewRateMax': Decimal('2500000000000000.0'),\n", + " 'phaseRange': (Decimal('-99.0'),\n", + " Decimal('99.0')),\n", + " 'phaseResolution': Decimal('5E-7'),\n", + " 'rabiFrequencyRange': (Decimal('0.0'),\n", + " Decimal('15800000.0')),\n", + " 'rabiFrequencyResolution': Decimal('400.0'),\n", + " 'rabiFrequencySlewRateMax': Decimal('250000000000000.0'),\n", + " 'timeDeltaMin': Decimal('5E-8'),\n", + " 'timeMax': Decimal('0.000004'),\n", + " 'timeMin': Decimal('0.0'),\n", + " 'timeResolution': Decimal('1E-9')}}}\n" + ] + } + ], + "source": [ + "qpu = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/quera/Aquila\")\n", + "\n", + "# Capabilities, constraints and performance metrics are stored as 'paradigm' attribute of AwsDevice.\n", + "capabilities = qpu.properties.paradigm\n", + "pp(capabilities.dict())\n", + "\n", + "# get C6 coefficient in rad m^6/sec Pull from capabilities attribute\n", + "C6 = float(capabilities.rydberg.dict()['c6Coefficient'])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c9463c6f-474b-44da-bb2c-b8a20357ae88", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GRAPH: [(0, 3), (0, 5), (0, 6), (1, 2), (1, 3), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (4, 5), (5, 6)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Make a small king's graph\n", + "pos,small_G = kings_graph(3,3,0.8,seed = 1)\n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e6d08537-dabd-4c8a-9d6f-e76dcced7cb2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Find unit disk radius\n", + "unitdisk_radius,min_radius,max_radius = find_UDG_radius(pos,small_G)\n", + "\n", + "# Visualize using networkx\n", + "fig = plt.figure()\n", + "ax = plt.subplot(1,1,1)\n", + "visualize_graph(ax,small_G,pos)\n", + "\n", + "\n", + "# Draw the minimum and maximum unit disk radius of the graph\n", + "x0,y0 = (2,0)\n", + "angles = np.linspace(np.pi/2,np.pi,1001)\n", + "ax.plot(min_radius*np.cos(angles)+x0,min_radius*np.sin(angles)+y0,\n", + " linestyle=\":\",color=\"red\",label=\"$R_{min}$\")\n", + "ax.plot(unitdisk_radius*np.cos(angles)+x0,unitdisk_radius*np.sin(angles)+y0,\n", + " linestyle=\"--\",color=\"red\",label=\"$\\sqrt{R_{max}R_{min}}$\")\n", + "ax.plot(max_radius*np.cos(angles)+x0,max_radius*np.sin(angles)+y0,\n", + " linestyle=\"-\",color=\"red\",label=\"$R_{max}$\")\n", + "\n", + "ax.scatter(x0,y0,color=\"red\",zorder=3,marker=\"o\",s=350)\n", + "ax.set_xlim((-0.25,3))\n", + "plt.legend(loc=\"upper right\",)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3a9924cd-9e62-45d8-bd14-5fe7a3b5b01b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blockade radius of Rydberg system is 8.044e-06m\n", + "Unit disk radius of logical graph is 1.682\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Delta_final = 20e6 # rad/sec\n", + "\n", + "# Find blockade radius\n", + "blockade_radius = get_blockade_radius(Delta_final, 0) # no rabi amplitude at the end\n", + "print('Blockade radius of Rydberg system is {:0.3e}m'.format(blockade_radius))\n", + "print('Unit disk radius of logical graph is {:0.3f}'.format(unitdisk_radius))\n", + "\n", + "# Compute scaling value a, which converts between logical and physical coordinates\n", + "a = blockade_radius / unitdisk_radius\n", + "\n", + "# Generate the atom register\n", + "from braket.ahs.atom_arrangement import AtomArrangement\n", + "small_register = AtomArrangement()\n", + "for x in pos:\n", + " small_register.add((a * x).round(7))\n", + " \n", + " \n", + "from quera_ahs_utils.plotting import show_register\n", + "show_register(small_register,blockade_radius = a*1.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e1c56b2f-cb37-4722-b222-a4a049a5d1c7", + "metadata": {}, + "outputs": [], + "source": [ + "# QAOA \n", + "max_time = float(capabilities.rydberg.dict()['rydbergGlobal']['timeMax'])\n", + "time_res = float(capabilities.rydberg.dict()['rydbergGlobal']['timeResolution'])\n", + "\n", + "max_rabi = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyRange'][1])\n", + "rabi_res = float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencyResolution'])\n", + "\n", + "max_detuning = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningRange'][1])\n", + "detuning_res = float(capabilities.rydberg.dict()['rydbergGlobal']['detuningResolution'])\n", + "\n", + "max_slew_rate = min(\n", + " float(capabilities.rydberg.dict()['rydbergGlobal']['detuningSlewRateMax']),\n", + " float(capabilities.rydberg.dict()['rydbergGlobal']['rabiFrequencySlewRateMax'])\n", + ")\n", + "ramp_time = max_rabi/max_slew_rate # run = slope/rise. This is greater than time res\n", + "\n", + "p = 3\n", + "time_without_ramps = max_time - 2*ramp_time*p\n", + "init_params = [(max_time - time_without_ramps)/6 for i in range(2*p)] # default params [mixer, cost]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d722448a-41fc-4f32-9d2e-5bda92dcb745", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average post-processed IS size: 1.4765\n", + "Average post-processed IS size: 1.4960\n", + "Average post-processed IS size: 1.6354\n", + "Average post-processed IS size: 1.7327\n", + "Average post-processed IS size: 1.0000\n", + "Average post-processed IS size: 1.0294\n", + "Average post-processed IS size: 1.0357\n", + "Average post-processed IS size: 1.8509\n", + "Average post-processed IS size: 1.8890\n", + "Average post-processed IS size: 1.0000\n", + "Average post-processed IS size: 1.6622\n", + "Average post-processed IS size: 1.0000\n", + "Average post-processed IS size: 1.7475\n", + "Average post-processed IS size: 2.1155\n", + "Average post-processed IS size: 1.6315\n" + ] + } + ], + "source": [ + "# Constraint to ensure total time falls within maximum allowable time\n", + "def enforce_time_bound(x):\n", + " return 0.000004*(10**6) - (sum(x) + (15800000.0*(10**6)/250000000000000.0)*(len(x)))\n", + "\n", + "# Constraint to ensure all time durations are positive\n", + "def enforce_positive_params(x):\n", + " for elem in x:\n", + " if elem < 0:\n", + " return -1 # penalty for negative parameter\n", + " \n", + " return 1\n", + "\n", + "def objective(params):\n", + " '''\n", + " The objective function that the classical optimizer minimzes the parameters of.\n", + " Runs evolution by given paramters\n", + " \n", + " params: a list of points in time, in picoseconds (so that the number is large enough for scipy to optimize). \n", + " '''\n", + " \n", + " scaled_params = [elem*10**(-6) for elem in params] # convert to microseconds\n", + " \n", + " # Check if constraints are violated\n", + " for i in range(len(params)):\n", + " if params[i] < 0:\n", + " params[i] = 0\n", + " \n", + " if enforce_time_bound(params) < 0:\n", + " for i in range(len(scaled_params)):\n", + " scaled_params[i] = abs(0.000004*scaled_params[i]/((15800000.0*(10**6)/250000000000000.0)*(len(x))))\n", + " \n", + " time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_params)\n", + " # Define the drive\n", + " drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + " #show_global_drive(drive);\n", + " \n", + " small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + " )\n", + " \n", + " # Define Device\n", + " device = LocalSimulator(\"braket_ahs\")\n", + " small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + " \n", + " # Run\n", + " result = small_ahs_run.result()\n", + " \n", + " # Store results in json string\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " #json.dumps(result_dict,io,indent=2) # dumps instead of dump to avoid saving file\n", + " \n", + " IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_dict, print_extra=False)\n", + " return -1*IS_sizes.mean() # Multiply by -1 since we want to minimze rather than maximize\n", + "\n", + "# Constraint Dictionary\n", + "cons = (\n", + " {\n", + " 'type': 'ineq', \n", + " 'fun': enforce_time_bound # sum of times must be less than max time\n", + " },\n", + " {\n", + " 'type': 'ineq',\n", + " 'fun': enforce_positive_params\n", + " }\n", + ")\n", + "\n", + "init_params = [elem*10**6 for elem in init_params]\n", + "optimized_params = minimize(objective, init_params, method='COBYLA', constraints = cons, options = {'maxiter': 15})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2ae63fd9-7690-4fef-a129-e00f0c1f58b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scaled_optimal_params = [elem*(10**-6) for elem in optimized_params['x']]\n", + "time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_optimal_params)\n", + "\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);\n", + "\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")\n", + "\n", + "device = LocalSimulator(\"braket_ahs\")\n", + "small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + "\n", + "\n", + "# Results are loaded and saved to file\n", + "result = small_ahs_run.result()\n", + "save_result_json(\"classical_results/small_kings_graph_mis_trial_1.json\",result)\n", + "\n", + "trial_file = \"classical_results/small_kings_graph_mis_trial_1.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "633e6212-9fb3-40fa-905a-e2d9e6014c38", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average pre-processed size: 2.0470\n", + "Average post-processed IS size: 2.1029\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d61d9764-6b4f-47fa-be3d-d29df970cb11", + "metadata": {}, + "outputs": [], + "source": [ + "def objective_qpu(params):\n", + " scaled_params = [elem*10**(-6) for elem in params]\n", + " time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_params)\n", + " # Define the drive\n", + " \n", + " # Check if constraints are violated\n", + " for i in range(len(params)):\n", + " if params[i] < 0:\n", + " params[i] = 0\n", + " \n", + " if enforce_time_bound(params) < 0:\n", + " for i in range(len(scaled_params)):\n", + " scaled_params[i] = abs(0.000004*scaled_params[i]/((15800000.0*(10**6)/250000000000000.0)*(len(x))))\n", + " \n", + " drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + " #show_global_drive(drive);\n", + " \n", + " small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + " )\n", + " \n", + " # Define Device\n", + " #device = LocalSimulator(\"braket_ahs\")\n", + " device = qpu\n", + " small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + " \n", + " # Run\n", + " result = small_ahs_run.result()\n", + " result_json = open_json(\"qaoa.json\")\n", + " nmeas = len(result_json[\"measurements\"])\n", + " seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,nmeas-2,nmeas-1]]\n", + " \n", + " # Store results in json string\n", + " result_dict = {\"measurements\":[]}\n", + " for measurement in result.measurements:\n", + " shot_result = {\n", + " \"pre_sequence\":[int(qubit) for qubit in measurement.pre_sequence],\n", + " \"post_sequence\":[int(qubit) for qubit in measurement.post_sequence]\n", + " } \n", + " result_dict[\"measurements\"].append(shot_result)\n", + " \n", + " #json.dumps(result_dict,io,indent=2) # dumps instead of dump to avoid saving file\n", + " \n", + " IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_dict, print_extra=False)\n", + " return -1*IS_sizes.mean() # Multiply by -1 since we want to minimze rather than maximize\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac62f35c-1e8a-44a5-a642-f35b24aba854", + "metadata": {}, + "outputs": [], + "source": [ + "scaled_optimal_params = [elem*(10**-6) for elem in optimized_params['x']]\n", + "time_points, amplitude_values, detuning_values, phase_values = get_ham_values(scaled_optimal_params)\n", + "\n", + "drive = get_drive(time_points, amplitude_values, detuning_values, phase_values)\n", + "show_global_drive(drive);\n", + "\n", + "small_ahs_program = AnalogHamiltonianSimulation(\n", + " register=small_register, \n", + " hamiltonian=drive\n", + ")\n", + "\n", + "device = qpu\n", + "small_ahs_run = device.run(small_ahs_program, shots=1000)\n", + "\n", + "\n", + "# Results are loaded and saved to file\n", + "result = small_ahs_run.result()\n", + "save_result_json(\"classical_results/small_kings_graph_mis_trial_1.json\",result)\n", + "\n", + "trial_file = \"classical_results/small_kings_graph_mis_trial_1.json\"\n", + "result_json = open_json(trial_file)\n", + "nmeas = len(result_json[\"measurements\"]) \n", + "seqs = [result_json[\"measurements\"][i][\"post_sequence\"] for i in [0,1,nmeas-1]]\n", + "\n", + "fig = plt.figure(figsize=(25,15))\n", + "\n", + "for i in range(3):\n", + " ax = plt.subplot(1,3,i+1)\n", + " \n", + " color_lookup = {0:\"r\",1:'k'}\n", + " seqs_color = [color_lookup[seqs[i][j]] for j in range(len(seqs[i]))]\n", + " visualize_graph(ax,small_G,pos,node_colors = seqs_color)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce56f419-7632-45f7-b11f-d55a44594a43", + "metadata": {}, + "outputs": [], + "source": [ + "IS_sizes,pp_bitstrings = analysis_MIS(small_G,result_json)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "585b132d-6bbe-4b3e-98c7-9e2eb6998a56", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Braket]", + "language": "python", + "name": "python3_aws_braket_kwx6dl" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/team_solutions/team_solutions.md b/team_solutions/team_solutions.md index 1a1c42c8..191a1a4b 100644 --- a/team_solutions/team_solutions.md +++ b/team_solutions/team_solutions.md @@ -1,6 +1,20 @@ -# List of Challenges +# QuEra Challenge iQuHack 2023 -### Sample Team +### Team *Q* +Corey Ferrier, Avneesh Verma, Dhruv Srinivasan, Jade LeSchack, Jyoti Rani + + +#### Code + +- [99 qubit random shape](q/99_qubits_random.ipynb) + +- [100 qubit snake](q/100_qubit_snake.ipynb) + +- [QAOA Tests](q/qaoa_tests.ipynb) + +#### Documentation + +- [Documentation](q/iQuHackDocumentation.pdf) + +- [Presentation](q/iQuHackPresentation.pdf) -- [Code](TEAM_NAME) -- [Documentation](https://url_to_documentation.com) \ No newline at end of file diff --git a/tutorial/.ipynb_checkpoints/AWS_optimization_demo-checkpoint.ipynb b/tutorial/.ipynb_checkpoints/AWS_optimization_demo-checkpoint.ipynb index ef9c65b6..0d2d4f95 100644 --- a/tutorial/.ipynb_checkpoints/AWS_optimization_demo-checkpoint.ipynb +++ b/tutorial/.ipynb_checkpoints/AWS_optimization_demo-checkpoint.ipynb @@ -2,10 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], "source": [ + "!qbraid jobs enable amazon_braket\n", + "\n", "import numpy as np\n", "import json\n", "import matplotlib.pyplot as plt\n", @@ -23,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -1026,9 +1036,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3 [Braket]", "language": "python", - "name": "python3" + "name": "python3_aws_braket_kwx6dl" }, "language_info": { "codemirror_mode": { @@ -1040,7 +1050,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/tutorial/.ipynb_checkpoints/jyoti-checkpoint.ipynb b/tutorial/.ipynb_checkpoints/jyoti-checkpoint.ipynb new file mode 100644 index 00000000..b8c8a37d --- /dev/null +++ b/tutorial/.ipynb_checkpoints/jyoti-checkpoint.ipynb @@ -0,0 +1,51 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "87bfeccb-4ebd-47f9-91ba-48341c9b7a59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yay\n" + ] + } + ], + "source": [ + "print(\"yay\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f39635a-5996-4729-a94b-c4c20bcd099e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/AWS_optimization_demo.ipynb b/tutorial/AWS_optimization_demo.ipynb index ef9c65b6..86839d1b 100644 --- a/tutorial/AWS_optimization_demo.ipynb +++ b/tutorial/AWS_optimization_demo.ipynb @@ -2,10 +2,20 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;35mYou have already enabled qBraid Quantum Jobs in the amazon_braket environment.\u001b[0m\n" + ] + } + ], "source": [ + "!qbraid jobs enable amazon_braket\n", + "\n", "import numpy as np\n", "import json\n", "import matplotlib.pyplot as plt\n", @@ -13,6 +23,21 @@ "import networkx as nx" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Interfacing with Aquila\n", + "Import AwsDevice and use it to obtain a handle to the Aquila resource by ARN identifier. Get device properties, such as parameter constraints and the C6 coeffiecient quantifying the Rydberg interaction." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -23,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -112,9 +137,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -170,14 +195,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -255,26 +280,26 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Blockade radius of Rydberg system is 8.044e-06m\n", - "Unit disk radius of logical graph is 1.682\n" + "Blockade radius of Rydberg system is 8.044e-06m\n" ] }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'unitdisk_radius' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 7\u001b[0m\n\u001b[1;32m 5\u001b[0m blockade_radius \u001b[38;5;241m=\u001b[39m get_blockade_radius(Delta_final, \u001b[38;5;241m0\u001b[39m) \u001b[38;5;66;03m# no rabi amplitude at the end\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mBlockade radius of Rydberg system is \u001b[39m\u001b[38;5;132;01m{:0.3e}\u001b[39;00m\u001b[38;5;124mm\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(blockade_radius))\n\u001b[0;32m----> 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mUnit disk radius of logical graph is \u001b[39m\u001b[38;5;132;01m{:0.3f}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\u001b[43munitdisk_radius\u001b[49m))\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# Compute scaling value a, which converts between logical and physical coordinates\u001b[39;00m\n\u001b[1;32m 10\u001b[0m a \u001b[38;5;241m=\u001b[39m blockade_radius \u001b[38;5;241m/\u001b[39m unitdisk_radius\n", + "\u001b[0;31mNameError\u001b[0m: name 'unitdisk_radius' is not defined" + ] } ], "source": [ @@ -314,18 +339,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 1, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'Delta_final' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 10\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m# Define the strength of the detuning Δ\u001b[39;00m\n\u001b[1;32m 9\u001b[0m Delta_initial \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m20e6\u001b[39m \u001b[38;5;66;03m# rad / sec\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m Delta_final \u001b[38;5;241m=\u001b[39m \u001b[43mDelta_final\u001b[49m \u001b[38;5;66;03m# Defined above\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;66;03m# Define the total drive\u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mquera_ahs_utils\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mplotting\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m show_global_drive\n", + "\u001b[0;31mNameError\u001b[0m: name 'Delta_final' is not defined" + ] } ], "source": [ @@ -364,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -386,7 +412,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -432,14 +458,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB6UAAAJNCAYAAAB5mKCfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABwT0lEQVR4nO3dd5wlZZ3o/+8JE2DIAiIiMChRiYMCKyqDKAiKeq8BECRIEIYg7m9Z1xUVw92rK6AOiIEMuuxVQUQJLkuQUUkDCMoAI4ggBpQhx+nu8/uj98AMTOhwqup5Tr3fr1e/wO7T51vtcOZU16fqqUan0+kEAAAAAAAAABSgWfUGAAAAAAAAANC/RGkAAAAAAAAACiNKAwAAAAAAAFAYURoAAAAAAACAwojSAAAAAAAAABRGlAYAAAAAAACgMKI0AAAAAAAAAIURpQEAAAAAAAAojCgNAAAAAAAAQGFEaQAAAAAAAAAKI0oDAAAAAAAAUBhRGgAAAAAAAIDCiNIAAAAAAAAAFEaUBgAAAAAAAKAwojQAAAAAAAAAhRGlAQAAAAAAACiMKA0AAAAAAABAYURpAAAAAAAAAAojSgMAAAAAAABQGFEaAAAAAAAAgMKI0gAAAAAAAAAURpQGAAAAAAAAoDCiNAAAAAAAAACFEaUBAAAAAAAAKIwoDQAAAAAAAEBhRGkAAAAAAAAACiNKAwAAAAAAAFAYURoAAAAAAACAwojSAAAAAAAAABRGlAYAAAAAAACgMKI0AAAAAAAAAIURpQEAAAAAAAAojCgNAAAAAAAAQGFEaQAAAAAAAAAKI0oDAAAAAAAAUBhRGgAAAAAAAIDCiNIAAAAAAAAAFEaUBgAAAAAAAKAwojQAAAAAAAAAhRGlAQAAAAAAACiMKA0AAAAAAABAYdpVbwDA008/HbfeemvMnj075syZE08++WQ0Go1YYYUV4nWve11MmzYtXvva18aECROq3lQAAGro0UcfjZtvvjlmz54dd999dzz99NPRbrdj5ZVXji222CKmTZsW66+/fjSbzvsGAKACDz4YMXv28Mcf/xjx7LMREyZEvPzlEVttFTFtWsSrXhXRaFS9pUCNidJAJTqdTlx99dVx8sknx49+9KMYGBiIRqMR7XY7Op1OREQ0Go2YP39+REQss8wy8aEPfShmzJgRW2yxRYVbDgBAHcyfPz9+/OMfx8yZM+Pqq6+OiIhmsxmtVmuR+6srr7xyHHzwwXHIIYfE1KlTK9tuAABq4sknI773vYivfz3iN78Z/lyrFdFsRnQ6wwG604kYGBj+2jrrRMyYEbH//hGrrlrddgO11eh0f5sGKMk111wTBx98cNxxxx3RbrdjoLtjtBTdx77xjW+M73znO7HxxhsXvKUAANRNp9OJ8847L44++uj461//Gq1WKwYHB0f0va1WK4aGhuJ973tfzJw5M17+8pcXvLUAANTOwEDECSdEfO5zEU89Nfy5kWaeZnM4XB9+eMQXvhCx7LLFbSfAi4jSQGmeeuqp+OQnPxlf//rXo9lsjvjg3ou1Wq1oNpvx+c9/Pv7xH/8x2m2LPgAAMH5//etf45BDDokLL7wwGo1GjPXX5VarFcstt1yccsopsccee0TDMokAAPTCnDkR++wTcdNNIw/Ri9JsRqy9dsTZZ0e86U292z6AJRClgVL87W9/i7e+9a3x29/+NoaGhnr2vO94xzvihz/8YSyzzDI9e04AAOrn9ttvj+nTp8dDDz005pMnF9SN2kcffXQcf/zxwjQAAONz2WUR7353xODgC0tyj0erFTE0FPGtb0UcdND4nw9gKURpoHAPPfRQvPGNb4y77757xEt1j1Sz2Yzp06fHT3/605g0aVJPnxsAgHqYM2dOvPGNb4zHHnusJ0H6xWbMmBEzZ84UpgEAGJtLL41417uGI3IPL/h53je/GXHIIb1/XoAFiNJAoQYHB+NNb3pT3HDDDT0P0l3NZjP23nvvOOusswp5fgAA+tfDDz8cr33ta+PBBx8sJEh3HX/88fHxj3+8sOcHAKBP/fa3EdOmRcyfX0yQjohoNCIuuSRi552LeX6AiGhWvQFAfzvxxBPjV7/6VWFBOiJiaGgozj777Pjxj39c2AwAAPrTUUcdVXiQjoj4xCc+EXPmzCl0BgAAfWZgYPge0oODxQXpiOEove++EY88UtwMoPZcKQ0U5s4774xNN9005s+fX/isZrMZq6yyStx5552xyiqrFD4PAID8/eQnP4l3vetdpcxqt9uxxRZbxLXXXhutVquUmQAAZO7//t+IT34yooyM02oNB/Azzih+FlBLrpQGCnPcccdFWee9DA0NxcMPPxwzZ84sZR4AAHnrdDpxzDHHRLNZzq/FAwMDceONN8aFF15YyjwAADL3+OMRn/98OUE6Yvhq7DPPjLjrrnLmAbUjSgOFePDBB+P73/9+oct2v9jg4GB84xvfKOXKbAAA8vaLX/wi5syZE0NFLoP4Iq1WK0466aTS5gEAkLFzz414+ulyZ7ZaEd/8ZrkzgdoQpYFCnHbaaaUe4Ot68MEH46KLLip9LgAAeTn55JOj3W6XOnNwcDCuvPLKuMvVJwAALEmnE/H1r5c/d3Aw4tRTI556qvzZQN8TpYFC/PSnP60kSrfb7bj00ktLnwsAQD46nU5cfPHFpa7q09VoNOKyyy4rfS4AABn5058i7rijvKW7F/T44xHXX1/+XKDvidJAzw0NDcXNN99cyeyBgYG47rrrKpkNAEAe7r333njssccqmd1qtWL27NmVzAYAIBNV7i82m9XOB/qWKA303Ny5c+OpCpd4uf322+PZZ5+tbD4AAGmrMgoPDAzEtddeW9l8AAAyMHt2RMm3mnleoyFKA4UQpYGeu//++yudPzAwEA8++GCl2wAAQLruv//+aLValc1/4IEHKpsNAEAGqjy+OjgY8fvfVzcf6FuiNNBzKVyl/Mwzz1S9CQAAJOrZZ5+NRqNR6XwAAFisZ5+t5n7SXY6tAgUQpYGemzhxYtWbkMQ2AACQpgkTJkSnwoN8EyZMqGw2AAAZqHp/cdKkaucDfUmUBnputdVWq3R+o9GIl73sZZVuAwAA6Vp99dVjcHCwsvmrrrpqZbMBAMjA6qtHNCvKN81mxBprVDMb6GuiNNBzm2yySbTb7crmr7feerHccstVNh8AgLRttdVWlc1utVqxzTbbVDYfAIAMbLVVxPz51cxuNCKmTatmNtDXRGmg5yZOnBive93rKpndarVi2223rWQ2AAB52GijjWLy5MmVzZ/mIB8AAEtS5f7i4KAoDRRClAYKsdNOO0Wr1Sp97tDQUOywww6lzwUAIB+tViu23377SvZXBwcH7a8CALBkr351dUtot9sRLvoBCiBKA4U4+OCDK7lP37LLLht77LFH6XMBAMjLjBkzSt9fbTQa8brXvS7e8IY3lDoXAIDMNJsRhx1W/n2l2+2IPfaIWGWVcucCtSBKA4VYf/31S79aut1uxwEHHOB+0gAALNU73/nOWKOCq0+OPPLIaDQapc8FACAzBx44fH/nMg0MRMyYUe5MoDZEaaAwn/rUp0q9+qTVasXHPvax0uYBAJCvdrsdxx57bGnzms1mrLnmmrHXXnuVNhMAgIy94hXDYbqsi37a7Yi3vCVim23KmQfUjigNFOYtb3lLHHroodEsaZmZ4447LtZbb71SZgEAkL+PfvSjsf3220e73S581tDQUJxxxhkxZcqUwmcBANAnvvzliNVXL3wZ705EzI+IOOOM8q/OBmpDlAYK9eUvfzle+cpXlrKM9/nnnx+PPvpo4XMAAOgPzWYzzjrrrJgwYUIpJ1KeccYZMTAwUPgcAAD6xAorRJx5ZsTQUKFjGhFx5MBAfP7ccwudA9SbKA0UarnllotLL700ll9++cLD9PXXXx8777yzMA0AwIitt956cf7550ez2Sz8Xs//8R//ER/+8IeFaQAARu7tb4848cTCnr4TESdFxDcj4tOf/nR8/vOfL2wWUG+iNFC4TTbZJK666qpYccUVC18a8brrrhOmAQAYlV122SXOP//8aLfbhZ9IKUwDADBqH/tYxPHHD/97j06k7PzPP78REUcu8HlhGiiKKA2UYvPNN4/Zs2fHtttuO+7n6l7BsrgDhsI0AACj9a53vStmzZoVU6dOHfdS3q1Wa4lXXQvTAACM2sc/HnH++RErrRQxzhMpO+12DLTbMSMiDo8XAnWXMA0UQZQGSrPuuuvG1VdfHSeddFIss8wy0Wg0RrVEYvfg4Morrxw//OEP46qrrorllltukY8VpgEAGK03vOENceutt8Y//uM/RrPZHPVV093HT506NX75y1/GWWedtdj9XWEaAIBRe+97I+66K+J//+/h/z3aVSn/5/GN7baL9h13xPL//M+LfagwDfRao9PpvPgkGIDCzZs3L84666z4+te/Hvfee280Go1Y2l9Hm2++eRx11FHxwQ9+MJZddtmIiJg1a1a84x3viCeeeGKR37PNNtvEZZddFiuuuGLPfwYAAPrXfffdF9/+9rfjlFNOiXnz5kWz2YyhoaElfs9OO+0URxxxROy6667P37bm7LPPjv3222+x+7p77rlnnH322YXf5gYAgD5z220Rp5wSceaZEU8/HdFqxeDgYCx4WuXQ/3y0I4aD9PveFzFjRsQb3xjxP8dj/+Vf/iW+9KUvLXbM5z73uTj22GML/VGAehClgUoNDQ3FTTfdFDfeeGP8y7/8SzzyyCMLfX3llVeO448/PrbZZpvYZJNNFvkcwjQAAEV57rnn4tprr43Zs2fHZz/72XjssccW+voqq6wSJ598cmy33XaxzjrrLPI5hGkAAArz+OMRv/xlxOzZ8V//9m+xyhNPxOSIeC4i/hwR9666ahx26qkR//APEaut9pJvF6aBsojSQDI22WSTmDNnzkKf23jjjeP2229f6vcK0wAAFG08+6vCNAAARRvr/qowDZTBPaWBvrD99tvHJZdc4h7TAAAk6cMf/nCceeaZ7jENAEByGo1G/Nu//Vv8s3tMAwUSpYG+IUwDAJAyYRoAgFQJ00DRRGmgrwjTAACkTJgGACBVwjRQJFEa6DvCNAAAKROmAQBIlTANFEWUBvqSMA0AQMqEaQAAUiVMA0UQpYG+JUwDAJAyYRoAgFQJ00CvidJAXxOmAQBImTANAECqhGmgl0RpoO8J0wAApEyYBgAgVcI00CuiNFALwjQAACkTpgEASJUwDfSCKA3UhjANAEDKhGkAAFIlTAPjJUoDtSJMAwCQMmEaAIBUCdPAeIjSQO0I0wAApEyYBgAgVcI0MFaiNFBLwjQAACkTpgEASJUwDYyFKA3UljANAEDKhGkAAFIlTAOjJUoDtSZMAwCQMmEaAIBUCdPAaIjSQO0J0wAApEyYBgAgVcI0MFKiNEAI0wAApE2YBgAgVcI0MBKiNMD/EKYBAEiZMA0AQKqEaWBpRGmABQjTAACkTJgGACBVwjSwJKI0wIsI0wAApEyYBgAgVcI0sDiiNMAiCNMAAKRMmAYAIFXCNLAoojTAYgjTAACkTJgGACBVwjTwYqI0wBII0wAApEyYBgAgVcI0sCBRGmAphGkAAFImTAMAkCphGugSpQFGQJgGACBlwjQAAKkSpoEIURpgxIRpAABSJkwDAJAqYRoQpQFGQZgGACBlwjQAAKkSpqHeRGmAURKmAQBImTANAECqhGmoL1EaYAyEaQAAUiZMAwCQKmEa6kmUBhgjYRoAgJQJ0wAApEqYhvoRpQHGQZgGACBlwjQAAKkSpqFeRGmAcRKmAQBImTANAECqhGmoD1EaoAeEaQAAUiZMAwCQKmEa6kGUBugRYRoAgJQJ0wAApEqYhv4nSgP0kDANAEDKhGkAAFIlTEN/E6UBekyYBgAgZcI0AACpEqahf4nSAAUQpgEASJkwDQBAqoRp6E+iNEBBhGkAAFImTAMAkCphGvqPKA1QIGEaAICUCdMAAKRKmIb+IkoDFEyYBgAgZcI0AACpEqahf4jSACUQpgEASJkwDQBAqoRp6A+iNEBJhGkAAFImTAMAkCphGvInSgOUSJgGACBlwjQAAKkSpiFvojRAyYRpAABSJkwDAJAqYRryJUoDVECYBgAgZcI0AACpEqYhT6I0QEWEaQAAUiZMAwCQKmEa8iNKA1RImAYAIGXCNAAAqRKmIS+iNEDFhGkAAFImTAMAkCphGvIhSgMkQJgGACBlwjQAAKkSpiEPojRAIoRpAABSJkwDAJAqYRrSJ0oDJESYBgAgZcI0AACpEqYhbaI0QGKEaQAAUiZMAwCQKmEa0iVKAyRImAYAIGXCNAAAqRKmIU2iNECihGkAAFImTAMAkCphGtIjSgMkTJgGACBlwjQAAKkSpiEtojRA4oRpAABSJkwDAJAqYRrSIUoDZECYBgAgZcI0AACpEqYhDaI0QCaEaQAAUiZMAwCQKmEaqidKA2REmAYAIGXCNAAAqRKmoVqiNEBmhGkAAFImTAMAkCphGqojSgNkSJgGACBlwjQAAKkSpqEaojRApoRpAABSJkwDAJAqYRrKJ0oDZEyYBgAgZcI0AACpEqahXKI0QOaEaQAAUiZMAwCQKmEayiNKA/QBYRoAgJQJ0wAApEqYhnKI0gB9QpgGACBlwjQAAKkSpqF4ojRAHxGmAQBImTANAECqhGkoligN0GeEaQAAUiZMAwCQKmEaiiNKA/QhYRoAgJQJ0wAApEqYhmKI0gB9SpgGACBlwjQAAKkSpqH3RGmAPiZMAwCQMmEaAIBUCdPQW6I0QJ8TpgEASJkwDQBAqoRp6B1RGqAGhGkAAFImTAMAkCphGnpDlAaoCWEaAICUCdMAAKRKmIbxE6UBakSYBgAgZcI0AACpEqZhfERpgJoRpgEASJkwDQBAqoRpGDtRGqCGhGkAAFImTAMAkCphGsZGlAaoKWEaAICUCdMAAKRKmIbRE6UBakyYBgAgZcI0AACpEqZhdERpgJoTpgEASJkwDQBAqoRpGDlRGgBhGgCApAnTAACkSpiGkRGlAYgIYRoAgLQJ0wAApEqYhqUTpQF4njANAEDKhGkAAFIlTMOSidIALESYBgAgZcI0AACpEqZh8URpAF5CmAYAIGXCNAAAqRKmYdFEaQAWSZgGACBlwjQAAKkSpuGlRGkAFkuYBgAgZcI0AACpEqZhYaI0AEskTAMAkDJhGgCAVAnT8AJRGoClEqYBAEiZMA0AQKqEaRgmSgMwIsI0AAApE6YBAEiVMA2iNACjIEwDAJAyYRoAgFQJ09SdKA3AqAjTAACkTJgGACBVwjR1JkoDMGrCNAAAKROmAQBIlTBNXYnSAIyJMA0AQMqEaQAAUiVMU0eiNABjJkwDAJAyYRoAgFQJ09SNKA3AuAjTAACkTJgGACBVwjR1IkoDMG7CNAAAKROmAQBIlTBNXYjSAPSEMA0AQMqEaQAAUiVMUweiNAA9I0wDAJAyYRoAgFQJ0/Q7URqAnhKmAQBImTANAECqhGn6mSgNQM8J0wAApEyYBgAgVcI0/UqUBqAQwjQAACkTpgEASJUwTT8SpQEojDANAEDKhGkAAFIlTNNvRGkACiVMAwCQMmEaAIBUCdP0E1EagMIJ0wAApEyYBgAgVcI0/UKUBqAUwjQAACkTpgEASJUwTT8QpQEojTANAEDKhGkAAFIlTJM7URqAUgnTAACkTJgGACBVwjQ5E6UBKJ0wDQBAyoRpAABSJUyTK1EagEoI0wAApEyYBgAgVcI0ORKlAaiMMA0AQMqEaQAAUiVMkxtRGoBKCdMAAKRMmAYAIFXCNDkRpQGonDANAEDKhGkAAFIlTJMLURqAJAjTAACkTJgGACBVwjQ5EKUBSIYwDQBAyoRpAABSJUyTOlEagKQI0wAApEyYBgAgVcI0KROlAUiOMA0AQMqEaQAAUiVMkypRGoAkCdMAAKRMmAYAIFXCNCkSpQFIljANAEDKhGkAAFIlTJMaURqApAnTAACkTJgGACBVwjQpEaUBSJ4wDQBAyoRpAABSJUyTClEagCwI0wAApEyYBgAgVcI0KRClAciGMA0AQMqEaQAAUiVMUzVRGoCsCNMAAKRMmAYAIFXCNFUSpQHIjjANAEDKhGkAAFIlTFMVURqALAnTAACkTJgGACBVwjRVEKUByJYwDQBAyoRpAABSJUxTNlEagKwJ0wAApEyYBgAgVcI0ZRKlAcieMA0AQMqEaQAAUiVMUxZRGoC+IEwDAJAyYRoAgFQJ05RBlAagbwjTAACkTJgGACBVwjRFE6UB6CvCNAAAKROmAQBIlTBNkURpAPqOMA0AQMqEaQAAUiVMUxRRGoC+JEwDAJAyYRoAgFQJ0xRBlAagbwnTAACkTJgGACBVwjS9JkoD0NeEaQAAUiZMAwCQKmGaXhKlAeh7wjQAACkTpgEASJUwTa+I0gDUgjANAEDKhGkAAFIlTNMLojQAtSFMAwCQMmEaAIBUCdOMlygNQK0I0wAApEyYBgAgVcI04yFKA1A7wjQAACkTpgEASJUwzViJ0gDUkjANAEDKhGkAAFIlTDMWojQAtSVMAwCQMmEaAIBUCdOMligNQK0J0wAApEyYBgAgVcI0oyFKA1B7wjQAACkTpgEASJUwzUiJ0gAQwjQAAGkTpgEASJUwzUiI0gDwP4RpAABSJkwDAJAqYZqlEaUBYAHCNAAAKROmAQBIlTDNkojSAPAiwjQAACkTpgEASJUwzeKI0gCwCMI0AAApE6YBAEiVMM2iiNIAsBjCNAAAKROmAQBIlTDNi4nSALAEwjQAACkTpgEASJUwzYJEaQBYCmEaAICUCdMAAKRKmKZLlAaAERCmAQBImTANAECqhGkiRGkAGDFhGgCAlAnTAACkSphGlAaAURCmAQBImTANAECqhOl6E6UBYJSEaQAAUiZMAwCQKmG6vkRpABgDYRoAgJQJ0wAApEqYridRGgDGSJgGACBlwjQAAKkSputHlAaAcRCmAQBImTANAECqhOl6EaUBYJyEaQAAUiZMAwCQKmG6PkRpAOgBYRoAgJQJ0wAApEqYrgdRGgB6RJgGACBlwjQAAKkSpvufKA0APSRMAwCQMmEaAIBUCdP9TZQGgB4TpgEASJkwDQBAqoTp/iVKA0ABhGkAAFImTAMAkCphuj+J0gBQEGEaAICUCdMAAKRKmO4/ojQAFEiYBgAgZcI0AACpEqb7iygNAAUTpgEASJkwDQBAqoTp/iFKA0AJhGkAAFImTAMAkCphuj+I0gBQEmEaAICUCdMAAKRKmM6fKA0AJRKmAQBImTANAECqhOm8idIAUDJhGgCAlAnTAACkSpjOlygNABUQpgEASJkwDQBAqoTpPInSAFARYRoAgJQJ0wAApEqYzo8oDQAVEqYBAEiZMA0AQKqE6byI0gBQMWEaAICUCdMAAKRKmM6HKA0ACRCmAQBImTANAECqhOk8iNIAkAhhGgCAlAnTAACkSphOnygNAAkRpgEASJkwDQBAqoTptInSAJAYYRoAgJQJ0wAApEqYTpcoDQAJEqYBAEiZMA0AQKqE6TSJ0gCQKGEaAICUCdMAAKRKmE6PKA0ACROmAQBImTANAECqhOm0iNIAkDhhGgCAlAnTAACkSphOhygNABkQpgEASJkwDQBAqoTpNIjSAJAJYRoAgJQJ0wAApEqYrp4oDQAZEaYBAEiZMA0AQKqE6WqJ0gCQGWEaAICUCdMAAKRKmK6OKA0AGRKmAQBImTANAECqhOlqiNIAkClhGgCAlAnTAACkSpgunygNABkTpgEASJkwDQBAqoTpconSAJA5YRoAgJQJ0wAApEqYLo8oDQB9QJgGACBlwjQAAKkSpsshSgNAnxCmAQBImTANAECqhOniidIA0EeEaQAAUiZMAwCQKmG6WKI0APQZYRoAgJQJ0wAApEqYLo4oDQB9SJgGACBlwjQAAKkSposhSgNAnxKmAQBImTANAECqhOneE6UBoI8J0wAApEyYBgAgVcJ0b4nSANDnhGkAAFImTAMAkCphundEaSAZnU5nRJ8DRq/XYfqJJ56Ie++9N+bOnRv33XdfPPvss73cXABIkn1TKE7Pw/TDD0f8/vcRc+dG/PGPEYODPdxaAEjT0NBQ1ZsAfanXYbrT6cSDDz4Yd999d/zud7+Lv/zlL7X4fbPRqcNPCSTrlltuifPOOy+uvfbauOaaa16y49RsNuPtb397bLvttrHPPvvEeuutV9GWQn+YNWtWvOMd74gnnnhikV/fZptt4rLLLosVV1xxoc8//vjjcd5558VVV10V1157bfz+979faEep3W7HRhttFNtuu23ssssusfvuu8eECRMK/VkAoGidTieuuOKK+NGPfhTXXXdd3HjjjS85UNBut2P33XeP7bffPvbee+9YbbXVKtpa6A9nn3127Lfffos9KLfnnnvG2WefHe12e+Ev/PWvEeeeGzFrVsR110X8+c8Lf33y5IjNNovYdtuI97434i1viVhMAAeAXMyfPz9+9KMfxWWXXRbXXntt/Pa3v33JYyZMmBAf/OAHY4cddog99tgjpkyZUsGWQn/odDrxL//yL/GlL31psY/53Oc+F8cee+xLPj937tz47ne/G7/61a/ihhtuiIcffnihry+//PKx9dZbxzbbbBN77rlnbLbZZj3f/qqJ0kDphoaG4rzzzouvfvWrccMNN0S73V7i2e6NRiOazWYMDQ3F29/+9jj66KNj5513LnGLob+MJkzfc889ccIJJ8QZZ5wRTz/9dDSbzRhcwlUm3dfz6quvHocddlgcccQRscoqqxT1owBAIZ555pn41re+FTNnzoy77757qfurzWbz+X9+8IMfjI9//OOx1VZblbW50HdGFaZvvDHi+OMjfvCDiO5Jzku6SqzdjhgYiFh//Ygjj4w46KCISZMK+CkAoDh///vfY+bMmfGNb3wj/v73vy91f7XVasXg4GAst9xyccABB8TRRx8d6667bnkbDH1ktGH64osvjhNPPDEuv/zyaLVaMTQ0tMSroruv5+222y6OOuqo+MAHPrDY1YRyI0oDpbrnnntiv/32i2uuueb50Dwa3R2oD37wg3HSSSfFqquuWtCWQn9bWph+wxveEO9973vjs5/9bAwODo7p/n2tVitWXnnlOO2002L33Xcf7yYDQCmuu+662HvvvePuu++OiNEv2d1ut2NwcDD+6Z/+KY477riYPHlyEZsJfW9pYXrf978/Tn/lK6P5ta9FtFrDoXk0ugf2Nthg+Arrrbce5xYDQDnOP//8OOigg+LRRx9d4oUDi9Nut6PdbsdXvvKVOPTQQ58/wRIYuZGE6WOOOSZ+97vfxfnnn/981xiNbj+ZPn16nHHGGbHOOuuMd7MrJ0oDpTn77LPjkEMOiYGBgTEFrgW1Wq1YccUV4//9v/8Xb33rW3u0hVAvSwvTvdDdefrwhz8c3/72t2OSq1AASFSn04nPfOYz8YUvfGGpK4OMRLPZjPXWWy9+/OMfx8Ybb9yjrYR6WVyYfm1E/Dgi1o2IcR9Gb7UiOp2Iz3424lOfsqQ3AMl65pln4oADDoj/+I//iEaj0ZP7z775zW+OH/7why78gTEYSZjuxWu13W7HhAkT4tRTT4299tprXM9VNVEaKMXXvva1+NjHPtbT52w2m9FsNuMHP/hBvPvd7+7pc0NdlBGmI4ZfrzvuuGP8+Mc/jmWWWabQWQAwWkNDQ3HIIYfEqaee2tPnbbVascIKK8QVV1wRW2yxRU+fG+rixWF6WkT8d0RMiYj2kr5xLA47LOKkk4RpAJLz5JNPxq677hqzZs0a9cqTS9Jut2Pq1Knx85//PNZYY42ePS/UxUjCdC+dfPLJcdhhh5UyqwiiNFC40047LQ488MBCnrvRaESr1YpLLrkkdtppp0JmQL8rM0zvsssuceGFFw7f/w8AEnH00UfHV7/61UKeuxumr7vuulh//fULmQH9rhumN+x04lcRsVwUEKS7jjkmoqSDigAwEvPnz49dd901rrzyynGv5rMo7XY71l9//fjlL38ZK620Us+fH/pd2WH67LPPjn322aeUWb0mSgOFuv3222PzzTcf93LdS9JsNmOllVaKO++801IzMEazZs2KHXbYoZBfbl7sS1/6UhxzzDGFzwGAkbjwwgvjPe95T6EzWq1WbLbZZnH99dc7MQvG6NzTT48tP/KR2CAiJhQ97OKLI97xjqKnAMCIfP7zn4/PfOYzPVmue3FarVbstddecfbZZxc2A/pZp9OJI488Mk466aTCZ02aNCluu+22LE96dgd7oDADAwOlnLEzNDQUjz76aBx++OGFz4J+9de//rWUIB0R8alPfSrmzJlTyiwAWJKHHnooPvKRj0Sj4KV6BwcH45Zbbol///d/L3QO9LO977svNmk0ig/SzWbE/vtHPPJI0ZMAYKluvfXW+NznPldokI4Y3l8955xz4qKLLip0DvSz+++/v/DfLSOGX68f/vCHSzuW20uulAYKM3PmzDjqqKMK32la0GWXXRZvf/vbS5sH/eCpp56KV73qVfHwww+X8npttVqx3XbbxTXXXFP4LABYkoMOOijOOOOM0n6Zb7fbMXfu3Fh33XVLmQd9Y+7ciI03jijrwFurFXHooREzZ5YzDwAWodPpxBve8Ia45ZZbCl2FsqvZbMaqq64a9913X0yaNKnwedBPLrrooth9991Lnfmtb30rDj744FJnjpcrpYFCDA0NxQknnFBqkG61WnHiiSeWNg/6xXnnnRfz5s0r7fU6ODgYs2bNiltuuaWUeQCwKA899FCcffbZpZ5d3ul04pvf/GZp86BvfOMbESVcdfK8wcGIU0+NePTR8mYCwIvccMMNceONN5YSpCOGj+c++OCD8YMf/KCUedBPTjjhhGi1WqXNazQacfzxx5faX3pBlAYKcfnll8e9995b6szBwcG47LLL4p577il1LuSs0+nE1772tWg2y90laLfbccopp5Q6EwAWdOaZZ5Z2gK9rcHAwvvWtb8UzzzxT6lzI2pNPDgfikl+v8eyzEeecU+5MAFjAySefHO12u9SZzWYzZlopBEbljjvuiKuuuqr0E57vuuuu+PnPf17azF4QpYFCnHXWWaXvNEUM7zide+65pc+FXN1+++1x6623xtDQUKlzBwYG4pxzzon58+eXOhcAuk477bTS3/8iIh555JG45JJLSp8L2brooognnqhm9mmnVTMXgNp75pln4rzzziv9JMqhoaG47rrrYu7cuaXOhZydc845lbSQdrsdZ511Vulzx0OUBgoxa9as0neaIoZ3nH71q1+VPhdydd1111U2++mnn47bb7+9svkA1NcTTzwRd9xxRyWz2+12pe+/kJ3rrouYMKH8uZ1OxG23RVjZAIAK3HrrrfHcc89VNv/666+vbDbk5pe//GUlLWRgYCBmzZpV+tzxaHRyW3AcSN4jjzwSK6+8cmXzm81mbLDBBtEo855jkKm//OUv8fDDD1c2/7TTTosDDjigsvkA1NOsWbPiTW96U2Xzl1122VhnnXUqmw85Offee2PLp5+Oyn67u/76iNe/vqrpANTUKaecEjNmzKjsfrGrrLJKvPzlL69kNuSku4x2FatwRQy3kMceeyymTJlSyfzRKv96cqDv/fa3v610/tDQUGVXvgAjN2HChLjtttuq3gwAaug3v/lNNBqNyg7yPfXUUzFnzpxKZkNuXhNRXZCOGL5aWpQGoGS/+c1vot1uV3bbs3nz5sW8efMqmQ2M3NDQUNx+++3x+kz2Vy3fDfTc448/XvUmABnodDr+vgCgEo899lg0m34dhhxUes1Hs1nd/awBqLXHHnussisvgbw8kdH+qt/CgZ5zVwBgpPx9AUAVOp2OW70AIyMIAFABx0uAkcrpBBZRGui5ZZddtupNADLQaDT8fQFAJaZMmRKDg4NVbwYwAs9UOXxoKML+KgAVmDJlipMogRHJ6fiqe0oDPbfRRhtVOr/ZbMYGG2xgxw1G4E9/+lM8+uijlcweGBiITTbZpJLZANTbxhtvXOnVJ8sss0ysu+66lc2HnNx7zz3x2mefrW4D7K8CUIGNN9640qsfV1555VhjjTUqmw+56HQ6ceedd1b6+2XVPWY0RGmg517+8pfHy1/+8vjrX/9ayfw3v/nNceWVV1YyG3JzyimnxIwZMyrZcep0OjFt2rTS5wLAVlttVdnsCRMmxCGHHBInnnhiZdsAWTnssIhTT42YP7/82Y1GxBZblD8XgNqbNm1apVH6K1/5ShxwwAGVzYec/MM//EP86le/qmT22muvHSuvvHIls8fC8t1AIbbbbrtotVqlz22327HNNtuUPhdy9frXv76yM/na7XZsttlmlcwGoN5WXnnlWGeddSqZPX/+/Nh6660rmQ1Zev3rIwYGqpn9mtdELLdcNbMBqLUtt9wyms3q8o39VRi5bbfdNtrt8q8BbrVasd1225U+dzxEaaAQe+65ZyX36RsYGIg99tij9LmQq6222qqS5UPb7Xa8973vjcmTJ5c+GwAiIvbZZ59KTqKcPHlyvPOd7yx9LmRr990jJkwof26zGfHhD5c/FwAiYrnllovddtut9NDVaDRigw02iE033bTUuZCzPfbYIwYqOIlycHAw9txzz9LnjocoDRTiPe95T6y66qqlzmw2m7HNNtvEFpZXgxFrNptxxBFHlH4P9oGBgZgxY0apMwFgQQcffHDpSyK22+3Yd999Y8UVVyx1LmTtZS+L2GuviLKvPmk0Ig48sNyZALCAww8/vJLQdeSRR5Z+nAhy9vrXvz4233zz0lc3eMUrXhG77bZbqTPHS5QGCjFx4sSYMWNGqX8RDw0NxVFHHVXaPOgX++23X6lXLLdardhoo43izW9+c2kzAeDFXvWqV8W73/3uUq8+GRgYiMMOO6y0edA3Zswodwnvdjvi/e+PWGON8mYCwIvstNNO8epXv7rU46vLLrts7LPPPqXNg37QaDTiYx/7WKknPXcvNKpi2fDxEKWBwvzTP/1TvOpVryrlzLpmsxlvfvOb44Mf/GDhs6DfrLLKKvHlL3+5tHlDQ0Pxne98x1m3AFTuxBNPjAklLQvcPWiw2WablTIP+srWW0ccdFB0yjooP3lyxL//ezmzAGAxms1mfPvb3y41dJ144omxwgorlDYP+sU+++wT2267bSknkbRarVhvvfXi6KOPLnxWr4nSQGGWXXbZ2GGHHaLT6RQ+a2hoKN71rneVvkQG9Iu3ve1tMXHixMLnNJvNOOqoo2L77bcvfBYALM0rX/nK2GijjUqZ1el04l3velcps6AfXfPud8efh4ZisIxhX/96xFprlTEJAJZoyy23LO0WiZMmTYodd9yxlFnQb1qtVuy2226lnEQyNDQU55xzTqkrX/aKegMUotPpxGc+85k466yzSpt5zDHHlDoP+sXcuXPjrW99azz33HOFzmm1WrHpppvGF7/4xULnAMBIzJ8/P/baa6+4+eabS5nX6XTive99b8yaNauUedBPrrrqqtj5/e+PPSJiMCIKO9TXbEa8730R++1X1AQAGLGHH3443va2t8Xf//73UuY9++yzseOOO8Y999xTyjzoJ6eeemoce+yxpcz63Oc+F9tuu20ps3qt0SnjEkagVrpB+vOf/3zpsxuNRpxxxhmx7777lj4bcjR37tyYPn16PPDAA4XOabVasf7668fPf/7zWG211QqdBQBL0w3SP/jBD0qfPWXKlLj00kutGgIjdNVVV8Wuu+4aTz/9dEREvCsifhjDV1m0ejmo2Yx4+9sjLrwwooQVhABgSbpBevbs2aXPXnvttePKK6+M9dZbr/TZkKNTTz01DjrooFJmffzjH4+vfOUr2d4W0ZXSQE+NJEj34i/MxT1Hp9OJ/fff3xXTMAJlBemIiG222SZ+8YtfCNIAVG4kQbrIX/CffPLJ2GWXXVwxDSPw4iAdEXFRROwWEU9ExEAvhnRf73vuKUgDkIQqg3RExH333RfTp093xTSMwNKCdC9+t2y1WtFoNOJzn/tc1kE6QpQGemgkQXrfffeNtddee8z3fm40GtFoNGLLLbeM3XbbbbHbIUzDki0tSK+zzjqxzz77RMTwjs9YtNvtmDhxYhx//PHx85//PFZZZZUxby8A9MLSgnSj0YjDDz88VlhhhTG//3X3c3fbbbfYaqutFvkYYRqWblFBuuu/ImLfN7whYuedhz8xxt8vo9WKWGmliO9/P+LccwVpACq3tCC9/PLLx2GHHRbtdjva7faYZnQD1/777x9rrbXWIh8jTMPSLS1I77777rHZZpuNKyI3m81YZ5114he/+EUce+yxWQfpCFEa6JGRBOljjz02zjjjjLj99tvj05/+dKy66qoRMbLg1d3JWmeddeLrX/96XHfddfGjH/0o9tprr8VujzANi7a0ID116tS4+uqr4+yzz46rr746pk+fHhEjj9PNZjPa7Xa8//3vj1tvvTU+/vGPj/nAPgD0ytKCdLPZjO9+97sxc+bMuOOOO+KjH/1oLLvsss+fFLk03f3VLbbYIr7//e/HRRddFFdcccVi7/UlTMPiLSlIR0Rsv/32cc7ll0f7kksizjsvYtNNh78wkoPzjcbwx5QpETNmRNxxx/B9pAGgYksL0iussEL87Gc/i5NPPjl+/etfx/ve975ot9sjvvinG6N32mmnuOaaa+L000+Pq6++OtZee+1FPl6YhsVbWpDed9994/zzz48bbrghTjjhhOdfZyM5Rtp9zOqrrx7HHXdc/OY3v4ntttuuNxteMfeUBsZtpEH6uOOOW+iA3vz58+NHP/pRfO9734trr702/vKXvyzye9dZZ53YfvvtY9999423vvWtC+1oDQwMxL777hvf+973Fvm97jENCxtJkL7yyitjnXXWecn3fec734nLL788br755kV+77LLLhtbbbVV7LbbbnHAAQfE6quv3vPtB4CxGEmQPvfcc2PPPfdc6POPP/54nHvuuXHBBRfEDTfcEI888sgiv3+jjTaKHXbYIQ488MCYNm3aQl979NFHY5dddolrr712kd/rHtOwsJEE6YsvvjiWX375hb9www0Rp54acfXVMXTnnYu+CmPllSNe//qI//2/Iz70oeEwDQAJGEmQvuyyy15ywuNf//rXOO200+Liiy+Om266abHvn1tttVW87W1vi4MOOihe/epXL/S1e+65J6ZPnx733XffIr/XPaZhYSMJ0qeddtpCAXpoaCh+9rOfxdlnnx2/+MUvFvt6e8UrXhHbbrttfOhDH4rdd989JkyY0PPtr5IoDYzLWIP0omywwQYxd+7cl3zuzjvvXOL3CdMwMmMN0i+28cYbxx133LHQ59Zbb72YO3fumJfmB4CijDVIv1in04kNNtggfve73y30+Q033PAl74svJkzDyIw5SL/IVhttFO0774yVIqIdEU9HROM1r4kr7rrrhXtIA0AixhqkX2xoaCjWX3/9l1zZvNFGG8WcOXOW+L3CNIzMWIL0omy44YZx1113LfS59ddf/yWf6zeOHANj1ssgHRGLvA/KSJf2PuussyzlDUvQqyAdEYt8PU+aNEmQBiA5vQrSEcPvf4s6S30k738rrrhiXHrppZbyhiXoVZCOiHim2YwbYvje05dExFUR8ZcJEwRpAJLTqyAdMbxfOmnSpJd8fiTHZddbb7248sorLeUNS9CrIB2x6O4x1vvE58TRY2BMeh2kx0uYhsXrZZAGgFz0Mkj3gjANi9fLIA0AuehlkO4FYRoWr5dBus5EaWDUUgvSXcI0vJQgDUAdpRaku4RpeClBGoA6Si1IdwnT8FKCdO+I0sCopBqku4RpeIEgDUAdpRqku4RpeIEgDUAdpRqku4RpeIEg3VuiNDBiqQfpLmEaBGkA6in1IN0lTIMgDUA9pR6ku4RpEKSLIEoDI5JLkO4SpqkzQRqAOsolSHcJ09SZIA1AHeUSpLuEaepMkC6GKA0sVW5BukuYpo4EaQDqKLcg3SVMU0eCNAB1lFuQ7hKmqSNBujiiNLBEuQbpLmGaOhGkAaijXIN0lzBNnQjSANRRrkG6S5imTgTpYonSwGLlHqS7hGnqQJAGoI5yD9JdwjR1IEgDUEe5B+kuYZo6EKSLJ0oDi9QvQbpLmKafCdIA1FG/BOkuYZp+JkgDUEf9EqS7hGn6mSBdDlEaeIl+C9JdwjT9SJAGoI76LUh3CdP0I0EagDrqtyDdJUzTjwTp8ojSwEL6NUh3CdP0E0EagDrq1yDdJUzTTwRpAOqoX4N0lzBNPxGkyyVKA8/r9yDdJUzTDwRpAOqo34N0lzBNPxCkAaijfg/SXcI0/UCQLp8oDUREfYJ0lzBNzgRpAOqoLkG6S5gmZ4I0AHVUlyDdJUyTM0G6GqI0ULsg3SVMkyNBGoA6qluQ7hKmyZEgDUAd1S1IdwnT5EiQro4oDTVX1yDdJUyTE0EagDqqa5DuEqbJiSANQB3VNUh3CdPkRJCuligNNVb3IN0lTJMDQRqAOqp7kO4SpsmBIA1AHdU9SHcJ0+RAkK6eKA01JUgvTJgmZYI0AHUkSC9MmCZlgjQAdSRIL0yYJmWCdBpEaaghQXrRhGlSJEgDUEeC9KIJ06RIkAagjgTpRROmSZEgnQ5RGmpGkF4yYZqUCNIA1JEgvWTCNCkRpAGoI0F6yYRpUiJIp0WUhhoRpEdGmCYFgjQAdSRIj4wwTQoEaQDqSJAeGWGaFAjS6RGloSYE6dERpqmSIA1AHQnSoyNMUyVBGoA6EqRHR5imSoJ0mkRpqAFBemyEaaogSANQR4L02AjTVEGQBqCOBOmxEaapgiCdLlEa+pwgPT7CNGUSpAGoI0F6fIRpyiRIA1BHgvT4CNOUSZBOmygNfUyQ7g1hmjII0gDUkSDdG8I0ZRCkAagjQbo3hGnKIEinT5SGPiVI95YwTZEEaQDqSJDuLWGaIgnSANSRIN1bwjRFEqTzIEpDHxKkiyFMUwRBGoA6EqSLIUxTBEEagDoSpIshTFMEQTofojT0GUG6WMI0vSRIA1BHgnSxhGl6SZAGoI4E6WIJ0/SSIJ0XURr6iCBdDmGaXhCkAagjQbocwjS9IEgDUEeCdDmEaXpBkM6PKA19QpAulzDNeAjSANSRIF0uYZrxEKQBqCNBulzCNOMhSOdJlIY+IEhXQ5hmLARpAOpIkK6GMM1YCNIA1JEgXQ1hmrEQpPMlSkPmBOlqCdOMhiANQB0J0tUSphkNQRqAOhKkqyVMMxqCdN5EaciYIJ0GYZqREKQBqCNBOg3CNCMhSANQR4J0GoRpRkKQzp8oDZkSpNMiTLMkgjQAdSRIp0WYZkkEaQDqSJBOizDNkgjS/UGUhgwJ0mkSplkUQRqAOhKk0yRMsyiCNAB1JEinSZhmUQTp/iFKQ2YE6bQJ0yxIkAagjgTptAnTLEiQBqCOBOm0CdMsSJDuL6I0ZESQzoMwTYQgDUA9CdJ5EKaJEKQBqCdBOg/CNBGCdD8SpSETgnRehOl6E6QBqCNBOi/CdL0J0gDUkSCdF2G63gTp/iRKQwYE6TwJ0/UkSANQR4J0noTpehKkAagjQTpPwnQ9CdL9S5SGxAnSeROm60WQBqCOBOm8CdP1IkgDUEeCdN6E6XoRpPubKA0JE6T7gzBdD4I0AHUkSPcHYboeBGkA6kiQ7g/CdD0I0v1PlIZECdL9RZjub4I0AHUkSPcXYbq/CdIA1JEg3V+E6f4mSNeDKA0JEqT7kzDdnwRpAOpIkO5PwnR/EqQBqCNBuj8J0/1JkK4PURoSI0j3N2G6vwjSANSRIN3fhOn+IkgDUEeCdH8TpvuLIF0vojQkRJCuB2G6PwjSANSRIF0PwnR/EKQBqCNBuh6E6f4gSNePKA2JEKTrRZjOmyANQB0J0vUiTOdNkAagjgTpehGm8yZI15MoDQkQpOtJmM6TIA1AHQnS9SRM50mQBqCOBOl6EqbzJEjXlygNFROk602YzosgDUAdCdL1JkznRZAGoI4E6XoTpvMiSNebKA0VEqSJEKZzIUgDUEeCNBHCdC4EaQDqSJAmQpjOhSCNKA0VEaRZkDCdNkEagDoSpFmQMJ02QRqAOhKkWZAwnTZBmghRGiohSLMownSaBGkA6kiQZlGE6TQJ0gDUkSDNogjTaRKk6RKloWSCNEsiTKdFkAagjgRplkSYTosgDUAdCdIsiTCdFkGaBYnSUCJBmpEQptMgSANQR4I0IyFMp0GQBqCOBGlGQphOgyDNi4nSUBJBmtEQpqslSANQR4I0oyFMV0uQBqCOBGlGQ5iuliDNoojSUAJBmrEQpqshSANQR4I0YyFMV0OQBqCOBGnGQpiuhiDN4ojSUDBBmvEQpsslSANQR4I04yFMl0uQBqCOBGnGQ5gulyDNkojSUCBBml4QpsshSANQR4I0vSBMl0OQBqCOBGl6QZguhyDN0ojSUBBBml4SposlSANQR4I0vSRMF0uQBqCOBGl6SZguliDNSIjSUABBmiII08UQpAGoI0GaIgjTxRCkAagjQZoiCNPFEKQZKVEaekyQpkjCdG8J0gDUkSBNkYTp3hKkAagjQZoiCdO9JUgzGqI09JAgTRmE6d4QpAGoI0GaMgjTvSFIA1BHgjRlEKZ7Q5BmtERp6BFBmjIJ0+MjSANQR4I0ZRKmx0eQBqCOBGnKJEyPjyDNWIjS0AOCNFUQpsdGkAagjgRpqiBMj40gDUAdCdJUQZgeG0GasRKlYZwEaaokTI+OIA1AHQnSVEmYHh1BGoA6EqSpkjA9OoI04yFKwzgI0qRAmB4ZQRqAOhKkSYEwPTKCNAB1JEiTAmF6ZARpxkuUhjESpEmJML1kgjQAdSRIkxJheskEaQDqSJAmJcL0kgnS9IIoDWMgSJMiYXrRBGkA6kiQJkXC9KIJ0gDUkSBNioTpRROk6RVRGkZJkCZlwvTCBGkA6kiQJmXC9MIEaQDqSJAmZcL0wgRpekmUhlEQpMmBMD1MkAagjgRpciBMDxOkAagjQZocCNPDBGl6TZSGERKkyUndw7QgDUAdCdLkpO5hWpAGoI4EaXJS9zAtSFMEURpGQJAmR3UN04I0AHUkSJOjuoZpQRqAOhKkyVFdw7QgTVFEaVgKQZqc1S1MC9IA1JEgTc7qFqYFaQDqSJAmZ3UL04I0RRKlYQkEafpBXcK0IA1AHQnS9IO6hGlBGoA6EqTpB3UJ04I0RROlYTEEafpJv4dpQRqAOhKk6Sf9HqYFaQDqSJCmn/R7mBakKYMoDYsgSNOP+jVMC9IA1JEgTT/q1zAtSANQR4I0/ahfw7QgTVlEaXgRQZp+1m9hWpAGoI4EafpZv4VpQRqAOhKk6Wf9FqYFacokSsMCBGnqoF/CtCANQB0J0tRBv4RpQRqAOhKkqYN+CdOCNGUTpeF/CNLUSe5hWpAGoI4Eaeok9zAtSANQR4I0dZJ7mBakqYIoDSFIU0+5hmlBGoA6EqSpo1zDtCANQB0J0tRRrmFakKYqojS1J0hTZ7mFaUEagDoSpKmz3MK0IA1AHQnS1FluYVqQpkqiNLUmSEM+YVqQBqCOBGnIJ0wL0gDUkSAN+YRpQZqqidLUliANL0g9TAvSANSRIA0vSD1MC9IA1JEgDS9IPUwL0qRAlKaWBGl4qVTDtCANQB0J0vBSqYZpQRqAOhKk4aVSDdOCNKkQpakdQRoWL7UwLUgDUEeCNCxeamFakAagjgRpWLzUwrQgTUpEaWpFkIalSyVMC9IA1JEgDUuXSpgWpAGoI0Eali6VMC1IkxpRmtoQpGHkqg7TgjQAdSRIw8hVHaYFaQDqSJCGkas6TAvSpEiUphYEaRi9qsK0IA1AHQnSMHpVhWlBGoA6EqRh9KoK04I0qRKl6XuCNIxd2WFakAagjgRpGLuyw7QgDUAdCdIwdmWHaUGalInS9DVBGsavrDAtSANQR4I0jF9ZYVqQBqCOBGkYv7LCtCBN6kRp+pYgDb1TdJgWpAGoI0EaeqfoMC1IA1BHgjT0TtFhWpAmB6I0fUmQht4rKkwL0gDUkSANvVdUmBakAagjQRp6r6gwLUiTC1GaviNIQ3F6HaYFaQDqSJCG4vQ6TAvSANSRIA3F6XWYFqTJiShNXxGkoXi9CtOCNAB1JEhD8XoVpgVpAOpIkIbi9SpMC9LkRpSmbwjSUJ7xhmlBGoA6EqShPOMN04I0AHUkSEN5xhumBWlyJErTFwRpKN9Yw7QgDUAdCdJQvrGGaUEagDoSpKF8Yw3TgjS5EqXJniAN1RltmBakAagjQRqqM9owLUgDUEeCNFRntGFakCZnojRZE6SheiMN01/60pcEaQBqR5CG6o00TM+cOVOQBqB2BGmo3kjD9L/9278J0mRNlCZbgjSkYyRh+hOf+IQgDUCtCNKQjpGE6SOPPFKQBqBWBGlIx0jC9Cc/+cnFfr8gTQ5EabIkSEN6lhamF0eQBqAfCdKQnqWF6cURpAHoR4I0pGdpYXpxBGlyIUqTHUEa0jXaMC1IA9CPBGlI12jDtCANQD8SpCFdow3TgjQ5EaXJiiAN6euG6Xe9611LfNyqq64qSAPQdwRpSF83TG+yySZLfNymm24qSAPQdwRpSF83TK+yyipLfNz/+l//S5AmK6I02RCkIR+///3vF/vLTddDDz0UV111VTkbBAAlEKQhHzfffHPcc889S3zMPffcE7/+9a9L2iIAKJ4gDfm44oorYt68eUt8zI033hh/+MMfStoiGD9RmiwI0pCPuXPnxvTp0+NPf/rTEh/X6XRi//33j7POOqukLQOA4gjSkI+rrroqdt1113jmmWeW+Lgnn3wydtlll5g1a1ZJWwYAxRGkIR+nnnpqHHTQQUt93H333RfTp09f6smWkApRmuQJ0pCPbpB+4IEHRvR4YRqAfiBIQz66Qfrpp58e0eOFaQD6gSAN+RhpkO4SpsmJKE3SBGnIx9KC9JQpUxb5eWEagJwJ0pCPpQXpxd07WpgGIGeCNORjaUF6ccdXhWlyIUqTLEEa8rG0ID116tT49a9/HXvttdcivy5MA5AjQRrysbQgvf3228ftt9++2APywjQAORKkIR9LC9L77rtv3HzzzbH22msv8uvCNDkQpUmSIA35GEmQvvLKK+PVr351nHXWWcI0AH1BkIZ8jCRIX3zxxbHWWmvFpZdeKkwD0BcEacjHSIL0aaedFuuvv35ceeWVwjTZEqVJjiAN+RhpkF5nnXUiIqLdbgvTAGRPkIZ8jDRId5fuXnHFFYVpALInSEM+RhqkW61WRESst956wjTZEqVJiiAN+RhtkO4SpgHImSAN+RhtkO4SpgHImSAN+RhtkO4SpsmVKE0yBGnIx1iDdJcwDUCOBGnIx1iDdJcwDUCOBGnIx1iDdJcwTY5EaZIgSEM+xhuku4RpAHIiSEM+xhuku4RpAHIiSEM+xhuku4RpciNKUzlBGvLRqyDdJUwDkANBGvLRqyDdJUwDkANBGvLRqyDdJUyTE1GaSgnSkI9eB+kuYRqAlAnSkI9eB+kuYRqAlAnSkI9eB+kuYZpciNJURpCGfBQVpLuEaQBSJEhDPooK0l3CNAApEqQhH0UF6S5hmhyI0lRCkIZ8FB2ku4RpAFIiSEM+ig7SXcI0ACkRpCEfRQfpLmGa1InSlE6QhnyUFaS7hGkAUiBIQz7KCtJdwjQAKRCkIR9lBekuYZqUidKUSpCGfJQdpLuEaQCqJEhDPsoO0l3CNABVEqQhH2UH6S5hmlSJ0pRGkIZ8VBWku4RpAKogSEM+qgrSXcI0AFUQpCEfVQXpLmGaFInSlEKQhnxUHaS7hGkAyiRIQz6qDtJdwjQAZRKkIR9VB+kuYZrUiNIUTpCGfKQSpLuEaQDKIEhDPlIJ0l3CNABlEKQhH6kE6S5hmpSI0hRKkIZ8pBaku4RpAIokSEM+UgvSXcI0AEUSpCEfqQXpLmGaVIjSFEaQhnykGqS7hGkAiiBIQz5SDdJdwjQARRCkIR+pBukuYZoUiNIUQpCGfKQepLuEaQB6SZCGfKQepLuEaQB6SZCGfKQepLuEaaomStNzgjTkI5cg3SVMA9ALgjTkI5cg3SVMA9ALgjTkI5cg3SVMUyVRmp4SpCEfuQXpLmEagPEQpCEfuQXpLmEagPEQpCEfuQXpLmGaqojS9IwgDfnINUh3CdMAjIUgDfnINUh3CdMAjIUgDfnINUh3CdNUQZSmJwRpyEfuQbpLmAZgNARpyEfuQbpLmAZgNARpyEfuQbpLmKZsojTjJkhDPvolSHcJ0wCMhCAN+eiXIN0lTAMwEoI05KNfgnSXME2ZRGnGRZCGfPRbkO4SpgFYEkEa8tFvQbpLmAZgSQRpyEe/BekuYZqyiNKMmSAN+ejXIN0lTAOwKII05KNfg3SXMA3AogjSkI9+DdJdwjRlEKUZE0Ea8tHvQbpLmAZgQYI05KPfg3SXMA3AggRpyEe/B+kuYZqiidKMmiAN+ahLkO4SpgGIEKQhJ3UJ0l3CNAARgjTkpC5BukuYpkiiNKMiSEM+6haku4RpgHoTpCEfdQvSXcI0QL0J0pCPugXpLmGaoojSjJggDfmoa5DuEqYB6kmQhnzUNUh3CdMA9SRIQz7qGqS7hGmKIEozIoI05KPuQbpLmAaoF0Ea8lH3IN0lTAPUiyAN+ah7kO4Spuk1UZqlEqQhH4L0woRpgHoQpCEfgvTChGmAehCkIR+C9MKEaXpJlGaJBGnIhyC9aMI0QH8TpCEfgvSiCdMA/U2QhnwI0osmTNMrojSLJUhDPgTpJROmAfqTIA35EKSXTJgG6E+CNORDkF4yYZpeEKVZJEEa8iFIj4wwDdBfBGnIhyA9MsI0QH8RpCEfgvTICNOMlyjNSwjSkA9BenSEaYD+IEhDPgTp0RGmAfqDIA35EKRHR5hmPERpFiJIQz4E6bERpgHyJkhDPgTpsRGmAfImSEM+BOmxEaYZK1Ga5wnSkA9BenyEaYA8CdKQD0F6fIRpgDwJ0pAPQXp8hGnGQpQmIgRpyIkg3RvCNEBeBGnIhyDdG8I0QF4EaciHIN0bwjSjJUojSENGBOneEqYB8iBIQz4E6d4SpgHyIEhDPgTp3hKmGQ1RuuYEaciHIF0MYRogbYI05EOQLoYwDZA2QRryIUgXQ5hmpETpGhOkIR+CdLGEaYA0CdKQD0G6WMI0QJoEaciHIF0sYZqREKVrSpCGfAjS5RCmAdIiSEM+BOlyCNMAaRGkIR+CdDmEaZZGlK4hQRryIUiXS5gGSIMgDfkQpMslTAOkQZCGfAjS5RKmWRJRumYEaciHIF0NYRqgWoI05EOQroYwDVAtQRryIUhXQ5hmcUTpGhGkIR+CdLWEaYBqCNKQD0G6WsI0QDUEaciHIF0tYZpFEaVrQpCGfAjSaRCmAcolSEM+BOk0CNMA5RKkIR+CdBqEaV5MlK4BQRryIUinRZgGKIcgDfkQpNMiTAOUQ5CGfAjSaRGmWZAo3ecEaciHIJ0mYRqgWII05EOQTpMwDVAsQRryIUinSZimS5TuY4I05EOQTpswDVAMQRryIUinTZgGKIYgDfkQpNMmTBMhSvctQRryIUjnQZgG6C1BGvIhSOdBmAboLUEa8iFI50GYRpTuQ4I05EOQzoswDdAbgjTkQ5DOizAN0BuCNORDkM6LMF1vonSfEaQhH4J0noRpgPERpCEfgnSehGmA8RGkIR+CdJ6E6foSpfuIIA35EKTzJkwDjI0gDfkQpPMmTAOMjSAN+RCk8yZM15Mo3ScEaciHIN0fhGmA0RGkIR+CdH8QpgFGR5CGfAjS/UGYrh9Rug8I0pAPQbq/CNMAIyNIQz4E6f4iTAOMjCAN+RCk+4swXS+idOYEaciHIN2fhGmAJROkIR+CdH8SpgGWTJCGfAjS/UmYrg9ROmOCNORDkO5vwjTAognSkA9Bur8J0wCLJkhDPgTp/iZM14MonSlBGvIhSNeDMA2wMEEa8iFI14MwDbAwQRryIUjXgzDd/0TpDAnSkA9Bul6EaYBhgjTkQ5CuF2EaYJggDfkQpOtFmO5vonRmBGnIhyBdT8I0UHeCNORDkK4nYRqoO0Ea8iFI15Mw3b9E6YwI0pAPQbrehGmgrgRpyIcgXW/CNFBXgjTkQ5CuN2G6P4nSmRCkIR+CNBHCNFA/gjTkQ5AmQpgG6keQhnwI0kQI0/1IlM6AIA35EKRZkDAN1IUgDfkQpFmQMA3UhSAN+RCkWZAw3V9E6cQJ0pAPQZpFEaaBfidIQz4EaRZFmAb6nSAN+RCkWRRhun+I0gkTpCEfgjRLIkwD/UqQhnwI0iyJMA30K0Ea8iFIsyTCdH8QpRMlSEM+BGlGQpgG+o0gDfkQpBkJYRroN4I05EOQZiSE6fyJ0gkSpCEfgjSjIUwD/UKQhnwI0oyGMA30C0Ea8iFIMxrCdN5E6cQI0pAPQZqxEKaB3AnSkA9BmrEQpoHcCdKQD0GasRCm8yVKJ0SQhnwI0oyHMA3kSpCGfAjSjIcwDeRKkIZ8CNKMhzCdJ1E6EYI05EOQpheEaSA3gjTkQ5CmF4RpIDeCNORDkKYXhOn8iNIJEKQhH4I0vSRMA7kQpCEfgjS9JEwDuRCkIR+CNL0kTOdFlK6YIA35EKQpgjANpE6QhnwI0hRBmAZSJ0hDPgRpiiBM50OUrpAgDfkQpCmSMA2kSpCGfAjSFEmYBlIlSEM+BGmKJEznQZSuiCAN+RCkKYMwDaRGkIZ8CNKUQZgGUiNIQz4EacogTKdPlK6AIA35EKQpkzANpEKQhnwI0pRJmAZSIUhDPgRpyiRMp02ULpkgDfkQpKmCMA1UTZCGfAjSVEGYBqomSEM+BGmqIEynS5QukSAN+RCkqZIwDVRFkIZ8CNJUSZgGqiJIQz4EaaokTKdJlC6JIA35EKRJgTANlE2QhnwI0qRAmAbKJkhDPgRpUiBMp0eULoEgDfkQpEmJMA2URZCGfAjSpESYBsoiSEM+BGlSIkynRZQumCAN+RCkSZEwDRRNkIZ8CNKkSJgGiiZIQz4EaVIkTKdDlC6QIA35EKRJmTANFEWQhnwI0qRMmAaKIkhDPgRpUiZMp0GULoggDfkQpMmBMA30miAN+RCkyYEwDfSaIA35EKTJgTBdPVG6AII05EOQJifCNNArgjTkQ5AmJ8I00CuCNORDkCYnwnS1ROkeE6QhH4I0ORKmgfESpCEfgjQ5EqaB8RKkIR+CNDkSpqsjSveQIA35EKTJmTANjJUgDfkQpMmZMA2MlSAN+RCkyZkwXQ1RukcEaciHIE0/EKaB0RKkIR+CNP1AmAZGS5CGfAjS9ANhunyidA8I0pAPQZp+IkwDIyVIQz4EafqJMA2MlCAN+RCk6SfCdLlE6XESpCEfgjT9SJgGlkaQhnwI0vQjYRpYGkEa8iFI04+E6fKI0uMgSEM+BGn6mTANLI4gDfkQpOlnwjSwOII05EOQpp8J0+UQpcdIkIZ8CNLUgTANvJggDfkQpKkDYRp4MUEa8iFIUwfCdPFE6TEQpCEfgjR1IkwDXYI05EOQpk6EaaBLkIZ8CNLUiTBdLFF6lARpyIcgTR0J04AgDfkQpKkjYRoQpCEfgjR1JEwXR5QeBUEa8iFIU2fCNNSXIA35EKSpM2Ea6kuQhnwI0tSZMF0MUXqEBGnIhyANwjTUkSAN+RCkQZiGOhKkIR+CNAjTRRClR0CQhnwI0vACYRrqQ5CGfAjS8AJhGupDkIZ8CNLwAmG6t0TppRCkIR+CNLyUMA39T5CGfAjS8FLCNPQ/QRryIUjDSwnTvSNKL4EgDfkQpGHxhGnoX4I05EOQhsUTpqF/CdKQD0EaFk+Y7o121RtQmKGhiLvuirjxxoibbor4618jnnsuYuLEiLXWipg2bfhjvfUiFhGUBWkoz8MPPxw33XRTPPTQQy/52rx582LWrFmx5ZZbxpQpUxb5/YI0LF03TEdEfO9733vJ17thOmL4l4xFGRwcjDvuuCMeeeSRl3ztwQcfjB/84Acxbdq0WHfddb03wkg891zEb387vL96yy0R8+ZFDAxELLNMxNSpEVtvPby/uuaai/x2QRrK8+c//zlmz54df/vb317ytYcffjhmz54dm266aUycOHGR3y9Iw9J1w/Quu+wS11577Uu+3g3Tl156aWy//faLfI5nn302brvttnj44Ydf8rW//e1v8dOf/jSmTZsWa6yxRs+3H/rSU08N76feeGPEbbdFPPZYRKcTMWVKxIYbDu+vbrVVxCqrLPLbBWkoR6fTid///vcxe/bsePDBB1/y9UcffTRuv/322HDDDRcblAVpWLpumJ4+fXrcd999L/l6N0xfeeWVsd566y36SZ54IuLmm2OfefNitYhYPiIaEfFERMx76KGIK64Yfm9daaXifpAqdfrNAw90Op/9bKez+uqdzvBuUqczYUKn02p1Oo3G8D8nTHjha+us0+n8+793On//+/NPMTQ01Dn22GM7EbHYj2OPPbYzNDRU3c8JmRsYGOhcdNFFnZ133rnTaDSW+HqLiE673e7ssccenWuuuWah195dd93VeeUrX7nY75s6dWrn3nvvrfAnhbTMnz+/s9deey32NdNoNDpnnnnmQt/zhz/8ofOv//qvnZe97GVLfa1GROfVr35156tf/Wrn4YcfruaHhNTNmdPpHHlkp7PccgvvrzabL+yvttsvfG2LLTqd00/vdJ588vmneO655zrve9/7Fvs6bDabne9973sV/pCQv6eeeqpz5plndrbaaqsRvf8tu+yynRkzZnR+85vfLPQ8V155ZWeZZZZZ7Pdtv/32nccee6yinxLS88gjj3S23Xbbxb5mpkyZ0rnmmmsW+p5bb721c+ihhy7xtbbgx+tf//rOOeec03n66acr+ikhYUNDnc4vftHp7LXXC/ukjcbwvzebwx/t9vA+a3d/daedOp0LL+x0Bgaef5p58+Z1pk2bttjX4QorrND51a9+VeEPCvmbN29e54QTTuhMnTp1RO9/q622WufTn/505/7771/oeb7zne8s8fv23XffzsACr2+ou7vvvruz9tprL/Y1s/baa3fuvvvuF75haKjTueqqTuf973/+/XMgovPc//xzwX9//n33He/odC6+uNMZHKzuBy1A/0Tpxx7rdD760eEdowV3ikby0WwOHwj8l3/pDD39tCANBbv00kuf/0u71WqNaKepG6YjorP55pt3Zs+eLUjDGI00TM+bN6+z//77dxqNxqheq41Go9NoNDqTJ0/uHHfccZ3nnnuu6h8Z0vDHP3Y673zn8P7ngtF5JPuqEZ3OCit0Ot/4Rue5Z54RpKFAQ0NDnW9/+9udlVZa6fnX1Gj3V3fZZZfOH/7wB0EaxmikYfr3v/99Z6eddlro9TeSj+7reuWVV+6cfvrpjvFA1y23dDpbbTX6/dXusdi11up0fvpTQRoK9uyzz3aOPfbYzsSJE58/BjPS98BWq9VpNpudAw88sPPII48I0jBGIw7T11/f6bzudWN/b1133U7n8sur/nF7ptHpdDqRu8svj9h334i//GV42e4x6jQa8dDKK8c75s2LGxfzGEt2w9g9+uij8fGPfzxOP/30aDabMTTG12ur1YpOpxNTpkyJxx9/fJGPsWQ3LNnAwEDsu+++i1zKu2uFFVaIJ598MgYHB8c8p9FoxGtf+9o499xzY/PNNx/z80DWOp2IM8+MOPLIiGeeGV6iexx+s+qq8c6//z3+sIivWbIbxue+++6Lj3zkI3H55ZeP63na7Xa0Wq0YGhqK+fPnL/IxluyGJXv00UcXu5R3RDy/XP7Q0FAMjPG9tdFoRKfTiV122SVOPfXUeOUrXznm7YWszZ8f8X/+T0T3NoZj/R2w2YwYGoqfrLJK7D1vXjy6iIdYshvG56abboq999477rjjjhhP2mm1WrHccsvFo48u6pU6zJLdsGT33HPPYpfynhgRJ6ywQhz2+OPRaDbH/d4aBx8c8ZWvRGT++2P+UfrkkyMOP/yFP5hxGojh0xj2iogX351PkIaxe+CBB2LHHXeMu+++e1yBayQEaRiZkYTpXmi1WtFsNuP888+Pd77znYXOguQMDQ3vq55ySkSjMRyox2l+RDwZEW+LWOhESkEaxuemm26KnXbaKR5//PExB66REqRhZJYWpnul3W7HiiuuGFdccUVsttlmhc6C5Dz5ZMR73hPx3//dk33ViOHjq/dGxPSI+OMCnxekYXwuuOCC+MAHPhCdTqfw46uCNIzMosL08hFxcUT8Q0Q0ezWo2YzYcMPhe06vsUavnrV0eUfpk06KOOKInj9tN21/MF4I04I0jN1f/vKX2G677eKPf/xj4Qf4BGkYnbLCdKPRiGazGRdeeGHstttuhc6CZHQ6ER/9aMS3v93zpx6IiGcj4s0RcVMI0jBet9xyS7zpTW+Kp59+uvADfII0jE5ZYbp7xdisWbPida97XaGzIBnPPBOx884Rv/jF2K/gWoz5EfHniNj2f/4pSMP4XHDBBfG+970vOsO3ZC10liANo7NgmJ4SEVdExFYR0e71oFYrYurUiF/+MmK11Xr97KXIN0pffHFEgQe1hyJiMIbPZHiHIA1jNn/+/Nhmm23itttuE6QhUWWG6QkTJsTs2bMd6KMe/v3fI445prCnH4iIRyNi00Yjjv/udwVpGKO//e1vsckmm8TDDz8sSEOiygzTq666asyZMydWXnnlQmdBEj70oYjzzuvJ6pOLMj8i5kTEjssvHz/52c8EaRijW265JV7/+tfH4OCgIA2Juueee2L6DjvE1++/P3aLAoJ0V7sdMW3a8AllGb5O84zSDz88fJn6Qw8VttMUMXyg75FVVomXPfBANCZPLmwO9LMvfOEL8elPf7rwHaaIiJNPPjkOO+ywwudAP3rggQdi6tSpi73vZa+02+143eteFzfccEO024XtnkH1fvvbiC22GPf9o5dmICL+Mm1arHXDDcPLgwOj9oEPfCDOP//8woN0RMQvf/nL2G677QqfA/3oqquuiunTpxc+p9VqxZ577hnnnHNO4bOgUj/6UcR731v4mKGI+NMBB8Rap51W+CzoR88991xsueWWceeddxa+vzpp0qS47777YvXVVy90DvSrB084IVb/x38sZ9iXvxzxT/9Uzqwe6tly5qX62Mci5s0rNEhHDJ/J8LKHH47G5z5X6BzoV7fddlscd9xxpQTpRqMRn/rUp+Jvf/tb4bOgHx1xxBExVPD7asTwVdm//vWv48tf/nLhs6Ayg4MRH/5wz+7JtyTtiFhr9uzhK1yAUfvhD38Y3//+90sJ0q1WKw455JDCTwCDfvTcc8/FoYceWspVW4ODg3HuuefGRRddVPgsqMxDD0UceGApJzU2I2Kts86KuPnmwmdBP/o//+f/xJw5c0rZXx0YGIijjjqq8DnQl/7851j9uOOiU9YFA//6rxF33FHOrB7KL0rfdVfE2Wf3/D4ni9PodCKOP354Zw0Ylc+VeEJHp9OJxx57LL7+9a+XNhP6xc033xwXXHBBKb/gRAy/Xr/4xS/GE088Uco8KN2Pfxxx002l7a9GoxHxyU8WfsIm9JtOpxOf+MQnSrtN0+DgYNx2221xwQUXlDIP+sl//ud/xh133FHa/mqz2YxPfOITpZxgDZU4+eThlSjL/G/8s58tbxb0iUceeSS+9KUvlfZ+NDg4GOedd17cfvvtpcyDvnLiiRFPPjncFMvQ6UR84QvlzOqh/KL0N79Z/jrpAwMRZ55Z7kzI3J/+9Ke44IILCr+P9IIGBwfjlFNOieeee660mdAPvvGNb5S+lPbTTz8d3/3ud0udCaWZObPc/dVOJ+LeeyMuv7y8mdAHrrrqqvjd735XanRqtVoxc+bM0uZBv5g5c2Y0m+UdwhoaGorbb789fvWrX5U2E0ozf/5wlC7zhMbBwYiLLoq4//7yZkIfOPvss+PZZ58tdWa73Y5TTjml1JmQvaefjvj2t8u7OCFiuFv+539GZLZybF5R+umnI049tdw/2IjhnbSZM8s9exAyd9ppp1VyVvlDDz3k6hMYhUcffTTOPffcUk8g6bKyAX1p7tyIK68sf3+13Y446aRyZ0Lmqjgpa3BwMGbNmuXqExiFW265JW644YZSbjWzoHa7HSeffHKpM6EUP/lJxIMPlj+32Rw+YA+MSKfTqeRkxoGBgTj99NPjySefLH02ZOsHP4h49NHy5w4NRZx+evlzxyGvKH3jjRGPP17N7D/8IeL3v69mNmTokksuKf2gQcTwgYP/+q//Kn0u5OqXv/xlPPPMM6XP7XQ6cfvtt8eDVRwMgSL913+Vcm++lxgYGL5S2hLeMCKdTicuu+yySk7Kajab9ldhFH72s5+Vci/pFxsYGIhLL73UEt70n5/9bPiExrINDkZcckn5cyFTf/zjH0tf1afrqaeeiuuuu670uZCtn/2s/BWeI4aPAV16aflzxyGvKD179vBZdVXOB5ZqcHAwbr755kpmDwwMxLXXXlvJbMjR7NmzKznIt+B86CuzZ1fzi0jE8KpCd91VzWzIzD333BOPV3TCc7PZ9P4Ho1Dl62XevHnxwAMPVDYfCnHddcMnNFbhttuGlw8HlqrK9z/7qzBK115b/op5XbNnZ7XKc6OT0ymf++wT8R//Uckf7vyIOOtlL4sTVl+99NmQm2effTbuueeeSrdhww03LPWeY5Cr+++/P5544olKZrdarfjMZz4Txx57bCXzoRCvfW1Ehcvy/vOaa8ZFK65Y2XzIxWOPPVZpaJowYUK85jWvqWw+5GTu3LmVrGrQdcEFF8R73vOeyuZDT82fH7HsstVF6Yh479SpcefkyZXNh1w8+OCD8dBDD1U2f/nll4+11lqrsvmQi2WHhuL6O++s9grg3/0u4tWvrnILRqyCtVrG4b77KjvboBERkx96KOZU+EYAjNydd95Z9SYAS9FsNl15Qv/5058qGz3/f+bPqXAbgJGZP39+zJkzp+rNAJai0WjEn7yv0k/+/vdKg3RExDO//314B4T0Pf744/ZXYQReEwksSf2nP2UTpSv//2pUKrjnZVcjIiZVNh0A+k+n04lnn3226s2A3nruucpGd8L+KgD0UrPZtL9Kf6lwX7XL/ioA/WRi1RsQEZHR/mpeUXpSdbstnYjI548VANLXaDRiUoXv7VCICRMqG90I+6sA0EtDQ0MxcWIShxqhNxL477n6LA4AvZPE+1oC7+8jlVeUXnPNiFarktFDEfFgJZMBoD91Op1YffXVq94M6K0K/5tuh/1VAOgl+6v0nVVWqezYapf9VQD6SRLvaxntr+Z1T+mttor4/vcrGT0xIv6y5pqx8YorVjIfctLpdOKOO+6obP7EiRPj1ZncQwGq9re//S3+/ve/VzJ7YGAgpk2bVslsKMw220Tcc0/E4GDpoxsR8fDUqbHx5Mmlz4bcPPvss3HPPfdUNn/55ZePtdZaq7L5kJP7778/nnjiicrm21+lr0yaFLHhhhG3317J+IGImL/hhrFxM6/rpKAKjz32WDzwwAOVzV9ttdVi1VVXrWw+5ORPc+fGmgMD1QxfZpmIDTaoZvYY5BWlt946YmiosvFfvuKK+PKGG1Y2H3Ky9dZbx+zZs0uf2263Y4899oizzjqr9NmQox//+Mfx7ne/u7L5W2+9dWWzoRBbbx3xve9VM3vixPjRXXdFtPPaxYcqDA4OxvLLLx9PP/106bObzWZ8+tOfjv/v//v/Sp8NOfriF78Yn/nMZ2KwghO+ll9++Zg6dWrpc6FQ220XcdddERUcPG9vtln8+te/Ln0u5Oiee+6p9KKbc845J3beeefK5kNW9tgj4gc/qOQChdhqq4iMTvbKZ0sjIl7/+oiqrvx4+csj1l+/mtmQobe//e3RqmBJqIGBgZg+fXrpcyFXb3zjG6NdQcBqNBoxderUWHPNNUufDYXaccdqTqJstSLe9CZBGkao1WrF9OnTK9lfHRoasr8Ko7DjjjtWEqTb7Xa89a1vjUajUfpsKNSOO1YSpKPVinjb28qfC5maOnVqvPKVr6xk9sSJE2ObbbapZDZkqcpjQTvtVP7cccgrSi+/fMS++5Z/sK3ZjJgxI6uzDaBqBx10UAxV8BfxCiusEB/4wAdKnwu5etnLXhYf+MAHKgnTRxxxhIN89J9NNx1ewrvs/cbBwYjDDy93JmTusMMOKz10NZvN2HLLLS0HDKOw7bbbxiabbFL6fuPAwEDMmDGj1JlQiv/1vyJWWqn8uYODEYccUv5cyFSj0YjDDz88miX/btlut+NDH/pQrFTF3xOQqz33HF5Gu2ydTsSBB5Y/dxzyq6yHHlr+2XyNRnZ/sFC1qVOnxi677FLq1SetVisOPPDAWHbZZUubCf1gxowZMVDye+vEiRNjv/32K3UmlOaII8o/Q3aNNSLe+c5yZ0Lmdtlll9Lv6zw0NBRHHnlkqTMhd41Go5LXzXrrrRc77rhj6XOhcJMnD8fhMlcLabUi3vpWq1DCKB1wwAGlR2knZcEYLL98xP77l3tBbasVsfvuESX/Tjte+UXpzTePeNe7yvvDbTYjDjoo4hWvKGce9JFPf/rTpV4tPWnSpPjYxz5W2jzoF9ttt13ssMMOpV0t3Ww248gjj4yVV165lHlQuve9L+I1ryn3QN+nP23pbhilVqsVn/3sZ0udN3Xq1PjgBz9Y2kzoF3vvvXe88pWvLPXA/Gc/+9nSQwCU5sgjy72ia3Aw4jOfKW8e9InVV189ZsyYUdr7Ubvdjp133tmqPjAW//iP5R6X6XQiPvWp8ub1SJ5719/6VsSyyw5fwVykZnM4Rn/5y8XOgT617bbbxtFHH13ajtOJJ54Yr3rVq0qZBf2k0WjEGWecERMmTCh8VveA/HHHHVf4LKjMpEkR555bztXS7XbEm99sKUQYowMOOCB22mmnUk7MGhoainPOOSeWqWJZN8jclClT4qyzzirlpOd2ux277rpr7L333oXPgsqsuWbE179ezqxmc3gloTe9qZx50Ge++MUvxlprrVXKapSTJ0+OU089tfA50JemTi2vJTYaEf/8zxEZnkCSZ5R+xSsivvGN4TMBijQ0FHHWWcOX3gNj8oUvfCGmTp1a6IG+VqsVO+64Yxx00EGFzYB+t+6668aJJ55Y+BwH5KmNbbaJOOaYYk+ibDYjJkyIOPPM8u9hDX2i0WjEaaedFpMmTSr0RMpGoxFHH310vPGNbyxsBvS7HXfcMQ499NBCX6vNZjOWXXbZ+M53vlP6PayhdPvtF7HLLsWu7tNqRbzqVRH/9m/FzYA+N2XKlDj77LNLOTFr5syZpd/eBvrKjBkR229f7Htrux2xwQbZrkCS79GrD30o4l//tdgZJ588fL8TYMyWWWaZuOyyy2KllVYq5Iy+drsdG2ywQXz/+9930ADG6eCDD46jjjqq0BlnnHFGbLfddoXOgGR84QsR7353McG42Rz+uOii4bNxgTFbe+214yc/+Um0Wq1CYlez2Yxdd901/u///b89f26om69+9aux0047FfZanTBhQlx88cWx5ppr9vz5ITmNRsR//EfEJpsUc/C81YpYccWIn/0sYsqU3j8/1Mhb3vKW+Na3vlXojGOOOSb222+/QmdA32s2Iy64IGK99YpZyrvdjnjZyyIuu2x4lb4M5RulIyI+//kX1kzvVYzq/mJz0kkRhx3Wm+eEmnv1q18d11xzTay22mo9vWK61WrFxhtvHFdddVWsssoqPXteqKtGoxEnnHBCz+/N3mw2o9FoxOmnnx777rtvT58bktZuR/znf0a85z29vWK61Rq+QvonP3ECJfTIDjvsEJdccklMnDixp/urjUYj3vnOd8YPfvCDUm6TAf1u4sSJ8aMf/Sh23nnnnp6U3G63Y/LkyXHZZZdZ0YB6WWmliCuuiNhss96G6e5B85//fPhqLmDcDjrooPjmN78ZjUajZydndd9LjznmGCdQQq+suurw+9/66/f2vbXVinj5yyNmzYpYZ53ePW/J8o7SjcZwmD733OEltsf7B9xqDf8H89OfDl9mD/TMRhttFLNnz46ddtopImJcBxC6O1777bdfzJo1K1ZfffWebCMw/Po64YQT4tRTT40pU6aM+8B8s9mMV7ziFXH55ZfH/vvv36OthIxMnBjx//7f8FXT7fb4z5RtNCI23DDi2msjdt65N9sIRETEW9/61rj++utj4403Hnfsarfb0W6347jjjosf/vCHMXny5B5tJbDMMsvEhRdeGMcee2w0m81xr8jVaDRi0003jRtuuCHe8pa39GgrISPdg+cHHjj8v3sRu6ZPj5g9O+K1rx3/cwHPO+SQQ+LSSy+N1Vdffdzvf+12O6ZMmRJnnnlmfOlLX7ICJfTSGmtE/OpXEXvvPfy/x/Pe2n1t7rprxI03RrzmNePfvgrlHaW7PvShiDvuGP5DiRj9wb7uX+Avfh6gp9Zcc824+OKL48wzz4zll18+Go3GqHZ4ujtba6yxRlx66aVx6qmnxgorrFDU5kJtNRqN+MhHPhJz5syJ6dOnR0SMOk63Wq1oNBpx4IEHxpw5c2LHHXcsYlMhD61WxCc/GXHzzRGbbjr8udHurzabw9/zqU8NP88WW/R8M4GITTfdNGbPnh2f/exnY8KECaO+CqX7frnJJpvE7Nmz49hjj+3pldfAsAkTJsRxxx0XN9xwQ2y00UYREaM+ON9drvsLX/hCXH/99bHJJpsUsamQh+WWi/jmNyP+678iusvXj+Y11WgMfyy3XMSppw4vK+q+tFCIt7/97XHHHXfEvvvuG41GY9Tvf9190wWfByjAiitGnHnm8Cp3q602/LnRvF67v4uuuOLwhbkXXjgcuzPX6HQ6nao3oqd+/euIU06JOOusiGeeeeEPeXDwhce02xFDQ8MfK6wQcdBBEYccMnw5PVCKJ598Mr73ve/F1772tfjtb38bEcMHFubPn//8YxqNRrTb7ec/96Y3vSmOOOKIeM973mP5QyjR7Nmz4+STT47vfve78dxzzz3/C8/gAu+t7XY7BgcHo9PpxEorrRQf/ehH4+CDD46p7nULC+t0Iq6+OuLkk4fvMzQ4uPC+adeECREDA8OPf8UrIg4/POIjHxleqgkoxYMPPhinn356nHTSSfHAAw9ExEv3V5vNZjSbzRgYGIhmsxnvfve74/DDD4/p06e72gRKMjQ0FP/93/8dJ510Ulx00UXR6XQW2jftWvD1+6pXvSqOOOKI2H///WPVVVetatMhTfPnR/z4xxEzZw7vt0YM768ODg7vm3ZNmDD82IiIjTeOOOqo4Qt+lluu/G2Gmrr77rvjW9/6Vnz729+ORx99dKF9065WqxWdTieGhoZi8uTJsc8++8Shhx4aW265ZYVbDjXz3HMR558//N76y18Of67dHj7us6AF31s322z4vXWPPSKWXbbc7S1Q/0XprieeiLjhhuHL2WfPjvjznyOefTZi8uSIV70qYuutI6ZNG/5YZpmqtxZqq9PpxJ133hk33nhjzJ49O37zm9/EE088Ea1WK1ZYYYXYbLPNYtq0afGGN7wh1sn4XgnQDx577LG4/vrrY/bs2XHTTTfFX/7yl3j22Wdj8uTJse6668a0adOe/5g0aVLVmwvp+/vfI66/fnh/9aabIubNG/5FZdllh5dj6u6vbrFFb+9DBIzK4OBg/PrXv47Zs2fH7NmzY+7cufHUU0/FhAkTYpVVVoktt9wypk2bFttss02s1j0DHqjEX//61+f3V2+++eaYN29ezJ8/P6ZMmRIbbLDB8/uqm2++ec/uxwl97f77X9hfvfXWiEcfHY7Tyy0Xsckmw/urW28dsdFGLywvCpTumWeeeX5fdfbs2fGHP/whnnnmmZg0aVKsscYaz7//veENb4jll1++6s2Ferv33uH31tmzI267bfi9tdMZvkXxa187fBxo660jNtigL99b+zdKAwAAAAAAAFA5p4UCAAAAAAAAUBhRGgAAAAAAAIDCiNIAAAAAAAAAFEaUBgAAAAAAAKAwojQAAAAAAAAAhRGlAQAAAAAAACiMKA0AAAAAAABAYURpAAAAAAAAAAojSgMAAAAAAABQGFEaAAAAAAAAgMKI0gAAAAAAAAAURpQGAAAAAAAAoDCiNAAAAAAAAACFEaUBAAAAAAAAKIwoDQAAAAAAAEBhRGkAAAAAAAAACiNKAwAAAAAAAFAYURoAAAAAAACAwojSAAAAAAAAABRGlAYAAAAAAACgMKI0AAAAAAAAAIURpQEAAAAAAAAojCgNAAAAAAAAQGFEaQAAAAAAAAAKI0oDAAAAAAAAUBhRGgAAAAAAAIDCiNIAAAAAAAAAFEaUBgAAAAAAAKAwojQAAAAAAAAAhRGlAQAAAAAAACiMKA0AAAAAAABAYURpAAAAAAAAAAojSgMAAAAAAABQGFEaAAAAAAAAgMKI0gAAAAAAAAAURpQGAAAAAAAAoDCiNAAAAAAAAACFEaUBAAAAAAAAKIwoDQAAAAAAAEBhRGkAAAAAAAAACiNKAwAAAAAAAFAYURoAAAAAAACAwvz/iIRvwqnXmcAAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1026,9 +1052,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3 [Braket]", "language": "python", - "name": "python3" + "name": "python3_aws_braket_kwx6dl" }, "language_info": { "codemirror_mode": { @@ -1040,7 +1066,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/tutorial/jyoti.ipynb b/tutorial/jyoti.ipynb new file mode 100644 index 00000000..b8c8a37d --- /dev/null +++ b/tutorial/jyoti.ipynb @@ -0,0 +1,51 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "87bfeccb-4ebd-47f9-91ba-48341c9b7a59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "yay\n" + ] + } + ], + "source": [ + "print(\"yay\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f39635a-5996-4729-a94b-c4c20bcd099e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/small_kings_graph_mis.json b/tutorial/small_kings_graph_mis.json index 25fa60ee..164ee9a0 100644 --- a/tutorial/small_kings_graph_mis.json +++ b/tutorial/small_kings_graph_mis.json @@ -11,10 +11,10 @@ ], "post_sequence": [ 1, - 0, 1, 1, 1, + 0, 1 ] }, @@ -32,8 +32,8 @@ 0, 1, 1, - 1, - 0 + 0, + 1 ] }, { @@ -46,12 +46,12 @@ 1 ], "post_sequence": [ - 1, 0, 1, 1, 1, - 0 + 0, + 1 ] }, { @@ -64,10 +64,10 @@ 1 ], "post_sequence": [ - 1, 0, 1, 1, + 1, 0, 1 ] @@ -82,10 +82,10 @@ 1 ], "post_sequence": [ - 1, 0, 1, 1, + 1, 0, 1 ] @@ -280,11 +280,11 @@ 1 ], "post_sequence": [ - 0, 0, 1, 1, 1, + 0, 1 ] }, @@ -298,9 +298,9 @@ 1 ], "post_sequence": [ - 0, 0, 1, + 0, 1, 1, 1 @@ -316,9 +316,9 @@ 1 ], "post_sequence": [ - 0, 0, 1, + 0, 1, 1, 1 @@ -374,7 +374,7 @@ 0, 1, 1, - 0, + 1, 1 ] }, @@ -392,7 +392,7 @@ 0, 1, 1, - 0, + 1, 1 ] },