Repository: ThalesGroup/kessler-game (language: python)

Issue:
Origin/type hinting and mypyc



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml
index da1cff4..6f6a2c2 100644
--- a/.github/workflows/publish-to-pypi.yml
+++ b/.github/workflows/publish-to-pypi.yml
@@ -18,7 +18,7 @@ jobs:
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Set up Python  
+      - name: Set up Python
         uses: actions/setup-python@v4
         with:
           python-version: '3.10'
@@ -32,4 +32,5 @@ jobs:
           TWINE_PASSWORD: ${{secrets.PYPI_API_TOKEN}}
         run: |
           python setup.py sdist bdist_wheel
-          twine upload dist/*
+          python setup_mypyc.py sdist bdist_wheel
+          twine upload --skip-existing dist/*
diff --git a/examples/original_timings.csv b/examples/original_timings.csv
new file mode 100644
index 0000000..351b73a
--- /dev/null
+++ b/examples/original_timings.csv
@@ -0,0 +1,5000 @@
+    0.032117
+    0.018268
+    0.036241
+    0.007172
+    0.033650
+    0.030776
+    0.035119
+    0.013449
+    0.025453
+    0.039954
+    0.038228
+    0.041217
+    0.012165
+    0.037821
+    0.039266
+    0.046847
+    0.010411
+    0.026908
+    0.039925
+    0.009043
+    0.037804
+    0.020503
+    0.032541
+    0.025810
+    0.040550
+    0.037069
+    0.014936
+    0.017189
+    0.036590
+    0.016068
+    0.025088
+    0.041359
+    0.013641
+    0.036269
+    0.038258
+    0.030270
+    0.028357
+    0.039208
+    0.038191
+    0.009271
+    0.022251
+    0.039269
+    0.038575
+    0.025407
+    0.038723
+    0.036844
+    0.016684
+    0.005826
+    0.021612
+    0.017092
+    0.039528
+    0.038224
+    0.019557
+    0.035613
+    0.036234
+    0.040885
+    0.031381
+    0.039157
+    0.039748
+    0.042205
+    0.039007
+    0.038155
+    0.025223
+    0.033608
+    0.017948
+    0.032220
+    0.031960
+    0.028786
+    0.023161
+    0.022576
+    0.015544
+    0.039365
+    0.012411
+    0.017622
+    0.010675
+    0.038165
+    0.034269
+    0.035738
+    0.020407
+    0.041102
+    0.021487
+    0.015828
+    0.039144
+    0.038599
+    0.036918
+    0.029331
+    0.019527
+    0.015885
+    0.030092
+    0.009953
+    0.029791
+    0.022348
+    0.037425
+    0.007653
+    0.037727
+    0.027442
+    0.028912
+    0.026245
+    0.033066
+    0.006576
+    0.041124
+    0.040920
+    0.022670
+    0.035989
+    0.036939
+    0.035371
+    0.025520
+    0.041162
+    0.044573
+    0.017930
+    0.037158
+    0.021371
+    0.025620
+    0.017387
+    0.038225
+    0.037817
+    0.018643
+    0.021376
+    0.036843
+    0.036854
+    0.040128
+    0.029462
+    0.025394
+    0.030891
+    0.038024
+    0.035602
+    0.014514
+    0.012584
+    0.037648
+    0.021998
+    0.039700
+    0.007692
+    0.014993
+    0.010198
+    0.046018
+    0.009904
+    0.032563
+    0.036145
+    0.013195
+    0.033686
+    0.029236
+    0.039636
+    0.031698
+    0.026908
+    0.008549
+    0.038623
+    0.021964
+    0.041063
+    0.040285
+    0.039536
+    0.035153
+    0.028306
+    0.015617
+    0.038191
+    0.037390
+    0.014111
+    0.010031
+    0.040723
+    0.037566
+    0.040169
+    0.038145
+    0.004777
+    0.039757
+    0.035106
+    0.042078
+    0.045716
+    0.017658
+    0.039901
+    0.019300
+    0.051175
+    0.012531
+    0.018991
+    0.024209
+    0.028219
+    0.036567
+    0.040993
+    0.018336
+    0.040312
+    0.004482
+    0.038232
+    0.037718
+    0.037925
+    0.016455
+    0.040863
+    0.043540
+    0.027817
+    0.013429
+    0.033485
+    0.031054
+    0.034194
+    0.004641
+    0.003789
+    0.018133
+    0.033272
+    0.005121
+    0.030929
+    0.018843
+    0.035448
+    0.019567
+    0.035352
+    0.047432
+    0.005313
+    0.038002
+    0.025225
+    0.024687
+    0.005575
+    0.026931
+    0.039827
+    0.026981
+    0.010773
+    0.044683
+    0.017041
+    0.021842
+    0.029268
+    0.046173
+    0.042317
+    0.040202
+    0.024745
+    0.011374
+    0.024555
+    0.039223
+    0.021983
+    0.041593
+    0.024832
+    0.015630
+    0.038206
+    0.010626
+    0.039617
+    0.003903
+    0.040299
+    0.036237
+    0.040987
+    0.004034
+    0.037538
+    0.038443
+    0.037712
+    0.039012
+    0.039135
+    0.038535
+    0.042028
+    0.041776
+    0.045013
+    0.014573
+    0.032895
+    0.019410
+    0.029211
+    0.018853
+    0.008220
+    0.026285
+    0.010791
+    0.003930
+    0.027732
+    0.014766
+    0.037749
+    0.023990
+    0.037459
+    0.019988
+    0.008224
+    0.021519
+    0.019048
+    0.009256
+    0.037526
+    0.009288
+    0.004052
+    0.040178
+    0.022230
+    0.009397
+    0.032390
+    0.025360
+    0.025088
+    0.026040
+    0.018279
+    0.023282
+    0.023174
+    0.024450
+    0.013532
+    0.035056
+    0.036639
+    0.036934
+    0.035663
+    0.038150
+    0.017346
+    0.026845
+    0.025525
+    0.033770
+    0.040395
+    0.036941
+    0.039538
+    0.011226
+    0.039036
+    0.031496
+    0.020267
+    0.044329
+    0.026106
+    0.030588
+    0.037553
+    0.015527
+    0.022586
+    0.039602
+    0.041550
+    0.038756
+    0.028121
+    0.041114
+    0.034878
+    0.008092
+    0.024137
+    0.028268
+    0.016529
+    0.038020
+    0.029723
+    0.009661
+    0.010010
+    0.025676
+    0.040936
+    0.042557
+    0.042488
+    0.040654
+    0.043822
+    0.025437
+    0.034272
+    0.037605
+    0.025256
+    0.038434
+    0.029252
+    0.038066
+    0.041940
+    0.014592
+    0.031851
+    0.021992
+    0.042432
+    0.039605
+    0.033334
+    0.016043
+    0.015916
+    0.034647
+    0.037074
+    0.043163
+    0.037271
+    0.037507
+    0.035006
+    0.018312
+    0.044352
+    0.040753
+    0.040395
+    0.041170
+    0.020504
+    0.039911
+    0.045675
+    0.035507
+    0.038602
+    0.019004
+    0.011594
+    0.020479
+    0.039378
+    0.014903
+    0.041473
+    0.033426
+    0.033602
+    0.007584
+    0.016474
+    0.018710
+    0.039190
+    0.041743
+    0.025682
+    0.031918
+    0.030619
+    0.020354
+    0.038306
+    0.026143
+    0.020148
+    0.031613
+    0.021730
+    0.024549
+    0.036103
+    0.043498
+    0.039209
+    0.029092
+    0.022552
+    0.040150
+    0.026444
+    0.038425
+    0.042011
+    0.040360
+    0.027007
+    0.036128
+    0.040657
+    0.010773
+    0.037537
+    0.032452
+    0.043083
+    0.031081
+    0.022017
+    0.039286
+    0.040017
+    0.021356
+    0.034414
+    0.038299
+    0.027497
+    0.007458
+    0.021471
+    0.041904
+    0.038096
+    0.007282
+    0.038057
+    0.019097
+    0.042914
+    0.027951
+    0.039789
+    0.038883
+    0.038221
+    0.022460
+    0.003801
+    0.018656
+    0.024906
+    0.003829
+    0.003695
+    0.004526
+    0.040720
+    0.042818
+    0.037405
+    0.036609
+    0.041018
+    0.036719
+    0.032063
+    0.022267
+    0.038737
+    0.016929
+    0.010767
+    0.037079
+    0.020307
+    0.036673
+    0.004084
+    0.030385
+    0.025370
+    0.010457
+    0.032153
+    0.025395
+    0.016820
+    0.045886
+    0.019812
+    0.039203
+    0.023681
+    0.011146
+    0.024690
+    0.023477
+    0.037466
+    0.026346
+    0.036057
+    0.041715
+    0.035595
+    0.004144
+    0.006417
+    0.045571
+    0.013568
+    0.045355
+    0.024237
+    0.034462
+    0.031802
+    0.024847
+    0.004298
+    0.044316
+    0.019331
+    0.018212
+    0.038151
+    0.033864
+    0.037643
+    0.031856
+    0.013563
+    0.040539
+    0.018626
+    0.038781
+    0.021776
+    0.039298
+    0.010420
+    0.038100
+    0.028699
+    0.037396
+    0.018607
+    0.038409
+    0.034993
+    0.022635
+    0.029177
+    0.015757
+    0.042265
+    0.017547
+    0.040683
+    0.035354
+    0.018370
+    0.038687
+    0.034580
+    0.033308
+    0.039966
+    0.020637
+    0.039694
+    0.038075
+    0.041461
+    0.024861
+    0.038440
+    0.016092
+    0.039169
+    0.041229
+    0.010652
+    0.004551
+    0.037280
+    0.009379
+    0.030846
+    0.025348
+    0.010625
+    0.040213
+    0.020273
+    0.033168
+    0.039808
+    0.030302
+    0.025132
+    0.005366
+    0.011787
+    0.007841
+    0.039088
+    0.016876
+    0.016134
+    0.038072
+    0.009779
+    0.038553
+    0.043053
+    0.041839
+    0.004419
+    0.037225
+    0.039044
+    0.041405
+    0.004165
+    0.037929
+    0.005881
+    0.014823
+    0.032424
+    0.030412
+    0.037154
+    0.031883
+    0.040034
+    0.036508
+    0.016373
+    0.037941
+    0.035607
+    0.017553
+    0.024404
+    0.032056
+    0.024965
+    0.012368
+    0.038693
+    0.037557
+    0.017603
+    0.010737
+    0.037554
+    0.005897
+    0.029342
+    0.006227
+    0.038190
+    0.037256
+    0.038192
+    0.029265
+    0.030024
+    0.041706
+    0.038764
+    0.011387
+    0.041483
+    0.024250
+    0.024462
+    0.013150
+    0.032322
+    0.016554
+    0.037288
+    0.019695
+    0.030166
+    0.039745
+    0.003800
+    0.029402
+    0.038398
+    0.021556
+    0.019006
+    0.010612
+    0.013177
+    0.022834
+    0.041016
+    0.013652
+    0.017107
+    0.009978
+    0.022768
+    0.017424
+    0.021005
+    0.014427
+    0.039074
+    0.023875
+    0.014624
+    0.021229
+    0.004738
+    0.011006
+    0.029865
+    0.035475
+    0.039201
+    0.005700
+    0.005530
+    0.039901
+    0.022553
+    0.043135
+    0.012306
+    0.038947
+    0.028862
+    0.036949
+    0.014927
+    0.025991
+    0.019625
+    0.023640
+    0.039105
+    0.039234
+    0.034223
+    0.014724
+    0.040281
+    0.038853
+    0.036298
+    0.012052
+    0.040120
+    0.009391
+    0.041795
+    0.041085
+    0.028198
+    0.034645
+    0.044778
+    0.041817
+    0.020155
+    0.017856
+    0.024686
+    0.024457
+    0.016549
+    0.007605
+    0.017063
+    0.019909
+    0.043685
+    0.038819
+    0.041871
+    0.042757
+    0.020935
+    0.026491
+    0.015341
+    0.038421
+    0.019056
+    0.035689
+    0.037181
+    0.029885
+    0.019725
+    0.026771
+    0.038933
+    0.009733
+    0.022228
+    0.039163
+    0.038612
+    0.035006
+    0.036387
+    0.037361
+    0.039252
+    0.017199
+    0.009299
+    0.038764
+    0.024530
+    0.025241
+    0.042618
+    0.038533
+    0.037020
+    0.036120
+    0.036819
+    0.024879
+    0.041426
+    0.029628
+    0.037077
+    0.039362
+    0.024084
+    0.008458
+    0.034631
+    0.036230
+    0.044593
+    0.040496
+    0.025127
+    0.037669
+    0.014354
+    0.042314
+    0.026037
+    0.040467
+    0.029684
+    0.008708
+    0.014731
+    0.038739
+    0.040375
+    0.024109
+    0.025289
+    0.038771
+    0.040944
+    0.014324
+    0.036230
+    0.036065
+    0.022679
+    0.041064
+    0.034914
+    0.027962
+    0.041904
+    0.038456
+    0.005909
+    0.040201
+    0.029784
+    0.005996
+    0.042123
+    0.029852
+    0.038388
+    0.019079
+    0.024125
+    0.042386
+    0.032453
+    0.012946
+    0.021200
+    0.010323
+    0.026658
+    0.029184
+    0.040408
+    0.052557
+    0.040549
+    0.010079
+    0.014956
+    0.012854
+    0.031604
+    0.014340
+    0.016019
+    0.022728
+    0.028847
+    0.040075
+    0.042218
+    0.039581
+    0.022723
+    0.035934
+    0.034447
+    0.043590
+    0.017439
+    0.023218
+    0.025117
+    0.021071
+    0.042612
+    0.006751
+    0.037812
+    0.041192
+    0.043368
+    0.019784
+    0.023803
+    0.006567
+    0.003899
+    0.042189
+    0.037492
+    0.013476
+    0.038133
+    0.006036
+    0.033771
+    0.021106
+    0.040121
+    0.022651
+    0.025224
+    0.040236
+    0.041419
+    0.040518
+    0.037693
+    0.040440
+    0.037568
+    0.053265
+    0.039018
+    0.022308
+    0.041242
+    0.040935
+    0.037520
+    0.026564
+    0.036698
+    0.005572
+    0.038993
+    0.038922
+    0.007896
+    0.038067
+    0.019706
+    0.015316
+    0.021217
+    0.027366
+    0.010102
+    0.004450
+    0.006502
+    0.041648
+    0.038386
+    0.022689
+    0.038576
+    0.032679
+    0.008791
+    0.031603
+    0.018961
+    0.040813
+    0.037930
+    0.013508
+    0.016458
+    0.007081
+    0.037972
+    0.005929
+    0.018321
+    0.029436
+    0.015734
+    0.006583
+    0.022726
+    0.016792
+    0.039910
+    0.011825
+    0.036628
+    0.008108
+    0.043344
+    0.040325
+    0.007225
+    0.011108
+    0.038448
+    0.012007
+    0.021609
+    0.004750
+    0.039722
+    0.010907
+    0.040685
+    0.038250
+    0.037658
+    0.043652
+    0.043597
+    0.043221
+    0.038164
+    0.039586
+    0.038817
+    0.004075
+    0.020065
+    0.043484
+    0.037001
+    0.021503
+    0.029414
+    0.028769
+    0.036641
+    0.036001
+    0.039273
+    0.036754
+    0.004100
+    0.037354
+    0.037785
+    0.018915
+    0.038738
+    0.035940
+    0.021138
+    0.026873
+    0.039963
+    0.039677
+    0.037211
+    0.015843
+    0.014154
+    0.004290
+    0.036301
+    0.019961
+    0.044664
+    0.038099
+    0.011447
+    0.003809
+    0.007080
+    0.031954
+    0.039516
+    0.028565
+    0.004167
+    0.039613
+    0.038660
+    0.015024
+    0.007962
+    0.008949
+    0.037511
+    0.038646
+    0.030239
+    0.039486
+    0.018539
+    0.038726
+    0.036799
+    0.037402
+    0.022013
+    0.041351
+    0.015555
+    0.030095
+    0.030817
+    0.039981
+    0.041781
+    0.037767
+    0.037987
+    0.043254
+    0.041953
+    0.041147
+    0.023599
+    0.027827
+    0.020383
+    0.027866
+    0.041547
+    0.036661
+    0.022322
+    0.041535
+    0.037229
+    0.036057
+    0.019404
+    0.036371
+    0.011902
+    0.036951
+    0.037203
+    0.036492
+    0.019892
+    0.010844
+    0.038213
+    0.031711
+    0.021411
+    0.012753
+    0.040235
+    0.038199
+    0.037615
+    0.015397
+    0.017073
+    0.037526
+    0.009284
+    0.034879
+    0.022760
+    0.012272
+    0.037801
+    0.022935
+    0.043205
+    0.008409
+    0.005265
+    0.004173
+    0.043377
+    0.042718
+    0.037162
+    0.020127
+    0.020932
+    0.035928
+    0.037842
+    0.018180
+    0.014501
+    0.012367
+    0.036505
+    0.037038
+    0.015595
+    0.027562
+    0.036778
+    0.042820
+    0.040093
+    0.040588
+    0.034920
+    0.019107
+    0.035442
+    0.031779
+    0.027706
+    0.042730
+    0.038303
+    0.014628
+    0.036036
+    0.020685
+    0.008953
+    0.026018
+    0.024054
+    0.045785
+    0.043709
+    0.029823
+    0.019859
+    0.036397
+    0.039418
+    0.021425
+    0.038678
+    0.010968
+    0.038892
+    0.006915
+    0.050332
+    0.039717
+    0.038306
+    0.038065
+    0.014034
+    0.032883
+    0.038404
+    0.042928
+    0.015192
+    0.038566
+    0.041148
+    0.017899
+    0.018615
+    0.022298
+    0.032941
+    0.010452
+    0.041400
+    0.006290
+    0.036658
+    0.037719
+    0.020815
+    0.027558
+    0.021644
+    0.039693
+    0.014315
+    0.041775
+    0.008772
+    0.019184
+    0.004470
+    0.037427
+    0.041627
+    0.037086
+    0.036095
+    0.018612
+    0.044587
+    0.029683
+    0.010039
+    0.018363
+    0.012999
+    0.036976
+    0.009749
+    0.035387
+    0.010313
+    0.037976
+    0.012599
+    0.006653
+    0.045234
+    0.009557
+    0.041520
+    0.044377
+    0.043102
+    0.041848
+    0.020593
+    0.031011
+    0.015772
+    0.035841
+    0.019926
+    0.042424
+    0.036803
+    0.028331
+    0.011609
+    0.021429
+    0.027916
+    0.040441
+    0.015887
+    0.037017
+    0.012067
+    0.020144
+    0.035997
+    0.004378
+    0.014779
+    0.036513
+    0.044472
+    0.037287
+    0.004918
+    0.039964
+    0.012734
+    0.004212
+    0.028285
+    0.039493
+    0.034630
+    0.036472
+    0.038275
+    0.021745
+    0.039991
+    0.042296
+    0.038874
+    0.010713
+    0.036718
+    0.039404
+    0.021367
+    0.041683
+    0.039625
+    0.030697
+    0.037930
+    0.016485
+    0.038841
+    0.012407
+    0.037902
+    0.022732
+    0.040133
+    0.012095
+    0.031464
+    0.024848
+    0.020501
+    0.017086
+    0.038108
+    0.035655
+    0.030234
+    0.035692
+    0.007624
+    0.036374
+    0.036636
+    0.034846
+    0.035594
+    0.035843
+    0.036269
+    0.036924
+    0.044791
+    0.038812
+    0.034944
+    0.037611
+    0.014366
+    0.031280
+    0.037449
+    0.026194
+    0.039563
+    0.040187
+    0.024437
+    0.039445
+    0.037470
+    0.037159
+    0.008347
+    0.041161
+    0.014734
+    0.013546
+    0.040619
+    0.042630
+    0.015661
+    0.028722
+    0.042676
+    0.036971
+    0.040185
+    0.030588
+    0.026402
+    0.023285
+    0.038979
+    0.036651
+    0.039494
+    0.014939
+    0.037375
+    0.014336
+    0.039069
+    0.017401
+    0.016184
+    0.041103
+    0.013168
+    0.041122
+    0.036835
+    0.041789
+    0.036565
+    0.041627
+    0.031101
+    0.040741
+    0.037854
+    0.040196
+    0.036635
+    0.013773
+    0.036650
+    0.040456
+    0.040243
+    0.038224
+    0.039455
+    0.020560
+    0.013681
+    0.038128
+    0.038923
+    0.014375
+    0.005820
+    0.014066
+    0.041085
+    0.029699
+    0.039369
+    0.019610
+    0.028481
+    0.043251
+    0.020229
+    0.030492
+    0.037417
+    0.037858
+    0.030691
+    0.003835
+    0.011342
+    0.037107
+    0.030315
+    0.037116
+    0.005060
+    0.003702
+    0.036854
+    0.012678
+    0.031886
+    0.041300
+    0.035148
+    0.023371
+    0.041009
+    0.014760
+    0.028996
+    0.014795
+    0.035153
+    0.039625
+    0.027679
+    0.037770
+    0.039614
+    0.041225
+    0.040046
+    0.017583
+    0.008528
+    0.039463
+    0.038750
+    0.031935
+    0.042201
+    0.039941
+    0.013436
+    0.019814
+    0.022210
+    0.020790
+    0.041261
+    0.041979
+    0.015736
+    0.038886
+    0.036156
+    0.038667
+    0.019839
+    0.036164
+    0.018008
+    0.006209
+    0.030953
+    0.037489
+    0.022045
+    0.008530
+    0.040037
+    0.037599
+    0.042561
+    0.016940
+    0.040244
+    0.014067
+    0.017283
+    0.003818
+    0.017143
+    0.038592
+    0.040008
+    0.037620
+    0.037063
+    0.036439
+    0.035082
+    0.028449
+    0.027127
+    0.022224
+    0.035494
+    0.018581
+    0.004353
+    0.019820
+    0.011527
+    0.036860
+    0.041555
+    0.030386
+    0.039032
+    0.038489
+    0.039359
+    0.037600
+    0.039540
+    0.017254
+    0.037406
+    0.039308
+    0.006932
+    0.007941
+    0.020425
+    0.009707
+    0.029191
+    0.039732
+    0.027096
+    0.023380
+    0.013592
+    0.039507
+    0.025891
+    0.024255
+    0.026895
+    0.047050
+    0.019991
+    0.007017
+    0.040013
+    0.005034
+    0.008548
+    0.022891
+    0.012375
+    0.003994
+    0.031334
+    0.030145
+    0.033516
+    0.015484
+    0.015910
+    0.014704
+    0.039869
+    0.013121
+    0.035988
+    0.018099
+    0.012941
+    0.021267
+    0.016706
+    0.037349
+    0.036696
+    0.037339
+    0.025542
+    0.027253
+    0.034852
+    0.014328
+    0.039915
+    0.010529
+    0.021658
+    0.037319
+    0.027860
+    0.030107
+    0.038399
+    0.012541
+    0.020284
+    0.037763
+    0.028125
+    0.039576
+    0.018053
+    0.031904
+    0.041253
+    0.042362
+    0.007251
+    0.035644
+    0.029234
+    0.038327
+    0.038965
+    0.030883
+    0.030248
+    0.018359
+    0.030308
+    0.016198
+    0.020740
+    0.006643
+    0.018081
+    0.036465
+    0.037060
+    0.036908
+    0.009462
+    0.030176
+    0.039540
+    0.039179
+    0.038016
+    0.029092
+    0.023690
+    0.037339
+    0.021221
+    0.040183
+    0.037839
+    0.036580
+    0.027621
+    0.018974
+    0.020934
+    0.037087
+    0.039003
+    0.013407
+    0.037098
+    0.022683
+    0.036299
+    0.037315
+    0.007396
+    0.035596
+    0.042636
+    0.039383
+    0.034465
+    0.036139
+    0.036431
+    0.036788
+    0.020295
+    0.016138
+    0.010416
+    0.014118
+    0.037368
+    0.034769
+    0.035979
+    0.041735
+    0.037461
+    0.037089
+    0.036927
+    0.037130
+    0.027584
+    0.020374
+    0.036409
+    0.016231
+    0.037743
+    0.042017
+    0.009855
+    0.016342
+    0.032654
+    0.033306
+    0.033815
+    0.045655
+    0.030340
+    0.021395
+    0.005016
+    0.027742
+    0.004273
+    0.006183
+    0.034620
+    0.028796
+    0.044810
+    0.027260
+    0.023683
+    0.011547
+    0.034452
+    0.035597
+    0.032429
+    0.034803
+    0.035153
+    0.040887
+    0.022770
+    0.037035
+    0.018114
+    0.037240
+    0.016156
+    0.035494
+    0.035687
+    0.017386
+    0.008881
+    0.040647
+    0.025447
+    0.021161
+    0.024275
+    0.005766
+    0.023155
+    0.022427
+    0.035560
+    0.038548
+    0.018155
+    0.036519
+    0.037497
+    0.007420
+    0.014089
+    0.035913
+    0.018686
+    0.035471
+    0.017926
+    0.036297
+    0.040804
+    0.018215
+    0.022308
+    0.035625
+    0.035312
+    0.012102
+    0.038968
+    0.037348
+    0.022198
+    0.018639
+    0.041944
+    0.040247
+    0.041143
+    0.035384
+    0.037779
+    0.035485
+    0.010516
+    0.022730
+    0.027318
+    0.033446
+    0.005398
+    0.038535
+    0.011519
+    0.018758
+    0.039341
+    0.028222
+    0.025613
+    0.039381
+    0.038261
+    0.037076
+    0.004861
+    0.009203
+    0.038115
+    0.007364
+    0.027094
+    0.038735
+    0.035042
+    0.036906
+    0.007227
+    0.036983
+    0.007344
+    0.016216
+    0.026902
+    0.036486
+    0.003751
+    0.033795
+    0.020125
+    0.026898
+    0.033383
+    0.035023
+    0.034663
+    0.008054
+    0.042527
+    0.022166
+    0.004387
+    0.035020
+    0.038205
+    0.039351
+    0.037100
+    0.027079
+    0.038276
+    0.013181
+    0.024740
+    0.003718
+    0.038557
+    0.005203
+    0.039533
+    0.038286
+    0.017119
+    0.013728
+    0.041423
+    0.037325
+    0.036852
+    0.040163
+    0.013108
+    0.020758
+    0.016342
+    0.038937
+    0.036231
+    0.036889
+    0.040766
+    0.041109
+    0.023691
+    0.035377
+    0.004736
+    0.026539
+    0.018856
+    0.009078
+    0.012149
+    0.035396
+    0.039491
+    0.038101
+    0.038615
+    0.007899
+    0.043121
+    0.006352
+    0.023411
+    0.017605
+    0.040270
+    0.021916
+    0.038068
+    0.037354
+    0.012088
+    0.036833
+    0.037181
+    0.037149
+    0.016470
+    0.030427
+    0.036346
+    0.017726
+    0.038513
+    0.036674
+    0.042462
+    0.025558
+    0.038934
+    0.039328
+    0.035775
+    0.019750
+    0.023442
+    0.037257
+    0.033856
+    0.039518
+    0.024146
+    0.027267
+    0.038332
+    0.010675
+    0.038833
+    0.040154
+    0.037335
+    0.028934
+    0.036948
+    0.025426
+    0.035634
+    0.031351
+    0.039729
+    0.022387
+    0.014381
+    0.027053
+    0.039635
+    0.036099
+    0.037446
+    0.014583
+    0.036821
+    0.039177
+    0.016654
+    0.028319
+    0.017648
+    0.021900
+    0.038010
+    0.025744
+    0.017774
+    0.032633
+    0.036857
+    0.012124
+    0.010540
+    0.042745
+    0.030599
+    0.020647
+    0.038973
+    0.039284
+    0.037883
+    0.031382
+    0.036702
+    0.036106
+    0.016444
+    0.041461
+    0.022562
+    0.037701
+    0.030222
+    0.015788
+    0.038249
+    0.039067
+    0.036930
+    0.017984
+    0.024828
+    0.029591
+    0.038651
+    0.024374
+    0.037622
+    0.040198
+    0.037968
+    0.009414
+    0.035533
+    0.036890
+    0.009392
+    0.013910
+    0.008563
+    0.026946
+    0.020030
+    0.036434
+    0.038708
+    0.042928
+    0.022670
+    0.034912
+    0.026959
+    0.012433
+    0.034423
+    0.003870
+    0.039637
+    0.015010
+    0.034972
+    0.006744
+    0.034988
+    0.033018
+    0.038862
+    0.010940
+    0.037537
+    0.008361
+    0.038732
+    0.037744
+    0.028331
+    0.027960
+    0.022785
+    0.038133
+    0.011860
+    0.008234
+    0.035012
+    0.023231
+    0.037023
+    0.035978
+    0.021903
+    0.024850
+    0.032481
+    0.024470
+    0.037479
+    0.033283
+    0.031523
+    0.026489
+    0.020697
+    0.036875
+    0.040627
+    0.034498
+    0.034708
+    0.039182
+    0.010217
+    0.017070
+    0.035288
+    0.024958
+    0.029280
+    0.035324
+    0.035909
+    0.036523
+    0.027683
+    0.022790
+    0.016814
+    0.015758
+    0.039885
+    0.034334
+    0.038898
+    0.038064
+    0.035495
+    0.022596
+    0.044890
+    0.013664
+    0.037850
+    0.014450
+    0.020144
+    0.024352
+    0.017294
+    0.006201
+    0.036968
+    0.023557
+    0.015564
+    0.040982
+    0.041926
+    0.026719
+    0.028802
+    0.034477
+    0.024624
+    0.044905
+    0.027504
+    0.036763
+    0.004283
+    0.004077
+    0.004363
+    0.035872
+    0.028064
+    0.033170
+    0.020753
+    0.041002
+    0.038770
+    0.029426
+    0.005865
+    0.006894
+    0.015248
+    0.027233
+    0.025389
+    0.018946
+    0.004886
+    0.012794
+    0.009808
+    0.022469
+    0.017411
+    0.035938
+    0.019337
+    0.024022
+    0.013121
+    0.007343
+    0.013014
+    0.014818
+    0.035565
+    0.032385
+    0.025723
+    0.017752
+    0.033404
+    0.036823
+    0.039274
+    0.038247
+    0.017319
+    0.018860
+    0.036165
+    0.016182
+    0.003811
+    0.036900
+    0.018273
+    0.017448
+    0.026353
+    0.022190
+    0.018189
+    0.021444
+    0.029063
+    0.035577
+    0.038513
+    0.029656
+    0.036087
+    0.038290
+    0.029476
+    0.040795
+    0.038331
+    0.019392
+    0.030033
+    0.033783
+    0.038437
+    0.019941
+    0.006707
+    0.028860
+    0.019591
+    0.031288
+    0.019729
+    0.011178
+    0.037311
+    0.035641
+    0.035794
+    0.031524
+    0.036222
+    0.006493
+    0.008509
+    0.035827
+    0.033761
+    0.015767
+    0.036498
+    0.037169
+    0.037206
+    0.039523
+    0.030423
+    0.035288
+    0.015105
+    0.026192
+    0.040246
+    0.024953
+    0.023583
+    0.010247
+    0.035004
+    0.036288
+    0.012029
+    0.021421
+    0.010253
+    0.039031
+    0.007051
+    0.039445
+    0.038886
+    0.040156
+    0.023323
+    0.028340
+    0.018912
+    0.018845
+    0.030636
+    0.035418
+    0.009272
+    0.035465
+    0.020283
+    0.005557
+    0.012171
+    0.014936
+    0.007700
+    0.037578
+    0.032989
+    0.039265
+    0.035337
+    0.041730
+    0.009940
+    0.009936
+    0.034939
+    0.015335
+    0.028552
+    0.025211
+    0.018591
+    0.008243
+    0.035968
+    0.032451
+    0.012001
+    0.037249
+    0.040030
+    0.036209
+    0.017117
+    0.021207
+    0.020550
+    0.034850
+    0.013037
+    0.017862
+    0.008427
+    0.032574
+    0.027802
+    0.036513
+    0.009891
+    0.032379
+    0.041005
+    0.018804
+    0.038473
+    0.039078
+    0.043312
+    0.043709
+    0.036842
+    0.033321
+    0.036451
+    0.037531
+    0.036771
+    0.037016
+    0.034729
+    0.035509
+    0.037918
+    0.010963
+    0.016632
+    0.009921
+    0.035604
+    0.023646
+    0.037305
+    0.036538
+    0.027043
+    0.031530
+    0.040299
+    0.025527
+    0.013678
+    0.035770
+    0.018680
+    0.035920
+    0.042677
+    0.012607
+    0.027018
+    0.023214
+    0.026915
+    0.036810
+    0.016223
+    0.029276
+    0.035896
+    0.031307
+    0.035968
+    0.039590
+    0.006903
+    0.031622
+    0.037472
+    0.015109
+    0.036969
+    0.020758
+    0.029727
+    0.005318
+    0.010956
+    0.027326
+    0.027092
+    0.038114
+    0.013918
+    0.011426
+    0.010456
+    0.013759
+    0.033671
+    0.035783
+    0.036629
+    0.019322
+    0.032818
+    0.019895
+    0.014902
+    0.040574
+    0.024321
+    0.019733
+    0.035289
+    0.037379
+    0.043583
+    0.022889
+    0.036414
+    0.016030
+    0.032932
+    0.041000
+    0.037214
+    0.033816
+    0.032883
+    0.025091
+    0.027681
+    0.010716
+    0.031126
+    0.023330
+    0.030458
+    0.007501
+    0.041838
+    0.020399
+    0.041783
+    0.036222
+    0.014875
+    0.009935
+    0.011017
+    0.008537
+    0.036579
+    0.030234
+    0.015742
+    0.034612
+    0.038978
+    0.011180
+    0.023877
+    0.040780
+    0.009523
+    0.014107
+    0.036036
+    0.018404
+    0.017935
+    0.038444
+    0.017028
+    0.035551
+    0.020193
+    0.027394
+    0.037541
+    0.032880
+    0.017405
+    0.023486
+    0.037860
+    0.040400
+    0.038738
+    0.037606
+    0.033391
+    0.037441
+    0.035197
+    0.019546
+    0.003715
+    0.036813
+    0.019236
+    0.019763
+    0.038777
+    0.022486
+    0.008589
+    0.018300
+    0.017783
+    0.043496
+    0.018349
+    0.019528
+    0.018591
+    0.025032
+    0.035935
+    0.037033
+    0.035667
+    0.022560
+    0.017278
+    0.035003
+    0.025457
+    0.012235
+    0.040446
+    0.042243
+    0.010314
+    0.015426
+    0.012365
+    0.033603
+    0.006410
+    0.037715
+    0.039167
+    0.006331
+    0.036458
+    0.025097
+    0.037142
+    0.039151
+    0.036011
+    0.020664
+    0.037452
+    0.008542
+    0.036168
+    0.041413
+    0.017287
+    0.037551
+    0.014091
+    0.036985
+    0.037916
+    0.034962
+    0.013372
+    0.038284
+    0.035183
+    0.037481
+    0.007252
+    0.023799
+    0.004028
+    0.036808
+    0.038252
+    0.004214
+    0.035444
+    0.003984
+    0.037019
+    0.005390
+    0.040592
+    0.034403
+    0.039259
+    0.043239
+    0.041144
+    0.036292
+    0.019481
+    0.028234
+    0.040472
+    0.013930
+    0.020209
+    0.012026
+    0.034452
+    0.036448
+    0.028301
+    0.015944
+    0.036343
+    0.036503
+    0.021946
+    0.017093
+    0.017925
+    0.037191
+    0.017289
+    0.004244
+    0.029041
+    0.006790
+    0.009785
+    0.004262
+    0.034280
+    0.037844
+    0.007163
+    0.021827
+    0.031481
+    0.014525
+    0.024976
+    0.038015
+    0.022439
+    0.010682
+    0.007744
+    0.037836
+    0.038489
+    0.037006
+    0.024513
+    0.024290
+    0.036463
+    0.035587
+    0.005136
+    0.010328
+    0.040730
+    0.041977
+    0.033914
+    0.030157
+    0.026303
+    0.036005
+    0.036176
+    0.037299
+    0.012399
+    0.012251
+    0.005721
+    0.040704
+    0.017382
+    0.014031
+    0.034069
+    0.011884
+    0.035151
+    0.007563
+    0.029030
+    0.036413
+    0.014255
+    0.019810
+    0.029152
+    0.007969
+    0.033855
+    0.007356
+    0.036899
+    0.034895
+    0.035926
+    0.035135
+    0.038122
+    0.038410
+    0.038118
+    0.004125
+    0.024527
+    0.010779
+    0.035974
+    0.024528
+    0.035013
+    0.020459
+    0.032604
+    0.023775
+    0.035482
+    0.011689
+    0.025507
+    0.023185
+    0.012294
+    0.037163
+    0.013216
+    0.039412
+    0.036730
+    0.037154
+    0.039714
+    0.005721
+    0.013325
+    0.014272
+    0.023886
+    0.031509
+    0.032165
+    0.039562
+    0.018504
+    0.037085
+    0.029767
+    0.033743
+    0.036856
+    0.017417
+    0.039424
+    0.035910
+    0.031181
+    0.011917
+    0.013403
+    0.034803
+    0.016871
+    0.041747
+    0.038547
+    0.030619
+    0.039150
+    0.032774
+    0.020672
+    0.043570
+    0.019070
+    0.003853
+    0.003598
+    0.040778
+    0.021550
+    0.035781
+    0.009614
+    0.016270
+    0.019192
+    0.024348
+    0.010130
+    0.017722
+    0.039716
+    0.010322
+    0.035061
+    0.038958
+    0.027000
+    0.004575
+    0.036695
+    0.009706
+    0.035485
+    0.037795
+    0.005805
+    0.036547
+    0.025023
+    0.036960
+    0.017802
+    0.023573
+    0.017902
+    0.030828
+    0.035338
+    0.034761
+    0.039654
+    0.031279
+    0.017588
+    0.034274
+    0.029495
+    0.036631
+    0.039015
+    0.030327
+    0.007549
+    0.031635
+    0.039962
+    0.025015
+    0.035449
+    0.029745
+    0.028102
+    0.037456
+    0.004177
+    0.028702
+    0.026819
+    0.039618
+    0.028246
+    0.025468
+    0.039283
+    0.038630
+    0.033793
+    0.037921
+    0.025531
+    0.039866
+    0.026756
+    0.036698
+    0.036901
+    0.040281
+    0.018720
+    0.016224
+    0.031787
+    0.026347
+    0.035611
+    0.005586
+    0.018771
+    0.035902
+    0.006009
+    0.023319
+    0.018065
+    0.024213
+    0.036268
+    0.037249
+    0.035198
+    0.014353
+    0.023562
+    0.013666
+    0.030485
+    0.035744
+    0.007206
+    0.035451
+    0.010000
+    0.005925
+    0.037189
+    0.035624
+    0.010928
+    0.022248
+    0.019551
+    0.015040
+    0.037618
+    0.036209
+    0.037374
+    0.021630
+    0.021932
+    0.035472
+    0.007615
+    0.037027
+    0.029208
+    0.016829
+    0.031589
+    0.015261
+    0.035528
+    0.007967
+    0.019982
+    0.036000
+    0.040774
+    0.006535
+    0.006395
+    0.022264
+    0.017672
+    0.035965
+    0.036880
+    0.040958
+    0.030884
+    0.039907
+    0.023785
+    0.037800
+    0.038866
+    0.026948
+    0.020563
+    0.014495
+    0.038735
+    0.037498
+    0.012142
+    0.039574
+    0.016613
+    0.015408
+    0.008399
+    0.028013
+    0.020972
+    0.027285
+    0.025018
+    0.017062
+    0.010588
+    0.035409
+    0.038773
+    0.036180
+    0.017436
+    0.038813
+    0.019856
+    0.008152
+    0.029286
+    0.032161
+    0.037091
+    0.039914
+    0.043457
+    0.036023
+    0.036425
+    0.034751
+    0.037088
+    0.036256
+    0.032547
+    0.040782
+    0.035350
+    0.036231
+    0.039595
+    0.008748
+    0.033001
+    0.016067
+    0.039030
+    0.022879
+    0.035237
+    0.032528
+    0.036244
+    0.037265
+    0.014771
+    0.009560
+    0.026278
+    0.018705
+    0.034422
+    0.032007
+    0.037832
+    0.025070
+    0.008664
+    0.035298
+    0.037070
+    0.030474
+    0.020765
+    0.033972
+    0.035929
+    0.008525
+    0.032213
+    0.029668
+    0.037110
+    0.037649
+    0.005999
+    0.033939
+    0.040197
+    0.038967
+    0.035420
+    0.022901
+    0.037964
+    0.041728
+    0.036933
+    0.032466
+    0.035027
+    0.038003
+    0.039031
+    0.019833
+    0.036337
+    0.024245
+    0.034752
+    0.004134
+    0.035210
+    0.037449
+    0.034377
+    0.039944
+    0.007783
+    0.028593
+    0.031216
+    0.015592
+    0.018474
+    0.021458
+    0.039019
+    0.010128
+    0.036750
+    0.020261
+    0.039709
+    0.018638
+    0.022680
+    0.036216
+    0.038456
+    0.023341
+    0.036073
+    0.041389
+    0.035132
+    0.035176
+    0.038754
+    0.020464
+    0.014338
+    0.037886
+    0.047560
+    0.004515
+    0.038887
+    0.032460
+    0.040770
+    0.038246
+    0.042147
+    0.026651
+    0.040057
+    0.045386
+    0.026016
+    0.031465
+    0.037361
+    0.037779
+    0.008849
+    0.012629
+    0.014874
+    0.039328
+    0.031801
+    0.037569
+    0.036505
+    0.020989
+    0.037310
+    0.032128
+    0.005796
+    0.030076
+    0.036993
+    0.021936
+    0.032295
+    0.026322
+    0.033359
+    0.010590
+    0.015027
+    0.033665
+    0.014661
+    0.037965
+    0.037451
+    0.043263
+    0.018704
+    0.037965
+    0.036295
+    0.042477
+    0.017185
+    0.014745
+    0.036049
+    0.037715
+    0.032515
+    0.005802
+    0.016073
+    0.040746
+    0.037675
+    0.042621
+    0.037139
+    0.007832
+    0.039176
+    0.035704
+    0.024887
+    0.017315
+    0.037333
+    0.012924
+    0.040416
+    0.015357
+    0.034800
+    0.039085
+    0.040775
+    0.040531
+    0.039328
+    0.037854
+    0.037271
+    0.035981
+    0.043004
+    0.035754
+    0.031972
+    0.023069
+    0.010485
+    0.033319
+    0.018267
+    0.011134
+    0.032735
+    0.010438
+    0.005363
+    0.033555
+    0.008943
+    0.032173
+    0.042023
+    0.035794
+    0.021823
+    0.039043
+    0.037331
+    0.037860
+    0.023857
+    0.019516
+    0.020412
+    0.034056
+    0.013816
+    0.012472
+    0.014694
+    0.032870
+    0.035617
+    0.037571
+    0.038958
+    0.021972
+    0.038670
+    0.033122
+    0.031755
+    0.036425
+    0.027281
+    0.040543
+    0.015678
+    0.022147
+    0.033933
+    0.028948
+    0.022161
+    0.012293
+    0.030828
+    0.023552
+    0.011688
+    0.017912
+    0.036678
+    0.019582
+    0.037455
+    0.033054
+    0.034949
+    0.038945
+    0.024647
+    0.027167
+    0.015263
+    0.028909
+    0.009716
+    0.007047
+    0.014239
+    0.037412
+    0.021120
+    0.041015
+    0.011612
+    0.013054
+    0.040649
+    0.036794
+    0.011726
+    0.028537
+    0.017664
+    0.036784
+    0.028718
+    0.026221
+    0.009966
+    0.037103
+    0.023010
+    0.004163
+    0.035336
+    0.038900
+    0.008817
+    0.006662
+    0.011322
+    0.036885
+    0.019915
+    0.010114
+    0.017153
+    0.025638
+    0.003928
+    0.010420
+    0.011570
+    0.035451
+    0.030812
+    0.024740
+    0.028803
+    0.036969
+    0.029479
+    0.037405
+    0.028866
+    0.028310
+    0.020042
+    0.035458
+    0.036634
+    0.033191
+    0.018972
+    0.015471
+    0.039415
+    0.010164
+    0.016805
+    0.016466
+    0.005339
+    0.037284
+    0.018539
+    0.014615
+    0.018285
+    0.007264
+    0.008202
+    0.035440
+    0.022896
+    0.021773
+    0.035329
+    0.040738
+    0.035982
+    0.025545
+    0.035916
+    0.009921
+    0.035884
+    0.037238
+    0.041139
+    0.026409
+    0.035599
+    0.028365
+    0.027636
+    0.003748
+    0.004540
+    0.036200
+    0.035458
+    0.014432
+    0.026435
+    0.006145
+    0.038018
+    0.022479
+    0.017114
+    0.032936
+    0.035056
+    0.036082
+    0.009073
+    0.008196
+    0.034230
+    0.023980
+    0.035844
+    0.024358
+    0.022276
+    0.031142
+    0.036651
+    0.035090
+    0.020223
+    0.005081
+    0.023238
+    0.017690
+    0.029777
+    0.034972
+    0.006339
+    0.011609
+    0.039003
+    0.030756
+    0.012613
+    0.030650
+    0.022638
+    0.035865
+    0.011628
+    0.024041
+    0.005517
+    0.010158
+    0.010820
+    0.007736
+    0.019899
+    0.036273
+    0.041400
+    0.039556
+    0.016708
+    0.016803
+    0.013437
+    0.016168
+    0.037289
+    0.020986
+    0.035510
+    0.005993
+    0.006419
+    0.034317
+    0.016965
+    0.033852
+    0.018245
+    0.031185
+    0.036253
+    0.032124
+    0.035963
+    0.013318
+    0.035354
+    0.035876
+    0.035544
+    0.036611
+    0.014432
+    0.020049
+    0.019283
+    0.038515
+    0.032176
+    0.021090
+    0.025620
+    0.021101
+    0.039728
+    0.016891
+    0.035629
+    0.035476
+    0.038647
+    0.033719
+    0.037360
+    0.024456
+    0.013099
+    0.033701
+    0.036207
+    0.035794
+    0.035620
+    0.007515
+    0.040598
+    0.017162
+    0.014207
+    0.040079
+    0.021957
+    0.021369
+    0.026283
+    0.034825
+    0.037615
+    0.034807
+    0.039193
+    0.039892
+    0.037431
+    0.018197
+    0.033820
+    0.028652
+    0.021122
+    0.039961
+    0.016429
+    0.033519
+    0.021072
+    0.008941
+    0.031293
+    0.005237
+    0.018230
+    0.035090
+    0.038381
+    0.012246
+    0.019690
+    0.033697
+    0.036565
+    0.036510
+    0.019006
+    0.034976
+    0.032193
+    0.005825
+    0.022510
+    0.039759
+    0.038224
+    0.036494
+    0.016302
+    0.038218
+    0.031982
+    0.015136
+    0.031413
+    0.038871
+    0.032173
+    0.015740
+    0.024291
+    0.036278
+    0.012168
+    0.036900
+    0.035842
+    0.030854
+    0.005954
+    0.035421
+    0.022000
+    0.016315
+    0.018981
+    0.019177
+    0.015842
+    0.037695
+    0.015516
+    0.017211
+    0.010915
+    0.014668
+    0.035141
+    0.034583
+    0.023790
+    0.026902
+    0.038448
+    0.016172
+    0.033440
+    0.013543
+    0.026239
+    0.019673
+    0.008516
+    0.041391
+    0.034109
+    0.004023
+    0.040108
+    0.023023
+    0.024487
+    0.034983
+    0.022373
+    0.037318
+    0.039364
+    0.026831
+    0.015351
+    0.034613
+    0.004589
+    0.037865
+    0.036139
+    0.037167
+    0.011340
+    0.011515
+    0.020938
+    0.033138
+    0.020482
+    0.037392
+    0.016095
+    0.038333
+    0.037449
+    0.019287
+    0.029155
+    0.019032
+    0.011377
+    0.026832
+    0.021516
+    0.010193
+    0.032055
+    0.016853
+    0.037585
+    0.009201
+    0.039498
+    0.034520
+    0.022395
+    0.035452
+    0.004019
+    0.025956
+    0.014982
+    0.008076
+    0.012582
+    0.008659
+    0.011238
+    0.003654
+    0.028548
+    0.036618
+    0.034448
+    0.028239
+    0.039342
+    0.026021
+    0.035153
+    0.010953
+    0.008669
+    0.014336
+    0.036963
+    0.020410
+    0.022809
+    0.033695
+    0.015982
+    0.037978
+    0.021486
+    0.037446
+    0.017518
+    0.037607
+    0.037013
+    0.035265
+    0.038214
+    0.039930
+    0.038520
+    0.028030
+    0.014271
+    0.039347
+    0.007021
+    0.033952
+    0.024422
+    0.009627
+    0.033916
+    0.035705
+    0.040184
+    0.034391
+    0.037097
+    0.027701
+    0.034798
+    0.035689
+    0.038240
+    0.032507
+    0.041460
+    0.014521
+    0.027295
+    0.023226
+    0.013282
+    0.035000
+    0.029275
+    0.015892
+    0.034896
+    0.005665
+    0.039801
+    0.025327
+    0.007644
+    0.026897
+    0.016122
+    0.034685
+    0.031523
+    0.023999
+    0.018577
+    0.037195
+    0.037286
+    0.028163
+    0.010598
+    0.017345
+    0.036104
+    0.020355
+    0.034028
+    0.039456
+    0.015739
+    0.035412
+    0.004680
+    0.013390
+    0.041335
+    0.035265
+    0.026838
+    0.039938
+    0.034084
+    0.024985
+    0.030278
+    0.029856
+    0.035485
+    0.040505
+    0.035448
+    0.026829
+    0.040499
+    0.029614
+    0.035442
+    0.019510
+    0.039145
+    0.036729
+    0.037726
+    0.028314
+    0.014948
+    0.032468
+    0.024122
+    0.035296
+    0.005295
+    0.036842
+    0.036917
+    0.033985
+    0.026152
+    0.034749
+    0.004597
+    0.035440
+    0.036734
+    0.019664
+    0.021627
+    0.015508
+    0.040394
+    0.022878
+    0.041697
+    0.004059
+    0.028371
+    0.032765
+    0.023406
+    0.035303
+    0.034665
+    0.019645
+    0.041821
+    0.036347
+    0.035544
+    0.017834
+    0.034570
+    0.014597
+    0.020333
+    0.020336
+    0.029343
+    0.038006
+    0.026436
+    0.022376
+    0.032147
+    0.008158
+    0.013517
+    0.034741
+    0.034718
+    0.035254
+    0.025145
+    0.023562
+    0.035874
+    0.018261
+    0.007842
+    0.006213
+    0.012902
+    0.027352
+    0.005759
+    0.025471
+    0.005962
+    0.008101
+    0.010175
+    0.037364
+    0.036486
+    0.049028
+    0.034278
+    0.012741
+    0.038188
+    0.038137
+    0.016047
+    0.040007
+    0.036277
+    0.015134
+    0.034895
+    0.020802
+    0.037846
+    0.038642
+    0.032291
+    0.034982
+    0.022798
+    0.008426
+    0.017468
+    0.014762
+    0.022738
+    0.019155
+    0.024461
+    0.017893
+    0.034256
+    0.024568
+    0.025987
+    0.011650
+    0.018206
+    0.015216
+    0.015914
+    0.020328
+    0.020240
+    0.034670
+    0.006127
+    0.027819
+    0.039466
+    0.039254
+    0.038414
+    0.008172
+    0.038159
+    0.039059
+    0.037322
+    0.035811
+    0.036966
+    0.016797
+    0.019568
+    0.014445
+    0.036838
+    0.035801
+    0.024341
+    0.007820
+    0.036285
+    0.018973
+    0.009151
+    0.025812
+    0.036273
+    0.035905
+    0.032735
+    0.036488
+    0.027505
+    0.008310
+    0.017054
+    0.007580
+    0.027151
+    0.035902
+    0.007838
+    0.024959
+    0.037705
+    0.037115
+    0.037469
+    0.010897
+    0.038166
+    0.036201
+    0.039602
+    0.035668
+    0.036971
+    0.013453
+    0.038595
+    0.009931
+    0.035607
+    0.040150
+    0.010242
+    0.035015
+    0.029360
+    0.023801
+    0.018180
+    0.029760
+    0.007961
+    0.035376
+    0.018584
+    0.036063
+    0.035701
+    0.036092
+    0.015464
+    0.023601
+    0.027470
+    0.010273
+    0.020064
+    0.036885
+    0.003940
+    0.011533
+    0.027252
+    0.037079
+    0.025356
+    0.035960
+    0.034844
+    0.039455
+    0.007827
+    0.017841
+    0.003975
+    0.034818
+    0.012695
+    0.008401
+    0.011360
+    0.041504
+    0.010474
+    0.034873
+    0.038307
+    0.035109
+    0.005186
+    0.034968
+    0.038149
+    0.043311
+    0.040242
+    0.012682
+    0.041820
+    0.035730
+    0.027608
+    0.033955
+    0.035378
+    0.007622
+    0.012472
+    0.020179
+    0.013546
+    0.038698
+    0.012395
+    0.033687
+    0.023720
+    0.019594
+    0.028281
+    0.035852
+    0.025665
+    0.004156
+    0.034985
+    0.013506
+    0.038714
+    0.033613
+    0.022297
+    0.019135
+    0.006919
+    0.034999
+    0.022282
+    0.040762
+    0.018915
+    0.035303
+    0.010942
+    0.011363
+    0.035197
+    0.038381
+    0.035410
+    0.019736
+    0.033562
+    0.033863
+    0.041601
+    0.008620
+    0.020307
+    0.035140
+    0.036540
+    0.021289
+    0.033656
+    0.008878
+    0.025895
+    0.035863
+    0.040360
+    0.008971
+    0.014915
+    0.037176
+    0.022891
+    0.006714
+    0.036251
+    0.021745
+    0.037746
+    0.035749
+    0.007391
+    0.026101
+    0.030091
+    0.039027
+    0.034673
+    0.042210
+    0.033567
+    0.027969
+    0.036043
+    0.035773
+    0.025326
+    0.024160
+    0.041932
+    0.036124
+    0.034613
+    0.010476
+    0.035340
+    0.036435
+    0.040506
+    0.020356
+    0.030562
+    0.038578
+    0.024763
+    0.036025
+    0.018788
+    0.022158
+    0.039482
+    0.013769
+    0.010663
+    0.029756
+    0.004090
+    0.018166
+    0.028506
+    0.021399
+    0.021849
+    0.007349
+    0.037346
+    0.036054
+    0.035065
+    0.027360
+    0.034533
+    0.040105
+    0.036950
+    0.038817
+    0.032185
+    0.030937
+    0.005907
+    0.003876
+    0.019601
+    0.037636
+    0.028129
+    0.016654
+    0.004958
+    0.028715
+    0.034961
+    0.018245
+    0.040006
+    0.005472
+    0.018926
+    0.037170
+    0.032090
+    0.010438
+    0.027418
+    0.023184
+    0.021527
+    0.034825
+    0.010719
+    0.031275
+    0.034348
+    0.003964
+    0.033820
+    0.025839
+    0.026187
+    0.018415
+    0.010967
+    0.029653
+    0.034384
+    0.040578
+    0.036246
+    0.018556
+    0.004142
+    0.041224
+    0.005358
+    0.032458
+    0.017437
+    0.036028
+    0.039509
+    0.036658
+    0.026125
+    0.006883
+    0.013559
+    0.017834
+    0.034675
+    0.035498
+    0.035453
+    0.004450
+    0.034409
+    0.033346
+    0.015168
+    0.037214
+    0.040332
+    0.027839
+    0.041137
+    0.014946
+    0.035851
+    0.025904
+    0.004688
+    0.038248
+    0.039192
+    0.029397
+    0.039919
+    0.019612
+    0.020244
+    0.036731
+    0.016568
+    0.028633
+    0.019764
+    0.026612
+    0.027553
+    0.035958
+    0.006209
+    0.026689
+    0.016727
+    0.036430
+    0.035979
+    0.028583
+    0.037138
+    0.014957
+    0.007927
+    0.037483
+    0.025754
+    0.035160
+    0.010519
+    0.035440
+    0.003892
+    0.022462
+    0.031380
+    0.012777
+    0.016180
+    0.017280
+    0.037058
+    0.035065
+    0.028662
+    0.043152
+    0.035082
+    0.038935
+    0.036427
+    0.011675
+    0.014172
+    0.030448
+    0.050495
+    0.035675
+    0.034341
+    0.038008
+    0.026424
+    0.010198
+    0.036789
+    0.022198
+    0.019926
+    0.039524
+    0.008218
+    0.036035
+    0.034271
+    0.014641
+    0.028805
+    0.037805
+    0.034281
+    0.026901
+    0.012604
+    0.003838
+    0.034755
+    0.003706
+    0.040405
+    0.020466
+    0.014484
+    0.010899
+    0.017873
+    0.036040
+    0.012895
+    0.034463
+    0.033904
+    0.039540
+    0.005680
+    0.024316
+    0.037568
+    0.035873
+    0.036495
+    0.031215
+    0.010957
+    0.023518
+    0.035364
+    0.030101
+    0.022582
+    0.006143
+    0.038127
+    0.030795
+    0.035432
+    0.032084
+    0.017864
+    0.036484
+    0.034770
+    0.021250
+    0.034986
+    0.020395
+    0.035777
+    0.023648
+    0.007439
+    0.007613
+    0.034201
+    0.017729
+    0.038121
+    0.035772
+    0.012678
+    0.035130
+    0.038059
+    0.032089
+    0.010712
+    0.026587
+    0.038587
+    0.037982
+    0.021927
+    0.015123
+    0.039634
+    0.040307
+    0.004270
+    0.034556
+    0.023752
+    0.036551
+    0.038211
+    0.015397
+    0.016049
+    0.021400
+    0.037387
+    0.014288
+    0.022780
+    0.034895
+    0.024843
+    0.039962
+    0.010863
+    0.039672
+    0.036425
+    0.006312
+    0.036019
+    0.033853
+    0.023573
+    0.004648
+    0.035817
+    0.003981
+    0.004907
+    0.026158
+    0.016764
+    0.033979
+    0.035940
+    0.036564
+    0.003719
+    0.017946
+    0.036157
+    0.036338
+    0.035820
+    0.019111
+    0.015158
+    0.037002
+    0.025150
+    0.013509
+    0.029956
+    0.034640
+    0.025412
+    0.038765
+    0.014168
+    0.038996
+    0.037720
+    0.034477
+    0.036857
+    0.007246
+    0.012480
+    0.018667
+    0.008982
+    0.026111
+    0.026934
+    0.030951
+    0.012544
+    0.022461
+    0.031830
+    0.035999
+    0.037579
+    0.038277
+    0.004378
+    0.036641
+    0.034309
+    0.012898
+    0.035601
+    0.035566
+    0.026862
+    0.031213
+    0.036750
+    0.024685
+    0.016403
+    0.019532
+    0.036855
+    0.009084
+    0.024083
+    0.036086
+    0.036821
+    0.040617
+    0.010486
+    0.037894
+    0.004080
+    0.023710
+    0.038423
+    0.034866
+    0.024455
+    0.031003
+    0.023898
+    0.031370
+    0.039295
+    0.016739
+    0.009175
+    0.020548
+    0.025350
+    0.003669
+    0.034872
+    0.035658
+    0.039517
+    0.036967
+    0.025316
+    0.020795
+    0.037476
+    0.035664
+    0.039553
+    0.017480
+    0.004951
+    0.030915
+    0.027848
+    0.030414
+    0.017698
+    0.026614
+    0.024661
+    0.015600
+    0.033756
+    0.038696
+    0.026276
+    0.008569
+    0.040131
+    0.025240
+    0.035140
+    0.029665
+    0.024422
+    0.009946
+    0.035133
+    0.032932
+    0.034474
+    0.036430
+    0.018553
+    0.013163
+    0.027545
+    0.031872
+    0.012727
+    0.023239
+    0.038281
+    0.025622
+    0.023206
+    0.023604
+    0.023214
+    0.031878
+    0.011816
+    0.017587
+    0.003967
+    0.006012
+    0.023805
+    0.038247
+    0.024466
+    0.009247
+    0.016084
+    0.031805
+    0.010907
+    0.029994
+    0.038260
+    0.026307
+    0.024549
+    0.041354
+    0.004335
+    0.025379
+    0.038771
+    0.034561
+    0.036090
+    0.037185
+    0.023338
+    0.039714
+    0.007163
+    0.018125
+    0.033846
+    0.009492
+    0.018022
+    0.033379
+    0.035529
+    0.016067
+    0.005875
+    0.012162
+    0.026151
+    0.037495
+    0.019675
+    0.034055
+    0.008540
+    0.004771
+    0.027020
+    0.041286
+    0.007311
+    0.038720
+    0.042870
+    0.032178
+    0.015153
+    0.021208
+    0.035002
+    0.035153
+    0.034428
+    0.003669
+    0.035166
+    0.007898
+    0.035620
+    0.039796
+    0.021750
+    0.035754
+    0.035085
+    0.037646
+    0.035768
+    0.006279
+    0.035828
+    0.032083
+    0.016609
+    0.017841
+    0.017447
+    0.037345
+    0.037354
+    0.027069
+    0.037511
+    0.036638
+    0.037091
+    0.040927
+    0.033782
+    0.034729
+    0.035660
+    0.041098
+    0.035666
+    0.028295
+    0.037538
+    0.017969
+    0.035656
+    0.006046
+    0.039297
+    0.007528
+    0.022787
+    0.004001
+    0.036544
+    0.008090
+    0.010223
+    0.016497
+    0.028478
+    0.031664
+    0.015938
+    0.033771
+    0.038856
+    0.027045
+    0.035723
+    0.036665
+    0.041024
+    0.037652
+    0.010953
+    0.009391
+    0.023851
+    0.035558
+    0.035768
+    0.018209
+    0.034831
+    0.022274
+    0.031805
+    0.048549
+    0.034612
+    0.030775
+    0.025074
+    0.012802
+    0.013767
+    0.034201
+    0.038723
+    0.022040
+    0.006534
+    0.040730
+    0.017502
+    0.035543
+    0.038607
+    0.009552
+    0.021396
+    0.021910
+    0.018518
+    0.039221
+    0.008817
+    0.038669
+    0.032479
+    0.040846
+    0.013059
+    0.029289
+    0.038444
+    0.022945
+    0.007701
+    0.007394
+    0.038494
+    0.014812
+    0.029602
+    0.026898
+    0.040395
+    0.023389
+    0.034464
+    0.022300
+    0.036009
+    0.035339
+    0.020671
+    0.030532
+    0.020775
+    0.037112
+    0.038174
+    0.037927
+    0.034176
+    0.027350
+    0.026806
+    0.030169
+    0.038123
+    0.019608
+    0.033785
+    0.013039
+    0.031794
+    0.020566
+    0.010745
+    0.034919
+    0.014815
+    0.025985
+    0.005797
+    0.036516
+    0.008077
+    0.034931
+    0.037995
+    0.026744
+    0.039144
+    0.028350
+    0.036469
+    0.038317
+    0.034466
+    0.041588
+    0.042432
+    0.004143
+    0.027773
+    0.028516
+    0.037015
+    0.030791
+    0.037266
+    0.035100
+    0.034925
+    0.025605
+    0.019198
+    0.009610
+    0.039794
+    0.032557
+    0.038676
+    0.027272
+    0.012056
+    0.016148
+    0.039573
+    0.017318
+    0.014557
+    0.036591
+    0.038276
+    0.029916
+    0.016211
+    0.039803
+    0.027511
+    0.035182
+    0.035854
+    0.036891
+    0.012315
+    0.006574
+    0.034757
+    0.030183
+    0.004231
+    0.022438
+    0.037625
+    0.012433
+    0.007518
+    0.022435
+    0.038664
+    0.032521
+    0.036323
+    0.006335
+    0.034033
+    0.007820
+    0.017654
+    0.040431
+    0.038284
+    0.014530
+    0.013862
+    0.020485
+    0.035894
+    0.013899
+    0.013671
+    0.029929
+    0.009725
+    0.003815
+    0.026988
+    0.035729
+    0.020701
+    0.037295
+    0.030774
+    0.024329
+    0.035613
+    0.021822
+    0.035140
+    0.039139
+    0.036425
+    0.038967
+    0.034409
+    0.019671
+    0.037251
+    0.035231
+    0.020357
+    0.035950
+    0.038427
+    0.036948
+    0.037876
+    0.023500
+    0.003820
+    0.008529
+    0.035717
+    0.017062
+    0.037858
+    0.033706
+    0.035488
+    0.019048
+    0.035967
+    0.034656
+    0.033067
+    0.009646
+    0.030155
+    0.014846
+    0.033621
+    0.038350
+    0.020973
+    0.031453
+    0.034958
+    0.035679
+    0.037958
+    0.036352
+    0.008555
+    0.034483
+    0.023860
+    0.035395
+    0.013421
+    0.028045
+    0.021209
+    0.038201
+    0.035918
+    0.012026
+    0.022029
+    0.035949
+    0.033483
+    0.016988
+    0.024773
+    0.014159
+    0.018269
+    0.037442
+    0.015864
+    0.036793
+    0.034597
+    0.040752
+    0.033081
+    0.035748
+    0.011455
+    0.013031
+    0.040524
+    0.015346
+    0.033868
+    0.025213
+    0.034772
+    0.037903
+    0.006474
+    0.023401
+    0.038249
+    0.015243
+    0.039015
+    0.007470
+    0.025343
+    0.038934
+    0.015441
+    0.037638
+    0.017518
+    0.024259
+    0.028643
+    0.036670
+    0.037005
+    0.035134
+    0.020501
+    0.039450
+    0.039426
+    0.019661
+    0.036619
+    0.041667
+    0.023032
+    0.035834
+    0.032224
+    0.032925
+    0.036757
+    0.035434
+    0.012417
+    0.039352
+    0.034331
+    0.035843
+    0.024830
+    0.038767
+    0.030544
+    0.022601
+    0.017893
+    0.027905
+    0.023407
+    0.041640
+    0.016049
+    0.036769
+    0.037236
+    0.032514
+    0.013501
+    0.039322
+    0.041760
+    0.040273
+    0.034959
+    0.003920
+    0.027802
+    0.022541
+    0.032707
+    0.026827
+    0.035954
+    0.040625
+    0.041930
+    0.004197
+    0.038586
+    0.034835
+    0.024657
+    0.040192
+    0.034234
+    0.020534
+    0.027009
+    0.035804
+    0.012672
+    0.036437
+    0.018371
+    0.022942
+    0.034431
+    0.034265
+    0.034345
+    0.035749
+    0.032831
+    0.033075
+    0.032684
+    0.016274
+    0.007730
+    0.038315
+    0.005546
+    0.036760
+    0.037930
+    0.004370
+    0.037099
+    0.020390
+    0.022754
+    0.031607
+    0.037580
+    0.009666
+    0.036695
+    0.034969
+    0.015665
+    0.030150
+    0.039711
+    0.036792
+    0.033748
+    0.012273
+    0.024053
+    0.028610
+    0.034596
+    0.025555
+    0.007015
+    0.040361
+    0.017699
+    0.019808
+    0.037988
+    0.038020
+    0.021328
+    0.018226
+    0.021636
+    0.013539
+    0.037591
+    0.038775
+    0.031513
+    0.037318
+    0.031175
+    0.016926
+    0.015384
+    0.036315
+    0.003957
+    0.039172
+    0.030366
+    0.034531
+    0.004883
+    0.035442
+    0.034422
+    0.037014
+    0.010121
+    0.008637
+    0.003792
+    0.017857
+    0.010769
+    0.035525
+    0.023570
+    0.014176
+    0.037152
+    0.029983
+    0.035241
+    0.013945
+    0.018151
+    0.018743
+    0.038001
+    0.039901
+    0.004114
+    0.008421
+    0.017137
+    0.017455
+    0.009551
+    0.035202
+    0.015097
+    0.016845
+    0.035902
+    0.035276
+    0.011264
+    0.034630
+    0.016534
+    0.020397
+    0.040888
+    0.024025
+    0.026113
+    0.006066
+    0.037856
+    0.036602
+    0.008817
+    0.035066
+    0.030548
+    0.026662
+    0.016740
+    0.028762
+    0.035025
+    0.026859
+    0.016709
+    0.038127
+    0.029636
+    0.028624
+    0.036012
+    0.004132
+    0.039086
+    0.014703
+    0.012796
+    0.030511
+    0.014526
+    0.015189
+    0.037827
+    0.029795
+    0.037056
+    0.035456
+    0.035241
+    0.017308
+    0.033303
+    0.025474
+    0.021381
+    0.034597
+    0.038831
+    0.021814
+    0.018305
+    0.003970
+    0.025096
+    0.035897
+    0.037049
+    0.041727
+    0.036604
+    0.036387
+    0.011899
+    0.021647
+    0.034938
+    0.035607
+    0.006245
+    0.020491
+    0.018241
+    0.037710
+    0.010517
+    0.014865
+    0.036289
+    0.018606
+    0.015233
+    0.037066
+    0.024656
+    0.009489
+    0.019250
+    0.011699
+    0.038885
+    0.025574
+    0.033675
+    0.035642
+    0.035001
+    0.040171
+    0.007691
+    0.025283
+    0.010618
+    0.034691
+    0.012458
+    0.031688
+    0.011254
+    0.037956
+    0.035091
+    0.035453
+    0.034510
+    0.036417
+    0.026240
+    0.035961
+    0.036754
+    0.011563
+    0.040723
+    0.007256
+    0.006783
+    0.015021
+    0.015097
+    0.039929
+    0.020211
+    0.037062
+    0.028901
+    0.035338
+    0.015373
+    0.016555
+    0.035608
+    0.010760
+    0.019793
+    0.035980
+    0.037072
+    0.031446
+    0.038537
+    0.028765
+    0.038030
+    0.019950
+    0.028125
+    0.016993
+    0.009660
+    0.037322
+    0.034349
+    0.036873
+    0.035480
+    0.036325
+    0.034801
+    0.011694
+    0.037847
+    0.023499
+    0.008063
+    0.020905
+    0.012134
+    0.031747
+    0.037890
+    0.035219
+    0.020464
+    0.034754
+    0.030462
+    0.018343
+    0.031124
+    0.036433
+    0.024862
+    0.040802
+    0.007152
+    0.018430
+    0.038466
+    0.022177
+    0.040599
+    0.029119
+    0.021978
+    0.014684
+    0.031726
+    0.038984
+    0.036301
+    0.035751
+    0.026134
+    0.008393
+    0.037580
+    0.035891
+    0.023645
+    0.004737
+    0.031466
+    0.036215
+    0.036057
+    0.034374
+    0.035390
+    0.005829
+    0.026852
+    0.035042
+    0.033380
+    0.039978
+    0.023078
+    0.034885
+    0.035254
+    0.023040
+    0.043001
+    0.033347
+    0.012838
+    0.035307
+    0.019168
+    0.017631
+    0.035440
+    0.021356
+    0.009475
+    0.037642
+    0.034257
+    0.042263
+    0.035820
+    0.035607
+    0.012455
+    0.026317
+    0.037082
+    0.036630
+    0.019907
+    0.009550
+    0.012234
+    0.038173
+    0.038140
+    0.014831
+    0.023916
+    0.031191
+    0.027312
+    0.019611
+    0.032797
+    0.020287
+    0.037872
+    0.039102
+    0.036760
+    0.037128
+    0.034325
+    0.017671
+    0.033627
+    0.034995
+    0.035547
+    0.039115
+    0.023056
+    0.008341
+    0.005875
+    0.031263
+    0.006979
+    0.034619
+    0.019189
+    0.037155
+    0.012595
+    0.016410
+    0.036425
+    0.005539
+    0.021509
+    0.035824
+    0.038273
+    0.037773
+    0.030011
+    0.025706
+    0.017738
+    0.037508
+    0.038086
+    0.019745
+    0.036941
+    0.021039
+    0.010826
+    0.037635
+    0.020631
+    0.020896
+    0.004397
+    0.031844
+    0.016471
+    0.021964
+    0.006502
+    0.019643
+    0.022113
+    0.004900
+    0.026735
+    0.012156
+    0.038984
+    0.034770
+    0.010146
+    0.035161
+    0.036103
+    0.034618
+    0.017913
+    0.005584
+    0.035373
+    0.007318
+    0.025560
+    0.013206
+    0.038982
+    0.030899
+    0.029016
+    0.022414
+    0.039457
+    0.024041
+    0.004370
+    0.015107
+    0.038678
+    0.036379
+    0.014335
+    0.027372
+    0.014659
+    0.021598
+    0.029524
+    0.009531
+    0.036274
+    0.034081
+    0.027301
+    0.021033
+    0.033474
+    0.046375
+    0.035974
+    0.023390
+    0.023691
+    0.026037
+    0.034962
+    0.033220
+    0.038848
+    0.040136
+    0.033236
+    0.036659
+    0.024824
+    0.023611
+    0.012995
+    0.027000
+    0.032564
+    0.019691
+    0.034989
+    0.035945
+    0.010068
+    0.009718
+    0.016126
+    0.004919
+    0.005575
+    0.024548
+    0.007608
+    0.035636
+    0.021271
+    0.038596
+    0.028625
+    0.034699
+    0.032086
+    0.034442
+    0.036753
+    0.036960
+    0.010156
+    0.036450
+    0.004075
+    0.005554
+    0.035000
+    0.035453
+    0.022901
+    0.035555
+    0.035500
+    0.037161
+    0.038145
+    0.022492
+    0.034081
+    0.039383
+    0.024070
+    0.034527
+    0.030446
+    0.034318
+    0.038420
+    0.031389
+    0.036150
+    0.037944
+    0.018463
+    0.030982
+    0.022320
+    0.030808
+    0.038112
+    0.007684
+    0.036214
+    0.024433
+    0.003792
+    0.020524
+    0.028415
+    0.019107
+    0.036915
+    0.005642
+    0.034953
+    0.033779
+    0.023115
+    0.020333
+    0.037507
+    0.012520
+    0.028758
+    0.018074
+    0.029938
+    0.035336
+    0.034234
+    0.033998
+    0.037168
+    0.019481
+    0.037791
+    0.028164
+    0.038406
+    0.014500
+    0.037400
+    0.033796
+    0.037729
+    0.010908
+    0.015683
+    0.035378
+    0.028891
+    0.016170
+    0.036792
+    0.008781
+    0.037330
+    0.035252
+    0.037994
+    0.041810
+    0.028718
+    0.018913
+    0.011500
+    0.017925
+    0.031247
+    0.021325
+    0.027100
+    0.009990
+    0.019443
+    0.037624
+    0.035507
+    0.036431
+    0.022483
+    0.035173
+    0.023194
+    0.038809
+    0.028806
+    0.030287
+    0.037849
+    0.036272
+    0.033348
+    0.008489
+    0.022488
+    0.034245
+    0.020166
+    0.032112
+    0.038215
+    0.038107
+    0.008841
+    0.029784
+    0.037972
+    0.022324
+    0.025752
+    0.019115
+    0.017894
+    0.018647
+    0.004031
+    0.022309
+    0.023736
+    0.015371
+    0.030210
+    0.032685
+    0.035205
+    0.040859
+    0.017161
+    0.038333
+    0.009565
+    0.034215
+    0.040075
+    0.010959
+    0.012396
+    0.035845
+    0.024402
+    0.020687
+    0.033911
+    0.039463
+    0.025352
+    0.038284
+    0.036929
+    0.024614
+    0.016843
+    0.019159
+    0.038187
+    0.018239
+    0.039213
+    0.020002
+    0.028961
+    0.013797
+    0.010724
+    0.024902
+    0.003862
+    0.038207
+    0.008078
+    0.037826
+    0.028975
+    0.028455
+    0.036040
+    0.010403
+    0.036899
+    0.020774
+    0.008715
+    0.043971
+    0.021554
+    0.028787
+    0.009838
+    0.034983
+    0.042233
+    0.036017
+    0.017593
+    0.038205
+    0.013495
+    0.006536
+    0.038122
+    0.042511
+    0.042490
+    0.018607
+    0.038978
+    0.013851
+    0.040570
+    0.023837
+    0.026611
+    0.012396
+    0.026897
+    0.036454
+    0.006293
+    0.034349
+    0.003760
+    0.027336
+    0.032987
+    0.011988
+    0.010367
+    0.034380
+    0.034350
+    0.005242
+    0.025432
+    0.032729
+    0.034511
+    0.037077
+    0.024104
+    0.036269
+    0.027010
+    0.034709
+    0.042366
+    0.037739
+    0.023159
+    0.039377
+    0.031552
+    0.034582
+    0.020822
+    0.017442
+    0.029218
+    0.032820
+    0.035308
+    0.031102
+    0.039220
+    0.036824
+    0.026237
+    0.012845
+    0.024066
+    0.014689
+    0.006144
+    0.005774
+    0.018109
+    0.014773
+    0.035585
+    0.036389
+    0.039595
+    0.025119
+    0.038411
+    0.036702
+    0.035017
+    0.036720
+    0.013618
+    0.038724
+    0.035332
+    0.017787
+    0.013063
+    0.036043
+    0.026013
+    0.037722
+    0.040988
+    0.037177
+    0.027789
+    0.010778
+    0.014130
+    0.039386
+    0.006377
+    0.037776
+    0.038097
+    0.027986
+    0.008658
+    0.021239
+    0.035154
+    0.018730
+    0.037906
+    0.042413
+    0.039380
+    0.036474
+    0.036761
+    0.036164
+    0.028344
+    0.038309
+    0.012760
+    0.020541
+    0.037490
+    0.037924
+    0.042092
+    0.036320
+    0.019404
+    0.034099
+    0.016577
+    0.017278
+    0.037656
+    0.039415
+    0.035973
+    0.016007
+    0.041535
+    0.033914
+    0.035047
+    0.013684
+    0.039375
+    0.021533
+    0.033651
+    0.016660
+    0.035619
+    0.027715
+    0.020808
+    0.007541
+    0.030756
+    0.020419
+    0.027006
+    0.031929
+    0.035920
+    0.014842
+    0.021466
+    0.036670
+    0.046077
+    0.035387
+    0.036543
+    0.035739
+    0.009951
+    0.036127
+    0.032714
+    0.015719
+    0.012621
+    0.034694
+    0.026108
+    0.035345
+    0.021038
+    0.035310
+    0.008530
+    0.038804
+    0.025861
+    0.035346
+    0.011765
+    0.018588
+    0.034387
+    0.036776
+    0.036609
+    0.035552
+    0.010922
+    0.008275
+    0.037989
+    0.018874
+    0.020094
+    0.036898
+    0.020782
+    0.005275
+    0.034916
+    0.009721
+    0.012510
+    0.036066
+    0.037031
+    0.023150
+    0.033900
+    0.036349
+    0.034312
+    0.036838
+    0.036161
+    0.024075
+    0.039481
+    0.023464
+    0.034578
+    0.014303
+    0.009819
+    0.038189
+    0.012506
+    0.029582
+    0.019839
+    0.014340
+    0.017900
+    0.023787
+    0.036698
+    0.021192
+    0.035838
+    0.028526
+    0.038410
+    0.020925
+    0.040178
+    0.035445
+    0.003980
+    0.035336
+    0.012166
+    0.021192
+    0.021315
+    0.021957
+    0.035422
+    0.022923
+    0.012364
+    0.040286
+    0.015509
+    0.010404
+    0.020305
+    0.035723
+    0.003987
+    0.029313
+    0.019512
+    0.040235
+    0.013155
+    0.036331
+    0.035949
+    0.009618
+    0.037443
+    0.038416
+    0.022340
+    0.027725
+    0.034384
+    0.034416
+    0.035812
+    0.026446
+    0.031854
+    0.024577
+    0.019388
+    0.011098
+    0.029310
+    0.025124
+    0.035625
+    0.014767
+    0.037548
+    0.036054
+    0.024300
+    0.017275
+    0.037794
+    0.028314
+    0.032363
+    0.037770
+    0.035521
+    0.012496
+    0.033832
+    0.039354
+    0.031078
+    0.028211
+    0.034621
+    0.017540
+    0.034900
+    0.039173
+    0.012147
+    0.016007
+    0.018772
+    0.038536
+    0.037504
+    0.038564
+    0.035975
+    0.038260
+    0.038059
+    0.030673
+    0.019962
+    0.041645
+    0.013928
+    0.018355
+    0.038715
+    0.009600
+    0.005276
+    0.033760
+    0.020771
+    0.039816
+    0.037953
+    0.021499
+    0.005168
+    0.025404
+    0.039600
+    0.034033
+    0.037030
+    0.021641
+    0.034462
+    0.035129
+    0.031518
+    0.028524
+    0.017620
+    0.019295
+    0.007481
+    0.016229
+    0.023085
+    0.023983
+    0.036875
+    0.035990
+    0.026849
+    0.011873
+    0.015850
+    0.007049
+    0.004117
+    0.010618
+    0.016194
+    0.035041
+    0.036503
+    0.005908
+    0.033438
+    0.024048
+    0.037213
+    0.036161
+    0.034565
+    0.003904
+    0.023007
+    0.037596
+    0.011968
+    0.015219
+    0.037938
+    0.034206
+    0.038850
+    0.037021
+    0.040425
+    0.039730
+    0.034274
+    0.012601
+    0.035459
+    0.006680
+    0.038859
+    0.024901
+    0.020521
+    0.025036
+    0.027069
+    0.032092
+    0.021993
+    0.037123
+    0.004223
+    0.004013
+    0.039416
+    0.029560
+    0.033714
+    0.022846
+    0.020213
+    0.037698
+    0.010691
+    0.003847
+    0.021596
+    0.029138
+    0.005665
+    0.036151
+    0.007047
+    0.035031
+    0.012668
+    0.033672
+    0.028178
+    0.017051
+    0.033927
+    0.019186
+    0.037058
+    0.014645
+    0.041849
+    0.037157
+    0.039887
+    0.035757
+    0.035625
+    0.036349
+    0.035868
+    0.020754
+    0.007084
+    0.003824
+    0.024575
+    0.028124
+    0.018118
+    0.026314
+    0.016964
+    0.021938
+    0.031195
+    0.004181
+    0.036507
+    0.032633
+    0.027710
+    0.020505
+    0.028550
+    0.035165
+    0.014653
+    0.017542
+    0.036185
+    0.003805
+    0.036554
+    0.034590
+    0.023199
+    0.025942
+    0.022712
+    0.008366
+    0.038770
+    0.035359
+    0.035125
+    0.014808
+    0.014225
+    0.026337
+    0.031768
+    0.011381
+    0.033463
+    0.037913
+    0.039974
+    0.003786
+    0.034060
+    0.034302
+    0.017810
+    0.034420
+    0.037015
+    0.035886
+    0.036253
+    0.028221
+    0.012678
+    0.033851
+    0.033816
+    0.035397
+    0.037377
+    0.034186
+    0.019001
+    0.035572
+    0.038715
+    0.013071
+    0.016388
+    0.035986
+    0.037784
+    0.026827
+    0.037443
+    0.034020
+    0.038808
+    0.028779
+    0.035135
+    0.038853
+    0.033345
+    0.012742
+    0.027710
+    0.026289
+    0.019728
+    0.014088
+    0.012764
+    0.041720
+    0.026359
+    0.020057
+    0.034555
+    0.034074
+    0.026341
+    0.038179
+    0.031322
+    0.020547
+    0.005162
+    0.022842
+    0.052612
+    0.037041
+    0.005098
+    0.024964
+    0.033814
+    0.030761
+    0.036975
+    0.041362
+    0.018857
+    0.025658
+    0.031610
+    0.014326
+    0.037885
+    0.009827
+    0.034842
+    0.017079
+    0.028910
+    0.028353
+    0.036235
+    0.010494
+    0.014125
+    0.021385
+    0.008731
+    0.007503
+    0.006702
+    0.009397
+    0.038305
+    0.022311
+    0.022171
+    0.012536
+    0.036635
+    0.035647
+    0.042722
+    0.020061
+    0.036486
+    0.026577
+    0.038003
+    0.034441
+    0.034923
+    0.014254
+    0.035392
+    0.038436
+    0.014817
+    0.023573
+    0.026759
+    0.004424
+    0.014623
+    0.037398
+    0.039192
+    0.024732
+    0.019343
+    0.034636
+    0.015778
+    0.036784
+    0.036395
+    0.009288
+    0.032175
+    0.022936
+    0.030029
+    0.017263
+    0.039396
+    0.037949
+    0.037673
+    0.034677
+    0.020226
+    0.037658
+    0.026156
+    0.027153
+    0.036906
+    0.033319
+    0.033765
+    0.003786
+    0.015153
+    0.035147
+    0.036391
+    0.034364
+    0.033005
+    0.019633
+    0.033716
+    0.035686
+    0.016808
+    0.038481
+    0.026385
+    0.036956
+    0.035616
+    0.011480
+    0.036783
+    0.036620
+    0.030047
+    0.036632
+    0.014286
+    0.035194
+    0.019831
+    0.028049
+    0.008966
+    0.034678
+    0.038032
+    0.035751
+    0.004200
+    0.012712
+    0.008772
+    0.037742
+    0.020907
+    0.024024
+    0.039687
+    0.040182
+    0.021382
+    0.034268
+    0.043332
+    0.007485
+    0.030283
diff --git a/pyproject.toml b/pyproject.toml
index 5a8ac1a..caf9fb9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,10 +5,13 @@
 
 # Minimum requirements for the build system to execute.
 [build-system]
-requires = ["setuptools>=42.0", "wheel"]
+requires = ["setuptools>=42.0", "wheel", "mypy"]
 build-backend = "setuptools.build_meta"
 
 [tool.pytest.ini_options]
 testpaths = [
     "test",
 ]
+
+[tool.mypy]
+ignore_missing_imports = true
diff --git a/requirements.txt b/requirements.txt
index d738a3e..fcd9e12 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,4 @@
 numpy
 pillow
 inputs
+mypy
diff --git a/setup.cfg b/setup.cfg
index 1347ad1..de39003 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -8,9 +8,9 @@ name = kesslergame
 version = attr: kesslergame.__version__
 url = https://github.com/ThalesGroup/kessler-game
 author = Zachariah Phillips
-author_email = zachariah.phillips@us.thalesgroup.com
+author_email = zach.phillips@defense.us.thalesgroup.com
 maintainer = Timothy Arnett
-maintainer_email = tim.arnett@psibernetix.com
+maintainer_email = tim.arnett@defense.us.thalesgroup.com
 description = Asteroids game simulation environment for ML and AI applications
 long_description = file: README.md
 keywords = artificial intelligence, asteroids, machine learning
diff --git a/setup.py b/setup.py
index 0b5f516..be1ce21 100644
--- a/setup.py
+++ b/setup.py
@@ -3,12 +3,28 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-from setuptools import setup
+from setuptools import setup, find_packages
 
 with open('requirements.txt') as f:
     requirements = f.read().splitlines()
 
+import re
+VERSIONFILE="src/kesslergame/_version.py"
+verstrline = open(VERSIONFILE, "rt").read()
+VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]"
+mo = re.search(VSRE, verstrline, re.M)
+if mo:
+    verstr = mo.group(1)
+else:
+    raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,))
+
 setup(
+    name='KesslerGame',
+    version=verstr,
     install_requires=requirements,
 )
 
+
+
+
+
diff --git a/setup_mypyc.py b/setup_mypyc.py
new file mode 100644
index 0000000..030f3a9
--- /dev/null
+++ b/setup_mypyc.py
@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2022 Thales. All Rights Reserved.
+# NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
+# this source code package.
+
+from setuptools import setup, find_packages
+from mypyc.build import mypycify
+
+with open('requirements.txt') as f:
+    requirements = f.read().splitlines()
+
+import re
+VERSIONFILE="src/kesslergame/_version.py"
+verstrline = open(VERSIONFILE, "rt").read()
+VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]"
+mo = re.search(VSRE, verstrline, re.M)
+if mo:
+    verstr = mo.group(1)
+else:
+    raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,))
+
+# List of all Python modules to compile with MyPyC
+mypyc_modules = [
+    "src/kesslergame/asteroid.py",
+    "src/kesslergame/bullet.py",
+    "src/kesslergame/collisions.py",
+    "src/kesslergame/controller.py",
+    "src/kesslergame/controller_gamepad.py",
+    "src/kesslergame/kessler_game.py",
+    "src/kesslergame/mines.py",
+    "src/kesslergame/scenario.py",
+    "src/kesslergame/score.py",
+    "src/kesslergame/ship.py",
+    "src/kesslergame/team.py",
+    "src/kesslergame/graphics/graphics_base.py",
+    "src/kesslergame/graphics/graphics_handler.py",
+    "src/kesslergame/graphics/graphics_plt.py",
+    "src/kesslergame/graphics/graphics_tk.py",
+    "src/kesslergame/graphics/graphics_ue.py",
+    # Add __init__.py if you have specific initialization code that needs compilation.
+    # "src/__init__.py",
+    "src/kesslergame/__init__.py",
+    "src/kesslergame/graphics/__init__.py",
+]
+
+setup(
+    name='KesslerGame',
+    version=verstr,
+    packages=find_packages(where='src', exclude=['examples', 'src.examples', '*.examples.*', 'examples.*']),
+    install_requires=requirements,
+    ext_modules=mypycify(mypyc_modules),
+    package_data={
+        '': ['*.png'],
+    },
+    package_dir={'': 'src'},
+)
+
+
+
+
+
diff --git a/src/kesslergame/__init__.py b/src/kesslergame/__init__.py
index 6dc8464..eaaaf1a 100644
--- a/src/kesslergame/__init__.py
+++ b/src/kesslergame/__init__.py
@@ -10,8 +10,8 @@
 from .scenario import Scenario
 from .score import Score
 from .graphics import GraphicsType, KesslerGraphics
+from ._version import __version__
 
 
 __all__ = ['KesslerGame', 'TrainerEnvironment', 'KesslerController', 'Scenario', 'Score', 'GraphicsType',
-           'KesslerGraphics', 'GamepadController']
-__version__ = '2.1.1'
+           'KesslerGraphics', 'GamepadController', 'Ship']
diff --git a/src/kesslergame/_version.py b/src/kesslergame/_version.py
new file mode 100644
index 0000000..d7fc335
--- /dev/null
+++ b/src/kesslergame/_version.py
@@ -0,0 +1,1 @@
+__version__ = '2.1.2'
\ No newline at end of file
diff --git a/src/kesslergame/asteroid.py b/src/kesslergame/asteroid.py
index 53e808d..a75376d 100644
--- a/src/kesslergame/asteroid.py
+++ b/src/kesslergame/asteroid.py
@@ -3,19 +3,23 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-from typing import Tuple, Dict, List, Any
+from typing import Tuple, Dict, List, Any, Optional, TYPE_CHECKING, Union
 import random
 import math
-from .mines import Mine
 
+if TYPE_CHECKING:
+    from .ship import Ship
+    from .bullet import Bullet
+from .mines import Mine
 
 class Asteroid:
     """ Sprite that represents an asteroid. """
+    __slots__ = ('size', 'max_speed', 'num_children', 'radius', 'mass', 'vx', 'vy', 'velocity', 'position', 'angle', 'turnrate')
     def __init__(self,
-                 position: Tuple[float, float] = None,
-                 speed: float = None,
-                 angle: float = None,
-                 size: float = None):
+                 position: Tuple[float, float],
+                 speed: Optional[float] = None,
+                 angle: Optional[float] = None,
+                 size: Optional[int] = None) -> None:
         """
         Constructor for Asteroid Sprite
 
@@ -30,7 +34,7 @@ def __init__(self,
             if 1 <= size <= 4:
                 self.size = size
             else:
-                raise ValueError("AsteroidSize can only be between 1 and 4")
+                raise ValueError("Asteroid size can only be between 1 and 4")
         else:
             self.size = 4
 
@@ -42,9 +46,9 @@ def __init__(self,
         self.num_children = 3
 
         # Set collision radius based on size # TODO May need to change once size can be visualized
-        self.radius = self.size * 8
+        self.radius = self.size * 8.0
 
-        self.mass = 0.25*math.pi*self.radius**2
+        self.mass = 0.25*math.pi*self.radius*self.radius
 
         # Use optional angle and speed arguments otherwise generate random angle and speed
         starting_angle = angle if angle is not None else random.random()*360.0
@@ -58,31 +62,31 @@ def __init__(self,
 
         self.vx = starting_speed*math.cos(math.radians(starting_angle))
         self.vy = starting_speed*math.sin(math.radians(starting_angle))
-        self.velocity = [self.vx, self.vy]
+        self.velocity = (self.vx, self.vy)
 
         # Set position as specified
         self.position = position
 
         # Random rotations for use in display or future use with complex hit box
-        self.angle = random.randint(0, 360)
-        self.turnrate = random.randint(0, 200) - 100
+        self.angle: float = random.uniform(0.0, 360.0)
+        self.turnrate: float = random.uniform(-100, 100)
 
     @property
     def state(self) -> Dict[str, Any]:
         return {
-            "position": tuple(self.position),
-            "velocity": tuple(self.velocity),
-            "size": int(self.size),
-            "mass": float(self.mass),
-            "radius": float(self.radius)
+            "position": self.position,
+            "velocity": self.velocity,
+            "size": self.size,
+            "mass": self.mass,
+            "radius": self.radius
         }
 
-    def update(self, delta_time: float = 1/30):
+    def update(self, delta_time: float = 1/30) -> None:
         """ Move the asteroid based on velocity"""
-        self.position = [pos + v*delta_time for pos, v in zip(self.position, self.velocity)]
+        self.position = (self.position[0] + self.velocity[0] * delta_time, self.position[1] + self.velocity[1] * delta_time)
         self.angle += delta_time * self.turnrate
 
-    def destruct(self, impactor):
+    def destruct(self, impactor: Union['Bullet', 'Mine', 'Ship']) -> list['Asteroid']:
         """ Spawn child asteroids"""
 
         if self.size != 1:
@@ -103,7 +107,7 @@ def destruct(self, impactor):
                     v = math.sqrt(vfx*vfx + vfy*vfy)
                     # Split angle is the angle off of the new velocity vector for the two asteroids to the sides, the center child
                     # asteroid continues on the new velocity path
-                    split_angle = 15
+                    split_angle = 15.0
                 else:
                     vfx = self.vx
                     vfy = self.vy
@@ -113,7 +117,7 @@ def destruct(self, impactor):
                     v = math.sqrt(vfx*vfx + vfy*vfy + a*a)
                     # Split angle is the angle off of the new velocity vector for the two asteroids to the sides, the center child
                     # asteroid continues on the new velocity path
-                    split_angle = 120
+                    split_angle = 120.0
             else:
                 # Calculating new velocity vector of asteroid children based on bullet-asteroid collision/momentum
                 # Currently collisions are considered perfectly inelastic i.e. the bullet is absorbed by the asteroid
@@ -131,7 +135,7 @@ def destruct(self, impactor):
                 v = math.sqrt(vfx*vfx + vfy*vfy)
                 # Split angle is the angle off of the new velocity vector for the two asteroids to the sides, the center child
                 # asteroid continues on the new velocity path
-                split_angle = 15
+                split_angle = 15.0
             # Calculate angle of center asteroid for split (degrees)
             theta = math.degrees(math.atan2(vfy, vfx))
             angles = [theta + split_angle, theta, theta - split_angle]
diff --git a/src/kesslergame/bullet.py b/src/kesslergame/bullet.py
index 338db24..f2ba62e 100644
--- a/src/kesslergame/bullet.py
+++ b/src/kesslergame/bullet.py
@@ -6,31 +6,37 @@
 from typing import List, Tuple, Dict, Any
 import math
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .ship import Ship
+
 
 class Bullet:
-    def __init__(self, starting_position: List[float], starting_heading: float, owner):
+    __slots__ = ('owner', 'speed', 'length', 'mass', 'position', 'heading', 'rad_heading', 'tail', 'vx', 'vy', 'velocity')
+    def __init__(self, starting_position: Tuple[float, float], starting_heading: float, owner: 'Ship') -> None:
         self.owner = owner
-        self.speed = 800  # m/s
-        self.length = 12
-        self.mass = 1  # mass units - kg?
+        self.speed = 800.0  # m/s
+        self.length = 12.0
+        self.mass = 1.0  # mass units - kg?
         self.position = starting_position
         self.heading = starting_heading
         self.rad_heading = math.radians(starting_heading)
         cos_heading = math.cos(self.rad_heading)
         sin_heading = math.sin(self.rad_heading)
-        self.tail = [self.position[0] - self.length*cos_heading,
-                     self.position[1] - self.length*sin_heading]
+        self.tail = (self.position[0] - self.length*cos_heading,
+                     self.position[1] - self.length*sin_heading)
         self.vx = self.speed*cos_heading
         self.vy = self.speed*sin_heading
         self.velocity = [self.vx, self.vy]
 
-    def update(self, delta_time=1/30):
+    def update(self, delta_time: float = 1/30) -> None:
         # Update the position:
-        self.position = [pos + v * delta_time for pos, v in zip(self.position, self.velocity)]
-        self.tail = [pos + v * delta_time for pos, v in zip(self.tail, self.velocity)]
+        self.position = (self.position[0] + self.velocity[0] * delta_time, self.position[1] + self.velocity[1] * delta_time)
+        self.tail = (self.tail[0] + self.velocity[0] * delta_time, self.tail[1] + self.velocity[1] * delta_time)
 
-    def destruct(self):
-        ...
+    def destruct(self) -> None:
+        pass
 
     @property
     def state(self) -> Dict[str, Any]:
diff --git a/src/kesslergame/collisions.py b/src/kesslergame/collisions.py
index c2687be..dc34d00 100644
--- a/src/kesslergame/collisions.py
+++ b/src/kesslergame/collisions.py
@@ -5,13 +5,13 @@
 
 import math
 
-def circle_line_collision(line_A, line_B, center, radius):
+def circle_line_collision(line_A: tuple[float, float], line_B: tuple[float, float], center: tuple[float, float], radius: float) -> bool:
     # Check if circle edge is within the outer bounds of the line segment (offset for radius)
     # Not 100% accurate (some false positives) but fast and rare inaccuracies
-    x_bounds = [min(line_A[0], line_B[0])-radius, max(line_A[0], line_B[0])+radius]
+    x_bounds = [min(line_A[0], line_B[0]) - radius, max(line_A[0], line_B[0]) + radius]
     if center[0] < x_bounds[0] or center[0] > x_bounds[1]:
         return False
-    y_bounds = [min(line_A[1], line_B[1])-radius, max(line_A[1], line_B[1])+radius]
+    y_bounds = [min(line_A[1], line_B[1]) - radius, max(line_A[1], line_B[1]) + radius]
     if center[1] < y_bounds[0] or center[1] > y_bounds[1]:
         return False
 
@@ -23,12 +23,7 @@ def circle_line_collision(line_A, line_B, center, radius):
     # Heron's formula to calculate area of triangle and resultant height (distance from circle center to line segment)
     s = 0.5 * (a + b + c)
 
-    cen_dist = 2 / c * math.sqrt(max(0.0, s * (s-a) * (s-b) * (s-c)))
+    cen_dist = 2.0 / c * math.sqrt(max(0.0, s * (s-a) * (s-b) * (s-c)))
 
     # If circle distance to line segment is less than circle radius, they are colliding
-    if cen_dist < radius:
-        return True
-    return False
-
-
-
+    return cen_dist < radius
diff --git a/src/kesslergame/controller.py b/src/kesslergame/controller.py
index 4cf10a1..b78aaf7 100644
--- a/src/kesslergame/controller.py
+++ b/src/kesslergame/controller.py
@@ -3,10 +3,7 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-from typing import Dict, Tuple
-import time
-
-from .ship import Ship
+from typing import Dict, Tuple, Any
 
 
 class KesslerController:
@@ -16,7 +13,7 @@ class KesslerController:
     game_state dictionary. This action method then sets the thrust, turn_rate, and fire commands on the ship object.
     """
 
-    def actions(self, ship_state: Dict, game_state: Dict) -> Tuple[float, float, bool, bool]:
+    def actions(self, ship_state: Dict[str, Any], game_state: Dict[str, Any]) -> Tuple[float, float, bool, bool]:
         """
         Method processed each time step by this controller.
         """
@@ -26,11 +23,11 @@ def actions(self, ship_state: Dict, game_state: Dict) -> Tuple[float, float, boo
 
     # Property to store the ID for the ship this controller is attached to during a scenario
     @property
-    def ship_id(self):
+    def ship_id(self) -> int:
         return self._ship_id if self._ship_id else 0
 
     @ship_id.setter
-    def ship_id(self, value):
+    def ship_id(self, value: int) -> None:
         self._ship_id = value
 
     @property
diff --git a/src/kesslergame/controller_gamepad.py b/src/kesslergame/controller_gamepad.py
index 33df6bc..8c7963f 100644
--- a/src/kesslergame/controller_gamepad.py
+++ b/src/kesslergame/controller_gamepad.py
@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 from .controller import KesslerController
-from typing import Dict, Tuple
-from inputs import get_gamepad
+from typing import Dict, NoReturn, Tuple, Any, Final
+from inputs import get_gamepad  # type: ignore[import-untyped]
 import math
 import threading
 import time
@@ -10,7 +10,7 @@
 
 class GamepadController(KesslerController):
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.gamepad = XboxController()
         # tracker to determine if human paused game
         self.paused = False
@@ -18,7 +18,7 @@ def __init__(self):
         # can only toggle pausing every 0.5 seconds
         self.pause_time_buffer = 0.5
 
-    def actions(self, ship_state: Dict, game_state: Dict) -> Tuple[float, float, bool, bool]:
+    def actions(self, ship_state: Dict[str, Any], game_state: Dict[str, Any]) -> Tuple[float, float, bool, bool]:
         """
         Read in the current gamepad state, and create the appropriate actions
         """
@@ -33,13 +33,13 @@ def actions(self, ship_state: Dict, game_state: Dict) -> Tuple[float, float, boo
         if abs(self.gamepad.LeftJoystickY) > joystick_deadzone:
             thrust = self.gamepad.LeftJoystickY * 480.0
         else:
-            thrust = 0
+            thrust = 0.0
 
         # Set turn control
         if abs(self.gamepad.RightJoystickX) > joystick_deadzone:
-            turn_rate = -1 * self.gamepad.RightJoystickX * 180.0
+            turn_rate = -1.0 * self.gamepad.RightJoystickX * 180.0
         else:
-            turn_rate = 0
+            turn_rate = 0.0
 
         # Setfire control
         if self.gamepad.RightTrigger > trigger_deadzone:
@@ -60,11 +60,11 @@ def actions(self, ship_state: Dict, game_state: Dict) -> Tuple[float, float, boo
     def name(self) -> str:
         return "Gamepad Controller"
 
-    def explanation(self):
-        exp = None
+    def explanation(self) -> None:
+        exp: None = None
         return exp
 
-    def pause_handler(self):
+    def pause_handler(self) -> None:
 
         break_pause = False
         if time.perf_counter() - self.time_last_paused > self.pause_time_buffer and self.gamepad.Back == 1:
@@ -81,10 +81,10 @@ class XboxController(object):
     MIT License
     """
 
-    MAX_TRIG_VAL = math.pow(2, 8)
-    MAX_JOY_VAL = math.pow(2, 15)
+    MAX_TRIG_VAL: Final[float] = 2.0**8
+    MAX_JOY_VAL: Final[float] = 2.0**15
 
-    def __init__(self):
+    def __init__(self) -> None:
 
         self.LeftJoystickY = 0
         self.LeftJoystickX = 0
@@ -112,7 +112,7 @@ def __init__(self):
         self._monitor_thread.start()
 
 
-    def read(self):
+    def read(self) -> list[int | Any]:
         x = self.LeftJoystickX
         y = self.LeftJoystickY
         a = self.A
@@ -121,7 +121,7 @@ def read(self):
         return [x, y, a, b, rb]
 
 
-    def _monitor_controller(self):
+    def _monitor_controller(self) -> NoReturn:
         while True:
             events = get_gamepad()
             for event in events:
diff --git a/src/kesslergame/graphics/graphics_base.py b/src/kesslergame/graphics/graphics_base.py
index 71b6159..366c187 100644
--- a/src/kesslergame/graphics/graphics_base.py
+++ b/src/kesslergame/graphics/graphics_base.py
@@ -3,18 +3,25 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-import os
+#import os
 from tkinter import *
-from PIL import Image, ImageTk
+from typing import List
+#from PIL import Image, ImageTk  # type: ignore[import-untyped]
 
+from ..ship import Ship
+from ..asteroid import Asteroid
+from ..bullet import Bullet
+from ..mines import Mine
+from ..score import Score
+from ..scenario import Scenario
 
-class KesslerGraphics:
 
-    def start(self, scenario):
+class KesslerGraphics:
+    def start(self, scenario: Scenario) -> None:
         raise NotImplementedError('Your derived KesslerController must include a start() method.')
 
-    def update(self, score, ships, asteroids, bullets, mines):
+    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet], mines: List[Mine]) -> None:
         raise NotImplementedError('Your derived KesslerController must include an update() method.')
 
-    def close(self):
+    def close(self) -> None:
         raise NotImplementedError('Your derived KesslerController must include a close() method.')
diff --git a/src/kesslergame/graphics/graphics_handler.py b/src/kesslergame/graphics/graphics_handler.py
index 9fde35a..605aad0 100644
--- a/src/kesslergame/graphics/graphics_handler.py
+++ b/src/kesslergame/graphics/graphics_handler.py
@@ -4,8 +4,14 @@
 # this source code package.
 
 from enum import Enum
-import numpy as np
+from typing import Optional, Dict, List
 from .graphics_base import KesslerGraphics
+from ..scenario import Scenario
+from ..ship import Ship
+from ..asteroid import Asteroid
+from ..bullet import Bullet
+from ..mines import Mine
+from ..score import Score
 
 class GraphicsType(Enum):
     NoGraphics = 0
@@ -16,12 +22,12 @@ class GraphicsType(Enum):
 
 
 class GraphicsHandler:
-
-    def __init__(self, type: GraphicsType=GraphicsType.NoGraphics, scenario=None, UI_settings=None, graphics_obj=None):
+    def __init__(self, type: GraphicsType = GraphicsType.NoGraphics, scenario: Optional[Scenario] = None, UI_settings: Optional[Dict[str, bool]] = None, graphics_obj: Optional[KesslerGraphics] = None) -> None:
         """
         Create a graphics handler utilizing the assigned graphics engine defined from GraphicsType
         """
         self.type = type
+        self.graphics: Optional[KesslerGraphics]
         if graphics_obj is not None:
             self.graphics = graphics_obj
             if not issubclass(graphics_obj.__class__, KesslerGraphics):
@@ -40,24 +46,28 @@ def __init__(self, type: GraphicsType=GraphicsType.NoGraphics, scenario=None, UI
                     from .graphics_plt import GraphicsPLT
                     self.graphics = GraphicsPLT()
                 case GraphicsType.Custom:
-                    if graphics_obj is None:
-                        raise ValueError('"graphics_obj" must be defined in settings when using GraphicsType.Custom')
-                    else:
-                        self.graphics = graphics_obj
+                    #if graphics_obj is None:
+                    raise ValueError('"graphics_obj" must be defined in settings when using GraphicsType.Custom')
+                    #else:
+                    #    self.graphics = graphics_obj
 
         if self.type != GraphicsType.NoGraphics:
+            assert self.graphics is not None
+            assert scenario is not None
             self.graphics.start(scenario)
 
-    def update(self, score, ships, asteroids, bullets, mines):
+    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet], mines: List[Mine]) -> None:
         """
         Update the graphics draw with new simulation data each simulation time-step
         """
         if self.type != GraphicsType.NoGraphics:
+            assert self.graphics is not None
             self.graphics.update(score, ships, asteroids, bullets, mines)
 
-    def close(self):
+    def close(self) -> None:
         """
         Finalize and close the graphics window
         """
         if self.type != GraphicsType.NoGraphics:
+            assert self.graphics is not None
             self.graphics.close()
diff --git a/src/kesslergame/graphics/graphics_plt.py b/src/kesslergame/graphics/graphics_plt.py
index 67a6e6f..34e9252 100644
--- a/src/kesslergame/graphics/graphics_plt.py
+++ b/src/kesslergame/graphics/graphics_plt.py
@@ -7,17 +7,28 @@
 import matplotlib.markers
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
-import scipy.ndimage as ndimage
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+
+import scipy.ndimage as ndimage  # type: ignore[import-untyped]
+
+from typing import List, Optional
 
 from .graphics_base import KesslerGraphics
+from ..ship import Ship
+from ..asteroid import Asteroid
+from ..bullet import Bullet
+from ..mines import Mine
+from ..score import Score
+from ..scenario import Scenario
 
 
 class GraphicsPLT(KesslerGraphics):
-    def __init__(self):
+    def __init__(self) -> None:
 
         # Objects for plotting data
-        self.fig = None
-        self.ax = None
+        self.fig: Optional[Figure] = None
+        self.ax: Optional[Axes] = None
         script_dir = os.path.dirname(__file__)
         self.images = ["images/playerShip1_green.png",
                        "images/playerShip1_orange.png",
@@ -26,12 +37,12 @@ def __init__(self):
         self.ship_images = [mpimg.imread(os.path.join(script_dir, image)) for image in self.images]
         self.bullets_line = 0
 
-    def start(self, scenario):
+    def start(self, scenario: Scenario) -> None:
         # Environment data
         self.map_size = scenario.map_size
 
         ships = scenario.ships()
-        bullets = []
+        bullets: List[Bullet] = []
         asteroids = scenario.asteroids()
 
         plt.ion()
@@ -44,7 +55,7 @@ def start(self, scenario):
 
         # plt.show()
 
-    def update(self, score, ships, bullets, asteroids):
+    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet], mines: List[Mine]) -> None:
         # clears ax
         plt.cla()
 
@@ -52,12 +63,14 @@ def update(self, score, ships, bullets, asteroids):
 
         plt.xlim([0, self.map_size[0]])
         plt.ylim([0, self.map_size[1]])
+        assert self.fig is not None
         self.fig.canvas.draw()
         self.fig.canvas.flush_events()
 
-    def plot_markers(self, ships, bullets, asteroids):
+    def plot_markers(self, ships: List[Ship], bullets: List[Bullet], asteroids: List[Asteroid]) -> None:
 
         # marker = matplotlib.markers.MarkerStyle(marker='<')
+        assert self.ax is not None
         for ship in ships:
             if ship.alive:
                 img = self.ship_images[1]
@@ -84,10 +97,10 @@ def plot_markers(self, ships, bullets, asteroids):
         y_asteroids2 = []
         y_asteroids3 = []
         y_asteroids4 = []
-        radius1 = 0
-        radius2 = 0
-        radius3 = 0
-        radius4 = 0
+        radius1 = 0.0
+        radius2 = 0.0
+        radius3 = 0.0
+        radius4 = 0.0
         # plot asteroids
         for asteroid in asteroids:
             if asteroid.size == 1:
@@ -107,7 +120,8 @@ def plot_markers(self, ships, bullets, asteroids):
                 y_asteroids4.append(asteroid.position[1])
                 radius4 = asteroid.radius
 
-        # TODO asteroids radiusi not hard coded
+        # TODO asteroids radii not hard coded
+        assert self.ax is not None
         self.ax.scatter(x_asteroids1, y_asteroids1, c='grey', marker='o', s=8)
         self.ax.scatter(x_asteroids2, y_asteroids2, c='b', marker='o', s=16)
         self.ax.scatter(x_asteroids3, y_asteroids3, c='g', marker='o', s=24)
@@ -124,5 +138,5 @@ def plot_markers(self, ships, bullets, asteroids):
         y_bullets = [bullet.position[1] for bullet in bullets]
         self.ax.scatter(x_bullets, y_bullets, color='r', marker='*', s=1)
 
-    def close(self):
+    def close(self) -> None:
         plt.close(self.fig)
diff --git a/src/kesslergame/graphics/graphics_tk.py b/src/kesslergame/graphics/graphics_tk.py
index 32631e1..c755272 100644
--- a/src/kesslergame/graphics/graphics_tk.py
+++ b/src/kesslergame/graphics/graphics_tk.py
@@ -4,14 +4,22 @@
 # this source code package.
 
 import os
-from tkinter import *
-from PIL import Image, ImageTk
+from tkinter import Tk, Canvas, NW
+from PIL import Image, ImageTk  # type: ignore[import-untyped]
 
+from typing import Dict, Optional, List
 from .graphics_base import KesslerGraphics
+from ..ship import Ship
+from ..asteroid import Asteroid
+from ..bullet import Bullet
+from ..mines import Mine
+from ..score import Score
+from ..scenario import Scenario
+from ..team import Team
 
 
 class GraphicsTK(KesslerGraphics):
-    def __init__(self, UI_settings):
+    def __init__(self, UI_settings: Optional[Dict[str, bool]] = None) -> None:
         # UI settings
         # lives, accuracy, asteroids hit, shots taken, bullets left
         # default_ui = {'ships': True, 'lives_remaining': True, 'accuracy': True, 'asteroids_hit': True}
@@ -24,13 +32,13 @@ def __init__(self, UI_settings):
         self.show_bullets_remaining = UI_settings.get('bullets_remaining', False)
         self.show_controller_name = UI_settings.get('controller_name', True)
 
-    def start(self, scenario):
+    def start(self, scenario: Scenario) -> None:
         self.game_width = scenario.map_size[0]
         self.game_height = scenario.map_size[1]
         self.max_time = scenario.time_limit
         self.score_width = 385
         self.window_width = self.game_width + self.score_width
-        ship_radius = scenario.ships()[0].radius * 2 - 5
+        ship_radius: int = int(scenario.ships()[0].radius * 2 - 5)
 
         # create and center main window
         self.window = Tk()
@@ -58,9 +66,9 @@ def start(self, scenario):
         self.ship_icons = [ImageTk.PhotoImage((Image.open(os.path.join(script_dir, image))).resize((ship_radius, ship_radius))) for image in self.image_paths]
 
         self.detoantion_time = 0.3
-        self.detonation_timers = []
+        #self.detonation_timers = []
 
-    def update(self, score, ships, asteroids, bullets, mines):
+    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet], mines: List[Mine]) -> None:
 
         # Delete everything from canvas so we can re-plot
         self.game_canvas.delete("all")
@@ -78,10 +86,10 @@ def update(self, score, ships, asteroids, bullets, mines):
         # Push updates to graphics refresh
         self.window.update()
 
-    def close(self):
+    def close(self) -> None:
         self.window.destroy()
 
-    def update_score(self, score, ships):
+    def update_score(self, score: Score, ships: List[Ship]) -> None:
 
         # offsets to deal with cleanliness and window borders covering data
         x_offset = 5
@@ -113,6 +121,7 @@ def update_score(self, score, ships):
                     if ship.team == team.team_id:
                         ships_text += ("Ship " + str(ship.id))
                         if self.show_controller_name:
+                            assert ship.controller is not None
                             ships_text += ": " + str(ship.controller.name)
                         ships_text += '\n'
 
@@ -121,7 +130,7 @@ def update_score(self, score, ships):
 
             # determine output location based off order in team list
             if (team_num % 2) == 0:
-                output_location_x = self.game_width + x_offset
+                output_location_x = int(self.game_width + x_offset)
 
                 # y location is based off the number of lines in the previous teams row
                 output_location_y = output_location_y + (17 * max_lines) + y_offset
@@ -130,7 +139,7 @@ def update_score(self, score, ships):
                 self.game_canvas.create_line(self.game_width, output_location_y - 10, self.window_width, output_location_y - 10, fill="white")
                 max_lines = score_board.count("\n")
             else:
-                output_location_x = self.window_width + x_offset - self.score_width / 2
+                output_location_x = int(self.window_width + x_offset - self.score_width / 2)
 
                 # change max lines in the row if odd team has more lines then even
                 if score_board.count("\n") > max_lines:
@@ -144,7 +153,7 @@ def update_score(self, score, ships):
                                      image=self.ship_icons[(team.team_id-1) % self.num_images])
             team_num += 1
 
-    def format_ui(self, team):
+    def format_ui(self, team: Team) -> str:
         # lives, accuracy, asteroids hit, shots taken, bullets left
         team_info = "_________\n"
         if self.show_lives:
@@ -160,7 +169,7 @@ def format_ui(self, team):
 
         return team_info
 
-    def plot_ships(self, ships):
+    def plot_ships(self, ships: List[Ship]) -> None:
         """
         Plots each ship on the game screen using cached sprites and rotating them
         """
@@ -174,7 +183,7 @@ def plot_ships(self, ships):
                                              self.game_height - (ship.position[1] + ship.radius), text=str(ship.id),
                                              fill="white")
 
-    def plot_shields(self, ships):
+    def plot_shields(self, ships: List[Ship]) -> None:
         """
         Plots each ship's shield ring
         """
@@ -193,7 +202,7 @@ def plot_shields(self, ships):
                                              self.game_height - (ship.position[1] - ship.radius),
                                              fill="black", outline=color)
 
-    def plot_bullets(self, bullets):
+    def plot_bullets(self, bullets: List[Bullet]) -> None:
         """
         Plots each bullet object on the game screen
         """
@@ -202,7 +211,7 @@ def plot_bullets(self, bullets):
                                          bullet.tail[0], self.game_height - bullet.tail[1],
                                          fill="#EE2737", width=3)
 
-    def plot_asteroids(self, asteroids):
+    def plot_asteroids(self, asteroids: List[Asteroid]) -> None:
         """
         Plots each asteroid object on the game screen
         """
@@ -213,7 +222,7 @@ def plot_asteroids(self, asteroids):
                                          self.game_height - (asteroid.position[1] - asteroid.radius),
                                          fill="grey")
 
-    def plot_mines(self, mines):
+    def plot_mines(self, mines: List[Mine]) -> None:
         """
         Plots and animates each mine object on the game screen and their detonations
         """
@@ -240,6 +249,3 @@ def plot_mines(self, mines):
                                              self.game_height - (mine.position[1] - explosion_radius),
                                              # fill="#fa441b",
                                              fill="", outline="white", width=10)
-
-
-
diff --git a/src/kesslergame/graphics/graphics_ue.py b/src/kesslergame/graphics/graphics_ue.py
index 049a156..d33b518 100644
--- a/src/kesslergame/graphics/graphics_ue.py
+++ b/src/kesslergame/graphics/graphics_ue.py
@@ -10,13 +10,14 @@
 from ..ship import Ship
 from ..asteroid import Asteroid
 from ..bullet import Bullet
+from ..mines import Mine
 from ..score import Score
 from ..scenario import Scenario
 from .graphics_base import KesslerGraphics
 
 
 class GraphicsUE(KesslerGraphics):
-    def __init__(self):
+    def __init__(self) -> None:
         # Create udp senders/receivers
         udp_host = 'localhost'
         udp_port = 12345
@@ -25,7 +26,7 @@ def __init__(self):
         self.udp_recvr.bind(('localhost', 12346))
         self.udp_addr = (udp_host, udp_port)
 
-    def start(self, scenario: Scenario):
+    def start(self, scenario: Scenario) -> None:
         self.map_size = scenario.map_size
         ship_count = len(scenario.ships())
         team_count = len(np.unique([ship.team for ship in scenario.ships()]))
@@ -46,7 +47,7 @@ def start(self, scenario: Scenario):
         start_str += 'teams:' + str(team_count)
         self.udp_sock.sendto(start_str.encode('utf-8'), self.udp_addr)
 
-    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet]):
+    def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bullets: List[Bullet], mines: List[Mine]) -> None:
         update_parts = ['::frame::']
 
         for ship in ships:
@@ -100,5 +101,5 @@ def update(self, score: Score, ships: List[Ship], asteroids: List[Asteroid], bul
 
         self.udp_sock.sendto(update_str.encode('utf-8'), self.udp_addr)
 
-    def close(self):
+    def close(self) -> None:
         self.udp_sock.close()
diff --git a/src/kesslergame/kessler_game.py b/src/kesslergame/kessler_game.py
index e5830c5..2c48a2a 100644
--- a/src/kesslergame/kessler_game.py
+++ b/src/kesslergame/kessler_game.py
@@ -6,7 +6,7 @@
 import time
 
 import math
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Tuple, TypedDict, Optional
 from enum import Enum
 from collections import OrderedDict
 
@@ -15,6 +15,11 @@
 from .controller import KesslerController
 from .collisions import circle_line_collision
 from .graphics import GraphicsType, GraphicsHandler
+from .mines import Mine
+from .asteroid import Asteroid
+from .ship import Ship
+from .bullet import Bullet
+from .graphics import KesslerGraphics
 
 
 class StopReason(Enum):
@@ -25,20 +30,30 @@ class StopReason(Enum):
     out_of_bullets = 4
 
 
+class PerfDict(TypedDict, total=False):
+    controller_times: List[float]
+    total_controller_time: float
+    physics_update: float
+    collisions_check: float
+    score_update: float
+    graphics_draw: float
+    total_frame_time: float
+
+
 class KesslerGame:
-    def __init__(self, settings: Dict[str, Any] = None):
+    def __init__(self, settings: Optional[Dict[str, Any]] = None) -> None:
 
         if settings is None:
             settings = {}
         # Game settings
-        self.frequency = settings.get("frequency", 30.0)
-        self.time_step = 1 / settings.get("frequency", 30.0)
-        self.perf_tracker = settings.get("perf_tracker", True)
-        self.prints_on = settings.get("prints_on", True)
-        self.graphics_type = settings.get("graphics_type", GraphicsType.Tkinter)
-        self.graphics_obj = settings.get("graphics_obj", None)
-        self.realtime_multiplier = settings.get("realtime_multiplier", 0 if self.graphics_type==GraphicsType.NoGraphics else 1)
-        self.time_limit = settings.get("time_limit", None)
+        self.frequency: float = settings.get("frequency", 30.0)
+        self.time_step: float = 1 / settings.get("frequency", 30.0)
+        self.perf_tracker: bool = settings.get("perf_tracker", True)
+        self.prints_on: bool = settings.get("prints_on", True)
+        self.graphics_type: GraphicsType = settings.get("graphics_type", GraphicsType.Tkinter)
+        self.graphics_obj: Optional[KesslerGraphics] = settings.get("graphics_obj", None)
+        self.realtime_multiplier: float = settings.get("realtime_multiplier", 0 if self.graphics_type==GraphicsType.NoGraphics else 1)
+        self.time_limit: float = settings.get("time_limit", float("inf"))
 
         # UI settings
         default_ui = {'ships': True, 'lives_remaining': True, 'accuracy': True,
@@ -49,7 +64,7 @@ def __init__(self, settings: Dict[str, Any] = None):
                                 'asteroids_hit': True, 'shots_fired': True, 'bullets_remaining': True,
                                 'controller_name': True}
         
-    def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Score, OrderedDict):
+    def run(self, scenario: Scenario, controllers: List[KesslerController]) -> Tuple[Score, List[PerfDict]]:
         """
         Run an entire scenario from start to finish and return score and stop reason
         """
@@ -58,18 +73,18 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
         # INITIALIZATION #
         ##################
         # Initialize objects lists from scenario
-        asteroids = scenario.asteroids()
-        ships = scenario.ships()
-        bullets = []
-        mines = []
+        asteroids: List[Asteroid] = scenario.asteroids()
+        ships: List[Ship] = scenario.ships()
+        bullets: List[Bullet] = []
+        mines: List[Mine] = []
 
         # Initialize Scoring class
         score = Score(scenario)
 
         # Initialize environment parameters
         stop_reason = StopReason.not_stopped
-        sim_time = 0
-        step = 0
+        sim_time: float = 0.0
+        step: int = 0
         time_limit = scenario.time_limit if scenario.time_limit else self.time_limit
 
         # Assign controllers to each ship
@@ -81,16 +96,20 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
         graphics = GraphicsHandler(type=self.graphics_type, scenario=scenario, UI_settings=self.UI_settings, graphics_obj=self.graphics_obj)
 
         # Initialize list of dictionary for performance tracking (will remain empty if perf_tracker is false
-        perf_list = []
+        perf_list: List[PerfDict] = []
 
         ######################
         # MAIN SCENARIO LOOP #
         ######################
+        bullet_remove_idxs: list[int] = []
+        asteroid_remove_idxs: set[int] = set()
+        mine_remove_idxs: list[int] = []
+        new_asteroids: list[Asteroid] = []
         while stop_reason == StopReason.not_stopped:
 
             # Get perf time at the start of time step evaluation and initialize performance tracker
             step_start = time.perf_counter()
-            perf_dict = OrderedDict()
+            perf_dict: PerfDict = {}
 
             # --- CALL CONTROLLER FOR EACH SHIP ------------------------------------------------------------------------
             # Get all live ships
@@ -118,8 +137,8 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
             for idx, ship in enumerate(ships):
                 if ship.alive:
                     # Reset controls on ship to defaults
-                    ship.thrust = 0
-                    ship.turn_rate = 0
+                    ship.thrust = 0.0
+                    ship.turn_rate = 0.0
                     ship.fire = False
                     # Evaluate each controller letting control be applied
                     if controllers[idx].ship_id != ship.id:
@@ -157,19 +176,15 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
             bullets = [bullet
                        for bullet
                        in bullets
-                       if 0 <= bullet.position[0] <= scenario.map_size[0]
-                       and 0 <= bullet.position[1] <= scenario.map_size[1]]
+                       if 0.0 <= bullet.position[0] <= scenario.map_size[0]
+                       and 0.0 <= bullet.position[1] <= scenario.map_size[1]]
 
             # Wrap ships and asteroids to other side of map
             for ship in liveships:
-                for idx, pos in enumerate(ship.position):
-                    bound = scenario.map_size[idx]
-                    ship.position[idx] = pos % bound
+                ship.position = (ship.position[0] % scenario.map_size[0], ship.position[1] % scenario.map_size[1])
 
             for asteroid in asteroids:
-                for idx, pos in enumerate(asteroid.position):
-                    bound = scenario.map_size[idx]
-                    asteroid.position[idx] = pos % bound
+                asteroid.position = (asteroid.position[0] % scenario.map_size[0], asteroid.position[1] % scenario.map_size[1])
 
             # Update performance tracker with
             if self.perf_tracker:
@@ -180,8 +195,6 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
 
 
             # --- Check asteroid-bullet collisions ---
-            bullet_remove_idxs = []
-            asteroid_remove_idxs = set() # Keep track of deleted asteroids, and cull all at once at the end
             for idx_bul, bullet in enumerate(bullets):
                 for idx_ast, asteroid in enumerate(asteroids):
                     if idx_ast in asteroid_remove_idxs:
@@ -201,10 +214,9 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
             # Cull bullets and asteroids that are marked for removal
             if bullet_remove_idxs:
                 bullets = [bullet for idx, bullet in enumerate(bullets) if idx not in bullet_remove_idxs]
+                bullet_remove_idxs.clear()
 
             # --- Check mine-asteroid and mine-ship effects ---
-            mine_remove_idxs = []
-            new_asteroids = []
             for idx_mine, mine in enumerate(mines):
                 if mine.detonating:
                     for idx_ast, asteroid in enumerate(asteroids):
@@ -231,11 +243,14 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
                     mine.destruct()
             if mine_remove_idxs:
                 mines = [mine for idx, mine in enumerate(mines) if idx not in mine_remove_idxs]
-            asteroids.extend(new_asteroids)
+                mine_remove_idxs.clear()
+            if new_asteroids:
+                asteroids.extend(new_asteroids)
+                new_asteroids.clear()
 
 
             # --- Check asteroid-ship collisions ---
-            for idx_ship, ship in enumerate(liveships):
+            for ship in liveships:
                 if not ship.is_respawning:
                     for idx_ast, asteroid in enumerate(asteroids):
                         if idx_ast in asteroid_remove_idxs:
@@ -243,8 +258,8 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
                         dx = ship.position[0] - asteroid.position[0]
                         dy = ship.position[1] - asteroid.position[1]
                         radius_sum = ship.radius + asteroid.radius
-                        # If collision occurs
-                        if dx * dx + dy * dy <= radius_sum * radius_sum:
+                        # Most of the time no collision occurs, so use early exit to optimize collision check
+                        if abs(dx) <= radius_sum and abs(dy) <= radius_sum and dx * dx + dy * dy <= radius_sum * radius_sum:
                             # Asteroid destruct function and mark for removal
                             asteroids.extend(asteroid.destruct(impactor=ship))
                             asteroid_remove_idxs.add(idx_ast)
@@ -257,6 +272,7 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
             liveships = [ship for ship in liveships if ship.alive]
             if asteroid_remove_idxs:
                 asteroids = [asteroid for idx, asteroid in enumerate(asteroids) if idx not in asteroid_remove_idxs]
+                asteroid_remove_idxs.clear()
 
             # --- Check ship-ship collisions ---
             for i, ship1 in enumerate(liveships):
@@ -265,7 +281,8 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
                         dx = ship1.position[0] - ship2.position[0]
                         dy = ship1.position[1] - ship2.position[1]
                         radius_sum = ship1.radius + ship2.radius
-                        if dx * dx + dy * dy <= radius_sum * radius_sum:
+                        # Most of the time no collision occurs, so use early exit to optimize collision check
+                        if abs(dx) <= radius_sum and abs(dy) <= radius_sum and dx * dx + dy * dy <= radius_sum * radius_sum:
                             ship1.destruct(map_size=scenario.map_size)
                             ship2.destruct(map_size=scenario.map_size)
             # Cull ships that are not alive
@@ -340,7 +357,7 @@ def run(self, scenario: Scenario, controllers: List[KesslerController]) -> (Scor
 
 
 class TrainerEnvironment(KesslerGame):
-    def __init__(self, settings: Dict[str, Any] = None):
+    def __init__(self, settings: Optional[Dict[str, Any]] = None) -> None:
         """
         Instantiates a KesslerGame object with settings to optimize training time
         """
@@ -352,6 +369,6 @@ def __init__(self, settings: Dict[str, Any] = None):
             'prints_on': settings.get("prints_on", False),
             'graphics_type': GraphicsType.NoGraphics,
             'realtime_multiplier': 0,
-            'time_limit': settings.get("time_limit", None)
+            'time_limit': settings.get("time_limit", float("inf"))
         }
         super().__init__(trainer_settings)
diff --git a/src/kesslergame/mines.py b/src/kesslergame/mines.py
index 20532ec..2f65a7f 100644
--- a/src/kesslergame/mines.py
+++ b/src/kesslergame/mines.py
@@ -3,34 +3,39 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-from typing import List, Tuple, Dict, Any
+from typing import List, Tuple, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .ship import Ship
+    from .asteroid import Asteroid
 
 
 class Mine:
-    def __init__(self, starting_position: List[float], owner):
-        self.fuse_time = 3
+    __slots__ = ('fuse_time', 'detonation_time', 'mass', 'radius', 'blast_radius', 'blast_pressure', 'owner', 'countdown_timer', 'detonating', 'position')
+    def __init__(self, starting_position: List[float], owner: 'Ship') -> None:
+        self.fuse_time = 3.0
         self.detonation_time = 0.25
-        self.mass = 25  # mass units - kg?
-        self.radius = 12
-        self.blast_radius = 150
-        self.blast_pressure = 2000
+        self.mass = 25.0  # mass units - kg?
+        self.radius = 12.0
+        self.blast_radius = 150.0
+        self.blast_pressure = 2000.0
 
         self.owner = owner
         self.countdown_timer = self.fuse_time
         self.detonating = False
         self.position = starting_position
 
-    def update(self, delta_time=1/30):
+    def update(self, delta_time: float = 1/30) -> None:
         self.countdown_timer -= delta_time
         if self.countdown_timer <= 1e-15:
             self.detonate()
 
-    def detonate(self):
+    def detonate(self) -> None:
         # perform any detonation stuff here
         self.detonating = True
 
-    def destruct(self):
-        ...
+    def destruct(self) -> None:
+        pass
 
     @property
     def state(self) -> Dict[str, Any]:
@@ -41,9 +46,9 @@ def state(self) -> Dict[str, Any]:
             "remaining_time": float(self.countdown_timer)
         }
 
-    def calculate_blast_force(self, dist, obj):
+    def calculate_blast_force(self, dist: float, obj: 'Asteroid') -> float:
         """
         Calculates the blast force based on the blast radius, blast pressure, and a linear decrease in intensity from the mine location to the blast radius
         Also takes into account asteroid diameter to resolve total acceleration based on size/mass
         """
-        return (-dist/self.blast_radius + 1) * self.blast_pressure * 2 * obj.radius
\ No newline at end of file
+        return (-dist/self.blast_radius + 1) * self.blast_pressure * 2.0 * obj.radius
diff --git a/src/kesslergame/mypy.ini b/src/kesslergame/mypy.ini
new file mode 100644
index 0000000..5434809
--- /dev/null
+++ b/src/kesslergame/mypy.ini
@@ -0,0 +1,2 @@
+[mypy-numpy.*,matplotlib.*,scipy.*,inputs.*]
+ignore_missing_imports = True
diff --git a/src/kesslergame/scenario.py b/src/kesslergame/scenario.py
index ab5edac..60e65e9 100644
--- a/src/kesslergame/scenario.py
+++ b/src/kesslergame/scenario.py
@@ -3,8 +3,7 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-import math
-from typing import List, Tuple, Dict, Any
+from typing import List, Tuple, Dict, Any, Optional
 import random
 
 from .ship import Ship
@@ -12,9 +11,9 @@
 
 
 class Scenario:
-    def __init__(self, name: str = "Unnamed", num_asteroids: int = 0, asteroid_states: List[Dict[str, Any]] = None,
-                 ship_states: List[Dict[str, Any]] = None, map_size: Tuple[int, int] = None, seed: int = None,
-                 time_limit: float = float("inf"), ammo_limit_multiplier: float = 0.0, stop_if_no_ammo: bool = False):
+    def __init__(self, name: str = "Unnamed", num_asteroids: int = 0, asteroid_states: Optional[List[Dict[str, Any]]] = None,
+                 ship_states: Optional[List[Dict[str, Any]]] = None, map_size: Optional[Tuple[int, int]] = None, seed: Optional[int] = None,
+                 time_limit: float = float("inf"), ammo_limit_multiplier: float = 0.0, stop_if_no_ammo: bool = False) -> None:
         """
         Specify the starting state of the environment, including map dimensions and optional features
 
@@ -32,7 +31,7 @@ def __init__(self, name: str = "Unnamed", num_asteroids: int = 0, asteroid_state
         :param stop_if_no_ammo: Optional flag for stopping the scenario if all ships run out of ammo
         """
         # Protected variable for managing the name, through getter/setter interface
-        self._name = None
+        self._name: Optional[str] = None
 
         # Store name as string using setter
         self.name = name
@@ -83,11 +82,11 @@ def __init__(self, name: str = "Unnamed", num_asteroids: int = 0, asteroid_state
                               "valid custom starting states for the environment"))
 
     @property
-    def name(self):
+    def name(self) -> None | str:
         return self._name
 
     @name.setter
-    def name(self, name: str):
+    def name(self, name: str) -> None:
         # Raises error if the name cannot be converted to string
         self._name = str(name)
 
@@ -116,7 +115,7 @@ def bullet_limit(self) -> int:
             return -1
 
     @staticmethod
-    def count_asteroids(asteroid_size) -> float:
+    def count_asteroids(asteroid_size: int) -> int:
         # Counting based off of each asteroid making 3 children when destroyed
         return sum([3 ** (size - 1) for size in range(1, asteroid_size + 1)])
 
diff --git a/src/kesslergame/score.py b/src/kesslergame/score.py
index ce508c4..479eefb 100644
--- a/src/kesslergame/score.py
+++ b/src/kesslergame/score.py
@@ -3,7 +3,7 @@
 # NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
 # this source code package.
 
-from typing import List
+from typing import List, Optional, TYPE_CHECKING
 
 import numpy as np
 
@@ -11,18 +11,20 @@
 from .asteroid import Asteroid
 from .scenario import Scenario
 from .team import Team
+if TYPE_CHECKING:
+    from .kessler_game import StopReason
 
 
 class Score:
-    def __init__(self, scenario: Scenario):
-        self.sim_time = 0
-        self.stop_reason = None
+    def __init__(self, scenario: Scenario) -> None:
+        self.sim_time: float = 0.0
+        self.stop_reason: Optional['StopReason'] = None
 
 
         # Initialize team classes to score team-specific scores
         team_ids = [ship.team for ship in scenario.ships()]
         team_names = [ship.team_name for ship in scenario.ships()]
-        self.teams = [Team(team_id, team_name) for team_id, team_name in zip(np.unique(team_ids), np.unique(team_names))]
+        self.teams = [Team(int(team_id), str(team_name)) for team_id, team_name in zip(np.unique(team_ids), np.unique(team_names))]
 
         # Populate scenario initial conditions into score parameters
         for team in self.teams:
@@ -31,7 +33,7 @@ def __init__(self, scenario: Scenario):
                 if team.team_id == ship.team:
                     team.total_bullets += scenario.bullet_limit
 
-    def update(self, ships: List[Ship], sim_time, controller_perf: List[float] = None):
+    def update(self, ships: List[Ship], sim_time: float, controller_perf: Optional[List[float]] = None) -> None:
         self.sim_time = sim_time
         for team in self.teams:
             ast_hit, bul_hit, shots, bullets, deaths, lives = (0, 0, 0, 0, 0, 0)
@@ -47,7 +49,7 @@ def update(self, ships: List[Ship], sim_time, controller_perf: List[float] = Non
                         team.eval_times.append(controller_perf[idx])
             team.asteroids_hit, team.bullets_hit, team.shots_fired, team.bullets_remaining, team.deaths, team.lives_remaining = (ast_hit, bul_hit, shots, bullets, deaths, lives)
 
-    def finalize(self, sim_time, stop_reason, ships):
+    def finalize(self, sim_time: float, stop_reason: 'StopReason', ships: List[Ship]) -> None:
         self.sim_time = sim_time
         self.stop_reason = stop_reason
         self.final_controllers = [ship.controller for ship in ships]
diff --git a/src/kesslergame/ship.py b/src/kesslergame/ship.py
index 984bff3..74e5bd4 100644
--- a/src/kesslergame/ship.py
+++ b/src/kesslergame/ship.py
@@ -6,58 +6,68 @@
 import math
 import warnings
 import numpy as np
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Tuple, Optional
 
 from .bullet import Bullet
 from .mines import Mine
+from .controller import KesslerController
 
 
 class Ship:
-    def __init__(self, ship_id,
-                 position: List[float],
-                 angle: float = 90,
+    __slots__ = (
+        'controller', 'thrust', 'turn_rate', 'id', 'speed', 'position',
+        'velocity', 'heading', 'lives', 'deaths', 'team', 'team_name',
+        'fire', 'drop_mine', 'thrust_range', 'turn_rate_range', 'max_speed',
+        'drag', 'radius', 'mass', '_respawning', '_respawn_time', '_fire_limiter',
+        '_fire_time', '_mine_limiter', '_mine_deploy_time', 'mines_remaining',
+        'bullets_remaining', 'bullets_shot', 'mines_dropped', 'bullets_hit',
+        'mines_hit', 'asteroids_hit'
+    )
+    def __init__(self, ship_id: int,
+                 position: Tuple[float, float],
+                 angle: float = 90.0,
                  lives: int = 3,
                  team: int = 1,
-                 team_name: str = None,
+                 team_name: Optional[str] = None,
                  bullets_remaining: int = -1,
-                 mines_remaining: int = 0):
+                 mines_remaining: int = 0) -> None:
         """
         Instantiate a ship with default parameters and infinite bullets if not specified
         """
 
         # Control information
-        self.controller = None
-        self.thrust = 0.0     # speed defaults to minimum
-        self.turn_rate = 0.0
+        self.controller: Optional[KesslerController] = None
+        self.thrust: float = 0.0  # speed defaults to minimum
+        self.turn_rate: float = 0.0
 
         # State info
-        self.id = ship_id
-        self.speed = 0.0
-        self.position = position
-        self.velocity = [0.0, 0.0]
-        self.heading = angle
-        self.lives = lives
-        self.deaths = 0
-        self.team = team
-        self.team_name = team_name if team_name is not None else 'Team ' + str(self.team)
+        self.id: int = ship_id
+        self.speed: float = 0.0
+        self.position: tuple[float, float] = position
+        self.velocity: tuple[float, float] = (0.0, 0.0)
+        self.heading: float = angle
+        self.lives: int = lives
+        self.deaths: int = 0
+        self.team: int = team
+        self.team_name: str = team_name if team_name is not None else 'Team ' + str(self.team)
 
         # Controller inputs
         self.fire = False
-        self.thrust = 0
-        self.turn_rate = 0
+        self.thrust = 0.0
+        self.turn_rate = 0.0
         self.drop_mine = False
 
         # Physical model constants/params
         self.thrust_range = (-480.0, 480.0)  # m/s^2
         self.turn_rate_range = (-180.0, 180.0)  # Degrees per second
-        self.max_speed = 240  # Meters per second
+        self.max_speed = 240.0  # Meters per second
         self.drag = 80.0  # m/s^2
-        self.radius = 20  # meters TODO verify radius size
-        self.mass = 300  # kg - reasonable? max asteroid mass currently is ~490 kg
+        self.radius = 20.0  # meters TODO verify radius size
+        self.mass = 300.0  # kg - reasonable? max asteroid mass currently is ~490 kg
 
         # Manage respawns/firing via timers
-        self._respawning = 0
-        self._respawn_time = 3  # seconds
+        self._respawning = 0.0
+        self._respawn_time = 3.0  # seconds
         self._fire_limiter = 0.0 # seconds
         self._fire_time = 1 / 10  # seconds
         self._mine_limiter = 0.0 # second
@@ -104,7 +114,7 @@ def ownstate(self) -> Dict[str, Any]:
         }
 
     @property
-    def alive(self):
+    def alive(self) -> bool:
         return True if self.lives > 0 else False
 
     @property
@@ -143,10 +153,10 @@ def fire_wait_time(self) -> float:
     def mine_wait_time(self) -> float:
         return self._mine_limiter
 
-    def shoot(self):
+    def shoot(self) -> None:
         self.fire = True
 
-    def update(self, delta_time: float = 1 / 30) -> tuple[Bullet, Mine]:
+    def update(self, delta_time: float = 1 / 30) -> tuple[Optional[Bullet], Optional[Mine]]:
         """
         Update our position and other particulars.
         """
@@ -163,8 +173,8 @@ def update(self, delta_time: float = 1 / 30) -> tuple[Bullet, Mine]:
             new_mine = None
 
         # Decrement respawn timer (if necessary)
-        if self._respawning <= 0:
-            self._respawning = 0
+        if self._respawning <= 0.0:
+            self._respawning = 0.0
         else:
             self._respawning -= delta_time
 
@@ -210,18 +220,19 @@ def update(self, delta_time: float = 1 / 30) -> tuple[Bullet, Mine]:
         self.heading += self.turn_rate * delta_time
 
         # Keep the angle within (0, 360)
-        self.heading %= 360
+        self.heading %= 360.0
 
         # Use speed magnitude to get velocity vector
-        self.velocity = [math.cos(math.radians(self.heading)) * self.speed,
-                         math.sin(math.radians(self.heading)) * self.speed]
+        rad_heading = math.radians(self.heading)
+        self.velocity = (math.cos(rad_heading) * self.speed,
+                         math.sin(rad_heading) * self.speed)
 
         # Update the position based off the velocities
-        self.position = [pos + v * delta_time for pos, v in zip(self.position, self.velocity)]
+        self.position = (self.position[0] + self.velocity[0] * delta_time, self.position[1] + self.velocity[1] * delta_time)
 
         return new_bullet, new_mine
 
-    def destruct(self, map_size):
+    def destruct(self, map_size: tuple[float, float]) -> None:
         """
         Called by the game when a ship collides with something and dies. Handles life decrementing and triggers respawn
         """
@@ -233,7 +244,7 @@ def destruct(self, map_size):
         spawn_heading = self.heading
         self.respawn(spawn_position, spawn_heading)
 
-    def respawn(self, position: List[float], heading: float = 90.0) -> None:
+    def respawn(self, position: Tuple[float, float], heading: float = 90.0) -> None:
         """
         Called when we die and need to make a new ship.
         'respawning' is an invulnerability timer.
@@ -244,15 +255,15 @@ def respawn(self, position: List[float], heading: float = 90.0) -> None:
         # Set location and physical parameters
         self.position = position
         self.speed = 0.0
-        self.velocity = [0.0, 0.0]
+        self.velocity = (0.0, 0.0)
         self.heading = heading
 
-    def deploy_mine(self):
+    def deploy_mine(self) -> Mine | None:
         # if self.mines_remaining != 0 and not self._mine_limiter:
         if self.can_deploy_mine:
 
             # Remove respawn invincibility. Mine deployment limiter
-            self._respawning = 0
+            self._respawning = 0.0
             self._mine_limiter = self._mine_deploy_time
 
             if self.mines_remaining > 0:
@@ -264,12 +275,12 @@ def deploy_mine(self):
         else:
             return None
 
-    def fire_bullet(self):
+    def fire_bullet(self) -> Bullet | None:
         # if self.bullets_remaining != 0 and not self._fire_limiter:
         if self.can_fire:
 
             # Remove respawn invincibility. Trigger fire limiter
-            self._respawning = 0
+            self._respawning = 0.0
             self._fire_limiter = self._fire_time
 
             # Bullet counters
@@ -278,9 +289,10 @@ def fire_bullet(self):
             self.bullets_shot += 1
 
             # Return the bullet object that was fired
-            bullet_x = self.position[0] + self.radius * math.cos(math.radians(self.heading))
-            bullet_y = self.position[1] + self.radius * math.sin(math.radians(self.heading))
-            return Bullet([bullet_x, bullet_y], self.heading, owner=self)
+            rad_heading = math.radians(self.heading)
+            bullet_x = self.position[0] + self.radius * math.cos(rad_heading)
+            bullet_y = self.position[1] + self.radius * math.sin(rad_heading)
+            return Bullet((bullet_x, bullet_y), self.heading, owner=self)
 
         # Return nothing if we can't fire a bullet right now
         return None
diff --git a/src/kesslergame/team.py b/src/kesslergame/team.py
index a640626..5493666 100644
--- a/src/kesslergame/team.py
+++ b/src/kesslergame/team.py
@@ -7,24 +7,24 @@
 
 
 class Team:
-    def __init__(self, id, name):
+    def __init__(self, id: int, name: str) -> None:
         self.team_id = id
         self.team_name = name
 
-        self.total_bullets = 0
-        self.total_asteroids = 0
+        self.total_bullets: int = 0
+        self.total_asteroids: int = 0
 
-        self.asteroids_hit = 0
-        self.bullets_hit = 0
-        self.shots_fired = 0
-        self.bullets_remaining = 0
-        self.deaths = 0
-        self.eval_times = []
-        self.lives_remaining = 0
+        self.asteroids_hit: int = 0
+        self.bullets_hit: int = 0
+        self.shots_fired: int = 0
+        self.bullets_remaining: int = 0
+        self.deaths: int = 0
+        self.eval_times: list[float] = []
+        self.lives_remaining: int = 0
 
     @property
     def accuracy(self) -> float:
-        return self.bullets_hit / self.shots_fired if self.shots_fired else 0
+        return self.bullets_hit / self.shots_fired if self.shots_fired else 0.0
 
     @property
     def fraction_total_asteroids_hit(self) -> float:
@@ -40,16 +40,28 @@ def ratio_bullets_needed(self) -> float:
 
     @property
     def mean_eval_time(self) -> float:
-        return np.mean(self.eval_times)
+        if self.eval_times:
+            return float(np.mean(self.eval_times))
+        else:
+            return 0.0
 
     @property
     def median_eval_time(self) -> float:
-        return np.median(self.eval_times)
+        if self.eval_times:
+            return float(np.median(self.eval_times))
+        else:
+            return 0.0
 
     @property
     def min_eval_time(self) -> float:
-        return min(self.eval_times)
+        if self.eval_times:
+            return min(self.eval_times)
+        else:
+            return 0.0
 
     @property
     def max_eval_time(self) -> float:
-        return max(self.eval_times)
+        if self.eval_times:
+            return max(self.eval_times)
+        else:
+            return 0.0


Test patch:
diff --git a/examples/scenario_timing_test_nographics.py b/examples/scenario_timing_test_nographics.py
new file mode 100644
index 0000000..fb97f87
--- /dev/null
+++ b/examples/scenario_timing_test_nographics.py
@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2022 Thales. All Rights Reserved.
+# NOTICE: This file is subject to the license agreement defined in file 'LICENSE', which is part of
+# this source code package.
+
+import time
+import numpy as np
+import sys
+
+from src.kesslergame import Scenario, KesslerGame, GraphicsType
+from test_controller import TestController
+from graphics_both import GraphicsBoth
+
+# Define game scenario
+my_test_scenario = Scenario(name='Test Scenario',
+                            num_asteroids=10,
+                            ship_states=[
+                                {'position': (400, 400), 'angle': 90, 'lives': 3, 'team': 1, "mines_remaining": 3},
+                                # {'position': (400, 600), 'angle': 90, 'lives': 3, 'team': 2, "mines_remaining": 3},
+                            ],
+                            map_size=(1000, 800),
+                            time_limit=60,
+                            ammo_limit_multiplier=0,
+                            stop_if_no_ammo=False)
+
+# Define Game Settings
+game_settings = {'perf_tracker': True,
+                 'graphics_type': GraphicsType.NoGraphics,
+                 'realtime_multiplier': 0,
+                 'graphics_obj': None,
+                 'frequency': 30}
+
+runs = 5000
+timings = np.zeros(runs)
+
+for ii in range(runs):
+    game = KesslerGame(settings=game_settings)  # Use this to visualize the game scenario
+    # game = TrainerEnvironment(settings=game_settings)  # Use this for max-speed, no-graphics simulation
+
+    # Evaluate the game
+    pre = time.perf_counter()
+    score, perf_data = game.run(scenario=my_test_scenario, controllers=[TestController(), TestController()])
+    timings[ii] = time.perf_counter()-pre
+    print("\r", "Progress: {:.2f}".format((ii/(runs-1))*100.0) + "%", end="")
+    # text = "\nProgress: {}".format((ii/runs)*100.0) + "%"
+    # sys.stdout.write(text)
+    # sys.stdout.flush()
+
+
+print("\nMax eval time:" + str(np.max(timings)))
+print("Min eval time:" + str(np.min(timings)))
+print("Avg eval time:" + str(np.mean(timings)))
+print("Var eval time:" + str(np.var(timings)))
+
+np.savetxt("mypyc_timings.csv", timings, delimiter=",", fmt="%12f")
+
+# Print out some general info about the result
+# print('Scenario eval time: '+str(time.perf_counter()-pre))
+# print(score.stop_reason)
+# print('Asteroids hit: ' + str([team.asteroids_hit for team in score.teams]))
+# print('Deaths: ' + str([team.deaths for team in score.teams]))
+# print('Accuracy: ' + str([team.accuracy for team in score.teams]))
+# print('Mean eval time: ' + str([team.mean_eval_time for team in score.teams]))