ngrams_PY150_6.csv

NAME = NAME . NAME ( ::: 593199
( NAME ) : NEWLINE INDENT ::: 567457
NAME ( NAME ) : NEWLINE ::: 566687
NAME . NAME . NAME ( ::: 553807
) NEWLINE NAME . NAME ( ::: 536889
NEWLINE DEDENT def NAME ( NAME ::: 461220
: NEWLINE INDENT NAME . NAME ::: 454900
NEWLINE NAME = NAME . NAME ::: 454211
NAME ) : NEWLINE INDENT NAME ::: 447667
: NEWLINE INDENT NAME = NAME ::: 439301
. NAME ( NAME . NAME ::: 427310
def NAME ( NAME ) : ::: 406192
NAME ( NAME , NAME ) ::: 405628
NAME . NAME ( NAME ) ::: 400446
def NAME ( NAME , NAME ::: 400334
NAME . NAME ( NAME . ::: 398516
NEWLINE NAME . NAME ( NAME ::: 380790
NAME . NAME ( ) NEWLINE ::: 335620
, NAME ) : NEWLINE INDENT ::: 331879
NAME , NAME ) : NEWLINE ::: 326586
. NAME ( NAME ) NEWLINE ::: 317615
) : NEWLINE INDENT NAME = ::: 316796
NAME . NAME ( NAME , ::: 308804
= NAME . NAME ( NAME ::: 304009
) : NEWLINE INDENT STRING NEWLINE ::: 303531
. NAME . NAME ( NAME ::: 296369
) NEWLINE DEDENT def NAME ( ::: 291564
) NEWLINE NAME = NAME . ::: 282836
DEDENT def NAME ( NAME ) ::: 280197
DEDENT def NAME ( NAME , ::: 279485
NUMBER , NUMBER , NUMBER , ::: 274621
, NUMBER , NUMBER , NUMBER ::: 272414
STRING , STRING , STRING , ::: 268783
NAME ) NEWLINE NAME . NAME ::: 267252
NAME ( NAME , NAME , ::: 265092
( NAME , NAME , NAME ::: 264918
, STRING , STRING , STRING ::: 259981
NEWLINE INDENT NAME . NAME ( ::: 259263
NEWLINE INDENT NAME = NAME . ::: 252181
INDENT NAME = NAME . NAME ::: 252168
NAME ) : NEWLINE INDENT STRING ::: 250461
NAME , NAME , NAME , ::: 247772
NAME . NAME ( STRING ) ::: 246474
, NAME , NAME , NAME ::: 243599
. NAME ( NAME , NAME ::: 240155
NAME . NAME ( STRING , ::: 229452
( NAME , NAME ) : ::: 227080
= NAME . NAME . NAME ::: 218522
NAME ( NAME . NAME ) ::: 217993
NAME = NAME . NAME . ::: 212749
STRING : STRING , STRING : ::: 210467
) : NEWLINE INDENT NAME . ::: 207769
. NAME ( ) NEWLINE NAME ::: 194832
NEWLINE NAME . NAME = NAME ::: 182407
NAME ( NAME ) NEWLINE NAME ::: 179968
: STRING , STRING : STRING ::: 178666
NAME , NAME , NAME ) ::: 178247
NAME ( NAME . NAME , ::: 173667
NAME ( NAME ) NEWLINE DEDENT ::: 166921
. NAME ( STRING ) NEWLINE ::: 161771
: NEWLINE INDENT STRING NEWLINE NAME ::: 155638
NAME ( NAME . NAME ( ::: 153929
NEWLINE NAME . NAME . NAME ::: 153447
NAME NEWLINE from NAME . NAME ::: 152633
NAME ) NEWLINE NAME = NAME ::: 152332
) NEWLINE NAME = NAME ( ::: 148964
NAME . NAME ( NAME = ::: 146374
= NAME . NAME ( ) ::: 145056
NAME . NAME import NAME NEWLINE ::: 144261
NAME = STRING , NAME = ::: 139488
( ) NEWLINE NAME . NAME ::: 139472
NAME ( ) NEWLINE NAME . ::: 139025
NAME . NAME ) NEWLINE NAME ::: 138613
. NAME , NAME . NAME ::: 138498
NAME . NAME : NEWLINE INDENT ::: 137765
NEWLINE NAME = NAME ( NAME ::: 137421
STRING ) NEWLINE NAME . NAME ::: 136772
NAME . NAME , NAME . ::: 136730
INDENT NAME . NAME ( NAME ::: 135355
NEWLINE DEDENT else : NEWLINE INDENT ::: 132952
( NAME . NAME , NAME ::: 132273
NAME ) NEWLINE DEDENT def NAME ::: 129379
NAME import NAME NEWLINE from NAME ::: 128436
NEWLINE NAME . NAME ( STRING ::: 126958
. NAME . NAME ( ) ::: 126691
NAME . NAME = NAME NEWLINE ::: 126354
, NAME = NAME . NAME ::: 125595
( NAME , NAME ) NEWLINE ::: 124534
. NAME ( STRING , NAME ::: 124427
NEWLINE INDENT NAME = NAME ( ::: 124193
NAME : NEWLINE INDENT NAME . ::: 122548
, STRING : ( STRING , ::: 122271
. NAME . NAME . NAME ::: 121772
) NEWLINE NAME . NAME = ::: 121690
( NAME . NAME . NAME ::: 121114
NAME : NEWLINE INDENT NAME = ::: 120798
NAME . NAME . NAME . ::: 120443
import NAME NEWLINE from NAME . ::: 118050
( STRING , [ ] , ::: 117827
STRING , [ ] , { ::: 117563
STRING : ( STRING , [ ::: 117543
: ( STRING , [ ] ::: 117472
NAME NEWLINE DEDENT def NAME ( ::: 116654
] , { STRING : STRING ::: 114722
NAME ) : NEWLINE INDENT return ::: 114130
[ ] , { STRING : ::: 114122
, [ ] , { STRING ::: 114103
= NAME . NAME ( STRING ::: 114061
class NAME ( NAME ) : ::: 113479
. NAME ( ) NEWLINE DEDENT ::: 111583
) NEWLINE NAME . NAME . ::: 109692
NAME ( STRING ) NEWLINE NAME ::: 109597
NEWLINE INDENT STRING NEWLINE NAME = ::: 109175
NEWLINE def NAME ( NAME , ::: 109097
NAME ( NAME . NAME . ::: 108754
NAME = NAME , NAME = ::: 107168
) , STRING : ( STRING ::: 107128
, STRING : STRING , STRING ::: 106573
. NAME = NAME . NAME ::: 105772
NAME ( NAME , NAME = ::: 105730
NAME . NAME = NAME . ::: 104746
DEDENT else : NEWLINE INDENT NAME ::: 104504
. NAME import NAME NEWLINE from ::: 104124
{ STRING : STRING , STRING ::: 103927
DEDENT DEDENT def NAME ( NAME ::: 103666
} ) , STRING : ( ::: 102435
( NAME . NAME ) NEWLINE ::: 102351
NEWLINE INDENT NAME . NAME = ::: 102231
STRING : STRING } ) , ::: 101847
: STRING } ) , STRING ::: 99936
STRING } ) , STRING : ::: 99884
NAME , NAME ) NEWLINE DEDENT ::: 99378
. NAME . NAME ( STRING ::: 99269
, NAME = STRING , NAME ::: 99189
, NAME , NAME ) : ::: 98274
STRING , STRING : STRING , ::: 98002
NAME ( ) : NEWLINE INDENT ::: 97145
NAME , NAME , NAME = ::: 97064
NAME . NAME ) NEWLINE DEDENT ::: 96890
NEWLINE from NAME . NAME import ::: 96713
NEWLINE def NAME ( NAME ) ::: 96512
NAME = NAME . NAME NEWLINE ::: 96359
NAME . NAME . NAME import ::: 95119
from NAME . NAME . NAME ::: 94877
) ) NEWLINE NAME . NAME ::: 94397
) : NEWLINE INDENT return NAME ::: 93902
NAME , NAME . NAME ) ::: 93612
from NAME . NAME import NAME ::: 93077
. NAME . NAME import NAME ::: 92520
NAME ( ) NEWLINE NAME = ::: 92392
NAME = STRING NEWLINE NAME = ::: 92181
NEWLINE DEDENT DEDENT def NAME ( ::: 90336
NAME . NAME ( NAME ( ::: 89988
NEWLINE from NAME . NAME . ::: 89190
, NAME . NAME ) NEWLINE ::: 88090
. NAME ) NEWLINE NAME . ::: 87061
. NAME : NEWLINE INDENT NAME ::: 86767
( NAME ) NEWLINE NAME . ::: 86467
NAME , NAME = NAME . ::: 85256
NAME , NAME ) NEWLINE NAME ::: 84696
NAME NEWLINE NAME . NAME = ::: 81885
NAME = NAME ( NAME , ::: 81271
NAME NEWLINE def NAME ( NAME ::: 80232
STRING , STRING : STRING } ::: 80218
NAME = NAME ( NAME ) ::: 79616
, NAME = NAME , NAME ::: 79608
STRING ) NEWLINE NAME = NAME ::: 79420
. NAME = NAME NEWLINE NAME ::: 79241
= NAME , NAME = NAME ::: 78770
: NEWLINE INDENT return NAME . ::: 78404
NEWLINE INDENT return NAME . NAME ::: 78402
import NAME NEWLINE import NAME NEWLINE ::: 78264
= NAME NEWLINE NAME . NAME ::: 78190
) : NEWLINE INDENT if NAME ::: 77687
NEWLINE NAME . NAME ( ) ::: 77317
INDENT NAME = NAME ( NAME ::: 77287
( NAME , NAME . NAME ::: 77240
NEWLINE NAME = STRING NEWLINE NAME ::: 77082
NAME = NAME ( ) NEWLINE ::: 76368
( ) NEWLINE NAME = NAME ::: 75474
. NAME ) : NEWLINE INDENT ::: 75372
NAME . NAME ) : NEWLINE ::: 75134
NAME = NUMBER NEWLINE NAME = ::: 74888
NAME ( STRING ) NEWLINE DEDENT ::: 74728
( NAME ) NEWLINE NAME = ::: 73877
NEWLINE INDENT NAME . NAME . ::: 73735
INDENT NAME . NAME . NAME ::: 73735
NAME = NAME NEWLINE NAME . ::: 73535
INDENT NAME . NAME = NAME ::: 72232
= NAME ( NAME ) NEWLINE ::: 71883
DEDENT class NAME ( NAME ) ::: 71541
= STRING , NAME = STRING ::: 71416
) NEWLINE DEDENT else : NEWLINE ::: 70774
NEWLINE import NAME NEWLINE import NAME ::: 70480
INDENT STRING NEWLINE NAME = NAME ::: 70281
NAME in NAME : NEWLINE INDENT ::: 69862
NAME = None , NAME = ::: 69735
, NAME , NAME ) NEWLINE ::: 69645
NAME . NAME , NAME = ::: 69522
NAME . NAME ( ) ) ::: 69494
. NAME ( STRING , STRING ::: 69099
. NAME ( NAME = NAME ::: 68730
NAME ( NAME , NAME . ::: 68340
NEWLINE NAME = NUMBER NEWLINE NAME ::: 68120
NAME ) : NEWLINE INDENT if ::: 67580
NAME , NAME . NAME , ::: 67555
INDENT NAME . NAME ( STRING ::: 67536
, NAME = NAME ) NEWLINE ::: 67345
, NAME . NAME , NAME ::: 66988
DEDENT DEDENT class NAME ( NAME ::: 66902
, NAME = None , NAME ::: 66507
NAME ( NAME ) ) NEWLINE ::: 66050
. NAME ( NAME ( NAME ::: 65897
: NEWLINE INDENT def NAME ( ::: 65869
{ STRING : STRING } ) ::: 65709
, { STRING : STRING , ::: 65360
for NAME in NAME . NAME ::: 64667
= NAME ( NAME . NAME ::: 64484
( NAME . NAME ( NAME ::: 64329
NEWLINE INDENT def NAME ( NAME ::: 63646
STRING , NAME = STRING , ::: 63606
= NAME ( NAME , NAME ::: 62625
STRING NEWLINE NAME = STRING NEWLINE ::: 62429
DEDENT NAME = NAME . NAME ::: 62403
NAME , NAME = NAME , ::: 62078
, { STRING : STRING } ::: 62025
( NAME . NAME ( ) ::: 61998
NEWLINE from NAME import NAME NEWLINE ::: 61993
NAME = NAME ( NAME . ::: 61842
NAME . NAME [ STRING ] ::: 61779
( STRING , NAME . NAME ::: 61657
NAME ( NAME , STRING ) ::: 61537
, STRING : STRING } ) ::: 61526
NUMBER ) NEWLINE NAME . NAME ::: 61270
in NAME : NEWLINE INDENT NAME ::: 60924
) NEWLINE DEDENT DEDENT def NAME ::: 60399
) NEWLINE DEDENT NAME . NAME ::: 60063
: NEWLINE INDENT NAME = STRING ::: 59681
STRING NEWLINE NAME = NAME . ::: 59168
: NEWLINE INDENT raise NAME ( ::: 59096
return NAME NEWLINE DEDENT def NAME ::: 58852
) : NEWLINE INDENT def NAME ::: 58830
= NAME . NAME NEWLINE NAME ::: 58587
NAME NEWLINE NAME = NAME . ::: 58420
NUMBER NEWLINE NAME = NUMBER NEWLINE ::: 58043
, NAME ) NEWLINE NAME . ::: 57688
NEWLINE DEDENT DEDENT class NAME ( ::: 57448
NAME . NAME . NAME , ::: 57359
= NUMBER NEWLINE NAME = NUMBER ::: 57280
, NAME = STRING ) NEWLINE ::: 56879
NAME = NUMBER , NAME = ::: 56742
) NEWLINE def NAME ( NAME ::: 56664
NAME ) : NEWLINE INDENT def ::: 56537
NEWLINE DEDENT NAME . NAME ( ::: 55926
if NAME : NEWLINE INDENT NAME ::: 55858
, NAME . NAME . NAME ::: 55846
= NAME ( ) NEWLINE NAME ::: 55687
NAME ( STRING , NAME = ::: 55644
: NEWLINE INDENT if NAME . ::: 54880
NEWLINE INDENT if NAME . NAME ::: 54872
NAME == STRING : NEWLINE INDENT ::: 54672
NEWLINE DEDENT NAME = NAME . ::: 54606
NAME . NAME . NAME ) ::: 54411
for NAME in NAME : NEWLINE ::: 54163
. NAME ( ) ) NEWLINE ::: 53873
( STRING ) NEWLINE NAME . ::: 53860
NAME NEWLINE from NAME import NAME ::: 52990
NAME , NAME = NAME ) ::: 52934
NAME . NAME = NAME ( ::: 52932
else : NEWLINE INDENT NAME = ::: 52144
( NAME . NAME ) : ::: 51692
( ) : NEWLINE INDENT NAME ::: 51601
NAME ( STRING , STRING ) ::: 51333
@ NAME NEWLINE def NAME ( ::: 51248
NAME . NAME ( NUMBER ) ::: 51192
return NAME . NAME ( NAME ::: 51191
= STRING NEWLINE NAME = STRING ::: 51185
) NEWLINE DEDENT NAME = NAME ::: 50439
) ) NEWLINE NAME = NAME ::: 50428
NAME = STRING ) NEWLINE NAME ::: 50371
NAME NEWLINE import NAME NEWLINE import ::: 50139
= None ) : NEWLINE INDENT ::: 50004
NAME = None ) : NEWLINE ::: 50004
, STRING ) NEWLINE NAME . ::: 49847
def NAME ( ) : NEWLINE ::: 49632
NAME [ STRING ] = NAME ::: 49594
NAME . NAME ( NAME [ ::: 49366
. NAME ( NAME , STRING ::: 49323
, NAME = None ) : ::: 48157
NAME . NAME , NAME ) ::: 47831
= None , NAME = None ::: 47729
== STRING : NEWLINE INDENT NAME ::: 47608
** NAME ) : NEWLINE INDENT ::: 47284
NEWLINE INDENT raise NAME ( STRING ::: 47097
NAME = NAME ( NAME = ::: 46915
: NEWLINE INDENT NAME ( NAME ::: 46890
, ** NAME ) : NEWLINE ::: 46365
NAME . NAME NEWLINE NAME = ::: 45713
, NAME ) NEWLINE NAME = ::: 45613
NAME . NAME [ NAME ] ::: 45434
STRING : NUMBER , STRING : ::: 44819
( NAME ) NEWLINE DEDENT DEDENT ::: 44484
NAME ( NAME ( NAME ) ::: 44091
: NEWLINE INDENT return NAME ( ::: 44084
. NAME ( NAME ) ) ::: 44078
NEWLINE if NAME : NEWLINE INDENT ::: 44031
. NAME ( ) : NEWLINE ::: 43974
DEDENT except NAME : NEWLINE INDENT ::: 43923
import NAME NEWLINE from NAME import ::: 43366
NAME . NAME [ NUMBER ] ::: 43218
. NAME , NAME = NAME ::: 43197
NUMBER ) NEWLINE NAME = NAME ::: 43149
( STRING ) NEWLINE NAME = ::: 43030
, NAME = NUMBER , NAME ::: 42788
STRING NEWLINE def NAME ( NAME ::: 42766
. NAME ) NEWLINE NAME = ::: 42729
class NAME ( NAME . NAME ::: 42551
) ) NEWLINE DEDENT def NAME ::: 42289
, NAME ) NEWLINE DEDENT def ::: 41996
NAME . NAME ( NUMBER , ::: 41739
NAME = NAME . NAME ) ::: 41533
NAME = NAME ) NEWLINE NAME ::: 41275
: NEWLINE INDENT pass NEWLINE DEDENT ::: 41255
NAME = NAME . NAME , ::: 41116
NAME . NAME ( ) : ::: 40900
DEDENT @ NAME NEWLINE def NAME ::: 40653
NAME . NAME ( ) , ::: 40582
( NAME = STRING , NAME ::: 40351
NAME ( STRING , NAME . ::: 40329
NEWLINE INDENT NAME = STRING NEWLINE ::: 40270
NAME ( NAME = STRING , ::: 40097
STRING , NAME = STRING ) ::: 39919
. NAME NEWLINE NAME = NAME ::: 39717
: NEWLINE INDENT STRING NEWLINE if ::: 39515
NEWLINE DEDENT except NAME : NEWLINE ::: 39362
NAME , NAME ) ) NEWLINE ::: 39254
INDENT return NAME . NAME ( ::: 39086
NEWLINE NAME = NAME ( STRING ::: 38978
NAME , ** NAME ) : ::: 38966
NEWLINE class NAME ( NAME ) ::: 38949
NAME , STRING ) NEWLINE NAME ::: 38646
NAME is None : NEWLINE INDENT ::: 38613
. NAME ( NAME = STRING ::: 38599
= NAME . NAME , NAME ::: 38583
* NAME , ** NAME ) ::: 38496
NAME . NAME ) ) NEWLINE ::: 38454
NAME : NEWLINE INDENT if NAME ::: 38404
STRING : NAME , STRING : ::: 38369
] ) NEWLINE NAME . NAME ::: 38199
NAME ( NAME [ STRING ] ::: 38090
) NEWLINE for NAME in NAME ::: 38024
NAME . NAME ( STRING % ::: 38003
) NEWLINE if NAME . NAME ::: 37936
) : NEWLINE INDENT NAME ( ::: 37856
if NAME . NAME : NEWLINE ::: 37850
NAME ( ) . NAME ( ::: 37741
( ) NEWLINE DEDENT def NAME ::: 37602
from NAME import NAME NEWLINE from ::: 37398
NEWLINE DEDENT return NAME NEWLINE DEDENT ::: 37395
. NAME ( NUMBER ) NEWLINE ::: 37316
NAME ( ) NEWLINE DEDENT def ::: 37316
. NAME ( ) . NAME ::: 37249
NAME ( NAME ) NEWLINE if ::: 37144
NEWLINE for NAME in NAME : ::: 37106
( STRING , STRING ) NEWLINE ::: 37081
) NEWLINE return NAME NEWLINE DEDENT ::: 37062
in NAME . NAME : NEWLINE ::: 37061
. NAME NEWLINE NAME . NAME ::: 37053
NAME . NAME . NAME NEWLINE ::: 36819
NAME ( STRING , NAME ) ::: 36789
is not None : NEWLINE INDENT ::: 36762
. NAME import NAME , NAME ::: 36722
) . NAME ( ) NEWLINE ::: 36628
: NEWLINE INDENT STRING NEWLINE return ::: 36605
. NAME . NAME , NAME ::: 36485
for NAME , NAME in NAME ::: 36360
NAME ( STRING , STRING , ::: 36272
) NEWLINE DEDENT DEDENT class NAME ::: 36232
NAME in NAME . NAME ( ::: 36225
NAME . NAME . NAME = ::: 36195
, STRING : NAME . NAME ::: 36138
, NAME . NAME ( NAME ::: 36131
DEDENT NAME . NAME ( NAME ::: 36042
else : NEWLINE INDENT NAME . ::: 35960
( NAME . NAME , STRING ::: 35633
NAME = NAME ( STRING ) ::: 35559
. NAME = NAME NEWLINE DEDENT ::: 35544
: NEWLINE INDENT NAME = [ ::: 35287
, NAME ) . NAME ( ::: 35090
NAME = NAME . NAME [ ::: 35042
NAME . NAME NEWLINE NAME . ::: 34967
NAME is not None : NEWLINE ::: 34877
NEWLINE DEDENT @ NAME NEWLINE def ::: 34874
, NAME , NAME = NAME ::: 34814
try : NEWLINE INDENT NAME = ::: 34770
[ STRING , STRING , STRING ::: 34765
NEWLINE NAME [ STRING ] = ::: 34674
INDENT NAME . NAME ( ) ::: 34526
NEWLINE DEDENT class NAME ( NAME ::: 34515
NAME , NAME ) . NAME ::: 34454
NAME NEWLINE class NAME ( NAME ::: 34376
, STRING : NUMBER , STRING ::: 34369
NAME = True , NAME = ::: 34305
NAME ) NEWLINE DEDENT else : ::: 34299
NEWLINE INDENT STRING NEWLINE NAME . ::: 34294
INDENT STRING NEWLINE NAME . NAME ::: 34293
NAME = NAME [ STRING ] ::: 34291
. NAME . NAME ) NEWLINE ::: 34268
( NAME ( NAME . NAME ::: 34257
NAME . NAME , STRING ) ::: 34202
INDENT def NAME ( NAME , ::: 34006
( NAME ) NEWLINE DEDENT def ::: 33916
( NAME = NAME . NAME ::: 33581
NEWLINE INDENT return NAME ( NAME ::: 33421
NAME ( NAME = NAME . ::: 33403
STRING ) NEWLINE DEDENT def NAME ::: 33311
( NAME , NAME ) ) ::: 33286
( STRING , STRING ) , ::: 33223
None , NAME = None , ::: 33176
: NUMBER , STRING : NUMBER ::: 33170
NAME import NAME , NAME NEWLINE ::: 32966
NAME ( NAME ) , NAME ::: 32939
( NAME , NAME ) . ::: 32862
. NAME , NAME ) NEWLINE ::: 32789
STRING ) : NEWLINE INDENT NAME ::: 32744
, NUMBER ) NEWLINE NAME . ::: 32524
= NAME . NAME ) NEWLINE ::: 32474
, STRING : { STRING : ::: 32467
, NAME = True ) NEWLINE ::: 32464
: NEWLINE INDENT STRING NEWLINE def ::: 32304
NEWLINE INDENT STRING NEWLINE def NAME ::: 32304
INDENT STRING NEWLINE def NAME ( ::: 32304
: NAME , STRING : NAME ::: 32298
. NAME ) NEWLINE DEDENT def ::: 32282
NAME , NAME . NAME . ::: 32213
NAME . NAME ( ) . ::: 32144
( NAME , STRING ) NEWLINE ::: 32137
NAME = NAME ( STRING , ::: 32068
( NAME ) ) NEWLINE DEDENT ::: 32053
NEWLINE import NAME NEWLINE from NAME ::: 31998
NEWLINE DEDENT if NAME . NAME ::: 31983
NAME . NAME import NAME , ::: 31947
NAME ( NAME , STRING , ::: 31942
STRING , STRING ) NEWLINE NAME ::: 31885
NEWLINE DEDENT NAME = NAME ( ::: 31855
, NAME ) NEWLINE DEDENT DEDENT ::: 31645
NAME ) ) NEWLINE NAME . ::: 31605
: NEWLINE INDENT for NAME in ::: 31494
NUMBER , NUMBER , NUMBER ) ::: 31490
, STRING ) NEWLINE NAME = ::: 31448
STRING NEWLINE NAME = NAME ( ::: 31251
NEWLINE INDENT try : NEWLINE INDENT ::: 31194
: NEWLINE INDENT try : NEWLINE ::: 31194
DEDENT return NAME NEWLINE DEDENT def ::: 31168
( STRING , NAME ) NEWLINE ::: 31120
NAME NEWLINE NAME . NAME ( ::: 30958
NAME ( NAME [ NUMBER ] ::: 30911
NAME ( STRING ) ) NEWLINE ::: 30768
NAME ( NAME ( NAME . ::: 30727
( NUMBER , NUMBER , NUMBER ::: 30726
NEWLINE return NAME . NAME ( ::: 30614
STRING : { STRING : STRING ::: 30606
NAME ( ) ) NEWLINE NAME ::: 30492
NEWLINE NAME = NAME ( ) ::: 30333
NAME ( NAME . NAME [ ::: 30316
( NAME , NAME = NAME ::: 30201
NEWLINE try : NEWLINE INDENT NAME ::: 30188
NEWLINE INDENT STRING NEWLINE return NAME ::: 30156
NAME , NAME = None ) ::: 30102
STRING , NAME . NAME ( ::: 30087
NEWLINE NAME . NAME ( NUMBER ::: 29972
if not NAME : NEWLINE INDENT ::: 29905
. NAME = NAME ( NAME ::: 29895
( NAME ) NEWLINE if NAME ::: 29783
DEDENT def NAME ( ) : ::: 29715
NAME = NAME ) NEWLINE DEDENT ::: 29702
. NAME ( NAME ) : ::: 29564
NAME , NAME NEWLINE from NAME ::: 29542
INDENT def NAME ( NAME ) ::: 29482
NEWLINE INDENT for NAME in NAME ::: 29167
NAME ( NAME = NAME , ::: 29118
NAME ( ) NEWLINE DEDENT DEDENT ::: 28958
STRING , STRING , STRING ] ::: 28940
if NAME is None : NEWLINE ::: 28929
NAME : NEWLINE INDENT raise NAME ::: 28890
) NEWLINE if NAME : NEWLINE ::: 28863
{ STRING : { STRING : ::: 28780
, NAME , NAME = None ::: 28773
) , NAME . NAME ( ::: 28754
NEWLINE INDENT STRING NEWLINE if NAME ::: 28647
NAME ) NEWLINE DEDENT DEDENT def ::: 28619
NEWLINE NAME = { STRING : ::: 28569
] NEWLINE NAME = NAME . ::: 28514
NUMBER , NUMBER , NUMBER ] ::: 28381
( NAME = NAME , NAME ::: 28346
NAME , NAME = None , ::: 28314
STRING % ( NAME , NAME ::: 28289
. NAME , STRING ) NEWLINE ::: 28237
= STRING NEWLINE NAME . NAME ::: 28199
NUMBER , STRING : NUMBER , ::: 28113
NAME . NAME = STRING NEWLINE ::: 28088
NAME ( NAME = NAME ) ::: 28084
[ NUMBER , NUMBER , NUMBER ::: 27979
if NAME == STRING : NEWLINE ::: 27942
( STRING , STRING , STRING ::: 27906
) , ( STRING , NAME ::: 27858
. NAME ( ) , NAME ::: 27759
return NAME . NAME . NAME ::: 27709
DEDENT NAME = NAME ( NAME ::: 27702
STRING NEWLINE NAME . NAME = ::: 27628
NAME in NAME . NAME : ::: 27585
NAME ) . NAME ( NAME ::: 27560
not None : NEWLINE INDENT NAME ::: 27532
( NAME . NAME ( STRING ::: 27519
STRING NEWLINE NAME . NAME ( ::: 27401
NEWLINE INDENT NAME = NAME [ ::: 27324
NEWLINE INDENT NAME ( NAME , ::: 27276
= STRING ) NEWLINE NAME . ::: 27174
NAME . NAME = None NEWLINE ::: 27125
NAME ( STRING % ( NAME ::: 27069
NAME ) NEWLINE DEDENT NAME = ::: 26939
, NAME = True , NAME ::: 26905
NAME ) . NAME ( ) ::: 26819
. NAME ( ) NEWLINE if ::: 26775
NEWLINE NAME ( NAME , NAME ::: 26700
NAME = [ STRING , STRING ::: 26665
NAME . NAME , STRING : ::: 26652
NAME ( STRING ) , NAME ::: 26562
: NEWLINE INDENT NAME , NAME ::: 26551
) , ( STRING , STRING ::: 26511
( NAME , NAME = None ::: 26500
NEWLINE NAME = [ ] NEWLINE ::: 26446
NEWLINE for NAME in NAME . ::: 26388
NAME = NAME NEWLINE NAME = ::: 26331
] ) NEWLINE NAME = NAME ::: 26198
, NAME ) ) NEWLINE DEDENT ::: 26159
NAME [ NAME ] = NAME ::: 26010
None : NEWLINE INDENT NAME = ::: 25957
NAME [ STRING ] ) NEWLINE ::: 25929
= STRING , NAME = NAME ::: 25848
NEWLINE return NAME NEWLINE DEDENT def ::: 25846
NAME [ NUMBER ] . NAME ::: 25813
INDENT NAME = NAME ( ) ::: 25699
NAME , NAME = STRING ) ::: 25676
: NEWLINE INDENT NAME [ STRING ::: 25639
NAME , NAME , NAME NEWLINE ::: 25612
) : NEWLINE INDENT pass NEWLINE ::: 25516
, NAME = NAME ( NAME ::: 25420
as NAME : NEWLINE INDENT NAME ::: 25384
NAME = STRING NEWLINE NAME . ::: 25362
NAME , NAME . NAME ( ::: 25342
STRING . NAME ( NAME ) ::: 25332
for NAME in NAME ( NAME ::: 25279
, NAME = NUMBER ) NEWLINE ::: 25260
} , STRING : { STRING ::: 25248
is None : NEWLINE INDENT NAME ::: 25244
NEWLINE INDENT NAME [ STRING ] ::: 25183
return NAME . NAME NEWLINE DEDENT ::: 25140
, NUMBER ) NEWLINE NAME = ::: 25046
( NAME ) ) NEWLINE NAME ::: 24966
) NEWLINE NAME ( NAME , ::: 24835
STRING ) , ( STRING , ::: 24795
STRING : NAME . NAME , ::: 24759
NAME = False , NAME = ::: 24733
NAME ) NEWLINE DEDENT NAME . ::: 24696
raise NAME ( STRING ) NEWLINE ::: 24665
: NEWLINE INDENT if not NAME ::: 24661
INDENT NAME ( NAME , NAME ::: 24655
STRING : NEWLINE INDENT NAME = ::: 24588
, STRING ) , ( STRING ::: 24572
. NAME ( NAME [ STRING ::: 24553
NAME = [ ] NEWLINE NAME ::: 24520
NAME . NAME = NUMBER NEWLINE ::: 24465
= NAME . NAME NEWLINE DEDENT ::: 24436
. NAME ( STRING ) ) ::: 24432
( NAME . NAME ) ) ::: 24425
DEDENT class NAME ( NAME . ::: 24388
( NAME ) NEWLINE DEDENT NAME ::: 24374
NAME ( NUMBER ) NEWLINE NAME ::: 24341
NAME : NEWLINE INDENT return NAME ::: 24290
if NAME . NAME . NAME ::: 24188
NAME ( ) NEWLINE if NAME ::: 24155
: NEWLINE INDENT if NAME ( ::: 24090
NAME , ** NAME ) NEWLINE ::: 24048
[ STRING ] [ STRING ] ::: 23987
STRING , STRING , STRING ) ::: 23977
, NAME . NAME ( STRING ::: 23969
NAME NEWLINE DEDENT else : NEWLINE ::: 23938
= NUMBER , NAME = NUMBER ::: 23877
NAME [ STRING ] , NAME ::: 23766
NAME ( NAME = STRING ) ::: 23756
NAME = NUMBER ) NEWLINE NAME ::: 23683
NAME ( ) ) NEWLINE DEDENT ::: 23642
NEWLINE INDENT if NAME ( NAME ::: 23504
, STRING : NAME , STRING ::: 23458
import NAME NEWLINE class NAME ( ::: 23404
) NEWLINE DEDENT return NAME NEWLINE ::: 23403
NAME ) : NEWLINE INDENT pass ::: 23396
NEWLINE INDENT NAME = NAME NEWLINE ::: 23390
= NAME ( STRING ) NEWLINE ::: 23306
, NAME NEWLINE from NAME . ::: 23220
. NAME ) NEWLINE DEDENT DEDENT ::: 23190
NAME ) NEWLINE NAME ( NAME ::: 23155
STRING , STRING ) , ( ::: 23142
STRING , NAME . NAME ) ::: 23048
] NEWLINE NAME . NAME ( ::: 23021
in NAME . NAME ( ) ::: 23003
INDENT try : NEWLINE INDENT NAME ::: 22930
NAME = True ) NEWLINE NAME ::: 22908
NAME = { STRING : NAME ::: 22889
NEWLINE DEDENT NAME . NAME = ::: 22869
STRING % ( NAME . NAME ::: 22865
( STRING , STRING , NAME ::: 22839
, NAME . NAME ( ) ::: 22807
NEWLINE NAME ( NAME . NAME ::: 22716
if NAME ( NAME , NAME ::: 22715
) : NEWLINE INDENT raise NAME ::: 22694
NAME , STRING : NAME . ::: 22667
: NAME . NAME , STRING ::: 22658
NEWLINE NAME , NAME = NAME ::: 22653
. NAME , STRING : NAME ::: 22652
NAME ) ) NEWLINE DEDENT DEDENT ::: 22625
( NAME ( NAME ) ) ::: 22614
NAME ( STRING . NAME ( ::: 22589
NAME NEWLINE NAME = NAME ( ::: 22545
NEWLINE DEDENT def NAME ( ) ::: 22427
NAME ) NEWLINE DEDENT DEDENT DEDENT ::: 22410
, NAME = False , NAME ::: 22349
STRING ) NEWLINE def NAME ( ::: 22347
= STRING NEWLINE NAME = NAME ::: 22320
NAME NEWLINE import NAME NEWLINE from ::: 22316
NAME , NAME = NAME ( ::: 22204
NAME . NAME , NAME , ::: 22176
DEDENT DEDENT else : NEWLINE INDENT ::: 22174
. NAME = STRING NEWLINE NAME ::: 22142
INDENT raise NAME ( STRING ) ::: 22122
, ( STRING , STRING ) ::: 22054
NAME , STRING : NAME , ::: 21974
) NEWLINE return NAME . NAME ::: 21959
INDENT NAME [ STRING ] = ::: 21925
import NAME , NAME , NAME ::: 21909
NAME ( NAME ) . NAME ::: 21898
. NAME ( STRING % NAME ::: 21881
( STRING . NAME ( NAME ::: 21848
NEWLINE NAME . NAME = STRING ::: 21767
( STRING , NAME = STRING ::: 21728
. NAME ( NUMBER , NAME ::: 21718
( STRING ) : NEWLINE INDENT ::: 21644
NAME ) NEWLINE DEDENT if NAME ::: 21464
] NEWLINE for NAME in NAME ::: 21454
) NEWLINE NAME [ STRING ] ::: 21426
NAME ( STRING ) : NEWLINE ::: 21392
NAME ) NEWLINE DEDENT except NAME ::: 21351
DEDENT DEDENT DEDENT def NAME ( ::: 21226
) NEWLINE DEDENT except NAME : ::: 21219
: NEWLINE INDENT NAME [ NAME ::: 21213
. NAME ( NAME = NUMBER ::: 21213
if NAME is not None : ::: 21154
None ) : NEWLINE INDENT STRING ::: 21058
= NAME NEWLINE DEDENT def NAME ::: 21033
NAME = NAME [ NUMBER ] ::: 20982
NAME , NAME = STRING , ::: 20971
[ STRING ] ) NEWLINE NAME ::: 20936
. NAME NEWLINE DEDENT def NAME ::: 20861
None : NEWLINE INDENT NAME . ::: 20830
, * NAME , ** NAME ::: 20808
STRING NEWLINE return NAME . NAME ::: 20804
NAME ) ) NEWLINE NAME = ::: 20789
STRING : STRING } , STRING ::: 20716
STRING ] = NAME . NAME ::: 20661
= NAME [ STRING ] NEWLINE ::: 20657
NAME ) NEWLINE DEDENT return NAME ::: 20654
= NAME ( NAME = NAME ::: 20638
NAME = { STRING : STRING ::: 20582
in NAME . NAME . NAME ::: 20581
) as NAME : NEWLINE INDENT ::: 20567
NEWLINE for NAME in NAME ( ::: 20565
: NEWLINE INDENT return NAME NEWLINE ::: 20552
NEWLINE INDENT return NAME NEWLINE DEDENT ::: 20545
) NEWLINE try : NEWLINE INDENT ::: 20544
[ STRING ] = NAME . ::: 20539
import NAME , NAME NEWLINE from ::: 20538
DEDENT else : NEWLINE INDENT return ::: 20457
. NAME ( STRING ) : ::: 20454
. NAME ( NAME ) , ::: 20403
( NAME = NAME ) NEWLINE ::: 20380
) : NEWLINE INDENT for NAME ::: 20325
: STRING } , STRING : ::: 20294
NAME ( STRING % NAME ) ::: 20244
NEWLINE DEDENT @ NAME . NAME ::: 20192
return NAME ( NAME , NAME ::: 20141
try : NEWLINE INDENT NAME . ::: 20114
= NAME NEWLINE NAME = NAME ::: 20086
NAME . NAME NEWLINE DEDENT def ::: 20056
NAME import NAME NEWLINE NAME = ::: 20044
INDENT STRING NEWLINE return NAME . ::: 19996
: NEWLINE INDENT NAME ( STRING ::: 19962
NAME import NAME , NAME , ::: 19960
NEWLINE NAME . NAME = None ::: 19902
STRING , NAME ) NEWLINE NAME ::: 19881
NAME import NAME NEWLINE class NAME ::: 19800
NAME ( STRING , NUMBER ) ::: 19758
. NAME . NAME = NAME ::: 19744
= NAME ) NEWLINE NAME . ::: 19690
( NUMBER , NUMBER ) , ::: 19684
NAME [ STRING ] NEWLINE NAME ::: 19647
NUMBER : NEWLINE INDENT NAME = ::: 19646
) . NAME ( NAME ) ::: 19607
DEDENT if NAME : NEWLINE INDENT ::: 19582
NAME ( NAME , * NAME ::: 19549
( NAME ( NAME ) , ::: 19494
= NUMBER NEWLINE NAME . NAME ::: 19484
NAME [ NUMBER ] , NAME ::: 19481
NAME = [ NAME . NAME ::: 19481
NEWLINE for NAME , NAME in ::: 19469
NAME ( NAME ( NAME , ::: 19425
) NEWLINE NAME ( NAME . ::: 19380
( STRING % NAME ) NEWLINE ::: 19370
, NAME in NAME . NAME ::: 19323
DEDENT NAME . NAME = NAME ::: 19224
NAME [ STRING ] . NAME ::: 19209
NAME , * NAME , ** ::: 19183
NAME , NAME in NAME . ::: 19183
NAME , NAME = True ) ::: 19130
NAME [ STRING ] [ STRING ::: 19124
, STRING , STRING ) NEWLINE ::: 19122
NEWLINE INDENT NAME , NAME = ::: 19065
] NEWLINE DEDENT def NAME ( ::: 19034
NAME . NAME , NUMBER ) ::: 19030
NAME ( NAME ) NEWLINE return ::: 19002
NEWLINE DEDENT DEDENT else : NEWLINE ::: 18982
= STRING ) NEWLINE NAME = ::: 18924
NEWLINE def NAME ( ) : ::: 18899
NAME ( STRING , NAME , ::: 18859
, STRING ) : NEWLINE INDENT ::: 18787
{ STRING : NAME . NAME ::: 18755
[ STRING ] NEWLINE NAME = ::: 18730
) NEWLINE DEDENT @ NAME NEWLINE ::: 18728
NAME = NAME NEWLINE DEDENT def ::: 18683
NAME ) NEWLINE DEDENT @ NAME ::: 18670
, NAME ( NAME ) ) ::: 18644
INDENT NAME = STRING NEWLINE NAME ::: 18641
NAME , NUMBER ) NEWLINE NAME ::: 18619
NAME : NEWLINE INDENT NAME [ ::: 18607
BOS NEWLINE from NAME . NAME ::: 18584
[ STRING ] = NAME NEWLINE ::: 18498
None ) : NEWLINE INDENT NAME ::: 18494
NAME ( ) NEWLINE DEDENT NAME ::: 18478
NEWLINE if not NAME : NEWLINE ::: 18474
NAME : NEWLINE INDENT NAME ( ::: 18443
. NAME = NUMBER NEWLINE NAME ::: 18413
NAME = NAME ( NAME ( ::: 18412
NAME ( NUMBER , NUMBER , ::: 18401
return NAME ( NAME . NAME ::: 18384
STRING : { STRING : { ::: 18361
import NAME NEWLINE NAME = NAME ::: 18341
NAME = [ ] NEWLINE for ::: 18327
: { STRING : { STRING ::: 18317
in NAME : NEWLINE INDENT if ::: 18307
= [ ] NEWLINE for NAME ::: 18302
NAME ) ) NEWLINE DEDENT def ::: 18263
. NAME ( NAME [ NUMBER ::: 18230
( ) ) NEWLINE NAME . ::: 18224
NAME ) NEWLINE if NAME . ::: 18205
. NAME import NAME NEWLINE NAME ::: 18131
. NAME , NUMBER ) NEWLINE ::: 18117
) . NAME ( STRING ) ::: 18103
NEWLINE if NAME . NAME : ::: 18066
) ) , ( STRING , ::: 18061
: { STRING : STRING , ::: 18030
. NAME NEWLINE def NAME ( ::: 18015
INDENT NAME , NAME = NAME ::: 17980
NAME = STRING . NAME ( ::: 17914
= [ STRING , STRING , ::: 17913
NAME = NUMBER NEWLINE NAME . ::: 17901
( * NAME , ** NAME ::: 17874
NAME . NAME NEWLINE def NAME ::: 17867
NAME in NAME . NAME . ::: 17835
. NAME ( NAME ( STRING ::: 17823
NAME ( NAME = NUMBER ) ::: 17817
NAME import NAME NEWLINE import NAME ::: 17804
NAME ( NAME ( STRING ) ::: 17774
. NAME , NAME , NAME ::: 17759
NAME . NAME ( ( NAME ::: 17731
NAME ( STRING ) . NAME ::: 17621
NAME , STRING ) NEWLINE DEDENT ::: 17615
NAME ( * NAME , ** ::: 17578
BOS NEWLINE from NAME import NAME ::: 17479
NAME [ NUMBER ] ) NEWLINE ::: 17475
NAME NEWLINE DEDENT NAME = NAME ::: 17475
) NEWLINE assert NAME . NAME ::: 17434
NEWLINE NAME . NAME = NUMBER ::: 17428
NEWLINE if NAME is None : ::: 17388
, NAME , NAME . NAME ::: 17385
) NEWLINE DEDENT if NAME . ::: 17321
( STRING ) NEWLINE DEDENT NAME ::: 17302
( NAME . NAME ) , ::: 17210
NUMBER , NUMBER ) , ( ::: 17186
NAME ) for NAME in NAME ::: 17157
== NUMBER : NEWLINE INDENT NAME ::: 17127
= NAME . NAME ( NUMBER ::: 17127
NAME . NAME . NAME [ ::: 17114
not NAME : NEWLINE INDENT NAME ::: 17091
. NAME ) ) NEWLINE DEDENT ::: 17052
NAME ) NEWLINE def NAME ( ::: 17037
) , ( NUMBER , NUMBER ::: 17028
NAME ) NEWLINE DEDENT DEDENT class ::: 17018
: NEWLINE INDENT NAME = { ::: 16992
( NAME ( NAME , NAME ::: 16942
STRING : NEWLINE INDENT NAME . ::: 16920
, NAME ) NEWLINE if NAME ::: 16919
except NAME : NEWLINE INDENT NAME ::: 16887
NEWLINE class NAME ( NAME . ::: 16836
, NAME . NAME ) ) ::: 16820
= NAME ) NEWLINE NAME = ::: 16812
. NAME ( NUMBER , NUMBER ::: 16775
: NEWLINE INDENT NAME = NUMBER ::: 16772
NEWLINE DEDENT DEDENT DEDENT def NAME ::: 16729
NAME ( NUMBER , NUMBER ) ::: 16726
( STRING ) ) NEWLINE NAME ::: 16726
] ) NEWLINE DEDENT def NAME ::: 16704
NAME , NAME ) NEWLINE if ::: 16700
STRING ) ) NEWLINE NAME . ::: 16696
( NAME [ STRING ] ) ::: 16632
DEDENT NAME . NAME . NAME ::: 16609
. NAME = None NEWLINE NAME ::: 16607
. NAME : NEWLINE INDENT return ::: 16603
) : NEWLINE INDENT try : ::: 16596
] NEWLINE NAME . NAME = ::: 16572
. NAME . NAME NEWLINE NAME ::: 16490
NAME ) NEWLINE return NAME NEWLINE ::: 16473
( NAME ) . NAME ( ::: 16450
NAME , NAME = NUMBER ) ::: 16443
, ** NAME ) NEWLINE DEDENT ::: 16412
from NAME import NAME , NAME ::: 16402
. NAME ( STRING % ( ::: 16363
NEWLINE if NAME . NAME ( ::: 16353
. NAME ( STRING ) , ::: 16345
NEWLINE DEDENT return NAME . NAME ::: 16304
NAME . NAME ) , NAME ::: 16261
NAME . NAME , STRING , ::: 16203
) , NAME ( STRING , ::: 16181
NAME . NAME is not None ::: 16074
NUMBER ) : NEWLINE INDENT NAME ::: 16025
) : NEWLINE INDENT if not ::: 16004
NAME . NAME . NAME : ::: 15927
. NAME ) ) NEWLINE NAME ::: 15924
NAME == NUMBER : NEWLINE INDENT ::: 15902
( NAME . NAME , NUMBER ::: 15899
. NAME import NAME NEWLINE class ::: 15891
) ) : NEWLINE INDENT NAME ::: 15873
, STRING ) NEWLINE DEDENT def ::: 15842
, ( STRING , NAME . ::: 15830
NEWLINE DEDENT elif NAME . NAME ::: 15824
NEWLINE DEDENT DEDENT NAME = NAME ::: 15823
= None NEWLINE NAME . NAME ::: 15814
, NAME = STRING ) , ::: 15811
NEWLINE if not NAME . NAME ::: 15786
NEWLINE INDENT NAME [ NAME ] ::: 15755
( STRING % ( NAME , ::: 15735
NUMBER ) NEWLINE DEDENT def NAME ::: 15719
NUMBER ) , ( NUMBER , ::: 15675
STRING , STRING , NAME = ::: 15665
( NAME = STRING ) NEWLINE ::: 15624
NAME . NAME ( [ NAME ::: 15615
NAME ) : NEWLINE INDENT raise ::: 15599
NAME = None NEWLINE NAME . ::: 15598
NAME in NAME ( NAME ) ::: 15580
. NAME = NAME ( ) ::: 15578
NUMBER ] NEWLINE NAME = NAME ::: 15543
STRING ] ) NEWLINE NAME . ::: 15526
, STRING : STRING } , ::: 15513
NAME NEWLINE NAME . NAME . ::: 15511
INDENT return NAME . NAME . ::: 15493
. NAME ( { STRING : ::: 15467
( NAME [ STRING ] , ::: 15460
[ STRING ] . NAME ( ::: 15438
NEWLINE from NAME import NAME , ::: 15408
NEWLINE DEDENT DEDENT NAME . NAME ::: 15371
] = NAME . NAME ( ::: 15347
[ ] NEWLINE for NAME in ::: 15331
) NEWLINE NAME = STRING NEWLINE ::: 15330
NEWLINE INDENT NAME = NUMBER NEWLINE ::: 15320
, NAME ) ) NEWLINE NAME ::: 15308
, NAME ( NAME . NAME ::: 15274
STRING , NAME = NAME . ::: 15259
DEDENT if NAME == STRING : ::: 15256
( NAME ) NEWLINE return NAME ::: 15251
. NAME . NAME ( NUMBER ::: 15247
( NAME , NAME = STRING ::: 15210
, NUMBER ) , ( NUMBER ::: 15189
. NAME [ STRING ] = ::: 15188
) NEWLINE if NAME ( NAME ::: 15182
( STRING ) NEWLINE DEDENT DEDENT ::: 15182
pass NEWLINE DEDENT def NAME ( ::: 15165
NAME . NAME = True NEWLINE ::: 15130
NAME = { } NEWLINE NAME ::: 15122
( STRING , NAME , NAME ::: 15073
NAME [ NAME . NAME ] ::: 15020
% ( NAME , NAME ) ::: 15010
NEWLINE NAME . NAME = [ ::: 15000
STRING . NAME ( NAME . ::: 14977
} , STRING : ( STRING ::: 14970
NAME ) NEWLINE if NAME : ::: 14964
= NAME [ NUMBER ] NEWLINE ::: 14956
= STRING . NAME ( NAME ::: 14955
NUMBER , NAME = NUMBER , ::: 14936
{ STRING : NAME , STRING ::: 14919
, NUMBER , NUMBER ] , ::: 14907
NAME ) ) : NEWLINE INDENT ::: 14852
, NAME = False ) NEWLINE ::: 14840
NEWLINE DEDENT for NAME in NAME ::: 14818
NAME . NAME ) NEWLINE if ::: 14812
( STRING , NUMBER ) NEWLINE ::: 14784
. NAME == NAME . NAME ::: 14753
NAME NEWLINE import NAME . NAME ::: 14737
, ( NUMBER , NUMBER ) ::: 14720
DEDENT DEDENT return NAME NEWLINE DEDENT ::: 14718
def NAME ( NAME , * ::: 14711
INDENT return NAME . NAME NEWLINE ::: 14690
NAME ) NEWLINE DEDENT elif NAME ::: 14687
) NEWLINE NAME = NAME [ ::: 14675
( NAME , STRING , NAME ::: 14660
= [ ] NEWLINE NAME = ::: 14653
= NAME ( NAME , STRING ::: 14646
NEWLINE if NAME is not None ::: 14642
INDENT NAME = STRING NEWLINE DEDENT ::: 14639
NUMBER , NUMBER ] , [ ::: 14605
STRING ] NEWLINE NAME = NAME ::: 14603
] , [ NUMBER , NUMBER ::: 14585
None , NAME = None ) ::: 14557
NEWLINE DEDENT if NAME : NEWLINE ::: 14555
NAME ) , NAME . NAME ::: 14534
STRING } , STRING : ( ::: 14521
NAME , NAME = False ) ::: 14510
NAME . NAME ( { STRING ::: 14489
( STRING ) . NAME ( ::: 14481
NAME ) : NEWLINE INDENT for ::: 14470
. NAME ( STRING . NAME ::: 14434
NAME ) NEWLINE for NAME in ::: 14428
. NAME ( STRING ) . ::: 14421
NUMBER ] , [ NUMBER , ::: 14379
) : NEWLINE INDENT return STRING ::: 14366
) } , STRING : { ::: 14357
{ STRING : STRING } , ::: 14356
NUMBER , NUMBER ) NEWLINE NAME ::: 14355
. NAME : NEWLINE INDENT if ::: 14342
NAME , NAME = NUMBER , ::: 14305
) , NUMBER ) NEWLINE NAME ::: 14289
STRING % NAME ) NEWLINE DEDENT ::: 14234
STRING : STRING } ) } ::: 14208
NAME = STRING ) , NAME ::: 14181
= NAME . NAME ( [ ::: 14144
( NAME = NUMBER , NAME ::: 14144
( ) . NAME ( ) ::: 14138
NAME . NAME == NAME . ::: 14127
not NAME . NAME : NEWLINE ::: 14115
NAME as NAME : NEWLINE INDENT ::: 14114
, NUMBER , NUMBER ) , ::: 14109
[ NAME ] = NAME NEWLINE ::: 14095
STRING STRING STRING STRING STRING STRING ::: 14092
NAME [ NUMBER ] NEWLINE NAME ::: 14066
NUMBER : NEWLINE INDENT NAME . ::: 14030
with NAME . NAME ( NAME ::: 14015
NAME NEWLINE DEDENT DEDENT class NAME ::: 14007
STRING , NUMBER ) NEWLINE NAME ::: 13984
NEWLINE DEDENT NAME . NAME . ::: 13954
) NEWLINE NAME , NAME = ::: 13907
NEWLINE from . NAME import NAME ::: 13902
} ) } , STRING : ::: 13876
NAME , NAME in NAME ( ::: 13875
NAME ( STRING , NAME ( ::: 13869
( NAME . NAME [ NUMBER ::: 13861
STRING , NAME ) NEWLINE DEDENT ::: 13858
NEWLINE INDENT NAME . NAME [ ::: 13853
= False ) : NEWLINE INDENT ::: 13826
. NAME . NAME : NEWLINE ::: 13824
= NAME ( NAME = STRING ::: 13822
NAME [ NAME ] NEWLINE DEDENT ::: 13809
, NAME ) NEWLINE DEDENT NAME ::: 13807
. NAME ( NAME = True ::: 13795
return NAME . NAME ( ) ::: 13781
, NAME . NAME ) : ::: 13775
STRING in NAME : NEWLINE INDENT ::: 13765
NAME = False ) : NEWLINE ::: 13762
NAME , NAME , NAME . ::: 13717
NAME import NAME as NAME NEWLINE ::: 13694
, [ NUMBER , NUMBER , ::: 13670
( NAME , * NAME , ::: 13663
( STRING , NAME = NAME ::: 13662
, NUMBER ] , [ NUMBER ::: 13646
NEWLINE NAME = [ STRING , ::: 13597
} ) NEWLINE NAME . NAME ::: 13580
[ NUMBER ] NEWLINE NAME = ::: 13568
NEWLINE DEDENT try : NEWLINE INDENT ::: 13563
None NEWLINE NAME . NAME = ::: 13559
: NAME . NAME . NAME ::: 13558
[ STRING ] ) NEWLINE DEDENT ::: 13548
NAME as NAME NEWLINE from NAME ::: 13544
INDENT if NAME . NAME ( ::: 13539
) : NEWLINE INDENT NAME [ ::: 13507
NEWLINE if NAME ( NAME ) ::: 13484
, NAME = { STRING : ::: 13450
NAME . NAME ( STRING . ::: 13449
, NAME in NAME ( NAME ::: 13413
( NAME [ NUMBER ] ) ::: 13399
) NEWLINE DEDENT @ NAME . ::: 13389
NAME ( NAME = NUMBER , ::: 13340
NUMBER NEWLINE NAME . NAME = ::: 13334
, NAME = False ) : ::: 13322
. NAME ( ) NEWLINE return ::: 13316
NEWLINE NAME = { } NEWLINE ::: 13303
if NAME . NAME ( STRING ::: 13301
NAME . NAME NEWLINE DEDENT DEDENT ::: 13280
= NAME . NAME [ NAME ::: 13269
True ) NEWLINE NAME = NAME ::: 13250
INDENT NAME = NAME NEWLINE DEDENT ::: 13244
if NAME . NAME ( ) ::: 13240
INDENT raise NAME ( STRING % ::: 13225
NAME . NAME = False NEWLINE ::: 13212
NAME ( NUMBER ) NEWLINE DEDENT ::: 13198
NAME = STRING % ( NAME ::: 13180
. NAME [ NAME ] NEWLINE ::: 13160
STRING NEWLINE if NAME . NAME ::: 13144
if NAME . NAME ( NAME ::: 13139
) : NEWLINE INDENT NAME , ::: 13136
: STRING } ) } , ::: 13126
STRING } ) } , STRING ::: 13092
NAME [ NAME ] . NAME ::: 13074
( NUMBER ) NEWLINE NAME . ::: 13073
, NAME , NAME NEWLINE from ::: 13064
NAME = None NEWLINE NAME = ::: 13062
: { STRING : STRING } ::: 13037
not NAME . NAME . NAME ::: 13018
NAME NEWLINE DEDENT DEDENT def NAME ::: 13007
in NAME ( NAME ) : ::: 12983
STRING ) NEWLINE DEDENT NAME = ::: 12970
: NEWLINE INDENT NAME = ( ::: 12950
: NEWLINE INDENT return NEWLINE DEDENT ::: 12949
= True ) NEWLINE NAME = ::: 12936
NEWLINE DEDENT if NAME ( NAME ::: 12934
NAME ) NEWLINE if not NAME ::: 12899
: NEWLINE INDENT if NAME : ::: 12889
( STRING ) , NAME = ::: 12871
) NEWLINE if not NAME : ::: 12853
STRING ) , NAME ( STRING ::: 12852
NAME . NAME NEWLINE if NAME ::: 12851
INDENT NAME = NAME ( STRING ::: 12836
NEWLINE INDENT NAME = [ ] ::: 12835
] NEWLINE NAME = NAME [ ::: 12830
% ( NAME . NAME , ::: 12826
NAME [ STRING ] = STRING ::: 12799
= { STRING : STRING , ::: 12786
INDENT NAME = [ ] NEWLINE ::: 12766
NAME = NAME [ NAME ] ::: 12765
( NAME ) NEWLINE DEDENT else ::: 12761
] NEWLINE NAME = NAME ( ::: 12739
NAME NEWLINE from . NAME import ::: 12700
) NEWLINE return NAME ( NAME ::: 12630
. NAME == STRING : NEWLINE ::: 12610
STRING , STRING ] ) NEWLINE ::: 12599
. NAME ( NAME ) . ::: 12597
NAME import NAME NEWLINE from . ::: 12576
= NAME ( NAME ( NAME ::: 12566
( NUMBER , NAME . NAME ::: 12536
= True , NAME = True ::: 12533
) NEWLINE class NAME ( NAME ::: 12529
NAME ) ) NEWLINE DEDENT NAME ::: 12501
. NAME ( STRING , NUMBER ::: 12499
NAME ( NAME , NAME ( ::: 12499
DEDENT NAME . NAME ( STRING ::: 12486
NAME ) , NAME ( NAME ::: 12483
( STRING ) NEWLINE DEDENT def ::: 12482
: NEWLINE INDENT continue NEWLINE DEDENT ::: 12426
NEWLINE if NAME ( NAME , ::: 12422
NAME . NAME = [ ] ::: 12407
NAME . NAME == STRING : ::: 12402
. NAME = [ ] NEWLINE ::: 12385
NEWLINE NAME = NAME [ STRING ::: 12380
else : NEWLINE INDENT return NAME ::: 12360
, STRING , NAME = STRING ::: 12341
INDENT NAME [ NAME ] = ::: 12332
for NAME in NAME ( NUMBER ::: 12313
True ) NEWLINE NAME . NAME ::: 12292
NAME ( STRING ) NEWLINE if ::: 12243
( ) . NAME ( NAME ::: 12243
: NEWLINE INDENT if NAME is ::: 12218
DEDENT NAME . NAME ( ) ::: 12196
NAME ) : NEWLINE INDENT try ::: 12193
) , NAME = NAME . ::: 12191
return NAME ( NAME ) NEWLINE ::: 12183
import NAME as NAME NEWLINE from ::: 12180
NAME , STRING ) : NEWLINE ::: 12140
= NAME ( STRING , NAME ::: 12137
) NEWLINE DEDENT DEDENT NAME = ::: 12133
INDENT pass NEWLINE DEDENT def NAME ::: 12123
NEWLINE INDENT pass NEWLINE DEDENT def ::: 12123
) NEWLINE NAME . NAME [ ::: 12113
. NAME . NAME , STRING ::: 12113
BOS NEWLINE import NAME NEWLINE import ::: 12106
NEWLINE NAME = NAME NEWLINE NAME ::: 12087
STRING NEWLINE NAME . NAME . ::: 12080
INDENT if NAME ( NAME , ::: 12049
DEDENT elif NAME == STRING : ::: 12016
elif NAME == STRING : NEWLINE ::: 12016
( NAME [ NUMBER ] , ::: 12000
. NAME ) NEWLINE if NAME ::: 11956
NUMBER , NAME = NUMBER ) ::: 11952
NAME ( ( NAME , NAME ::: 11947
NAME ( NAME [ NAME ] ::: 11936
NAME = NUMBER ) : NEWLINE ::: 11936
= NUMBER ) : NEWLINE INDENT ::: 11936
( STRING ) NEWLINE def NAME ::: 11926
NAME , NAME ( NAME ) ::: 11925
[ STRING ] : NEWLINE INDENT ::: 11900
INDENT if NAME : NEWLINE INDENT ::: 11889
NEWLINE INDENT if NAME : NEWLINE ::: 11889
NUMBER NEWLINE NAME . NAME ( ::: 11880
NAME ( STRING ) NEWLINE def ::: 11873
NAME ( ) NEWLINE NAME ( ::: 11851
STRING NEWLINE DEDENT def NAME ( ::: 11849
NAME ( ) NEWLINE for NAME ::: 11849
, NAME ( STRING , NAME ::: 11848
( NAME , STRING ) : ::: 11841
NAME ( NAME = True ) ::: 11828
NAME . NAME ) . NAME ::: 11816
( NAME ) NEWLINE DEDENT except ::: 11815
DEDENT @ NAME . NAME ( ::: 11793
STRING , NAME = NAME ) ::: 11777
[ STRING ] , NAME = ::: 11770
NAME ( NAME ) == NUMBER ::: 11724
= NAME . NAME [ STRING ::: 11722
INDENT if NAME . NAME : ::: 11720
NAME : NEWLINE INDENT pass NEWLINE ::: 11715
from NAME import NAME NEWLINE import ::: 11714
INDENT STRING NEWLINE NAME = STRING ::: 11688
. NAME is not None : ::: 11682
( NAME , NAME ) , ::: 11681
( NAME . NAME [ STRING ::: 11674
NAME NEWLINE DEDENT NAME . NAME ::: 11667
BOS NEWLINE STRING NEWLINE import NAME ::: 11641
: NEWLINE INDENT if NAME == ::: 11631
NAME NEWLINE DEDENT @ NAME NEWLINE ::: 11596
) NEWLINE DEDENT class NAME ( ::: 11572
) NEWLINE assert NAME ( NAME ::: 11568
== NAME . NAME : NEWLINE ::: 11564
, NAME , NAME = STRING ::: 11555
NAME ( ) , NAME = ::: 11525
( NAME , NAME = NUMBER ::: 11521
NAME ) NEWLINE DEDENT DEDENT NAME ::: 11520
] NEWLINE DEDENT else : NEWLINE ::: 11510
if not NAME . NAME ( ::: 11502
@ NAME . NAME ( STRING ::: 11478
INDENT for NAME in NAME . ::: 11476
) NEWLINE DEDENT DEDENT if NAME ::: 11449
NAME ( NAME ) ) ) ::: 11444
STRING : NAME . NAME ( ::: 11403
NAME ) NEWLINE return NAME . ::: 11403
NEWLINE DEDENT DEDENT return NAME NEWLINE ::: 11392
NEWLINE INDENT if not NAME . ::: 11346
INDENT if not NAME . NAME ::: 11346
, NAME ) NEWLINE NAME ( ::: 11336
) . NAME ( NAME , ::: 11323
> NUMBER : NEWLINE INDENT NAME ::: 11321
, STRING , NAME . NAME ::: 11319
NAME ] NEWLINE NAME = NAME ::: 11311
if not NAME . NAME : ::: 11297
, NAME = NUMBER ) : ::: 11291
. NAME [ NUMBER ] . ::: 11290
NEWLINE if NAME . NAME . ::: 11272
NEWLINE with NAME . NAME ( ::: 11257
= NAME , NAME = STRING ::: 11253
NUMBER , NUMBER ) ) NEWLINE ::: 11249
( STRING % NAME . NAME ::: 11237
) ) NEWLINE DEDENT else : ::: 11229
NEWLINE DEDENT elif NAME == STRING ::: 11222
, NUMBER ) ) NEWLINE NAME ::: 11201
NEWLINE assert NAME . NAME == ::: 11176
) . NAME ( NAME . ::: 11171
, NUMBER , NUMBER ) NEWLINE ::: 11168
. NAME ( ( NAME , ::: 11163
NAME ( NAME , ** NAME ::: 11144
. NAME [ NAME ] = ::: 11137
NEWLINE NAME . NAME [ STRING ::: 11116
[ STRING ] = STRING NEWLINE ::: 11095
NAME ] = NAME NEWLINE DEDENT ::: 11089
NEWLINE DEDENT except : NEWLINE INDENT ::: 11076
NAME ) NEWLINE if NAME is ::: 11066
, NAME , NAME ) ) ::: 11062
[ NUMBER ] ) NEWLINE NAME ::: 11058
NUMBER , NUMBER ) , NAME ::: 11049
@ NAME . NAME NEWLINE def ::: 11047
, STRING , STRING ] NEWLINE ::: 11038
. NAME ) NEWLINE DEDENT NAME ::: 11032
DEDENT else : NEWLINE INDENT raise ::: 11015
NAME ( ) NEWLINE return NAME ::: 10997
) NEWLINE DEDENT DEDENT DEDENT def ::: 10993
in NAME ( NAME . NAME ::: 10978
STRING , NAME . NAME , ::: 10977
: NEWLINE INDENT raise NAME . ::: 10960
NEWLINE INDENT raise NAME . NAME ::: 10960
( NAME , ** NAME ) ::: 10946
NAME ( NAME , NUMBER ) ::: 10940
NAME ( NUMBER , NAME . ::: 10937
in NAME . NAME ( NAME ::: 10930
STRING , NAME = True ) ::: 10923
) NEWLINE DEDENT DEDENT else : ::: 10910
. NAME [ STRING ] NEWLINE ::: 10906
) NEWLINE NAME = { STRING ::: 10902
[ NUMBER ] . NAME ( ::: 10886
= NAME . NAME NEWLINE if ::: 10862
NAME [ STRING ] NEWLINE DEDENT ::: 10856
DEDENT try : NEWLINE INDENT NAME ::: 10854
NAME ( [ STRING , STRING ::: 10824
( NAME , NAME ( NAME ::: 10823
. NAME [ NAME . NAME ::: 10817
= NAME [ NAME ] NEWLINE ::: 10816
STRING ] : NEWLINE INDENT NAME ::: 10812
from . NAME import NAME NEWLINE ::: 10812
NAME = ( NAME . NAME ::: 10812
STRING , NAME = NAME , ::: 10808
[ NAME . NAME ( NAME ::: 10805
= NUMBER ) NEWLINE NAME = ::: 10796
) ) NEWLINE DEDENT NAME = ::: 10770
( ) : NEWLINE INDENT if ::: 10766
DEDENT DEDENT NAME . NAME ( ::: 10760
INDENT return NAME ( NAME . ::: 10747
NAME . NAME [ NAME . ::: 10742
NEWLINE assert NAME . NAME ( ::: 10728
DEDENT return NAME . NAME ( ::: 10720
NAME = STRING ) : NEWLINE ::: 10714
= STRING ) : NEWLINE INDENT ::: 10714
, NAME = NAME ( STRING ::: 10703
STRING ) ) NEWLINE NAME = ::: 10696
return NAME . NAME ( STRING ::: 10683
except NAME as NAME : NEWLINE ::: 10675
DEDENT except NAME as NAME : ::: 10658
NEWLINE INDENT NAME = [ NAME ::: 10648
( NAME , STRING ) , ::: 10635
if not NAME ( NAME , ::: 10632
NAME = False ) NEWLINE NAME ::: 10625
: NEWLINE INDENT return False NEWLINE ::: 10615
NEWLINE INDENT return False NEWLINE DEDENT ::: 10612
NAME NEWLINE DEDENT except NAME : ::: 10598
NEWLINE NAME . NAME ( [ ::: 10572
( NAME ) NEWLINE DEDENT if ::: 10564
if NAME . NAME is not ::: 10558
. NAME . NAME NEWLINE DEDENT ::: 10552
BOS NEWLINE STRING NEWLINE from NAME ::: 10537
( ) : NEWLINE INDENT STRING ::: 10531
NEWLINE NAME = NAME [ NUMBER ::: 10512
, NAME ) NEWLINE return NAME ::: 10501
( ) , NAME . NAME ::: 10496
NAME , NAME ) , NAME ::: 10491
NAME ( [ NAME . NAME ::: 10462
{ STRING : NUMBER , STRING ::: 10452
INDENT STRING NEWLINE if NAME . ::: 10421
NAME ( ) , NAME . ::: 10416
if NAME ( NAME . NAME ::: 10412
NAME == NAME : NEWLINE INDENT ::: 10409
NAME . NAME ( [ STRING ::: 10356
NAME [ STRING ] : NEWLINE ::: 10354
NEWLINE DEDENT except NAME . NAME ::: 10354
: NEWLINE INDENT NAME = None ::: 10353
, NAME , ** NAME ) ::: 10346
NEWLINE DEDENT return NAME ( NAME ::: 10332
if STRING in NAME : NEWLINE ::: 10329
NAME : NEWLINE INDENT for NAME ::: 10311
STRING ) , NAME = NAME ::: 10306
= STRING , NAME = NUMBER ::: 10305
NEWLINE INDENT NAME = None NEWLINE ::: 10301
STRING , STRING ) NEWLINE DEDENT ::: 10278
NAME = [ STRING ] NEWLINE ::: 10265
, NAME . NAME ) , ::: 10264
NAME = ( STRING , STRING ::: 10261
NEWLINE NAME ( NAME ) NEWLINE ::: 10247
NAME . NAME import * NEWLINE ::: 10221
[ ] NEWLINE NAME . NAME ::: 10214
import NAME NEWLINE from . NAME ::: 10177
) NEWLINE DEDENT DEDENT return NAME ::: 10161
) == NUMBER : NEWLINE INDENT ::: 10160
NAME == NAME . NAME : ::: 10156
( NAME ) NEWLINE DEDENT return ::: 10153
NAME = NAME ( NAME [ ::: 10140
= NUMBER ) NEWLINE NAME . ::: 10140
( NAME = NUMBER ) NEWLINE ::: 10114
NAME ( STRING % NAME . ::: 10113
else : NEWLINE INDENT raise NAME ::: 10109
NAME in NAME ( NAME . ::: 10089
, NAME [ STRING ] ) ::: 10075
NEWLINE STRING NEWLINE import NAME NEWLINE ::: 10066
) NEWLINE if NAME is None ::: 10029
NAME , NAME , ** NAME ::: 10012
NAME ) NEWLINE NAME = [ ::: 10004
, NAME , NAME = NUMBER ::: 10002
STRING ) as NAME : NEWLINE ::: 9935
. NAME ( NAME , NUMBER ::: 9933
. NAME import NAME as NAME ::: 9921
) for NAME in NAME ] ::: 9908
NAME ) , ( STRING , ::: 9900
NAME = STRING ) NEWLINE DEDENT ::: 9895
NAME , NAME ) NEWLINE return ::: 9885
NAME ) , NUMBER ) NEWLINE ::: 9870
) , NAME = NAME ( ::: 9845
NAME . NAME NEWLINE DEDENT NAME ::: 9835
not in NAME : NEWLINE INDENT ::: 9827
( ) ) NEWLINE NAME = ::: 9826
= STRING NEWLINE def NAME ( ::: 9817
NEWLINE INDENT NAME = STRING % ::: 9816
STRING , STRING ] NEWLINE NAME ::: 9810
DEDENT DEDENT DEDENT class NAME ( ::: 9797
NAME ( NAME ) for NAME ::: 9797
. NAME ) . NAME ( ::: 9789
( STRING ) NEWLINE if NAME ::: 9788
: NEWLINE INDENT from NAME . ::: 9785
STRING : NAME . NAME . ::: 9779
NEWLINE INDENT from NAME . NAME ::: 9773
NEWLINE DEDENT elif NAME ( NAME ::: 9771
STRING ] NEWLINE NAME . NAME ::: 9744
, NAME = STRING ) : ::: 9732
NAME = STRING NEWLINE def NAME ::: 9721
) NEWLINE NAME = [ NAME ::: 9720
) ) NEWLINE DEDENT NAME . ::: 9711
= NUMBER NEWLINE NAME = NAME ::: 9699
( ) NEWLINE for NAME in ::: 9690
( STRING ) ) NEWLINE DEDENT ::: 9688
INDENT return NAME ( NAME , ::: 9666
NEWLINE INDENT return None NEWLINE DEDENT ::: 9662
: NEWLINE INDENT return None NEWLINE ::: 9662
import NAME NEWLINE def NAME ( ::: 9653
NAME NEWLINE NAME = STRING NEWLINE ::: 9647
: STRING , NUMBER : STRING ::: 9640
} NEWLINE NAME = NAME . ::: 9638
STRING ) NEWLINE DEDENT if NAME ::: 9637
STRING , NAME . NAME . ::: 9632
NAME . NAME import NAME as ::: 9623
NUMBER : STRING , NUMBER : ::: 9621
, STRING , STRING ) , ::: 9618
: STRING , STRING : NAME ::: 9617
NUMBER ) ) NEWLINE NAME = ::: 9616
, STRING , NAME ) NEWLINE ::: 9593
. NAME , NAME = STRING ::: 9586
( NAME ) for NAME in ::: 9585
NUMBER ] NEWLINE NAME . NAME ::: 9577
NAME . NAME ( ) [ ::: 9576
NEWLINE NAME . NAME = { ::: 9576
, NUMBER ) NEWLINE DEDENT def ::: 9576
STRING ) NEWLINE NAME ( NAME ::: 9557
NAME [ STRING ] , STRING ::: 9552
= [ ] NEWLINE NAME . ::: 9539
INDENT STRING NEWLINE NAME = [ ::: 9535
for NAME in NAME ] NEWLINE ::: 9529
NEWLINE INDENT NAME = { STRING ::: 9527
, STRING ) ) NEWLINE NAME ::: 9526
NAME = [ ( STRING , ::: 9519
( NAME . NAME ( NUMBER ::: 9514
) NEWLINE for NAME , NAME ::: 9510
. NAME ( STRING , None ::: 9496
) for NAME in NAME . ::: 9487
) NEWLINE DEDENT return NAME . ::: 9471
NAME ) , NAME = NAME ::: 9469
) NEWLINE if NAME is not ::: 9468
as NAME NEWLINE from NAME . ::: 9454
NAME ( STRING , None ) ::: 9443
INDENT NAME = { STRING : ::: 9430
STRING ) , NAME . NAME ::: 9430
( NUMBER , NUMBER ) ) ::: 9428
NEWLINE return NAME ( NAME , ::: 9414
) , NAME ) NEWLINE DEDENT ::: 9413
STRING : STRING } ) NEWLINE ::: 9395
NEWLINE NAME = None NEWLINE NAME ::: 9391
STRING ) NEWLINE DEDENT NAME . ::: 9390
NAME ) NEWLINE NAME = STRING ::: 9387
raise NAME ( STRING % NAME ::: 9371
) NEWLINE DEDENT DEDENT NAME . ::: 9370
INDENT for NAME in NAME : ::: 9365
NUMBER NEWLINE DEDENT def NAME ( ::: 9345
( STRING , NAME ( NAME ::: 9327
NAME NEWLINE if NAME . NAME ::: 9327
= [ NAME . NAME ( ::: 9305
NAME = NAME NEWLINE DEDENT DEDENT ::: 9305
INDENT raise NAME . NAME ( ::: 9288
( NAME ( STRING ) , ::: 9278
DEDENT if NAME . NAME : ::: 9268
NAME ] NEWLINE NAME . NAME ::: 9261
NEWLINE return NAME . NAME . ::: 9259
NUMBER ) ) NEWLINE NAME . ::: 9244
NAME . NAME = { } ::: 9232
STRING , NUMBER : STRING , ::: 9225
) ) NEWLINE NAME ( NAME ::: 9222
: NEWLINE INDENT return STRING NEWLINE ::: 9219
) : NEWLINE INDENT with NAME ::: 9219
NEWLINE INDENT return STRING NEWLINE DEDENT ::: 9217
. NAME = { } NEWLINE ::: 9194
( NAME ) ) ) NEWLINE ::: 9173
( NAME , NAME = True ::: 9170
NAME [ NAME ] NEWLINE NAME ::: 9168
NUMBER NEWLINE NAME = NAME . ::: 9157
) ) NEWLINE DEDENT DEDENT def ::: 9151
: NEWLINE INDENT NAME ( ) ::: 9146
not NAME ( NAME , NAME ::: 9141
) NEWLINE DEDENT DEDENT DEDENT DEDENT ::: 9133
NEWLINE DEDENT if NAME == STRING ::: 9105
( NAME ) NEWLINE NAME ( ::: 9096
. NAME ( ) , STRING ::: 9081
) NEWLINE NAME = [ ] ::: 9068
NEWLINE INDENT pass NEWLINE DEDENT DEDENT ::: 9061
NEWLINE DEDENT except NAME as NAME ::: 9055
. NAME [ STRING ] ) ::: 9010
NAME . NAME ) NEWLINE return ::: 9001
STRING ] ) NEWLINE NAME = ::: 9001
NAME ) NEWLINE DEDENT DEDENT EOS ::: 9000
) , STRING ) NEWLINE NAME ::: 8988
: NAME . NAME ( NAME ::: 8984
( STRING , NAME ) , ::: 8984
NAME . NAME ( STRING STRING ::: 8977
( ) . NAME ( STRING ::: 8962
= True ) : NEWLINE INDENT ::: 8955
DEDENT @ NAME . NAME NEWLINE ::: 8950
NAME NEWLINE NAME = NAME NEWLINE ::: 8949
NAME = True ) : NEWLINE ::: 8942
= NAME ( STRING , NUMBER ::: 8936
NEWLINE INDENT STRING NEWLINE if not ::: 8927
NAME = False NEWLINE NAME = ::: 8912
NAME ( NAME ) , STRING ::: 8910
= NAME . NAME [ NUMBER ::: 8906
, NAME ) NEWLINE DEDENT else ::: 8906
NAME , STRING , STRING ) ::: 8902
) NEWLINE DEDENT for NAME in ::: 8890
[ NUMBER ] ) NEWLINE DEDENT ::: 8876
[ NAME . NAME . NAME ::: 8873
except NAME : NEWLINE INDENT pass ::: 8859
def NAME ( * NAME , ::: 8853
INDENT NAME = NAME [ NAME ::: 8848
) , NAME . NAME ) ::: 8847
) NEWLINE with NAME . NAME ::: 8830
if not NAME . NAME . ::: 8826
if NAME ( NAME , STRING ::: 8825
NAME ( STRING ) , STRING ::: 8821
= [ STRING , STRING ] ::: 8820
, NAME ( STRING ) ) ::: 8805
NAME = True NEWLINE NAME = ::: 8800
STRING ) . NAME ( ) ::: 8793
) NEWLINE DEDENT elif NAME == ::: 8784
: NEWLINE INDENT return STRING % ::: 8771
= NUMBER , NAME = STRING ::: 8752
) NEWLINE NAME ( STRING , ::: 8743
True , NAME = True ) ::: 8733
, NUMBER , NUMBER ) ) ::: 8697
) > NUMBER : NEWLINE INDENT ::: 8688
( STRING ) NEWLINE DEDENT if ::: 8683
: NEWLINE INDENT import NAME NEWLINE ::: 8682
. NAME and NAME . NAME ::: 8674
NAME ) , NAME ) NEWLINE ::: 8669
) . NAME ( NAME = ::: 8668
[ NUMBER ] , NAME [ ::: 8667
] = NAME . NAME NEWLINE ::: 8665
( ) NEWLINE DEDENT NAME . ::: 8649
NAME . NAME and NAME . ::: 8638
) NEWLINE DEDENT except NAME . ::: 8628
, NUMBER : STRING , NUMBER ::: 8613
) NEWLINE NAME = NUMBER NEWLINE ::: 8613
( NUMBER ) NEWLINE NAME = ::: 8602
) ) NEWLINE DEDENT DEDENT DEDENT ::: 8591
. NAME : NEWLINE INDENT raise ::: 8591
= { STRING : NAME . ::: 8590
, NAME . NAME , STRING ::: 8581
NEWLINE if NAME == STRING : ::: 8561
NAME ( NAME = NAME ( ::: 8551
) NEWLINE @ NAME . NAME ::: 8522
NAME ) == NUMBER : NEWLINE ::: 8502
NAME NEWLINE try : NEWLINE INDENT ::: 8499
DEDENT DEDENT NAME = NAME ( ::: 8497
( ) NEWLINE DEDENT DEDENT def ::: 8493
* NAME ) : NEWLINE INDENT ::: 8491
if NAME . NAME == STRING ::: 8487
INDENT STRING NEWLINE if not NAME ::: 8476
) NEWLINE if not NAME . ::: 8476
NEWLINE NAME = ( STRING , ::: 8475
NUMBER ] , NAME [ NUMBER ::: 8474
NEWLINE DEDENT DEDENT DEDENT class NAME ::: 8470
NAME ( ) NEWLINE DEDENT EOS ::: 8468
( STRING ) NEWLINE NAME ( ::: 8464
) NEWLINE DEDENT elif NAME . ::: 8442
INDENT STRING NEWLINE return NAME ( ::: 8440
NAME , STRING , NAME = ::: 8438
[ NAME for NAME in NAME ::: 8431
[ STRING , STRING ] ) ::: 8407
NAME [ NAME ] ) NEWLINE ::: 8407
) , NAME ) NEWLINE NAME ::: 8400
NAME ) ) ) NEWLINE DEDENT ::: 8391
NAME , NAME : NEWLINE INDENT ::: 8389
) , NAME ( NAME ) ::: 8370
[ NAME ] . NAME ( ::: 8363
NAME . NAME , NAME ( ::: 8349
. NAME ( NAME , [ ::: 8348
NEWLINE NAME . NAME [ NAME ::: 8335
( NAME ( STRING ) ) ::: 8322
) NEWLINE DEDENT @ NAME ( ::: 8315
NEWLINE NAME , NAME , NAME ::: 8308
( STRING , STRING ) ) ::: 8289
NEWLINE NAME ( STRING ) NEWLINE ::: 8268
STRING ] = NAME NEWLINE NAME ::: 8264
NUMBER ] ) NEWLINE NAME = ::: 8263
. NAME ( ) ) ) ::: 8259
. NAME ( NAME [ NAME ::: 8251
, NAME , NAME = False ::: 8245
] , NAME [ NUMBER ] ::: 8239
, STRING , STRING ] ) ::: 8222
) ) NEWLINE DEDENT return NAME ::: 8218
STRING , NAME = NUMBER , ::: 8211
NAME = True ) NEWLINE DEDENT ::: 8203
. NAME ( STRING , [ ::: 8198
DEDENT else : NEWLINE INDENT if ::: 8190
= STRING , NAME = True ::: 8175
) NEWLINE NAME ( NAME ) ::: 8164
False ) NEWLINE NAME . NAME ::: 8161
NEWLINE NAME = [ NAME . ::: 8153
NAME [ NUMBER ] NEWLINE DEDENT ::: 8143
= NAME ) NEWLINE DEDENT def ::: 8141
] : NEWLINE INDENT NAME = ::: 8126
NAME ( NAME ) NEWLINE for ::: 8126
. NAME [ NUMBER ] ) ::: 8125
None ) NEWLINE NAME . NAME ::: 8121
( ) : NEWLINE INDENT return ::: 8108
[ NUMBER ] [ NUMBER ] ::: 8108
NEWLINE import NAME as NAME NEWLINE ::: 8094
STRING NEWLINE try : NEWLINE INDENT ::: 8086
( NAME ) , NAME ( ::: 8085
) ) NEWLINE DEDENT if NAME ::: 8084
NUMBER ] ) NEWLINE NAME . ::: 8072
INDENT NAME . NAME [ NAME ::: 8068
NAME . NAME ( NAME + ::: 8056
( STRING % ( NAME . ::: 8054
, NAME = True ) : ::: 8042
NEWLINE NAME . NAME = False ::: 8032
from NAME import NAME NEWLINE NAME ::: 8031
BOS NEWLINE import NAME NEWLINE from ::: 8018
( NAME ) NEWLINE for NAME ::: 8015
) NEWLINE DEDENT if NAME : ::: 8015
. NAME NEWLINE DEDENT else : ::: 8007
NEWLINE INDENT raise NAME ( NAME ::: 8003
NAME . NAME ( ) ] ::: 7999
NEWLINE NAME = STRING . NAME ::: 7999
NAME ( { STRING : NAME ::: 7993
. NAME = False NEWLINE NAME ::: 7979
( NAME , STRING , STRING ::: 7961
DEDENT for NAME in NAME : ::: 7961
NAME , NUMBER ) NEWLINE DEDENT ::: 7958
None NEWLINE DEDENT def NAME ( ::: 7950
NAME : NEWLINE INDENT try : ::: 7944
STRING NEWLINE from NAME import NAME ::: 7942
= NUMBER , NAME = NAME ::: 7938
NAME ) NEWLINE try : NEWLINE ::: 7934
NAME . NAME as NAME NEWLINE ::: 7915
, ( NAME , NAME ) ::: 7912
. NAME ( [ STRING , ::: 7911
. NAME [ STRING ] , ::: 7905
( ) ) NEWLINE DEDENT def ::: 7897
NEWLINE @ NAME NEWLINE def NAME ::: 7896
NEWLINE if NAME . NAME == ::: 7891
NEWLINE return NAME NEWLINE DEDENT DEDENT ::: 7886
NAME . NAME ( STRING + ::: 7884
NAME for NAME in NAME . ::: 7884
NEWLINE NAME = NAME [ NAME ::: 7884
. NAME ( ) NEWLINE for ::: 7882
NAME ( NAME ( NAME ( ::: 7875
[ STRING ] = NAME ( ::: 7870
( NAME ) NEWLINE def NAME ::: 7867
: NEWLINE INDENT with NAME . ::: 7858
NEWLINE INDENT with NAME . NAME ::: 7858
] , NAME [ STRING ] ::: 7842
from NAME . NAME import * ::: 7839
INDENT NAME = NAME [ STRING ::: 7831
NEWLINE if NAME . NAME is ::: 7829
if NAME ( NAME ) == ::: 7815
STRING , STRING ) ) NEWLINE ::: 7808
) NEWLINE DEDENT DEDENT @ NAME ::: 7804
DEDENT DEDENT NAME = NAME . ::: 7797
( ) NEWLINE DEDENT NAME = ::: 7797
NEWLINE @ NAME . NAME ( ::: 7789
STRING ] = NAME NEWLINE DEDENT ::: 7788
[ STRING ] , NAME [ ::: 7776
] == STRING : NEWLINE INDENT ::: 7766
. NAME [ NUMBER ] NEWLINE ::: 7756
[ STRING ] , STRING : ::: 7751
NEWLINE NAME = [ STRING ] ::: 7743
NAME NEWLINE def NAME ( ) ::: 7743
) . NAME ( STRING , ::: 7738
NAME ( NAME ) NEWLINE def ::: 7735
. NAME = True NEWLINE NAME ::: 7733
, NAME , NAME = True ::: 7724
not NAME . NAME ( NAME ::: 7724
NAME , NAME = True , ::: 7714
. NAME ( ) [ NUMBER ::: 7712
= NAME . NAME ( ( ::: 7711
== NAME : NEWLINE INDENT NAME ::: 7707
NAME ( NUMBER , NAME ( ::: 7701
[ STRING ] NEWLINE NAME . ::: 7699
NEWLINE INDENT NAME ( ) NEWLINE ::: 7695
} NEWLINE NAME . NAME ( ::: 7683
= STRING ) , NAME ( ::: 7680
NEWLINE import NAME NEWLINE NAME = ::: 7675
not NAME : NEWLINE INDENT return ::: 7672
: NEWLINE INDENT NAME = True ::: 7663
) NEWLINE DEDENT if not NAME ::: 7663
, STRING ) as NAME : ::: 7661
) ) ) NEWLINE NAME . ::: 7659
NAME ( ) NEWLINE DEDENT if ::: 7646
NAME as NAME NEWLINE import NAME ::: 7640
NAME . NAME ( ) == ::: 7640
NAME , ( NAME , NAME ::: 7640
DEDENT if NAME . NAME ( ::: 7637
NAME . NAME is None : ::: 7630
NAME ) NEWLINE NAME , NAME ::: 7626
NAME NEWLINE NAME [ STRING ] ::: 7625
NEWLINE INDENT NAME = True NEWLINE ::: 7612
NAME ( NAME ) > NUMBER ::: 7603
** NAME ) NEWLINE DEDENT def ::: 7592
NAME ( [ NUMBER , NUMBER ::: 7591
, ( NAME , STRING ) ::: 7575
( ) NEWLINE DEDENT else : ::: 7571
STRING ) . NAME ( STRING ::: 7571
) , ( NAME , STRING ::: 7570
= NAME NEWLINE DEDENT else : ::: 7570
. NAME is None : NEWLINE ::: 7569
NAME ] = NAME . NAME ::: 7558
. NAME = None NEWLINE DEDENT ::: 7550
( NAME = True ) NEWLINE ::: 7548
INDENT if NAME . NAME == ::: 7547
) NEWLINE DEDENT return NAME ( ::: 7541
NEWLINE INDENT if NAME is None ::: 7538
= True ) NEWLINE NAME . ::: 7535
NAME . NAME NEWLINE DEDENT else ::: 7527
NAME ( NAME , NAME [ ::: 7527
NAME ) NEWLINE return NAME ( ::: 7524
NAME : NEWLINE INDENT NAME += ::: 7522
= False NEWLINE NAME . NAME ::: 7517
INDENT NAME . NAME ( NUMBER ::: 7516
NAME , STRING : NAME } ::: 7512
NAME . NAME = NAME [ ::: 7503
NEWLINE import NAME . NAME NEWLINE ::: 7501
, ( NUMBER , NUMBER , ::: 7498
( NAME ) , NAME ) ::: 7498
NAME . NAME ] ) NEWLINE ::: 7497
NAME , NAME , * NAME ::: 7496
, STRING ] NEWLINE NAME = ::: 7495
NEWLINE INDENT NAME ( NAME ) ::: 7493
DEDENT def NAME ( * NAME ::: 7492
: NEWLINE INDENT return True NEWLINE ::: 7484
NAME ( { STRING : STRING ::: 7482
NEWLINE INDENT return True NEWLINE DEDENT ::: 7479
: NEWLINE INDENT break NEWLINE DEDENT ::: 7474
( NAME , NUMBER ) NEWLINE ::: 7473
, ( STRING , STRING , ::: 7473
= { STRING : NAME , ::: 7468
NUMBER : NEWLINE INDENT raise NAME ::: 7458
, NAME = True ) ) ::: 7449
NAME ( ) NEWLINE DEDENT except ::: 7439
( STRING , NAME ( STRING ::: 7430
NAME ( ) ) ) NEWLINE ::: 7428
STRING , NAME = NUMBER ) ::: 7425
( NAME = True , NAME ::: 7414
NAME [ NAME ] , NAME ::: 7413
NAME ( ) NEWLINE DEDENT else ::: 7406
NEWLINE INDENT NAME ( STRING ) ::: 7406
if NAME . NAME is None ::: 7405
. NAME ( STRING ) [ ::: 7404
( NUMBER , NUMBER ) NEWLINE ::: 7403
STRING NEWLINE DEDENT else : NEWLINE ::: 7401
DEDENT elif NAME ( NAME , ::: 7389
: NEWLINE INDENT if NAME [ ::: 7384
if NAME == NUMBER : NEWLINE ::: 7376
STRING , NAME = NAME ( ::: 7369
: STRING , STRING : NUMBER ::: 7367
= True NEWLINE NAME . NAME ::: 7365
STRING ] , NAME [ STRING ::: 7363
import NAME NEWLINE NAME . NAME ::: 7346
NAME = - NUMBER NEWLINE NAME ::: 7345
) NEWLINE DEDENT except : NEWLINE ::: 7340
NAME = NAME ( NUMBER , ::: 7333
NUMBER ) , ( STRING , ::: 7333
NAME , STRING ) , ( ::: 7326
NAME ( ) [ NUMBER ] ::: 7322
NAME = NAME NEWLINE DEDENT NAME ::: 7317
) NEWLINE def NAME ( ) ::: 7310
= { STRING : STRING } ::: 7302
NUMBER ) NEWLINE NAME ( NAME ::: 7288
DEDENT DEDENT def NAME ( ) ::: 7288
( NAME , NAME = False ::: 7274
STRING NEWLINE return NAME ( NAME ::: 7268
STRING ) NEWLINE DEDENT else : ::: 7253
) NEWLINE NAME ( NAME ( ::: 7248
assert NAME ( NAME . NAME ::: 7236
NAME . NAME = [ NAME ::: 7235
NAME ( ) NEWLINE NAME [ ::: 7235
NEWLINE INDENT NAME , NAME , ::: 7234
[ NUMBER ] [ STRING ] ::: 7229
INDENT return NAME NEWLINE DEDENT DEDENT ::: 7215
STRING ) NEWLINE return NAME NEWLINE ::: 7212
INDENT NAME ( NAME . NAME ::: 7209
NEWLINE INDENT NAME ( NAME . ::: 7209
NAME , STRING , NAME ) ::: 7208
STRING . NAME ( NAME , ::: 7206
INDENT NAME ( STRING ) NEWLINE ::: 7205
NAME = False NEWLINE NAME . ::: 7199
INDENT NAME , NAME , NAME ::: 7198
. NAME ( STRING + NAME ::: 7196
) . NAME ( ) ) ::: 7190
NEWLINE NAME [ NAME ] = ::: 7187
DEDENT if NAME ( NAME , ::: 7179
, STRING ] ) NEWLINE NAME ::: 7176
: NEWLINE INDENT from NAME import ::: 7175
) NEWLINE DEDENT except NAME as ::: 7175
NAME = True ) ) , ::: 7172
INDENT NAME = NAME [ NUMBER ::: 7159
NAME NEWLINE return NAME NEWLINE DEDENT ::: 7152
STRING NEWLINE import NAME NEWLINE import ::: 7152
= STRING , NAME = False ::: 7146
( ) NEWLINE if NAME . ::: 7144
NAME NEWLINE DEDENT return NAME NEWLINE ::: 7141
) NEWLINE DEDENT if NAME ( ::: 7141
, NAME ( NAME ) , ::: 7140
( ) NEWLINE NAME ( NAME ::: 7138
, STRING ) NEWLINE return NAME ::: 7136
NAME : NAME . NAME ( ::: 7134
def NAME ( NAME , ** ::: 7130
NEWLINE NAME . NAME = True ::: 7128
STRING % NAME . NAME ) ::: 7126
NAME ) NEWLINE if NAME ( ::: 7123
NEWLINE NAME = NAME ( [ ::: 7121
, STRING ) NEWLINE DEDENT DEDENT ::: 7121
NAME NEWLINE import NAME NEWLINE NAME ::: 7121
) , NAME = STRING ) ::: 7119
( ) NEWLINE def NAME ( ::: 7109
INDENT NAME ( NAME ) NEWLINE ::: 7106
, NAME = [ STRING , ::: 7101
INDENT if NAME . NAME . ::: 7098
, STRING ) , ( NAME ::: 7096
STRING ) NEWLINE NAME ( STRING ::: 7093
INDENT NAME = NAME NEWLINE NAME ::: 7091
NAME = ( NUMBER , NUMBER ::: 7084
, NAME [ NUMBER ] ) ::: 7080
NAME ( NAME ) , NUMBER ::: 7074
STRING NEWLINE NAME = { STRING ::: 7073
None ) : NEWLINE INDENT if ::: 7072
= ( STRING , STRING , ::: 7071
NAME ( STRING ) NEWLINE return ::: 7061
. NAME ( [ NAME . ::: 7057
try : NEWLINE INDENT return NAME ::: 7051
NEWLINE STRING NEWLINE from NAME import ::: 7049
NAME = [ NAME ( NAME ::: 7044
[ STRING , STRING ] , ::: 7042
STRING ] , NAME = NAME ::: 7040
( NAME , NAME , STRING ::: 7036
STRING ] = STRING NEWLINE NAME ::: 7024
, NUMBER , NUMBER ] ) ::: 7022
[ NUMBER ] NEWLINE NAME . ::: 7014
NUMBER ] . NAME ( ) ::: 7013
if NAME . NAME == NAME ::: 7008
NAME ) > NUMBER : NEWLINE ::: 7008
DEDENT return NAME NEWLINE DEDENT DEDENT ::: 7007
: NEWLINE INDENT if NAME in ::: 7001
= NAME ( ) NEWLINE DEDENT ::: 6994
. NAME , STRING , NAME ::: 6993
NEWLINE DEDENT def NAME ( * ::: 6991
NEWLINE INDENT from NAME import NAME ::: 6982
. NAME ( STRING ) ( ::: 6977
class NAME ( NAME , NAME ::: 6977
INDENT if NAME is None : ::: 6962
NAME [ NUMBER ] [ NUMBER ::: 6958
NAME ( STRING ) ) , ::: 6956
NAME , NAME ) = NAME ::: 6952
. NAME ) NEWLINE NAME ( ::: 6952
, ** NAME ) NEWLINE NAME ::: 6949
[ NAME ] ) NEWLINE DEDENT ::: 6945
STRING NEWLINE for NAME in NAME ::: 6942
NAME ( ** NAME ) NEWLINE ::: 6936
} ) NEWLINE NAME = NAME ::: 6930
( NAME ) == NUMBER : ::: 6929
) : NEWLINE INDENT assert NAME ::: 6920
) , STRING : NAME . ::: 6919
] . NAME ( STRING ) ::: 6915
. NAME ) NEWLINE DEDENT else ::: 6908
NAME ] ) NEWLINE NAME = ::: 6906
NAME ) : NEWLINE INDENT with ::: 6901
NAME = { } NEWLINE for ::: 6896
is None : NEWLINE INDENT return ::: 6895
DEDENT NAME = NAME ( ) ::: 6882
NAME = NUMBER ) NEWLINE DEDENT ::: 6880
NAME = NAME NEWLINE if NAME ::: 6880
= { } NEWLINE for NAME ::: 6875
) NEWLINE NAME ( STRING ) ::: 6874
NEWLINE NAME ( STRING , NAME ::: 6873
% NAME . NAME ) NEWLINE ::: 6871
) NEWLINE DEDENT if NAME == ::: 6869
NAME ( NAME ( STRING , ::: 6866
) [ NUMBER ] NEWLINE NAME ::: 6865
: NEWLINE INDENT for NAME , ::: 6864
if NAME in NAME : NEWLINE ::: 6864
NAME ( NUMBER ) ) NEWLINE ::: 6863
INDENT return NAME ( NAME ) ::: 6861
( NUMBER , NAME ( NAME ::: 6857
import NAME NEWLINE import NAME . ::: 6844
NEWLINE NAME = False NEWLINE NAME ::: 6840
NEWLINE NAME = STRING NEWLINE def ::: 6838
STRING : NAME . NAME } ::: 6830
= { } NEWLINE NAME = ::: 6814
[ NAME ] NEWLINE NAME = ::: 6806
] NEWLINE def NAME ( NAME ::: 6805
( NAME . NAME [ NAME ::: 6803
INDENT STRING NEWLINE NAME = { ::: 6799
{ } NEWLINE NAME . NAME ::: 6796
NAME ( NAME , ( NAME ::: 6794
STRING NEWLINE NAME = NUMBER NEWLINE ::: 6790
NAME > NUMBER : NEWLINE INDENT ::: 6787
. NAME ) NEWLINE return NAME ::: 6786
NAME ( ) NEWLINE def NAME ::: 6779
NUMBER , NUMBER ] ) NEWLINE ::: 6776
) , NAME = NAME ) ::: 6770
NAME ) NEWLINE NAME ( STRING ::: 6764
NAME . NAME ( * NAME ::: 6763
NEWLINE INDENT return NEWLINE DEDENT NAME ::: 6756
STRING , STRING ) , NAME ::: 6755
, STRING , STRING ] , ::: 6755
. NAME , NAME ) ) ::: 6747
( [ STRING , STRING , ::: 6744
) , STRING : NAME ( ::: 6740
NAME = True NEWLINE NAME . ::: 6737
. NAME [ STRING ] . ::: 6732
NAME import ( NAME , NAME ::: 6728
NAME . NAME . NAME == ::: 6727
STRING ) . NAME ( NAME ::: 6723
NAME = { STRING : { ::: 6705
NAME in NAME ( NUMBER , ::: 6704
= STRING , NAME = [ ::: 6700
NEWLINE INDENT for NAME , NAME ::: 6695
( NAME ) NEWLINE DEDENT elif ::: 6675
DEDENT DEDENT if NAME == STRING ::: 6665
STRING ) NEWLINE DEDENT DEDENT def ::: 6659
) NEWLINE NAME = ( NAME ::: 6656
NAME ) NEWLINE NAME [ STRING ::: 6651
else : NEWLINE INDENT if NAME ::: 6649
STRING : STRING } NEWLINE NAME ::: 6649
( ( NAME , NAME ) ::: 6645
} NEWLINE NAME . NAME = ::: 6642
NAME ( STRING ) ( NAME ::: 6629
NAME , STRING ) ) NEWLINE ::: 6611
return NAME NEWLINE DEDENT NAME = ::: 6611
: NUMBER , STRING : STRING ::: 6600
, NAME , STRING ) NEWLINE ::: 6595
NAME . NAME ( [ NUMBER ::: 6593
( STRING , None ) NEWLINE ::: 6588
. NAME [ NUMBER ] , ::: 6563
DEDENT for NAME in NAME . ::: 6559
STRING : NAME } ) NEWLINE ::: 6558
STRING % NAME ) NEWLINE NAME ::: 6556
DEDENT finally : NEWLINE INDENT NAME ::: 6552
return NAME NEWLINE DEDENT DEDENT class ::: 6552
STRING , NAME = True , ::: 6539
( NAME ) , NAME = ::: 6534
== STRING : NEWLINE INDENT return ::: 6531
= NUMBER , NAME = True ::: 6531
NAME , * NAME ) : ::: 6528
NAME , NAME NEWLINE NAME = ::: 6516
. NAME for NAME in NAME ::: 6512
, NAME ) , ( STRING ::: 6505
lambda NAME : NAME . NAME ::: 6504
) , NAME . NAME . ::: 6502
( ) NEWLINE DEDENT if NAME ::: 6490
NUMBER , NAME . NAME ) ::: 6476
, STRING , STRING , NAME ::: 6472
INDENT raise NAME ( STRING STRING ::: 6467
INDENT for NAME in NAME ( ::: 6465
[ STRING ] , STRING ) ::: 6464
NEWLINE return NAME . NAME NEWLINE ::: 6462
DEDENT if not NAME . NAME ::: 6447
, STRING : STRING , } ::: 6446
) : NEWLINE INDENT from NAME ::: 6446
: NEWLINE INDENT STRING NEWLINE try ::: 6438
NEWLINE INDENT STRING NEWLINE try : ::: 6438
. NAME ( NAME ( ) ::: 6437
NAME ) ) NEWLINE if NAME ::: 6437
NAME , NAME [ STRING ] ::: 6432
NAME , NAME NEWLINE import NAME ::: 6422
INDENT STRING NEWLINE try : NEWLINE ::: 6419
INDENT if NAME ( NAME ) ::: 6415
NEWLINE NAME . NAME ( ( ::: 6405
] , STRING ) NEWLINE NAME ::: 6405
NAME import NAME NEWLINE def NAME ::: 6405
return NAME NEWLINE DEDENT @ NAME ::: 6402
[ STRING ] [ NUMBER ] ::: 6401
NEWLINE return NAME NEWLINE DEDENT EOS ::: 6398
( NAME , NAME , ** ::: 6387
} , { STRING : STRING ::: 6382
] : NEWLINE INDENT NAME . ::: 6377
] NEWLINE NAME = [ ] ::: 6377
False ) : NEWLINE INDENT STRING ::: 6376
, * NAME ) : NEWLINE ::: 6359
= { } NEWLINE NAME . ::: 6357
. NAME . NAME [ STRING ::: 6356
pass NEWLINE DEDENT class NAME ( ::: 6350
( NAME ) , NUMBER ) ::: 6346
( NAME ) , NAME . ::: 6342
NAME . NAME for NAME in ::: 6326
, NAME NEWLINE from NAME import ::: 6325
STRING , NAME ) , ( ::: 6323
DEDENT if not NAME : NEWLINE ::: 6322
= STRING % ( NAME , ::: 6316
NEWLINE INDENT NAME = { } ::: 6314
( STRING ) ( NAME = ::: 6307
NEWLINE assert NAME ( NAME . ::: 6300
. NAME NEWLINE DEDENT @ NAME ::: 6296
** NAME ) NEWLINE NAME . ::: 6295
. NAME [ NAME ] . ::: 6295
, NAME = [ STRING ] ::: 6292
NAME ( NAME ( ) ) ::: 6284
STRING NEWLINE if NAME ( NAME ::: 6282
STRING : NEWLINE INDENT NAME ( ::: 6281
INDENT NAME = { } NEWLINE ::: 6279
None NEWLINE NAME = None NEWLINE ::: 6278
NEWLINE INDENT NAME = [ STRING ::: 6277
= None NEWLINE NAME = None ::: 6264
NEWLINE NAME = True NEWLINE NAME ::: 6258
NUMBER , NAME = STRING ) ::: 6248
= NAME ) NEWLINE DEDENT DEDENT ::: 6247
except NAME , NAME : NEWLINE ::: 6247
DEDENT except NAME , NAME : ::: 6240
NAME , NAME = False , ::: 6237
STRING ) , ( NAME , ::: 6223
. NAME ( ** NAME ) ::: 6216
= STRING NEWLINE NAME = [ ::: 6215
NAME ( NAME = True , ::: 6215
STRING , STRING ) : NEWLINE ::: 6214
STRING NEWLINE NAME = [ STRING ::: 6209
: NEWLINE INDENT NAME += STRING ::: 6208
= { STRING : { STRING ::: 6207
] . NAME ( NAME ) ::: 6205
class NAME : NEWLINE INDENT NAME ::: 6202
DEDENT elif NAME . NAME == ::: 6199
if NAME in NAME . NAME ::: 6198
STRING : True , STRING : ::: 6194
( NAME [ NAME ] ) ::: 6193
[ NAME , NAME , NAME ::: 6188
STRING ] = NAME ( NAME ::: 6170
DEDENT if NAME is not None ::: 6170
DEDENT except : NEWLINE INDENT NAME ::: 6167
assert NAME . NAME . NAME ::: 6163
NAME ( ( NAME . NAME ::: 6154
True NEWLINE DEDENT def NAME ( ::: 6151
( STRING , NAME = True ::: 6140
if NAME : NEWLINE INDENT return ::: 6140
NAME ( ( NUMBER , NUMBER ::: 6138
NEWLINE INDENT continue NEWLINE DEDENT NAME ::: 6133
STRING , NAME = False , ::: 6132
. NAME . NAME [ NUMBER ::: 6132
= NAME ( STRING ) , ::: 6129
= NAME ( STRING , STRING ::: 6112
NEWLINE if not NAME ( NAME ::: 6112
= False , NAME = False ::: 6103
NAME ) NEWLINE DEDENT DEDENT return ::: 6099
NUMBER ] , NAME . NAME ::: 6098
NAME ( STRING STRING ) NEWLINE ::: 6095
% ( NAME , NAME , ::: 6091
@ NAME . NAME ( NAME ::: 6090
import ( NAME , NAME , ::: 6089
STRING , STRING ) NEWLINE return ::: 6085
@ NAME . NAME . NAME ::: 6083
= True , NAME = STRING ::: 6082
STRING NEWLINE from NAME . NAME ::: 6081
NAME . NAME NEWLINE DEDENT if ::: 6078
STRING ] , NAME . NAME ::: 6073
NEWLINE INDENT if NAME in NAME ::: 6072
. NAME import NAME NEWLINE import ::: 6067
, ( STRING , NAME ) ::: 6065
NAME . NAME NEWLINE DEDENT @ ::: 6062
NEWLINE DEDENT finally : NEWLINE INDENT ::: 6062
STRING , NAME ( STRING ) ::: 6052
NAME : NEWLINE INDENT return NEWLINE ::: 6048
] NEWLINE NAME . NAME . ::: 6043
- NUMBER , - NUMBER , ::: 6041
INDENT NAME ( ) NEWLINE DEDENT ::: 6038
INDENT NAME = NUMBER NEWLINE NAME ::: 6035
STRING , NAME , NAME ) ::: 6034
= [ STRING ] NEWLINE NAME ::: 6033
STRING + NAME ( NAME ) ::: 6030
NAME ( NUMBER , NAME ) ::: 6024
) , ( STRING , NUMBER ::: 6022
, STRING ) NEWLINE NAME ( ::: 6022
NAME . NAME ] NEWLINE NAME ::: 6018
NEWLINE NAME ( NAME ( NAME ::: 6017
elif NAME ( NAME , NAME ::: 6016
STRING ] , STRING ) NEWLINE ::: 6015
NEWLINE class NAME : NEWLINE INDENT ::: 6011
NUMBER NEWLINE for NAME in NAME ::: 6006
, NAME ( STRING , STRING ::: 6004
NAME , STRING , STRING , ::: 5996
NAME , NAME ) for NAME ::: 5994
: NEWLINE INDENT STRING NEWLINE DEDENT ::: 5987
STRING , STRING ] , NAME ::: 5983
, NAME ) NEWLINE DEDENT except ::: 5983
INDENT with NAME . NAME ( ::: 5981
NAME ( NAME ) NEWLINE assert ::: 5974
, STRING ) NEWLINE def NAME ::: 5973
, STRING . NAME ( NAME ::: 5973
, STRING : STRING } NEWLINE ::: 5973
in NAME ( NAME ( NAME ::: 5968
NEWLINE NAME = NAME ( NUMBER ::: 5965
: STRING } ) NEWLINE NAME ::: 5962
[ NAME . NAME ( ) ::: 5953
. NAME ( ) ) , ::: 5952
. NAME ( NUMBER ) ) ::: 5949
NAME ) as NAME : NEWLINE ::: 5948
NUMBER NEWLINE NAME = NAME ( ::: 5945
. NAME ( * NAME , ::: 5944
INDENT for NAME , NAME in ::: 5942
NAME NEWLINE DEDENT class NAME ( ::: 5942
= NAME NEWLINE DEDENT if NAME ::: 5941
NAME = [ NAME for NAME ::: 5940
NEWLINE INDENT if not NAME ( ::: 5937
, STRING ) . NAME ( ::: 5934
NAME ) . NAME ( STRING ::: 5932
, STRING : NAME ( NAME ::: 5930
NAME , STRING ) as NAME ::: 5921
) NEWLINE DEDENT DEDENT DEDENT class ::: 5920
finally : NEWLINE INDENT NAME . ::: 5919
NAME = NAME NEWLINE DEDENT else ::: 5919
NAME in NAME ( NAME ( ::: 5918
if NAME ( NAME ) > ::: 5906
NAME ] NEWLINE DEDENT def NAME ::: 5896
[ NAME ] ) NEWLINE NAME ::: 5893
NAME , NAME , NAME ] ::: 5893
NAME : NEWLINE INDENT NAME , ::: 5893
[ STRING , STRING ] NEWLINE ::: 5891
NAME ) ) NEWLINE DEDENT else ::: 5884
NAME [ STRING ] ) ) ::: 5883
= True ) ) , ( ::: 5881
( NAME [ STRING ] [ ::: 5880
INDENT NAME = None NEWLINE DEDENT ::: 5879
( NAME ( NAME ( NAME ::: 5878
NAME = NUMBER NEWLINE for NAME ::: 5876
NEWLINE DEDENT NAME = NAME [ ::: 5869
NAME ) NEWLINE DEDENT DEDENT if ::: 5869
: NEWLINE INDENT NAME += NAME ::: 5869
, [ STRING , STRING , ::: 5868
= NAME NEWLINE def NAME ( ::: 5868
( ) NEWLINE NAME [ STRING ::: 5865
True ) ) , ( STRING ::: 5865
STRING NEWLINE NAME = [ ] ::: 5862
( NAME ) NEWLINE if not ::: 5861
] NEWLINE if NAME . NAME ::: 5856
] = NAME NEWLINE DEDENT DEDENT ::: 5850
NAME ) NEWLINE NAME = { ::: 5847
, NUMBER ) , ( STRING ::: 5846
STRING NEWLINE DEDENT class NAME ( ::: 5842
False ) NEWLINE NAME = NAME ::: 5838
. NAME . NAME ) ) ::: 5830
: NAME . NAME ( STRING ::: 5830
( NAME . NAME ) . ::: 5823
( ) NEWLINE DEDENT except NAME ::: 5809
. NAME . NAME ) : ::: 5806
STRING , NAME , NAME = ::: 5805
NEWLINE DEDENT DEDENT if NAME == ::: 5804
NEWLINE DEDENT DEDENT @ NAME NEWLINE ::: 5801
= None , NAME = False ::: 5801
. NAME ) NEWLINE DEDENT if ::: 5794
NAME NEWLINE for NAME in NAME ::: 5789
DEDENT DEDENT @ NAME NEWLINE def ::: 5781
raise NAME . NAME ( STRING ::: 5780
DEDENT class NAME : NEWLINE INDENT ::: 5774
NAME = [ ] NEWLINE DEDENT ::: 5774
NEWLINE INDENT STRING NEWLINE NAME ( ::: 5774
NEWLINE NAME = STRING NEWLINE DEDENT ::: 5771
NAME ] ) NEWLINE NAME . ::: 5770
, NAME ( STRING ) , ::: 5766
( NAME , STRING ) ) ::: 5759
( NAME , * NAME ) ::: 5758
, NAME ) NEWLINE DEDENT if ::: 5753
return NAME , NAME NEWLINE DEDENT ::: 5749
: NAME . NAME ( ) ::: 5747
[ ] NEWLINE NAME = NAME ::: 5746
: NEWLINE INDENT NAME = False ::: 5745
. NAME ( NAME = False ::: 5743
= NAME NEWLINE DEDENT NAME = ::: 5731
NAME : NEWLINE INDENT if not ::: 5727
, - NUMBER , - NUMBER ::: 5727
NEWLINE INDENT NAME = False NEWLINE ::: 5727
, STRING , NAME = NAME ::: 5719
[ NAME . NAME ] NEWLINE ::: 5714
] NEWLINE NAME = [ NAME ::: 5714
except NAME . NAME : NEWLINE ::: 5709
DEDENT except NAME . NAME : ::: 5707
STRING : NAME [ STRING ] ::: 5706
NAME = NAME ) NEWLINE if ::: 5704
= True , NAME = NAME ::: 5703
: NEWLINE INDENT raise NAME NEWLINE ::: 5703
NAME ( NAME ( NAME [ ::: 5700
. NAME NEWLINE DEDENT NAME = ::: 5699
, NAME NEWLINE DEDENT def NAME ::: 5697
( STRING , { STRING : ::: 5693
} NEWLINE DEDENT def NAME ( ::: 5692
INDENT if not NAME ( NAME ::: 5690
NAME = NAME NEWLINE def NAME ::: 5676
NAME ( ) , NAME ) ::: 5676
NEWLINE DEDENT if not NAME . ::: 5673
NEWLINE INDENT raise NAME NEWLINE DEDENT ::: 5671
INDENT if NAME . NAME is ::: 5671
) : NEWLINE INDENT class NAME ::: 5668
[ NUMBER , NUMBER ] , ::: 5662
NAME ( ) NEWLINE DEDENT return ::: 5661
( [ NUMBER , NUMBER , ::: 5660
( NAME , ( NAME , ::: 5656
. NAME ( ) NEWLINE assert ::: 5656
INDENT STRING NEWLINE if NAME ( ::: 5656
NEWLINE INDENT return STRING % ( ::: 5653
NAME not in NAME : NEWLINE ::: 5652
. NAME import ( NAME , ::: 5648
NAME , NAME ) in NAME ::: 5644
] . NAME ( ) NEWLINE ::: 5641
. NAME [ STRING ] [ ::: 5639
) NEWLINE DEDENT try : NEWLINE ::: 5635
. NAME ( STRING , { ::: 5633
NAME NEWLINE import NAME as NAME ::: 5628
STRING : [ STRING , STRING ::: 5608
NAME ( NUMBER ) , NAME ::: 5604
, NAME ) NEWLINE DEDENT return ::: 5604
= STRING , NAME = None ::: 5602
. NAME , NAME ( NAME ::: 5599
import NAME . NAME . NAME ::: 5586
( NAME ) > NUMBER : ::: 5583
NAME in NAME ( NUMBER ) ::: 5580
NAME ( NAME ) == NAME ::: 5575
= [ NAME for NAME in ::: 5571
, NUMBER ] ) NEWLINE NAME ::: 5570
, NAME [ STRING ] , ::: 5569
) , STRING ) NEWLINE DEDENT ::: 5568
assert NAME . NAME ( NAME ::: 5566
NEWLINE INDENT NAME = ( NAME ::: 5565
NAME : NEWLINE INDENT def NAME ::: 5560
[ STRING ] , NAME . ::: 5556
, NAME = NAME [ STRING ::: 5551
. NAME , STRING , STRING ::: 5544
INDENT return STRING % ( NAME ::: 5539
. NAME ( [ NUMBER , ::: 5534
return STRING . NAME ( NAME ::: 5533
NAME ( STRING , NAME [ ::: 5532
STRING , NAME = { STRING ::: 5526
NAME = NAME . NAME + ::: 5513
@ NAME ( STRING ) NEWLINE ::: 5509
STRING , NAME = [ STRING ::: 5507
) NEWLINE NAME [ NAME ] ::: 5506
NAME ) : NEWLINE INDENT assert ::: 5496
[ NAME ] = NAME . ::: 5495
NEWLINE INDENT STRING NEWLINE pass NEWLINE ::: 5495
: NEWLINE INDENT STRING NEWLINE pass ::: 5495
: NEWLINE INDENT STRING NEWLINE for ::: 5492
INDENT STRING NEWLINE pass NEWLINE DEDENT ::: 5487
NUMBER , STRING : NUMBER } ::: 5486
] NEWLINE DEDENT NAME = NAME ::: 5484
NAME not in NAME . NAME ::: 5481
DEDENT if NAME is None : ::: 5477
) , NAME ( STRING ) ::: 5476
NEWLINE return NAME ( NAME . ::: 5476
STRING ) NEWLINE for NAME in ::: 5474
] NEWLINE NAME = STRING NEWLINE ::: 5471
STRING : None , STRING : ::: 5467
NUMBER , - NUMBER , - ::: 5467
NAME ( NAME ) ) : ::: 5466
( NAME ) ) : NEWLINE ::: 5464
NAME = NAME ) ) NEWLINE ::: 5461
INDENT from NAME import NAME NEWLINE ::: 5460
) : NEWLINE INDENT @ NAME ::: 5457
, NAME ) NEWLINE DEDENT @ ::: 5451
) NEWLINE DEDENT NAME ( NAME ::: 5448
[ STRING ] ) ) NEWLINE ::: 5447
( NAME , NAME , * ::: 5445
NAME ( NAME = False ) ::: 5444
DEDENT NAME = [ ] NEWLINE ::: 5440
} NEWLINE for NAME in NAME ::: 5434
, NAME . NAME [ NUMBER ::: 5432
import * NEWLINE def NAME ( ::: 5431
NAME in NAME [ STRING ] ::: 5429
False ) : NEWLINE INDENT NAME ::: 5425
NAME = STRING NEWLINE DEDENT NAME ::: 5425
. NAME , NAME = True ::: 5424
STRING ) NEWLINE NAME = STRING ::: 5424
NAME . NAME NEWLINE import NAME ::: 5424
NAME ( [ NAME , NAME ::: 5424
NAME import * NEWLINE def NAME ::: 5419
NEWLINE NAME = STRING % ( ::: 5417
raise NAME ( STRING % ( ::: 5410
NEWLINE INDENT STRING NEWLINE for NAME ::: 5400
NAME : NEWLINE INDENT continue NEWLINE ::: 5399
, [ STRING , STRING ] ::: 5397
NAME ) ) NEWLINE DEDENT return ::: 5386
, NAME = STRING ) ) ::: 5385
NAME = STRING % NAME NEWLINE ::: 5385
) NEWLINE DEDENT elif NAME ( ::: 5378
) ) ) NEWLINE NAME = ::: 5375
NAME ( STRING ) [ NUMBER ::: 5370
NAME , NAME , STRING ) ::: 5369
for NAME in NAME ] ) ::: 5363
) NEWLINE NAME = NAME NEWLINE ::: 5352
NEWLINE INDENT NAME = NAME + ::: 5351
INDENT STRING NEWLINE if NAME is ::: 5350
, NAME ) ) : NEWLINE ::: 5342
, NUMBER ) , NAME ( ::: 5335
NAME [ STRING ] [ NUMBER ::: 5332
NEWLINE DEDENT if NAME is not ::: 5332
DEDENT if NAME ( NAME ) ::: 5330
NAME ) ) NEWLINE DEDENT if ::: 5321
STRING , STRING , NAME . ::: 5319
return STRING % ( NAME . ::: 5316
NEWLINE DEDENT except NAME , NAME ::: 5313
[ ] NEWLINE NAME = [ ::: 5303
, NUMBER ) , NAME = ::: 5303
else : NEWLINE INDENT NAME ( ::: 5303
( STRING ) , NAME . ::: 5300
) NEWLINE from NAME . NAME ::: 5299
NEWLINE INDENT if not NAME : ::: 5298
( STRING ) , NAME ( ::: 5296
INDENT NAME = STRING . NAME ::: 5295
NEWLINE INDENT NAME = STRING . ::: 5295
= NAME ) : NEWLINE INDENT ::: 5293
NAME = NAME ) : NEWLINE ::: 5292
) ) NEWLINE DEDENT @ NAME ::: 5286
NAME ( ) NEWLINE assert NAME ::: 5286
, NAME : NEWLINE INDENT NAME ::: 5283
[ NAME . NAME , NAME ::: 5278
NAME in NAME . NAME ] ::: 5276
) NEWLINE DEDENT if NAME is ::: 5275
. NAME NEWLINE DEDENT if NAME ::: 5273
] = NAME NEWLINE NAME [ ::: 5272
* NEWLINE def NAME ( NAME ::: 5272
( ) NEWLINE NAME = [ ::: 5261
. NAME import * NEWLINE def ::: 5258
. NAME ) NEWLINE DEDENT @ ::: 5252
NAME = [ NUMBER , NUMBER ::: 5251
NAME ) NEWLINE assert NAME . ::: 5244
NUMBER , NUMBER , - NUMBER ::: 5234
NAME , NAME NEWLINE class NAME ::: 5228
, NUMBER ) NEWLINE NAME ( ::: 5226
INDENT NAME = STRING % ( ::: 5224
NAME . NAME ( ( NUMBER ::: 5224
INDENT return NAME . NAME [ ::: 5223
except NAME : NEWLINE INDENT raise ::: 5218
: NEWLINE INDENT NAME STRING NEWLINE ::: 5217
) , NUMBER ) NEWLINE DEDENT ::: 5207
DEDENT def NAME ( NAME = ::: 5204
, NAME in NAME : NEWLINE ::: 5194
NAME ) NEWLINE DEDENT DEDENT else ::: 5190
, None ) NEWLINE NAME . ::: 5186
NAME = lambda NAME : NAME ::: 5185
STRING ] ) NEWLINE DEDENT def ::: 5183
NAME ( NAME , NUMBER , ::: 5182
( STRING , NUMBER ) , ::: 5178
NAME , NAME = NAME [ ::: 5176
, NUMBER ) : NEWLINE INDENT ::: 5175
: NEWLINE INDENT with NAME ( ::: 5174
except NAME : NEWLINE INDENT return ::: 5173
NAME ) NEWLINE assert NAME ( ::: 5172
NAME , NAME in NAME : ::: 5172
) NEWLINE NAME = ( STRING ::: 5169
DEDENT return NAME ( NAME , ::: 5166
NAME = NAME ( [ NAME ::: 5160
NUMBER , - NUMBER , NUMBER ::: 5156
NEWLINE NAME = NAME NEWLINE DEDENT ::: 5155
return NAME . NAME [ NAME ::: 5154
DEDENT class NAME ( NAME , ::: 5152
NEWLINE assert NAME ( NAME ) ::: 5152
DEDENT if NAME . NAME is ::: 5151
, NAME ( NAME , NAME ::: 5151
NAME , NAME . NAME [ ::: 5151
NEWLINE INDENT NAME ( STRING % ::: 5145
STRING , STRING : NUMBER , ::: 5143
[ STRING ] = NAME [ ::: 5143
else : NEWLINE INDENT NAME [ ::: 5141
, [ STRING ] ) NEWLINE ::: 5138
NAME . NAME ( ( STRING ::: 5134
NUMBER ) : NEWLINE INDENT STRING ::: 5133
STRING ) ) NEWLINE DEDENT def ::: 5131
if NAME == NAME . NAME ::: 5129
. NAME = True NEWLINE DEDENT ::: 5121
NAME , NAME = NAME NEWLINE ::: 5120
( NAME ) NEWLINE assert NAME ::: 5116
NAME in ( STRING , STRING ::: 5114
INDENT if not NAME : NEWLINE ::: 5109
, STRING ) , STRING : ::: 5106
NAME ) : NEWLINE INDENT @ ::: 5105
NEWLINE DEDENT @ NAME ( NAME ::: 5104
NAME ( ) NEWLINE try : ::: 5103
. NAME ( ) , NUMBER ::: 5096
None : NEWLINE INDENT return NAME ::: 5095
DEDENT NAME ( NAME , NAME ::: 5095
None ) NEWLINE NAME = NAME ::: 5094
STRING % NAME . NAME ( ::: 5090
) ) NEWLINE for NAME in ::: 5090
( ) ) NEWLINE DEDENT DEDENT ::: 5087
. NAME ( ( NUMBER , ::: 5086
) NEWLINE DEDENT DEDENT elif NAME ::: 5084
STRING ] . NAME ( NAME ::: 5081
NEWLINE import NAME . NAME . ::: 5081
( ) NEWLINE try : NEWLINE ::: 5079
import NAME . NAME as NAME ::: 5079
INDENT NAME . NAME = STRING ::: 5078
if NAME : NEWLINE INDENT if ::: 5077
[ NAME . NAME ] = ::: 5076
INDENT pass NEWLINE DEDENT class NAME ::: 5075
NEWLINE INDENT pass NEWLINE DEDENT class ::: 5075
, ( STRING , NAME ( ::: 5071
NEWLINE INDENT if NAME == STRING ::: 5065
) ) NEWLINE DEDENT DEDENT class ::: 5064
) NEWLINE NAME = STRING % ::: 5057
NEWLINE DEDENT NAME ( NAME , ::: 5047
NEWLINE NAME . NAME ( { ::: 5042
NEWLINE assert NAME . NAME . ::: 5040
: NEWLINE INDENT return NAME [ ::: 5039
NAME ) : NEWLINE INDENT from ::: 5038
DEDENT NAME = { STRING : ::: 5034
[ NAME ] [ STRING ] ::: 5033
in NAME . NAME ( STRING ::: 5033
STRING ) NEWLINE DEDENT @ NAME ::: 5032
, NAME NEWLINE class NAME ( ::: 5031
DEDENT DEDENT if NAME : NEWLINE ::: 5027
False NEWLINE DEDENT def NAME ( ::: 5025
STRING ] . NAME ( ) ::: 5022
== NUMBER : NEWLINE INDENT return ::: 5020
NAME ] . NAME ( NAME ::: 5016
( ) NEWLINE DEDENT DEDENT DEDENT ::: 5015
NAME NEWLINE DEDENT if NAME . ::: 5011
INDENT from NAME . NAME import ::: 5009
not NAME . NAME ( ) ::: 5008
NAME [ NAME ] [ NAME ::: 5004
, NAME , * NAME , ::: 5000
NAME ) ) ) NEWLINE NAME ::: 4999
, NAME . NAME ( NUMBER ::: 4996
NEWLINE DEDENT if NAME is None ::: 4994
NAME , NAME NEWLINE DEDENT def ::: 4993
( STRING ) [ NUMBER ] ::: 4993
STRING ) : NEWLINE INDENT return ::: 4992
) for NAME in NAME ( ::: 4987
None : NEWLINE INDENT raise NAME ::: 4985
assert NAME ( NAME , NAME ::: 4984
try : NEWLINE INDENT from NAME ::: 4984
NAME ) ) NEWLINE return NAME ::: 4983
= NUMBER NEWLINE for NAME in ::: 4982
( NUMBER ) : NEWLINE INDENT ::: 4981
. NAME . NAME ( ( ::: 4980
INDENT NAME = NUMBER NEWLINE DEDENT ::: 4967
INDENT NAME . NAME ( ( ::: 4964
NEWLINE return NAME ( NAME ) ::: 4962
and NAME . NAME . NAME ::: 4962
[ ( STRING , STRING ) ::: 4960
. NAME + NAME . NAME ::: 4958
DEDENT elif NAME . NAME ( ::: 4957
NAME , NAME ) ) : ::: 4956
NEWLINE DEDENT NAME = NAME NEWLINE ::: 4952
= False , NAME = STRING ::: 4948
NAME ( NUMBER ) : NEWLINE ::: 4945
NAME ) : NEWLINE INDENT class ::: 4943
= False ) NEWLINE NAME = ::: 4940
NAME ) = NAME . NAME ::: 4933
( ) ) : NEWLINE INDENT ::: 4933
( NAME ) NEWLINE NAME [ ::: 4929
) NEWLINE DEDENT NAME = [ ::: 4925
) , NAME ( NAME . ::: 4925
return NEWLINE DEDENT NAME = NAME ::: 4925
( ) , NAME = NAME ::: 4922
NEWLINE INDENT pass NEWLINE DEDENT NAME ::: 4922
[ NAME ] [ NAME ] ::: 4921
NAME . NAME + NAME . ::: 4917
, NAME , NAME ( NAME ::: 4915
NAME in NAME ( NAME , ::: 4911
( NAME , NAME ) for ::: 4909
STRING : False , STRING : ::: 4907
] , NAME . NAME ) ::: 4902
= STRING % ( NAME . ::: 4897
} NEWLINE def NAME ( NAME ::: 4895
= [ ( STRING , STRING ::: 4895
) , NAME = True ) ::: 4895
DEDENT DEDENT if NAME . NAME ::: 4893
] ) ) NEWLINE NAME . ::: 4891
NUMBER NEWLINE DEDENT else : NEWLINE ::: 4890
] NEWLINE NAME = [ STRING ::: 4886
, STRING , STRING , ] ::: 4885
{ } NEWLINE for NAME in ::: 4881
, NAME [ NUMBER ] , ::: 4878
NAME . NAME ) , STRING ::: 4876
, STRING ] , NAME = ::: 4875
raise NAME . NAME ( NAME ::: 4873
STRING ] [ STRING ] [ ::: 4871
not NAME : NEWLINE INDENT raise ::: 4871
assert NAME ( NAME ) == ::: 4865
NAME ( ) , STRING ) ::: 4864
[ NUMBER ] , NAME . ::: 4863
NAME ( lambda NAME : NAME ::: 4860
NAME = [ NAME ] NEWLINE ::: 4857
) . NAME ( ) , ::: 4857
} ) NEWLINE DEDENT def NAME ::: 4852
DEDENT if NAME . NAME . ::: 4850
NAME < NUMBER : NEWLINE INDENT ::: 4848
STRING . NAME ( NAME ( ::: 4846
, NAME , STRING , NAME ::: 4845
= None , NAME = STRING ::: 4845
. NAME = NAME NEWLINE if ::: 4843
STRING } , STRING : { ::: 4842
] = NAME . NAME . ::: 4832
. NAME ) , NAME . ::: 4821
NAME , STRING , NAME . ::: 4817
{ STRING : NAME } ) ::: 4817
( ) NEWLINE DEDENT return NAME ::: 4815
NEWLINE assert NAME ( NAME , ::: 4815
NEWLINE DEDENT if STRING in NAME ::: 4813
STRING ] NEWLINE NAME = [ ::: 4808
= STRING NEWLINE DEDENT else : ::: 4803
NAME ( NAME ) + STRING ::: 4802
NAME ) ) NEWLINE NAME ( ::: 4799
. NAME ( NUMBER ) , ::: 4798
( ) NEWLINE DEDENT @ NAME ::: 4791
NAME . NAME ( ** NAME ::: 4784
= STRING ) , NAME = ::: 4778
) ) NEWLINE DEDENT DEDENT NAME ::: 4777
NAME ( ) , NUMBER ) ::: 4772
% ( NAME . NAME . ::: 4771
NAME != STRING : NEWLINE INDENT ::: 4770
STRING NEWLINE NAME = NAME NEWLINE ::: 4767
INDENT NAME . NAME = None ::: 4766
] NEWLINE for NAME , NAME ::: 4766
NAME ) NEWLINE DEDENT for NAME ::: 4765
INDENT from NAME . NAME . ::: 4764
NAME ( ) NEWLINE DEDENT @ ::: 4763
, STRING : NAME } NEWLINE ::: 4763
INDENT NAME . NAME [ STRING ::: 4761
, NAME ) = NAME . ::: 4746
] ) : NEWLINE INDENT NAME ::: 4745
% ( NAME , NAME . ::: 4744
. NAME == NUMBER : NEWLINE ::: 4739
STRING , STRING ) , STRING ::: 4737
, STRING ) ) NEWLINE DEDENT ::: 4736
NAME : NEWLINE INDENT NAME STRING ::: 4735
) NEWLINE NAME = STRING . ::: 4735
NUMBER ) , NAME ( NUMBER ::: 4733
NAME ) NEWLINE class NAME ( ::: 4733
for NAME in NAME if NAME ::: 4730
, ( NAME . NAME , ::: 4728
NAME ) NEWLINE if NAME == ::: 4728
NAME is not None and NAME ::: 4718
NAME . NAME ) , ( ::: 4717
NAME . NAME == NUMBER : ::: 4717
if STRING in NAME . NAME ::: 4716
) ) ) NEWLINE DEDENT DEDENT ::: 4711
STRING , None ) NEWLINE NAME ::: 4703
NAME ( STRING ) NEWLINE assert ::: 4703
NEWLINE INDENT NAME = ( STRING ::: 4701
NAME = NAME ( NUMBER ) ::: 4701
, NAME ) for NAME in ::: 4699
( NAME , NAME ) in ::: 4697
NAME in NAME ] NEWLINE NAME ::: 4697
NAME . NAME ] NEWLINE DEDENT ::: 4697
not in NAME . NAME : ::: 4696
STRING ) NEWLINE DEDENT return NAME ::: 4688
. NAME . NAME ( [ ::: 4679
NUMBER : NEWLINE INDENT return NAME ::: 4673
] , NAME = NAME . ::: 4672
. NAME ) , NAME = ::: 4671
. NAME != NAME . NAME ::: 4669
NEWLINE if STRING in NAME : ::: 4663
, [ NUMBER , NUMBER ] ::: 4662
NAME [ NUMBER ] [ STRING ::: 4659
] NEWLINE DEDENT except NAME : ::: 4658
[ NAME ] = NAME ( ::: 4651
= NAME ) NEWLINE if NAME ::: 4648
) NEWLINE if NAME == STRING ::: 4647
= NAME ( NAME [ NUMBER ::: 4645
( NAME ( ) ) NEWLINE ::: 4643
NAME ( NAME ( NAME = ::: 4643
STRING : STRING } , { ::: 4641
. NAME ( NAME + STRING ::: 4641
[ NUMBER ] . NAME , ::: 4638
NEWLINE import NAME . NAME as ::: 4638
, ) NEWLINE NAME = NAME ::: 4637
) for NAME , NAME in ::: 4633
[ NAME ] NEWLINE DEDENT DEDENT ::: 4631
STRING ) , STRING : NAME ::: 4630
} NEWLINE NAME = { STRING ::: 4628
) ) NEWLINE DEDENT except NAME ::: 4627
in NAME ( NAME , NAME ::: 4627
) ) NEWLINE return NAME NEWLINE ::: 4627
NAME , NAME . NAME ] ::: 4621
= NAME , NAME = NUMBER ::: 4618
NAME NEWLINE if NAME : NEWLINE ::: 4617
NAME ( NAME ) ] NEWLINE ::: 4616
( STRING , STRING ) : ::: 4615
+ NAME ( NAME . NAME ::: 4611
STRING % NAME . NAME NEWLINE ::: 4611
) ] NEWLINE NAME . NAME ::: 4611
= False ) NEWLINE NAME . ::: 4610
NAME . NAME import ( NAME ::: 4609
NAME = { STRING : [ ::: 4607
, ) NEWLINE NAME . NAME ::: 4605
NUMBER , STRING : STRING , ::: 4605
, NAME NEWLINE import NAME NEWLINE ::: 4603
, NAME = NAME ) : ::: 4602
STRING } , { STRING : ::: 4601
INDENT if NAME == STRING : ::: 4600
, NAME ( NUMBER , NUMBER ::: 4600
) ) . NAME ( ) ::: 4600
. NAME ( ) ) : ::: 4600
STRING , NAME ( NAME ) ::: 4600
( NAME , STRING ) as ::: 4599
NAME = None NEWLINE if NAME ::: 4597
[ NAME . NAME ] ) ::: 4596
= NAME [ STRING ] [ ::: 4592
NEWLINE DEDENT @ NAME ( STRING ::: 4591
NAME ] = NAME ( NAME ::: 4587
NAME ( NAME ) ) , ::: 4585
NEWLINE INDENT STRING NEWLINE NAME , ::: 4579
( NAME . NAME , [ ::: 4574
. NAME = NUMBER NEWLINE DEDENT ::: 4573
: STRING } , { STRING ::: 4572
NAME . NAME != NAME . ::: 4570
: STRING , STRING : [ ::: 4569
import NAME NEWLINE NAME = STRING ::: 4566
NAME ) , STRING ) NEWLINE ::: 4562
NUMBER , NAME ( NAME ) ::: 4562
DEDENT DEDENT except NAME : NEWLINE ::: 4561
: STRING , STRING : { ::: 4558
STRING ) ) , ( STRING ::: 4558
, NAME = NAME ( ) ::: 4557
raise NAME ( NAME ) NEWLINE ::: 4556
] [ STRING ] [ STRING ::: 4552
NAME . NAME . NAME ] ::: 4551
INDENT STRING NEWLINE NAME , NAME ::: 4549
] , NAME ) NEWLINE NAME ::: 4546
NAME = False ) NEWLINE DEDENT ::: 4546
raise NAME ( ) NEWLINE DEDENT ::: 4545
NAME ( ) NEWLINE if not ::: 4541
NAME , NAME ( NAME . ::: 4538
NAME , NAME , NAME ( ::: 4534
NAME = ( NAME , NAME ::: 4533
NAME , NAME ] ) NEWLINE ::: 4532
NAME [ NUMBER ] ) ) ::: 4530
] ) NEWLINE DEDENT else : ::: 4529
( NUMBER , NUMBER ) : ::: 4527
INDENT NAME . NAME = NUMBER ::: 4522
] NEWLINE DEDENT NAME . NAME ::: 4521
) NEWLINE DEDENT finally : NEWLINE ::: 4521
) NEWLINE NAME = { } ::: 4514
. NAME ( ( STRING , ::: 4512
( ) NEWLINE return NAME NEWLINE ::: 4511
( ) , NUMBER ) NEWLINE ::: 4509
for NAME in NAME [ STRING ::: 4509
import NAME NEWLINE DEDENT except NAME ::: 4508
, None ) NEWLINE NAME = ::: 4503
DEDENT for NAME , NAME in ::: 4502
( ) , NAME ) NEWLINE ::: 4501
] , STRING : [ STRING ::: 4499
, NAME . NAME , NUMBER ::: 4499
DEDENT DEDENT DEDENT DEDENT def NAME ::: 4497
NAME [ STRING ] == STRING ::: 4497
NAME ) , NAME , NAME ::: 4492
: STRING } NEWLINE NAME = ::: 4491
NEWLINE NAME = [ NAME ( ::: 4490
DEDENT NAME , NAME = NAME ::: 4488
: NEWLINE INDENT class NAME ( ::: 4486
STRING ) , STRING ) NEWLINE ::: 4478
INDENT NAME . NAME = [ ::: 4478
. NAME [ NAME ] [ ::: 4476
( ) NEWLINE if NAME : ::: 4474
NAME . NAME == NUMBER NEWLINE ::: 4470
import NAME , NAME NEWLINE NAME ::: 4468
NEWLINE INDENT class NAME ( NAME ::: 4465
] , NAME . NAME [ ::: 4460
NAME NEWLINE from . . NAME ::: 4459
NAME = [ STRING ] ) ::: 4456
) : NEWLINE INDENT NAME += ::: 4456
) ) NEWLINE def NAME ( ::: 4454
None : NEWLINE INDENT NAME [ ::: 4450
NEWLINE DEDENT NAME = [ ] ::: 4447
= NAME ( NUMBER , NUMBER ::: 4446
( NAME ) NEWLINE DEDENT @ ::: 4446
NAME import * NEWLINE from NAME ::: 4443
: NEWLINE INDENT assert NAME ( ::: 4442
= NAME [ STRING ] , ::: 4442
False NEWLINE NAME . NAME = ::: 4441
: NEWLINE INDENT NAME += NUMBER ::: 4433
( NAME , NAME ) = ::: 4433
NAME . NAME ] = NAME ::: 4432
] = NAME NEWLINE NAME . ::: 4432
( ) NEWLINE if not NAME ::: 4430
NAME , NAME , STRING , ::: 4419
if NAME == NAME : NEWLINE ::: 4417
STRING ) : NEWLINE INDENT STRING ::: 4411
return NEWLINE DEDENT NAME . NAME ::: 4408
STRING % ( NAME ( NAME ::: 4407
** NAME ) NEWLINE DEDENT DEDENT ::: 4405
) , NAME ( NUMBER , ::: 4404
( ( NUMBER , NUMBER ) ::: 4402
[ NAME . NAME for NAME ::: 4400
( ) NEWLINE NAME = STRING ::: 4398
[ STRING ] , NAME ) ::: 4398
NAME ) NEWLINE NAME = ( ::: 4397
STRING , STRING , NAME ) ::: 4395
STRING NEWLINE if NAME is None ::: 4393
NAME = STRING NEWLINE DEDENT else ::: 4393
( STRING STRING ) NEWLINE DEDENT ::: 4390
, NAME = ( NUMBER , ::: 4387
INDENT NAME = STRING % NAME ::: 4386
NAME NEWLINE NAME = NUMBER NEWLINE ::: 4386
) : NEWLINE INDENT return ( ::: 4385
) NEWLINE NAME = [ STRING ::: 4382
not NAME . NAME ( STRING ::: 4381
% NAME ) NEWLINE DEDENT DEDENT ::: 4381
NAME = STRING ) ) NEWLINE ::: 4381
) NEWLINE DEDENT DEDENT DEDENT NAME ::: 4379
. NAME ( ( NAME . ::: 4377
NAME , NAME [ NUMBER ] ::: 4375
try : NEWLINE INDENT import NAME ::: 4375
( ) NEWLINE DEDENT DEDENT class ::: 4373
NAME = NAME ) . NAME ::: 4372
NAME ( STRING , NUMBER , ::: 4371
NAME . NAME ( ) + ::: 4371
NAME != NAME : NEWLINE INDENT ::: 4370
) NEWLINE DEDENT DEDENT except NAME ::: 4370
= False , NAME = True ::: 4369
STRING ) NEWLINE @ NAME . ::: 4367
NUMBER ] == STRING : NEWLINE ::: 4366
. NAME import NAME NEWLINE def ::: 4366
NAME != NAME . NAME : ::: 4361
) NEWLINE NAME , NAME , ::: 4360
NAME ( STRING , { STRING ::: 4354
) ] NEWLINE NAME = NAME ::: 4352
NEWLINE DEDENT if not NAME : ::: 4351
NEWLINE INDENT NAME += NUMBER NEWLINE ::: 4351
class NAME : NEWLINE INDENT def ::: 4345
, NAME NEWLINE NAME = NAME ::: 4344
( ) , STRING ) NEWLINE ::: 4343
, STRING : None , STRING ::: 4343
, NAME . NAME [ STRING ::: 4340
. NAME NEWLINE if NAME . ::: 4338
NEWLINE NAME = [ ( STRING ::: 4337
DEDENT DEDENT NAME . NAME = ::: 4336
] = NAME [ STRING ] ::: 4332
STRING , NAME = None , ::: 4329
( NAME ( STRING , NAME ::: 4329
STRING ) NEWLINE if NAME . ::: 4328
NUMBER , NAME = STRING , ::: 4328
NEWLINE DEDENT NAME , NAME = ::: 4325
) , NAME = STRING , ::: 4325
( [ STRING , STRING ] ::: 4321
== STRING : NEWLINE INDENT if ::: 4320
] ) NEWLINE NAME ( NAME ::: 4319
) , NAME = NAME , ::: 4319
( NAME [ NUMBER ] . ::: 4317
+ STRING + NAME ( NAME ::: 4316
+ NAME . NAME ( NAME ::: 4316
INDENT STRING NEWLINE for NAME in ::: 4315
NEWLINE NAME [ STRING ] [ ::: 4312
NAME . NAME : STRING , ::: 4312
( NUMBER ) ) NEWLINE NAME ::: 4311
= NAME ( NAME = NUMBER ::: 4307
NUMBER , NUMBER ) : NEWLINE ::: 4306
NAME = STRING NEWLINE if NAME ::: 4305
NAME ( NAME ) : return ::: 4302
. NAME ) NEWLINE for NAME ::: 4301
NAME = None , ** NAME ::: 4301
: ( STRING , STRING ) ::: 4299
} NEWLINE NAME = NAME ( ::: 4298
NEWLINE NAME ( NAME , STRING ::: 4296
= None , ** NAME ) ::: 4296
DEDENT DEDENT for NAME in NAME ::: 4292
NAME . NAME ) NEWLINE for ::: 4288
) ) NEWLINE DEDENT elif NAME ::: 4286
: NEWLINE INDENT if STRING in ::: 4282
) ) ) NEWLINE DEDENT def ::: 4279
: NEWLINE INDENT if ( NAME ::: 4277
STRING : NEWLINE INDENT return NAME ::: 4276
DEDENT DEDENT @ NAME . NAME ::: 4276
NEWLINE INDENT if STRING in NAME ::: 4272
NUMBER , NAME = True ) ::: 4270
) : NEWLINE INDENT return [ ::: 4263
, NAME ) NEWLINE DEDENT elif ::: 4260
) NEWLINE DEDENT DEDENT DEDENT EOS ::: 4259
. NAME ( ) NEWLINE try ::: 4257
, STRING ] : NEWLINE INDENT ::: 4256
return NAME ( NAME ( NAME ::: 4256
None , ** NAME ) : ::: 4256
] [ STRING ] ) NEWLINE ::: 4256
NAME ( ) ) : NEWLINE ::: 4254
. NAME ) NEWLINE DEDENT except ::: 4253
from NAME import NAME as NAME ::: 4251
if NAME not in NAME : ::: 4246
STRING NEWLINE DEDENT NAME = NAME ::: 4242
= ( NUMBER , NUMBER ) ::: 4241
. NAME or NAME . NAME ::: 4239
STRING , NUMBER ) , ( ::: 4238
STRING ) : NEWLINE INDENT if ::: 4236
) NEWLINE return NEWLINE DEDENT NAME ::: 4236
[ { STRING : STRING , ::: 4234
NAME [ NUMBER ] == STRING ::: 4234
NEWLINE NAME = - NUMBER NEWLINE ::: 4233
in NAME ( NUMBER , NAME ::: 4232
NEWLINE from . . NAME import ::: 4232
STRING NEWLINE class NAME ( NAME ::: 4230
NEWLINE if NAME ( NAME . ::: 4230
. NAME ( ) ] NEWLINE ::: 4228
NAME for NAME in NAME if ::: 4228
NAME NEWLINE assert NAME . NAME ::: 4222
INDENT NAME . NAME = True ::: 4221
== NAME . NAME . NAME ::: 4218
= NAME NEWLINE NAME [ STRING ::: 4216
NEWLINE DEDENT NAME = { STRING ::: 4215
if NAME . NAME and NAME ::: 4214
NAME . NAME or NAME . ::: 4211
= STRING NEWLINE NAME = { ::: 4204
return NAME NEWLINE DEDENT DEDENT def ::: 4201
[ NAME ( NAME ) for ::: 4199
) ) NEWLINE if NAME . ::: 4199
) , NAME ( NAME = ::: 4197
in ( STRING , STRING ) ::: 4194
, NAME = None , ** ::: 4193
= NAME ( NAME [ STRING ::: 4192
NAME . NAME , NUMBER , ::: 4185
( NAME . NAME ) == ::: 4185
try : NEWLINE INDENT NAME ( ::: 4182
STRING , STRING ] : NEWLINE ::: 4180
NEWLINE INDENT if NAME == NAME ::: 4176
NAME , NAME , NAME in ::: 4174
for NAME , NAME , NAME ::: 4173
NAME ) NEWLINE DEDENT class NAME ::: 4173
) NEWLINE NAME ( ) NEWLINE ::: 4169
: NEWLINE INDENT STRING NEWLINE raise ::: 4167
STRING , NAME = False ) ::: 4166
) NEWLINE DEDENT except NAME , ::: 4166
NAME [ : - NUMBER ] ::: 4165
. NAME = STRING NEWLINE DEDENT ::: 4164
NAME += NAME . NAME ( ::: 4164
, None ) NEWLINE if NAME ::: 4161
. NAME , NAME ) : ::: 4159
NEWLINE INDENT STRING NEWLINE raise NAME ::: 4155
DEDENT except ( NAME , NAME ::: 4152
NAME . NAME += NUMBER NEWLINE ::: 4150
STRING NEWLINE NAME = None NEWLINE ::: 4149
: NEWLINE INDENT return NUMBER NEWLINE ::: 4142
!= STRING : NEWLINE INDENT NAME ::: 4137
) . NAME ( ) . ::: 4134
NAME = NAME ) NEWLINE return ::: 4133
NAME = { } NEWLINE DEDENT ::: 4133
NUMBER ) , NAME . NAME ::: 4132
[ NUMBER ] , NAME ) ::: 4131
NEWLINE INDENT return NUMBER NEWLINE DEDENT ::: 4130
= NAME ( STRING ) ) ::: 4129
STRING % NAME ( NAME ) ::: 4126
: NEWLINE INDENT if NAME not ::: 4125
NEWLINE INDENT if NAME not in ::: 4125
STRING in NAME . NAME : ::: 4122
= { STRING : NAME } ::: 4120
. NAME ( NAME = [ ::: 4117
NAME , NAME NEWLINE from . ::: 4114
. NAME . NAME [ NAME ::: 4112
DEDENT NAME [ STRING ] = ::: 4112
, STRING ) NEWLINE DEDENT NAME ::: 4109
return True NEWLINE DEDENT def NAME ::: 4106
NEWLINE DEDENT NAME [ STRING ] ::: 4104
: STRING , NAME . NAME ::: 4104
. NAME ( NAME ( NUMBER ::: 4104
= NAME , NAME = True ::: 4103
, NAME = NAME ) ) ::: 4103
NAME = { STRING : NUMBER ::: 4101
NUMBER NEWLINE def NAME ( NAME ::: 4099
NEWLINE NAME = STRING % NAME ::: 4097
( NAME ) , STRING ) ::: 4095
NAME [ NAME ] [ STRING ::: 4093
import NAME as NAME NEWLINE import ::: 4093
as NAME NEWLINE from NAME import ::: 4090
= NAME NEWLINE DEDENT return NAME ::: 4087
. NAME ( [ NAME , ::: 4086
STRING ) NEWLINE DEDENT DEDENT class ::: 4085
INDENT STRING NEWLINE NAME ( NAME ::: 4084
NAME ( NAME ( NUMBER , ::: 4084
= - NUMBER NEWLINE NAME = ::: 4074
NEWLINE NAME = ( NAME . ::: 4073
( STRING ) NEWLINE DEDENT else ::: 4073
, STRING : True , STRING ::: 4071
( { STRING : STRING , ::: 4067
with NAME ( NAME , STRING ::: 4064
import NAME NEWLINE try : NEWLINE ::: 4059
NAME [ NUMBER ] , STRING ::: 4057
NAME . NAME ( None , ::: 4051
( STRING ) , STRING : ::: 4050
( NAME , ) ) NEWLINE ::: 4049
NAME = [ ] NEWLINE if ::: 4046
INDENT NAME = True NEWLINE DEDENT ::: 4045
import NAME . NAME NEWLINE import ::: 4044
= NAME NEWLINE DEDENT NAME . ::: 4037
STRING ) NEWLINE DEDENT except NAME ::: 4031
NAME , NAME ( STRING ) ::: 4031
NAME = NAME [ NUMBER : ::: 4030
STRING ] . NAME ( STRING ::: 4029
STRING : [ { STRING : ::: 4025
NAME . NAME ) ) ) ::: 4023
( STRING ) NEWLINE DEDENT return ::: 4023
= NAME ( ) NEWLINE for ::: 4022
assert NAME . NAME == NUMBER ::: 4019
< NUMBER : NEWLINE INDENT NAME ::: 4019
. NAME : STRING , NAME ::: 4019
STRING ] , STRING : [ ::: 4018
STRING ) NEWLINE NAME = [ ::: 4018
, NAME , NAME in NAME ::: 4016
NUMBER , NAME = NAME ) ::: 4016
STRING , STRING : { STRING ::: 4012
STRING : ( STRING , STRING ::: 4010
NUMBER NEWLINE assert NAME . NAME ::: 4005
) NEWLINE NAME = None NEWLINE ::: 4004
( STRING , STRING ) ] ::: 4004
NAME ( STRING , [ STRING ::: 4004
STRING : [ STRING ] , ::: 4003
, STRING : [ STRING ] ::: 4002
STRING , STRING ) . NAME ::: 3999
STRING , NAME , NAME , ::: 3994
from . . NAME import NAME ::: 3993
NAME : STRING , NAME . ::: 3993
NEWLINE DEDENT DEDENT if NAME . ::: 3989
NAME , STRING , None ) ::: 3987
continue NEWLINE DEDENT NAME = NAME ::: 3985
NAME NEWLINE DEDENT DEDENT NAME = ::: 3980
NEWLINE DEDENT DEDENT if NAME : ::: 3980
NEWLINE import NAME NEWLINE class NAME ::: 3979
NAME in [ STRING , STRING ::: 3978
. NAME ( NAME , None ::: 3976
NAME . NAME ) , NUMBER ::: 3976
NEWLINE NAME = NUMBER NEWLINE for ::: 3969
) = NAME . NAME ( ::: 3966
, STRING : [ STRING , ::: 3965
( STRING ) NEWLINE assert NAME ::: 3963
= NAME ( NUMBER ) NEWLINE ::: 3956
NAME ) , STRING : NAME ::: 3955
NAME [ NUMBER ] = NAME ::: 3954
( NUMBER , STRING ) , ::: 3954
, NUMBER , NAME . NAME ::: 3954
NEWLINE if NAME == NUMBER : ::: 3951
NEWLINE NAME = NAME + NAME ::: 3951
= NAME NEWLINE return NAME NEWLINE ::: 3948
NUMBER , NAME . NAME . ::: 3946
def NAME ( NAME = None ::: 3945
, NAME = True ) , ::: 3942
. NAME ( True ) NEWLINE ::: 3941
DEDENT return NAME . NAME NEWLINE ::: 3936
, NAME ) NEWLINE assert NAME ::: 3935
, NAME ) , NAME = ::: 3935
NAME in NAME ] ) NEWLINE ::: 3935
NEWLINE DEDENT DEDENT DEDENT if NAME ::: 3932
. NAME ) , NAME ( ::: 3930
is None : NEWLINE INDENT raise ::: 3928
, STRING ) NEWLINE if NAME ::: 3926
. NAME [ NAME ] ) ::: 3926
, - NUMBER , NUMBER , ::: 3923
NAME ] ) NEWLINE DEDENT DEDENT ::: 3923
NAME ( NAME , None ) ::: 3922
[ NUMBER ] ) ) NEWLINE ::: 3917
NAME ( STRING % NAME ( ::: 3916
] ) NEWLINE def NAME ( ::: 3915
None : NEWLINE INDENT if NAME ::: 3912
) NEWLINE DEDENT NAME = { ::: 3911
) , NAME = False ) ::: 3909
STRING % ( NAME , ) ::: 3906
= NAME NEWLINE DEDENT elif NAME ::: 3904
= NUMBER NEWLINE def NAME ( ::: 3899
NAME ( [ NAME ( NAME ::: 3896
in NAME ( NUMBER ) : ::: 3896
NUMBER : NEWLINE INDENT if NAME ::: 3894
import NAME NEWLINE from . . ::: 3892
. NAME ( NAME ) [ ::: 3890
STRING ) NEWLINE DEDENT DEDENT DEDENT ::: 3890
] , NAME ) NEWLINE DEDENT ::: 3888
. NAME , NAME = NUMBER ::: 3887
] = NAME NEWLINE DEDENT NAME ::: 3876
NEWLINE INDENT return NAME ( STRING ::: 3876
NAME ) NEWLINE NAME = NUMBER ::: 3873
{ STRING : STRING } NEWLINE ::: 3872
NAME = NUMBER NEWLINE def NAME ::: 3871
. NAME ) NEWLINE DEDENT return ::: 3870
, STRING : NAME , } ::: 3865
STRING , { STRING : NAME ::: 3863
. NAME = { STRING : ::: 3861
STRING ] NEWLINE NAME = STRING ::: 3861
) == STRING : NEWLINE INDENT ::: 3860
NAME = [ NAME , NAME ::: 3857
: NAME ( NAME . NAME ::: 3855
NAME . NAME = { STRING ::: 3855
True , NAME = True , ::: 3854
NAME ] = NAME NEWLINE NAME ::: 3852
STRING NEWLINE NAME , NAME = ::: 3851
( NAME [ NAME ] , ::: 3850
, STRING ) , NAME ( ::: 3847
NAME ( ) for NAME in ::: 3846
NAME NEWLINE NAME . NAME [ ::: 3845
) . NAME ( * NAME ::: 3845
. NAME = NAME [ STRING ::: 3843
. NAME ) NEWLINE def NAME ::: 3836
STRING NEWLINE if not NAME . ::: 3836
. NAME = NAME ( STRING ::: 3835
: NEWLINE INDENT return ( NAME ::: 3831
STRING NEWLINE NAME [ STRING ] ::: 3830
= NAME ) . NAME ( ::: 3829
. NAME . NAME ) , ::: 3828
, ( STRING , NUMBER ) ::: 3824
STRING NEWLINE NAME = { } ::: 3824
NAME ( STRING ) NEWLINE for ::: 3824
) NEWLINE with NAME ( NAME ::: 3823
NAME ( ) , STRING : ::: 3823
NAME , STRING . NAME ( ::: 3822
STRING : NAME ( STRING ) ::: 3822
NAME [ NUMBER : ] NEWLINE ::: 3820
NAME . NAME ) NEWLINE def ::: 3820
[ NAME . NAME ( STRING ::: 3819
) NEWLINE NAME = NAME + ::: 3819
[ NUMBER ] NEWLINE if NAME ::: 3817
if NAME ( NAME ) : ::: 3810
( ) for NAME in NAME ::: 3810
. NAME ) , NUMBER ) ::: 3805
. NAME import * NEWLINE from ::: 3804
NAME [ NAME . NAME ( ::: 3804
INDENT return NEWLINE DEDENT NAME = ::: 3803
- NUMBER NEWLINE NAME . NAME ::: 3803
NAME , STRING , NAME , ::: 3799
NAME NEWLINE NAME = [ STRING ::: 3798
STRING : NEWLINE INDENT if NAME ::: 3795
. NAME == NAME : NEWLINE ::: 3793
NEWLINE INDENT NAME ( STRING , ::: 3792
NUMBER , NAME ) NEWLINE NAME ::: 3788
: NEWLINE INDENT return [ NAME ::: 3788
NEWLINE if ( NAME . NAME ::: 3786
. NAME ( NAME ) for ::: 3786
( STRING , NAME = [ ::: 3786
( NUMBER , NAME ) NEWLINE ::: 3779
= True , NAME = False ::: 3778
NAME [ NUMBER : NUMBER ] ::: 3777
( ) [ NUMBER ] NEWLINE ::: 3775
( STRING ) NEWLINE for NAME ::: 3774
import NAME , NAME NEWLINE import ::: 3771
NAME NEWLINE if NAME ( NAME ::: 3771
try : NEWLINE INDENT if NAME ::: 3770
. NAME | NAME . NAME ::: 3770
STRING , NAME [ STRING ] ::: 3765
NAME . NAME | NAME . ::: 3762
[ NAME , NAME ] ) ::: 3762
NAME ] : NEWLINE INDENT NAME ::: 3761
. NAME ( ) == STRING ::: 3761
NAME : NEWLINE INDENT return False ::: 3757
NEWLINE DEDENT DEDENT except NAME : ::: 3755
% NAME . NAME . NAME ::: 3752
( NAME ) : return NAME ::: 3749
INDENT if NAME not in NAME ::: 3745
) : return NAME . NAME ::: 3744
STRING ] , STRING : NAME ::: 3743
NAME NEWLINE DEDENT @ NAME . ::: 3742
% NAME ) NEWLINE DEDENT NAME ::: 3741
= False , NAME = None ::: 3741
: NEWLINE INDENT assert NAME . ::: 3738
NEWLINE INDENT assert NAME . NAME ::: 3738
NAME . NAME NEWLINE DEDENT return ::: 3738
STRING ) NEWLINE assert NAME . ::: 3738
NAME [ STRING ] [ NAME ::: 3738
NAME ( * NAME ) NEWLINE ::: 3734
= STRING % NAME . NAME ::: 3732
NAME . NAME [ - NUMBER ::: 3731
DEDENT @ NAME . NAME . ::: 3725
NUMBER ) , NAME = NAME ::: 3723
STRING ] = NAME [ STRING ::: 3722
STRING ] [ STRING ] = ::: 3719
NAME . NAME NEWLINE assert NAME ::: 3718
NAME = NAME NEWLINE DEDENT if ::: 3717
NAME ) NEWLINE NAME [ NAME ::: 3717
( NAME ( NAME , STRING ::: 3716
) NEWLINE if STRING in NAME ::: 3714
import NAME NEWLINE import NAME as ::: 3713
NAME ( ) , NAME ( ::: 3711
NAME ( NAME ( NUMBER ) ::: 3710
NAME . NAME = - NUMBER ::: 3710
NEWLINE INDENT import NAME NEWLINE NAME ::: 3709
, STRING , NAME , NAME ::: 3707
for ( NAME , NAME ) ::: 3706
NAME ) NEWLINE for NAME , ::: 3700
STRING ] [ STRING ] ) ::: 3698
NEWLINE DEDENT DEDENT DEDENT return NAME ::: 3694
. NAME ( ) for NAME ::: 3691
NEWLINE DEDENT for NAME , NAME ::: 3691
( [ NAME . NAME ( ::: 3690
] NEWLINE if NAME ( NAME ::: 3684
DEDENT for NAME in NAME ( ::: 3683
) NEWLINE DEDENT NAME = STRING ::: 3681
NEWLINE try : NEWLINE INDENT from ::: 3680
, NAME ( ) ) NEWLINE ::: 3675
INDENT NAME = [ STRING , ::: 3674
[ NAME ] [ NUMBER ] ::: 3674
NAME ) : return NAME . ::: 3673
( NAME = False ) NEWLINE ::: 3673
, NAME ) NEWLINE if not ::: 3670
( NAME = NAME ( NAME ::: 3667
NAME . NAME == NAME : ::: 3667
. NAME NEWLINE DEDENT DEDENT class ::: 3667
. NAME = False NEWLINE DEDENT ::: 3666
NEWLINE DEDENT DEDENT DEDENT NAME = ::: 3665
. NAME = - NUMBER NEWLINE ::: 3665
) : NEWLINE INDENT return True ::: 3664
NUMBER ] . NAME ( STRING ::: 3664
NAME ( NAME . NAME + ::: 3662
DEDENT @ NAME ( STRING ) ::: 3659
( STRING , STRING ) . ::: 3658
] , NAME = STRING ) ::: 3658
, NUMBER ) NEWLINE DEDENT DEDENT ::: 3656
NAME = ( STRING , ) ::: 3656
STRING NEWLINE NAME ( NAME , ::: 3654
NUMBER NEWLINE NAME = - NUMBER ::: 3653
[ NAME ] : NEWLINE INDENT ::: 3653
, [ ] , { } ::: 3653
STRING , ) NEWLINE NAME = ::: 3651
NAME = STRING ) NEWLINE def ::: 3649
= STRING ) NEWLINE def NAME ::: 3649
INDENT return False NEWLINE DEDENT DEDENT ::: 3648
return NAME NEWLINE DEDENT return NAME ::: 3648
] NEWLINE NAME [ STRING ] ::: 3645
: NAME [ STRING ] , ::: 3643
NEWLINE INDENT assert NAME ( NAME ::: 3640
, STRING : NAME [ STRING ::: 3638
from . NAME import NAME , ::: 3638
= NAME . NAME ( { ::: 3635
if NAME not in NAME . ::: 3631
, STRING : NAME } ) ::: 3631
NAME . NAME NEWLINE return NAME ::: 3628
INDENT if NAME ( NAME . ::: 3618
if NAME . NAME == NUMBER ::: 3614
= NUMBER , NAME = None ::: 3613
NAME and not NAME . NAME ::: 3612
NEWLINE STRING NEWLINE from NAME . ::: 3612
NAME [ NAME ] [ NUMBER ::: 3611
STRING } ) NEWLINE NAME . ::: 3611
NAME . NAME ( True ) ::: 3610
NEWLINE DEDENT DEDENT @ NAME . ::: 3608
STRING : { STRING : NAME ::: 3603
INDENT NAME = [ NAME . ::: 3603
) : NEWLINE INDENT return False ::: 3599
. NAME ( ) NEWLINE def ::: 3597
STRING ) ) NEWLINE DEDENT DEDENT ::: 3596
in NAME [ STRING ] : ::: 3596
NAME = NAME ( ( NAME ::: 3591
[ NUMBER , NUMBER ] ) ::: 3590
NEWLINE DEDENT DEDENT for NAME in ::: 3589
NAME = NAME , ** NAME ::: 3589
return NAME NEWLINE DEDENT else : ::: 3588
NAME : NEWLINE INDENT break NEWLINE ::: 3586
STRING . NAME ( [ NAME ::: 3584
. NAME ( STRING ) ] ::: 3583
INDENT continue NEWLINE DEDENT NAME = ::: 3583
. NAME . NAME = STRING ::: 3581
INDENT NAME . NAME ( [ ::: 3577
. NAME ( NAME , { ::: 3576
. NAME ) , ( STRING ::: 3575
NEWLINE NAME [ NUMBER ] = ::: 3575
NAME , NAME [ NAME ] ::: 3574
from NAME import NAME NEWLINE class ::: 3573
= [ NUMBER , NUMBER , ::: 3570
[ ] , { } ) ::: 3569
NAME : NEWLINE INDENT return None ::: 3569
STRING ) , STRING : ( ::: 3569
( STRING ) , STRING ) ::: 3568
INDENT try : NEWLINE INDENT return ::: 3566
NAME . NAME ( ) - ::: 3566
) NEWLINE NAME ( STRING % ::: 3564
: NEWLINE INDENT NAME STRING % ::: 3564
NAME ] ) NEWLINE DEDENT def ::: 3563
NAME [ NAME ] NEWLINE if ::: 3562
in NAME : NEWLINE INDENT return ::: 3562
STRING % NAME . NAME . ::: 3561
NEWLINE NAME = True NEWLINE DEDENT ::: 3560
NAME . NAME [ NUMBER : ::: 3559
STRING ) NEWLINE class NAME ( ::: 3558
( NAME = NUMBER ) ) ::: 3555
. NAME , { STRING : ::: 3554
. NAME . NAME , NUMBER ::: 3553
NEWLINE INDENT with NAME ( NAME ::: 3551
NAME ) . NAME ( * ::: 3550
( STRING , NAME = NUMBER ::: 3544
. NAME [ - NUMBER ] ::: 3543
NAME = STRING % NAME . ::: 3542
STRING . NAME ( NAME = ::: 3541
. NAME NEWLINE DEDENT NAME . ::: 3540
STRING , STRING : NAME . ::: 3539
, STRING , STRING ) ) ::: 3538
NAME ) and NAME . NAME ::: 3534
= NAME ) NEWLINE return NAME ::: 3533
] ) NEWLINE DEDENT NAME = ::: 3531
NAME ] NEWLINE DEDENT else : ::: 3530
. NAME ( NAME , * ::: 3526
( NAME , NAME [ STRING ::: 3525
NEWLINE DEDENT NAME = STRING NEWLINE ::: 3524
not NAME ( NAME , STRING ::: 3524
. NAME ] ) NEWLINE NAME ::: 3524
NAME . NAME , { STRING ::: 3522
) , ] NEWLINE NAME = ::: 3522
if NAME > NUMBER : NEWLINE ::: 3520
STRING : NAME } NEWLINE NAME ::: 3520
NAME ( STRING ) ) ) ::: 3519
, NAME , NAME ) , ::: 3517
NAME . NAME ) ) : ::: 3517
( NAME , None ) NEWLINE ::: 3516
, NUMBER , - NUMBER , ::: 3516
True ) : NEWLINE INDENT NAME ::: 3513
STRING ] ) NEWLINE DEDENT DEDENT ::: 3511
, STRING : False , STRING ::: 3509
STRING : { STRING : NUMBER ::: 3509
, NAME ) NEWLINE for NAME ::: 3509
( ) ) ) NEWLINE DEDENT ::: 3504
NEWLINE if NAME [ STRING ] ::: 3504
. NAME as NAME NEWLINE import ::: 3503
NAME ( NUMBER , STRING ) ::: 3501
!= NAME . NAME : NEWLINE ::: 3501
NAME , NAME ) NEWLINE from ::: 3498
NAME ) NEWLINE DEDENT except : ::: 3496
NAME [ STRING ] ) , ::: 3492
) ) NEWLINE NAME = [ ::: 3490
elif NAME . NAME == STRING ::: 3488
NEWLINE NAME . NAME = - ::: 3486
NEWLINE DEDENT except ( NAME , ::: 3485
DEDENT if STRING in NAME : ::: 3485
return NAME NEWLINE DEDENT DEDENT EOS ::: 3482
NAME = NUMBER ) , NAME ::: 3480
NEWLINE DEDENT DEDENT DEDENT DEDENT def ::: 3477
NAME . NAME . NAME as ::: 3476
True ) : NEWLINE INDENT STRING ::: 3476
NAME ) ) . NAME ( ::: 3475
= None NEWLINE DEDENT def NAME ::: 3473
NAME . NAME NEWLINE DEDENT elif ::: 3473
[ NAME ] NEWLINE NAME . ::: 3473
: NAME ( STRING ) , ::: 3472
NEWLINE while True : NEWLINE INDENT ::: 3472
. NAME . NAME as NAME ::: 3472
. NAME = NAME NEWLINE return ::: 3469
as NAME NEWLINE import NAME . ::: 3466
) : NEWLINE INDENT return NEWLINE ::: 3465
[ NAME ] NEWLINE if NAME ::: 3465
, STRING : NAME ( STRING ::: 3464
, NAME . NAME [ NAME ::: 3464
STRING not in NAME : NEWLINE ::: 3463
, NAME = STRING , ) ::: 3460
NAME = [ STRING ] , ::: 3459
import NAME , NAME NEWLINE class ::: 3458
False , NAME = False , ::: 3458
STRING ) NEWLINE if NAME : ::: 3454
( { STRING : STRING } ::: 3453
) ) : NEWLINE INDENT if ::: 3453
assert NAME . NAME == NAME ::: 3451
( ( NUMBER , NUMBER , ::: 3451
: [ STRING ] , STRING ::: 3450
) : NEWLINE INDENT continue NEWLINE ::: 3449
. NAME NEWLINE import NAME . ::: 3446
STRING ] , NAME ) NEWLINE ::: 3446
NAME : NEWLINE INDENT return STRING ::: 3445
== NAME : NEWLINE INDENT return ::: 3444
( STRING % NAME ( NAME ::: 3442
) , NAME . NAME , ::: 3442
NEWLINE from NAME import NAME as ::: 3441
NAME . NAME ) == NUMBER ::: 3433
, NAME , NAME NEWLINE DEDENT ::: 3433
, NAME . NAME : STRING ::: 3431
NAME = None NEWLINE DEDENT def ::: 3427
NAME . NAME == STRING NEWLINE ::: 3427
NAME ) [ NUMBER ] NEWLINE ::: 3425
( NAME . NAME , ) ::: 3420
NAME ) NEWLINE DEDENT DEDENT @ ::: 3418
if NAME . NAME != NAME ::: 3417
NAME = True ) , NAME ::: 3416
True , NAME = STRING ) ::: 3415
NAME . NAME NEWLINE NAME [ ::: 3414
NAME [ STRING ] NEWLINE if ::: 3411
NAME != NUMBER : NEWLINE INDENT ::: 3409
= STRING NEWLINE DEDENT class NAME ::: 3408
, NAME ( NAME = STRING ::: 3408
STRING ] [ STRING ] NEWLINE ::: 3407
] = NAME ( NAME ) ::: 3406
] , [ STRING , STRING ::: 3405
% ( NAME . NAME ( ::: 3403
( NAME , STRING , None ::: 3403
NAME = STRING NEWLINE DEDENT class ::: 3400
NUMBER NEWLINE DEDENT NAME = NAME ::: 3392
NAME = [ { STRING : ::: 3390
( STRING ) NEWLINE @ NAME ::: 3387
, ) , NAME . NAME ::: 3385
NAME ( STRING ) NEWLINE @ ::: 3383
= [ ( STRING , NAME ::: 3382
. NAME . NAME ( { ::: 3380
STRING , NAME . NAME : ::: 3378
NAME ) NEWLINE DEDENT NAME ( ::: 3378
, NAME , NAME , ** ::: 3378
= None , NAME = NUMBER ::: 3373
) : NEWLINE INDENT yield NAME ::: 3372
NAME ( NAME ) [ NUMBER ::: 3372
NAME NEWLINE return NAME . NAME ::: 3371
= - NUMBER NEWLINE NAME . ::: 3370
except ( NAME , NAME ) ::: 3368
- NUMBER , NUMBER , NUMBER ::: 3368
NAME ( ) ) NEWLINE if ::: 3368
. NAME NEWLINE DEDENT elif NAME ::: 3367
= STRING NEWLINE NAME = NUMBER ::: 3366
NAME , STRING : STRING , ::: 3364
NEWLINE if NAME not in NAME ::: 3364
( NAME . NAME , { ::: 3364
) ) NEWLINE NAME ( STRING ::: 3361
NAME . NAME , None ) ::: 3361
[ NUMBER ] . NAME ) ::: 3360
NAME = NAME NEWLINE DEDENT elif ::: 3358
NAME for NAME in NAME ] ::: 3358
NAME ( NAME = [ STRING ::: 3358
= NAME , ** NAME ) ::: 3357
= None NEWLINE def NAME ( ::: 3357
. NAME : NAME . NAME ::: 3354
. NAME . NAME = [ ::: 3354
STRING , STRING ] , STRING ::: 3353
NAME . NAME : NAME . ::: 3350
] NEWLINE if NAME : NEWLINE ::: 3350
, [ ] ) NEWLINE NAME ::: 3350
NAME = None NEWLINE def NAME ::: 3350
. NAME ( STRING , ( ::: 3350
, NAME . NAME : NAME ::: 3349
, STRING : NUMBER } , ::: 3349
NAME in NAME ] NEWLINE DEDENT ::: 3349
= [ ] NEWLINE if NAME ::: 3348
DEDENT if NAME . NAME == ::: 3346
) ) , NAME . NAME ::: 3346
NAME ( NAME = None , ::: 3346
% NAME ) NEWLINE NAME . ::: 3343
. NAME as NAME : NEWLINE ::: 3342
. NAME ) ) : NEWLINE ::: 3342
NAME . NAME as NAME : ::: 3341
True ) NEWLINE DEDENT def NAME ::: 3341
None NEWLINE DEDENT NAME = NAME ::: 3341
[ STRING ] = NUMBER NEWLINE ::: 3340
NEWLINE from . import NAME NEWLINE ::: 3335
NEWLINE DEDENT elif NAME == NAME ::: 3335
= ( STRING , STRING ) ::: 3334
NAME , NAME ) NEWLINE assert ::: 3334
NAME = NAME NEWLINE return NAME ::: 3334
STRING NEWLINE if NAME : NEWLINE ::: 3333
] , NAME . NAME ( ::: 3329
DEDENT DEDENT DEDENT return NAME NEWLINE ::: 3329
= NAME [ NAME . NAME ::: 3328
STRING NEWLINE assert NAME . NAME ::: 3326
NAME , ) ) NEWLINE DEDENT ::: 3325
. NAME [ NUMBER ] [ ::: 3324
) [ NUMBER ] NEWLINE DEDENT ::: 3320
NEWLINE for NAME in NAME [ ::: 3318
NAME import NAME NEWLINE NAME . ::: 3315
NUMBER ) NEWLINE DEDENT NAME = ::: 3315
NEWLINE INDENT if NAME is not ::: 3314
. NAME ( STRING , False ::: 3312
, NAME [ NAME ] ) ::: 3312
NEWLINE INDENT NAME . NAME += ::: 3309
] NEWLINE DEDENT DEDENT def NAME ::: 3309
NAME ] . NAME ( ) ::: 3306
( ( NAME . NAME , ::: 3305
NUMBER , NAME = NAME . ::: 3304
NAME : NEWLINE INDENT from NAME ::: 3302
NUMBER , NAME . NAME ( ::: 3301
] , NAME = NAME ) ::: 3299
== NUMBER NEWLINE assert NAME . ::: 3297
. NAME ( [ NAME ] ::: 3294
DEDENT return NAME ( NAME ) ::: 3293
( ( STRING , STRING ) ::: 3288
[ STRING ] [ NAME ] ::: 3287
( STRING , NUMBER , NUMBER ::: 3287
) ) for NAME in NAME ::: 3287
NEWLINE INDENT break NEWLINE DEDENT DEDENT ::: 3286
NEWLINE DEDENT NAME . NAME [ ::: 3284
] : NEWLINE INDENT if NAME ::: 3282
, STRING , { STRING : ::: 3282
NUMBER ] . NAME . NAME ::: 3281
NAME ( NAME + STRING ) ::: 3280
NAME ( ) NEWLINE DEDENT elif ::: 3273
[ STRING ] NEWLINE if NAME ::: 3273
( NAME = None , NAME ::: 3273
[ ] NEWLINE for NAME , ::: 3268
NAME . NAME ( ) for ::: 3267
NAME ( STRING , False ) ::: 3266
. NAME ) ) ) NEWLINE ::: 3265
NEWLINE NAME = [ NAME for ::: 3265
: NEWLINE INDENT raise NAME , ::: 3264
NAME . NAME , ) NEWLINE ::: 3263
NEWLINE NAME += NAME . NAME ::: 3261
] [ STRING ] . NAME ::: 3261
: NEWLINE INDENT ( NAME , ::: 3260
!= NUMBER : NEWLINE INDENT NAME ::: 3254
( NAME = NAME ( STRING ::: 3251
= STRING NEWLINE DEDENT NAME = ::: 3251
NAME , NAME = { STRING ::: 3251
NUMBER ] : NEWLINE INDENT NAME ::: 3250
[ ( STRING , STRING , ::: 3249
= [ STRING ] ) NEWLINE ::: 3245
( NUMBER ) NEWLINE DEDENT NAME ::: 3242
: NAME } ) NEWLINE DEDENT ::: 3242
) : NEWLINE INDENT NAME STRING ::: 3242
= [ STRING ] , NAME ::: 3240
NAME ( STRING + NAME ( ::: 3239
NAME [ NAME ] : NEWLINE ::: 3237
( ) NEWLINE return NAME . ::: 3235
NAME . NAME NEWLINE DEDENT except ::: 3235
( ** NAME ) NEWLINE DEDENT ::: 3234
( NAME . NAME == NAME ::: 3231
, NAME ) NEWLINE def NAME ::: 3230
NAME = NAME + STRING NEWLINE ::: 3229
NAME ( NAME [ NUMBER : ::: 3228
None , NAME = False , ::: 3227
assert NAME . NAME ( ) ::: 3225
NAME ) for NAME , NAME ::: 3225
STRING ] ) ) NEWLINE NAME ::: 3225
NAME NEWLINE DEDENT elif NAME == ::: 3224
( STRING + NAME ( NAME ::: 3224
NEWLINE from NAME import * NEWLINE ::: 3223
] = STRING NEWLINE NAME [ ::: 3220
STRING ] , NAME = STRING ::: 3219
] , NAME = NAME [ ::: 3218
NAME . NAME = ( NAME ::: 3217
!= NAME : NEWLINE INDENT NAME ::: 3215
NUMBER NEWLINE if NAME . NAME ::: 3215
STRING ] [ STRING ] , ::: 3215
None ) NEWLINE DEDENT def NAME ::: 3215
: NEWLINE INDENT yield NAME NEWLINE ::: 3211
NAME = True NEWLINE DEDENT DEDENT ::: 3210
NUMBER , NUMBER ] , NAME ::: 3209
( STRING ) ) , ( ::: 3209
= None , NAME = NAME ::: 3208
( NUMBER ) NEWLINE DEDENT DEDENT ::: 3208
NAME ( NAME = { STRING ::: 3207
DEDENT return NAME NEWLINE DEDENT @ ::: 3207
, ] NEWLINE NAME = [ ::: 3202
. NAME ( STRING ) == ::: 3201
( NAME = { STRING : ::: 3200
= { STRING : NUMBER , ::: 3196
STRING ) , NAME ( NAME ::: 3196
( NAME ) , NAME , ::: 3195
STRING + NAME ( NAME . ::: 3193
DEDENT DEDENT DEDENT else : NEWLINE ::: 3192
NUMBER NEWLINE NAME . NAME . ::: 3191
( ) NEWLINE NAME = { ::: 3189
STRING ) NEWLINE NAME [ STRING ::: 3186
INDENT return NAME NEWLINE DEDENT NAME ::: 3186
NAME . NAME ( STRING in ::: 3185
, STRING ] ) NEWLINE DEDENT ::: 3185
NUMBER , NUMBER ] NEWLINE NAME ::: 3179
STRING . NAME ( NAME [ ::: 3174
False NEWLINE NAME = False NEWLINE ::: 3174
NUMBER ] NEWLINE DEDENT def NAME ::: 3172
( NAME ) ) NEWLINE if ::: 3172
= False NEWLINE NAME = False ::: 3169
( STRING ) NEWLINE return NAME ::: 3169
NAME NEWLINE from . import NAME ::: 3167
: NEWLINE INDENT raise NEWLINE DEDENT ::: 3166
STRING NEWLINE DEDENT NAME . NAME ::: 3163
. NAME ( ) - NAME ::: 3163
while True : NEWLINE INDENT NAME ::: 3162
) : NEWLINE INDENT import NAME ::: 3161
NAME ) NEWLINE return NEWLINE DEDENT ::: 3160
NEWLINE INDENT continue NEWLINE DEDENT if ::: 3159
, NUMBER , NUMBER ] NEWLINE ::: 3158
) , NUMBER : ( STRING ::: 3157
, NUMBER : ( STRING , ::: 3157
- NUMBER NEWLINE NAME = - ::: 3154
. NAME ( STRING in NAME ::: 3154
STRING ) NEWLINE if not NAME ::: 3152
NAME ( NAME , [ NAME ::: 3152
= None NEWLINE NAME = NAME ::: 3152
) NEWLINE DEDENT except ( NAME ::: 3148
INDENT return NAME ( NAME ( ::: 3148
] [ STRING ] = NAME ::: 3146
NEWLINE if NAME . NAME != ::: 3143
) ) . NAME ( NAME ::: 3142
NAME . NAME , NAME [ ::: 3140
= ( NAME . NAME , ::: 3140
= None , NAME = True ::: 3138
, NAME , NAME NEWLINE NAME ::: 3138
NAME ( STRING % NAME , ::: 3133
in NAME ] NEWLINE NAME = ::: 3133
. NAME ( ) == NAME ::: 3132
) NEWLINE return NAME , NAME ::: 3129
( [ NAME , NAME ] ::: 3128
STRING : STRING , } NEWLINE ::: 3128
* NAME . NAME ( NAME ::: 3127
NEWLINE NAME += NUMBER NEWLINE DEDENT ::: 3127
= False , NAME = NAME ::: 3126
return NAME ( NAME = NAME ::: 3126
NAME ( NAME = None ) ::: 3125
) == NUMBER NEWLINE assert NAME ::: 3125
NAME ( ) ) , NAME ::: 3124
STRING ) , NAME = STRING ::: 3122
[ NUMBER ] . NAME . ::: 3122
STRING NEWLINE import NAME NEWLINE from ::: 3120
DEDENT DEDENT DEDENT NAME . NAME ::: 3119
NUMBER , NAME . NAME , ::: 3119
NAME . NAME ) NEWLINE assert ::: 3118
] [ STRING ] NEWLINE NAME ::: 3118
= NAME [ STRING ] ) ::: 3116
. NAME ( * NAME ) ::: 3115
NAME in NAME . NAME [ ::: 3114
NUMBER , NAME = True , ::: 3113
STRING , NAME ) ) NEWLINE ::: 3113
) , ( NAME . NAME ::: 3113
INDENT STRING NEWLINE NAME = NUMBER ::: 3111
{ STRING : NAME } NEWLINE ::: 3110
DEDENT DEDENT class NAME : NEWLINE ::: 3107
NAME NEWLINE import NAME NEWLINE class ::: 3105
( NAME ( NUMBER , NUMBER ::: 3103
. NAME NEWLINE DEDENT return NAME ::: 3102
STRING NEWLINE NAME = ( STRING ::: 3099
. NAME ( NAME , ( ::: 3099
= NAME ( ) NEWLINE if ::: 3099
NAME < NAME : NEWLINE INDENT ::: 3099
NAME ( NAME = NAME [ ::: 3098
return NAME NEWLINE DEDENT if NAME ::: 3098
DEDENT DEDENT DEDENT NAME = NAME ::: 3094
( NAME ) ) NEWLINE return ::: 3094
NEWLINE DEDENT DEDENT DEDENT DEDENT DEDENT ::: 3093
, NAME = [ NAME . ::: 3093
STRING , { STRING : STRING ::: 3092
] = NAME NEWLINE DEDENT if ::: 3087
. NAME ( NAME ) ] ::: 3087
NAME = NAME [ NAME . ::: 3087
, NUMBER ) ) NEWLINE DEDENT ::: 3085
NAME ( NAME ) as NAME ::: 3085
import NAME NEWLINE NAME = [ ::: 3083
+ NAME . NAME . NAME ::: 3082
] ) ) NEWLINE NAME = ::: 3082
NAME . NAME ( None ) ::: 3081
INDENT if NAME is not None ::: 3081
NAME [ NUMBER : ] ) ::: 3080
NAME ( NAME , NAME + ::: 3080
NAME = NAME + NAME NEWLINE ::: 3079
. NAME ( STRING ) or ::: 3079
( NAME ) NEWLINE try : ::: 3077
+ STRING + NAME . NAME ::: 3075
NAME , NAME ( NAME , ::: 3075
NAME , STRING % ( NAME ::: 3072
NAME == NAME . NAME NEWLINE ::: 3071
) ] ) NEWLINE NAME = ::: 3071
( ) ) ) NEWLINE NAME ::: 3068
, NUMBER , NUMBER , NAME ::: 3068
NAME . NAME NEWLINE for NAME ::: 3063
STRING , STRING ) , ] ::: 3063
None NEWLINE def NAME ( NAME ::: 3060
NAME . NAME ( - NUMBER ::: 3058
( STRING , NAME , STRING ::: 3058
( NAME ) as NAME : ::: 3058
) NEWLINE if NAME == NAME ::: 3058
NAME NEWLINE DEDENT return NAME . ::: 3058
( ) , STRING : NAME ::: 3057
. NAME NEWLINE DEDENT except NAME ::: 3056
) NEWLINE NAME += NUMBER NEWLINE ::: 3055
NUMBER , NUMBER ) , STRING ::: 3055
( NAME ) [ NUMBER ] ::: 3054
STRING + NAME . NAME ( ::: 3053
) ) NEWLINE NAME = STRING ::: 3053
NEWLINE if NAME in NAME : ::: 3053
= STRING NEWLINE NAME [ STRING ::: 3053
( ) NEWLINE DEDENT elif NAME ::: 3049
in NAME : NEWLINE INDENT raise ::: 3049
= STRING ) NEWLINE NAME ( ::: 3048
NAME , NAME . NAME : ::: 3048
NUMBER , STRING ) , ( ::: 3046
NAME ( NAME ) NEWLINE try ::: 3046
NEWLINE NAME . NAME = ( ::: 3045
, NAME ] ) NEWLINE NAME ::: 3045
NAME [ NUMBER ] ) , ::: 3043
NUMBER NEWLINE NAME = STRING NEWLINE ::: 3035
NAME ) NEWLINE DEDENT if not ::: 3035
NEWLINE NAME ( ) NEWLINE NAME ::: 3034
NAME == NAME . NAME . ::: 3034
NAME import NAME NEWLINE DEDENT except ::: 3033
( NAME , NAME ) ] ::: 3032
STRING , [ STRING , STRING ::: 3031
NAME ) NEWLINE from NAME . ::: 3027
NEWLINE INDENT ( NAME , NAME ::: 3027
STRING , NAME ) NEWLINE if ::: 3025
. NAME , None ) NEWLINE ::: 3023
) : NEWLINE INDENT if ( ::: 3022
] , STRING : NAME [ ::: 3022
= STRING ) NEWLINE DEDENT def ::: 3021
STRING ) NEWLINE NAME = ( ::: 3020
, STRING % ( NAME , ::: 3018
[ NUMBER ] : NEWLINE INDENT ::: 3015
( ) ) NEWLINE DEDENT NAME ::: 3015
) ] ) NEWLINE NAME . ::: 3014
= NAME ) NEWLINE DEDENT NAME ::: 3013
in NAME . NAME ] NEWLINE ::: 3012
] = NAME NEWLINE NAME = ::: 3012
( ) NEWLINE if NAME is ::: 3011
) , ( NUMBER , STRING ::: 3011
) , NAME ) ) NEWLINE ::: 3009
STRING : NUMBER } ) NEWLINE ::: 3009
INDENT if NAME in NAME : ::: 3009
STRING ) NEWLINE try : NEWLINE ::: 3007
NAME ) , NAME = STRING ::: 3007
. NAME ( [ STRING ] ::: 3006
and NAME ( NAME . NAME ::: 3006
STRING ) NEWLINE DEDENT elif NAME ::: 3004
with NAME . NAME ( ) ::: 3004
{ } NEWLINE NAME = NAME ::: 3003
) for NAME in NAME ) ::: 3002
STRING ) ) : NEWLINE INDENT ::: 3002
NAME , None ) NEWLINE NAME ::: 3002
, STRING ) , ( NUMBER ::: 3001
True NEWLINE DEDENT else : NEWLINE ::: 2999
( NAME [ NUMBER ] [ ::: 2998
STRING , STRING , NAME , ::: 2997
] , NUMBER ) NEWLINE NAME ::: 2996
NAME NEWLINE DEDENT if NAME is ::: 2995
: NAME . NAME } NEWLINE ::: 2994
, NAME ) NEWLINE NAME [ ::: 2994
NAME ( ) NEWLINE NAME , ::: 2992
( ( NAME , NAME , ::: 2992
( ) NEWLINE NAME , NAME ::: 2990
NUMBER ) NEWLINE def NAME ( ::: 2990
INDENT class NAME ( NAME ) ::: 2989
NAME ( NUMBER , NAME = ::: 2983
NEWLINE pass NEWLINE DEDENT def NAME ::: 2981
and NAME . NAME : NEWLINE ::: 2980
return False NEWLINE DEDENT def NAME ::: 2979
from NAME import NAME NEWLINE DEDENT ::: 2977
if NAME < NUMBER : NEWLINE ::: 2975
NAME ( NAME ( ) , ::: 2972
NAME , { STRING : NAME ::: 2972
: NEWLINE INDENT STRING NEWLINE from ::: 2969
[ ] NEWLINE DEDENT def NAME ::: 2969
) ] NEWLINE NAME = [ ::: 2969
= STRING % NAME NEWLINE NAME ::: 2967
NEWLINE return NAME NEWLINE DEDENT @ ::: 2966
STRING ) , ( NUMBER , ::: 2963
STRING ] NEWLINE DEDENT def NAME ::: 2963
NAME ) ) NEWLINE for NAME ::: 2961
[ ( STRING , NAME . ::: 2958
NEWLINE INDENT NAME = [ ( ::: 2958
= ( NAME . NAME ( ::: 2957
. NAME ] ) NEWLINE DEDENT ::: 2957
] , NAME = STRING , ::: 2956
, NAME = NUMBER ) ) ::: 2955
. NAME ( NAME , ** ::: 2954
STRING , STRING ] , [ ::: 2954
if NAME ( NAME ) != ::: 2953
with NAME . NAME . NAME ::: 2952
NEWLINE DEDENT with NAME . NAME ::: 2951
STRING ) NEWLINE NAME = { ::: 2951
( NAME , NAME ) and ::: 2947
, STRING ) , ] NEWLINE ::: 2947
[ NAME ] = NAME [ ::: 2946
NEWLINE DEDENT NAME = [ NAME ::: 2946
NAME + STRING ) NEWLINE NAME ::: 2945
= ( NUMBER , NUMBER , ::: 2944
: [ STRING , STRING ] ::: 2941
) [ NUMBER ] . NAME ::: 2941
NUMBER ) NEWLINE DEDENT else : ::: 2940
, NAME = NAME NEWLINE NAME ::: 2939
return NAME ( ) NEWLINE DEDENT ::: 2938
not None : NEWLINE INDENT return ::: 2937
] . NAME ( ) ) ::: 2937
[ NUMBER ] == STRING : ::: 2934
NEWLINE NAME = NAME - NAME ::: 2934
: [ STRING , STRING , ::: 2932
NEWLINE INDENT NAME = STRING + ::: 2932
NUMBER ] ) NEWLINE DEDENT def ::: 2930
None ) : NEWLINE INDENT return ::: 2929
= True NEWLINE NAME = NAME ::: 2929
, NAME = NAME , ** ::: 2927
NEWLINE INDENT return STRING . NAME ::: 2926
: NEWLINE INDENT return STRING . ::: 2926
INDENT return STRING . NAME ( ::: 2926
NEWLINE NAME = NAME [ : ::: 2924
} NEWLINE NAME [ STRING ] ::: 2924
. NAME ( NUMBER , STRING ::: 2923
raise NAME ( STRING . NAME ::: 2922
INDENT return None NEWLINE DEDENT DEDENT ::: 2921
NEWLINE INDENT return STRING % NAME ::: 2916
import * NEWLINE from NAME . ::: 2912
= [ NAME . NAME . ::: 2912
* NEWLINE from NAME . NAME ::: 2912
, STRING ) , NUMBER : ::: 2911
] NEWLINE try : NEWLINE INDENT ::: 2910
DEDENT if not NAME ( NAME ::: 2910
. NAME ] NEWLINE NAME = ::: 2909
NEWLINE INDENT raise NAME ( ) ::: 2909
= ( NAME , NAME ) ::: 2908
@ NAME ( NAME ) NEWLINE ::: 2906
) NEWLINE return True NEWLINE DEDENT ::: 2906
. NAME , STRING ) ) ::: 2905
INDENT raise NAME ( ) NEWLINE ::: 2903
, NAME ( NAME ( NAME ::: 2903
) . NAME ( NAME ( ::: 2903
= NAME ( NAME = [ ::: 2902
NAME = NUMBER ) ) NEWLINE ::: 2901
NAME ( NAME , STRING % ::: 2901
DEDENT return NAME NEWLINE DEDENT NAME ::: 2900
( NAME , { STRING : ::: 2900
( ) NEWLINE if NAME == ::: 2899
NEWLINE return NAME NEWLINE DEDENT NAME ::: 2897
( STRING ) NEWLINE DEDENT except ::: 2896
) , NAME = NUMBER ) ::: 2894
NUMBER ] , NAME ) NEWLINE ::: 2893
INDENT STRING NEWLINE NAME = ( ::: 2892
) ) NEWLINE DEDENT DEDENT EOS ::: 2892
in NAME : NEWLINE INDENT for ::: 2891
STRING ) , NUMBER : ( ::: 2891
NAME . NAME } ) NEWLINE ::: 2891
] for NAME in NAME ] ::: 2891
+ NAME ( NAME ) + ::: 2890
NUMBER , STRING ) NEWLINE NAME ::: 2888
( STRING , NAME [ STRING ::: 2887
NAME ( [ STRING ] ) ::: 2887
True : NEWLINE INDENT NAME = ::: 2885
= NAME ( NAME ) . ::: 2885
. NAME NEWLINE NAME [ STRING ::: 2884
: NEWLINE INDENT del NAME . ::: 2883
NEWLINE INDENT del NAME . NAME ::: 2883
) , NAME = True , ::: 2877
NAME [ NAME , NAME ] ::: 2876
( NAME . NAME ) + ::: 2875
INDENT NAME ( STRING , NAME ::: 2875
) NEWLINE NAME = True NEWLINE ::: 2874
. NAME : NEWLINE INDENT for ::: 2874
NEWLINE NAME = NAME ( ( ::: 2874
) NEWLINE DEDENT DEDENT for NAME ::: 2874
NAME . NAME ( [ [ ::: 2873
] , NAME = [ STRING ::: 2870
( STRING , NAME = { ::: 2868
BOS NEWLINE STRING NEWLINE NAME = ::: 2867
NAME ) NEWLINE DEDENT DEDENT elif ::: 2867
, STRING , NAME = True ::: 2865
= NUMBER NEWLINE NAME = STRING ::: 2865
NAME , [ STRING , STRING ::: 2864
assert NAME . NAME == STRING ::: 2864
STRING , None ) NEWLINE if ::: 2864
, NAME , NAME ) = ::: 2863
NEWLINE try : NEWLINE INDENT import ::: 2862
NEWLINE NAME = NUMBER NEWLINE DEDENT ::: 2860
STRING NEWLINE NAME = [ NAME ::: 2860
= STRING NEWLINE NAME = ( ::: 2860
STRING ) , NAME ) NEWLINE ::: 2857
STRING , NAME , STRING , ::: 2856
< NAME : NEWLINE INDENT NAME ::: 2855
NEWLINE import NAME NEWLINE def NAME ::: 2855
NEWLINE DEDENT NAME = NUMBER NEWLINE ::: 2851
NAME , NUMBER , NUMBER , ::: 2849
] = NAME [ NAME ] ::: 2849
NEWLINE DEDENT NAME [ NAME ] ::: 2845
return STRING NEWLINE DEDENT def NAME ::: 2845
( NAME = NAME [ STRING ::: 2845
NAME NEWLINE DEDENT if NAME : ::: 2844
NAME ) ) NEWLINE DEDENT except ::: 2843
) NEWLINE return False NEWLINE DEDENT ::: 2839
] = STRING NEWLINE NAME . ::: 2839
None , NAME = STRING , ::: 2839
NAME = None NEWLINE DEDENT NAME ::: 2839
NEWLINE DEDENT DEDENT if not NAME ::: 2838
with NAME ( NAME . NAME ::: 2837
== STRING NEWLINE DEDENT def NAME ::: 2836
[ NAME ] NEWLINE DEDENT def ::: 2835
NAME ( NAME , [ STRING ::: 2834
NAME , NAME . NAME = ::: 2834
: NEWLINE INDENT @ NAME NEWLINE ::: 2833
( STRING , NAME ) ) ::: 2830
= [ NAME . NAME ] ::: 2829
: NAME . NAME } ) ::: 2829
NEWLINE INDENT yield NAME NEWLINE DEDENT ::: 2826
except : NEWLINE INDENT NAME . ::: 2826
return NAME NEWLINE DEDENT class NAME ::: 2825
, NAME ) NEWLINE from NAME ::: 2825
NAME ] , NAME = NAME ::: 2824
NEWLINE NAME [ STRING ] . ::: 2822
NAME [ STRING ] = NUMBER ::: 2822
not None : NEWLINE INDENT if ::: 2821
. NAME ( NAME [ : ::: 2821
. NAME ( None ) NEWLINE ::: 2821
as NAME NEWLINE import NAME NEWLINE ::: 2821
NAME = STRING ) . NAME ::: 2818
NAME = { } NEWLINE if ::: 2817
( ) , NAME = STRING ::: 2817
NAME ] , NAME . NAME ::: 2814
STRING ) NEWLINE DEDENT DEDENT NAME ::: 2813
if STRING not in NAME : ::: 2812
DEDENT with NAME . NAME ( ::: 2810
NUMBER , NUMBER ) ) ) ::: 2810
( NAME , NUMBER , NAME ::: 2808
STRING NEWLINE pass NEWLINE DEDENT def ::: 2808
False , NAME = STRING ) ::: 2806
NAME ] NEWLINE NAME = [ ::: 2805
NAME ] = NAME [ NAME ::: 2804
{ STRING : [ STRING ] ::: 2802
= NAME ) NEWLINE NAME ( ::: 2800
( NAME , NAME , NUMBER ::: 2800
= NAME [ NUMBER ] . ::: 2798
NAME [ NAME ( NAME ) ::: 2798
False ) NEWLINE DEDENT def NAME ::: 2798
, NAME NEWLINE from . NAME ::: 2797
, STRING ] , STRING : ::: 2796
NUMBER NEWLINE DEDENT NAME . NAME ::: 2796
NEWLINE INDENT import NAME NEWLINE DEDENT ::: 2794
) NEWLINE DEDENT NAME , NAME ::: 2794
NUMBER ] NEWLINE DEDENT else : ::: 2793
STRING ) and NAME . NAME ::: 2793
True NEWLINE NAME . NAME = ::: 2792
) NEWLINE if NAME and NAME ::: 2791
NUMBER , NUMBER ) NEWLINE DEDENT ::: 2791
STRING , STRING , ] NEWLINE ::: 2790
. . NAME import NAME NEWLINE ::: 2789
NAME [ : , NUMBER ] ::: 2789
STRING , NAME , STRING ) ::: 2788
NUMBER ] ) ) NEWLINE NAME ::: 2788
NAME NEWLINE NAME = { STRING ::: 2788
NAME = NUMBER ) ) , ::: 2787
= [ NAME ( NAME ) ::: 2787
STRING : [ STRING ] } ::: 2787
DEDENT NAME = NAME ( STRING ::: 2786
if NAME [ STRING ] == ::: 2785
[ NUMBER ] , NAME = ::: 2785
. NAME ) NEWLINE DEDENT elif ::: 2783
) , ( NAME , NAME ::: 2782
NAME ( NAME , { STRING ::: 2782
) . NAME ( NUMBER ) ::: 2782
NEWLINE DEDENT if not NAME ( ::: 2780
STRING + NAME + STRING + ::: 2780
STRING ] NEWLINE def NAME ( ::: 2778
NAME NEWLINE DEDENT elif NAME . ::: 2777
. NAME NEWLINE DEDENT DEDENT def ::: 2776
pass NEWLINE DEDENT else : NEWLINE ::: 2775
NAME ( [ NAME ] ) ::: 2773
NAME NEWLINE NAME ( NAME , ::: 2773
NAME = NAME + NUMBER NEWLINE ::: 2771
NAME NEWLINE NAME = NAME [ ::: 2771
, ( STRING , NUMBER , ::: 2769
NEWLINE DEDENT DEDENT elif NAME == ::: 2769
return None NEWLINE DEDENT def NAME ::: 2769
NEWLINE NAME = NAME + STRING ::: 2767
: NAME } ) NEWLINE NAME ::: 2764
, NAME ) , NAME ) ::: 2763
( NAME ) NEWLINE NAME , ::: 2763
( NAME ) NEWLINE class NAME ::: 2762
% ( NAME ( NAME ) ::: 2762
, { STRING : NAME . ::: 2761
] NEWLINE NAME = [ ( ::: 2760
, NAME , NUMBER ) NEWLINE ::: 2760
NAME NEWLINE DEDENT DEDENT return NAME ::: 2758
: NAME , STRING : STRING ::: 2757
and NAME . NAME == NAME ::: 2756
. NAME . NAME NEWLINE if ::: 2755
{ STRING : NAME ( NAME ::: 2755
[ NAME ( NAME . NAME ::: 2754
NEWLINE assert NAME [ STRING ] ::: 2754
, ) ) NEWLINE NAME . ::: 2754
( ** NAME ) NEWLINE NAME ::: 2753
) NEWLINE class NAME : NEWLINE ::: 2752
( ) NEWLINE if NAME ( ::: 2752
] ) , ( STRING , ::: 2751
) NEWLINE if NAME in NAME ::: 2749
STRING : STRING } , NAME ::: 2748
NAME and NAME . NAME ( ::: 2748
( lambda NAME : NAME . ::: 2746
NUMBER : NUMBER , NUMBER : ::: 2745
( NAME , NAME [ NAME ::: 2745
STRING , NAME = [ NAME ::: 2744
) NEWLINE DEDENT DEDENT DEDENT if ::: 2743
NAME ( STRING , [ ] ::: 2742
= NAME NEWLINE DEDENT DEDENT def ::: 2741
. NAME . NAME == NAME ::: 2740
DEDENT DEDENT return NAME . NAME ::: 2740
del NAME . NAME [ NAME ::: 2740
elif NAME == NUMBER : NEWLINE ::: 2739
DEDENT elif NAME == NUMBER : ::: 2738
= NAME ) ) NEWLINE DEDENT ::: 2738
] : NEWLINE INDENT NAME [ ::: 2737
[ ] ) NEWLINE NAME . ::: 2736
, NAME = [ ] , ::: 2734
NAME . NAME and not NAME ::: 2734
NAME , None ) NEWLINE DEDENT ::: 2733
] , { } ) , ::: 2731
NAME = STRING NEWLINE DEDENT DEDENT ::: 2730
: NUMBER , NUMBER : NUMBER ::: 2729
( STRING , NUMBER ) ) ::: 2729
NEWLINE INDENT pass NEWLINE DEDENT else ::: 2728
INDENT pass NEWLINE DEDENT else : ::: 2728
NAME ( NAME ) NEWLINE class ::: 2727
= NAME NEWLINE DEDENT DEDENT DEDENT ::: 2727
% ( NAME , ) ) ::: 2726
NUMBER ) ) NEWLINE DEDENT def ::: 2726
NEWLINE DEDENT return NAME , NAME ::: 2725
) NEWLINE NAME ( NAME [ ::: 2725
, { STRING : NUMBER , ::: 2724
NAME and NAME . NAME . ::: 2723
STRING , [ STRING ] ) ::: 2719
NAME , NUMBER , NUMBER ) ::: 2718
NAME ( [ ( STRING , ::: 2717
NAME NEWLINE if NAME is None ::: 2716
= NAME ( STRING , ( ::: 2715
NEWLINE INDENT if NAME [ STRING ::: 2715
in ( STRING , STRING , ::: 2714
. NAME . NAME import ( ::: 2714
NAME as NAME NEWLINE NAME = ::: 2714
, NAME ) , NAME ( ::: 2713
for NAME in NAME ) NEWLINE ::: 2712
DEDENT NAME = { } NEWLINE ::: 2712
. NAME ( NAME ) + ::: 2709
INDENT if NAME [ STRING ] ::: 2709
) or NAME . NAME ( ::: 2708
[ NAME ] NEWLINE DEDENT NAME ::: 2707
: return NAME . NAME NEWLINE ::: 2707
NAME == NAME . NAME and ::: 2706
True ) NEWLINE def NAME ( ::: 2706
+ NAME + STRING + NAME ::: 2704
] ) NEWLINE DEDENT DEDENT def ::: 2703
NEWLINE INDENT raise NAME , STRING ::: 2703
STRING STRING ) NEWLINE NAME . ::: 2702
NEWLINE DEDENT DEDENT DEDENT else : ::: 2702
, [ NAME ] ) NEWLINE ::: 2701
( NAME ( NAME [ NUMBER ::: 2701
( STRING , [ ] ) ::: 2700
STRING , NAME ( NAME . ::: 2700
NAME ) + STRING + NAME ::: 2700
NEWLINE INDENT @ NAME NEWLINE def ::: 2699
INDENT @ NAME NEWLINE def NAME ::: 2699
) . NAME NEWLINE NAME = ::: 2698
yield NAME . NAME ( NAME ::: 2697
INDENT NAME = NAME ( [ ::: 2697
] . NAME , STRING ) ::: 2694
NAME . NAME ( ) if ::: 2691
None , NAME = False ) ::: 2691
( NAME . NAME , ( ::: 2687
INDENT STRING NEWLINE NAME = None ::: 2686
) + STRING + NAME ( ::: 2686
STRING ) [ NUMBER ] NEWLINE ::: 2684
INDENT NAME = False NEWLINE DEDENT ::: 2683
, True ) NEWLINE NAME . ::: 2683
NAME NEWLINE NAME , NAME = ::: 2682
( { STRING : NAME . ::: 2682
raise NAME ( NAME . NAME ::: 2682
NAME = NAME ) , NAME ::: 2682
, NAME = NAME ) , ::: 2680
STRING ] , [ STRING , ::: 2680
NEWLINE try : NEWLINE INDENT return ::: 2679
STRING : NAME , } NEWLINE ::: 2678
NAME ( STRING , { } ::: 2678
= NAME ( ) . NAME ::: 2677
raise NAME ( STRING STRING ) ::: 2676
False , NAME = False ) ::: 2676
NUMBER ] . NAME , STRING ::: 2676
, NAME = NAME [ NUMBER ::: 2675
, NAME = None ) NEWLINE ::: 2675
, STRING % NAME . NAME ::: 2675
, NAME = NAME , ) ::: 2673
) : NEWLINE INDENT if STRING ::: 2670
, NAME [ STRING ] [ ::: 2668
NEWLINE DEDENT class NAME : NEWLINE ::: 2667
NAME is NAME : NEWLINE INDENT ::: 2666
DEDENT return NAME . NAME . ::: 2666
. NAME NEWLINE for NAME in ::: 2665
INDENT NAME . NAME = False ::: 2665
. NAME NEWLINE NAME = STRING ::: 2665
. NAME ] NEWLINE NAME . ::: 2664
[ NAME ] , NAME ) ::: 2663
{ } ) , STRING : ::: 2662
, ( NUMBER , STRING ) ::: 2662
NUMBER ] ) NEWLINE DEDENT DEDENT ::: 2660
( ) NEWLINE DEDENT DEDENT EOS ::: 2660
NAME , NAME , NUMBER ) ::: 2660
STRING ) NEWLINE DEDENT class NAME ::: 2659
. NAME = [ NAME . ::: 2659
( STRING , [ STRING ] ::: 2658
== NAME . NAME and NAME ::: 2658
= STRING ) ) NEWLINE NAME ::: 2658
. NAME ( [ NAME ( ::: 2657
, NAME , * NAME ) ::: 2657
NAME ] , NAME [ NAME ::: 2656
NEWLINE INDENT STRING NEWLINE from NAME ::: 2656
DEDENT DEDENT NAME . NAME . ::: 2655
, { } ) , STRING ::: 2654
NUMBER ) ) ) NEWLINE NAME ::: 2654
NAME , NAME ) ) ) ::: 2653
NAME ) in NAME . NAME ::: 2652
NAME , NAME ) NEWLINE for ::: 2652
( NAME , NAME [ NUMBER ::: 2651
STRING STRING . NAME ( NAME ::: 2650
STRING ] ) ) NEWLINE DEDENT ::: 2645
NAME ( NUMBER ) . NAME ::: 2644
) , NAME , NAME ) ::: 2644
NAME > NAME : NEWLINE INDENT ::: 2643
= ( STRING , ) NEWLINE ::: 2643
NAME and NAME : NEWLINE INDENT ::: 2642
] [ STRING ] , NAME ::: 2642
** NAME ) NEWLINE NAME = ::: 2642
NAME = STRING ) ) , ::: 2641
) NEWLINE if NAME == NUMBER ::: 2639
STRING , STRING ) , NUMBER ::: 2639
NAME + STRING NEWLINE NAME = ::: 2639
( NAME = NUMBER ) , ::: 2638
NAME , NAME ) , ( ::: 2638
NEWLINE return NAME , NAME NEWLINE ::: 2635
, { STRING : NAME , ::: 2635
. NAME ( False ) NEWLINE ::: 2635
, { } ) NEWLINE NAME ::: 2634
+ NAME NEWLINE NAME = NAME ::: 2633
NAME ] NEWLINE DEDENT except NAME ::: 2632
if NAME is not None and ::: 2632
= True , NAME = NUMBER ::: 2632
NAME = NAME ( ) . ::: 2631
) != NUMBER : NEWLINE INDENT ::: 2629
% NAME ( NAME ) ) ::: 2629
import NAME NEWLINE from . import ::: 2628
except : NEWLINE INDENT pass NEWLINE ::: 2627
] ) NEWLINE DEDENT NAME . ::: 2627
. NAME ( ) if NAME ::: 2625
STRING } NEWLINE NAME = NAME ::: 2624
, NAME = ( STRING , ::: 2624
NAME NEWLINE DEDENT DEDENT DEDENT def ::: 2624
NAME ( True ) NEWLINE NAME ::: 2623
NAME , STRING ) NEWLINE def ::: 2623
) ) ) NEWLINE DEDENT NAME ::: 2623
NAME [ - NUMBER ] NEWLINE ::: 2622
NAME ( STRING + NAME ) ::: 2621
NAME : NAME . NAME , ::: 2620
, { STRING : NAME } ::: 2619
DEDENT except : NEWLINE INDENT pass ::: 2619
+ NAME ( NAME ) ) ::: 2618
NEWLINE STRING NEWLINE NAME = STRING ::: 2618
in [ STRING , STRING , ::: 2618
NAME = None NEWLINE DEDENT DEDENT ::: 2617
[ STRING ] = True NEWLINE ::: 2617
NEWLINE def NAME ( NAME = ::: 2617
try : NEWLINE INDENT NAME , ::: 2615
, STRING ] , [ STRING ::: 2615
) ) , NAME ( NAME ::: 2614
( NAME , NAME ( STRING ::: 2611
) ) : NEWLINE INDENT return ::: 2611
{ STRING : STRING } } ::: 2611
= [ NAME ] NEWLINE DEDENT ::: 2611
] , STRING ) NEWLINE DEDENT ::: 2611
= NAME . NAME NEWLINE return ::: 2608
= NAME [ NUMBER : ] ::: 2606
( STRING ) ) ) NEWLINE ::: 2605
. NAME ) NEWLINE assert NAME ::: 2605
, STRING , None ) NEWLINE ::: 2605
INDENT NAME = STRING + NAME ::: 2605
, NAME , NAME NEWLINE import ::: 2604
% NAME . NAME NEWLINE DEDENT ::: 2604
= NAME ( NAME [ NAME ::: 2604
, NUMBER ) , STRING : ::: 2603
+ STRING NEWLINE NAME = NAME ::: 2602
NEWLINE with NAME ( NAME , ::: 2599
STRING : NAME ( NAME . ::: 2599
STRING : [ NUMBER , NUMBER ::: 2598
NUMBER , NAME = NAME , ::: 2597
( NAME ( NAME [ STRING ::: 2596
, } NEWLINE NAME = NAME ::: 2596
NEWLINE if NAME . NAME and ::: 2596
NAME ) NEWLINE DEDENT DEDENT except ::: 2594
True NEWLINE NAME . NAME ( ::: 2594
STRING ) , NAME = True ::: 2594
: None , STRING : None ::: 2593
NAME . NAME ) ) , ::: 2590
INDENT NAME ( STRING % NAME ::: 2590
, STRING % NAME ) NEWLINE ::: 2589
( STRING + NAME . NAME ::: 2589
NAME [ NUMBER ] NEWLINE if ::: 2588
NAME ( NAME ) + NAME ::: 2588
True , NAME = STRING , ::: 2588
if NAME and NAME . NAME ::: 2587
= { STRING : NAME ( ::: 2586
DEDENT elif NAME ( NAME ) ::: 2585
. NAME . NAME = NUMBER ::: 2584
[ NAME ] , NAME = ::: 2583
DEDENT NAME [ NAME ] = ::: 2583
NAME = NUMBER NEWLINE DEDENT NAME ::: 2582
) ) NEWLINE DEDENT DEDENT if ::: 2582
, NAME ) , ( NAME ::: 2582
) ) NEWLINE DEDENT DEDENT return ::: 2578
STRING ] [ STRING ] . ::: 2578
NAME . NAME + STRING + ::: 2577
INDENT NAME = NAME [ : ::: 2577
+= NAME . NAME ( NAME ::: 2577
lambda NAME : NAME ( NAME ::: 2574
NAME . NAME NEWLINE from NAME ::: 2574
in [ STRING , STRING ] ::: 2571
. NAME ] = NAME NEWLINE ::: 2571
( STRING STRING % ( NAME ::: 2570
( ) NEWLINE DEDENT DEDENT NAME ::: 2570
STRING , NAME [ NUMBER ] ::: 2565
NEWLINE DEDENT DEDENT class NAME : ::: 2565
STRING NEWLINE if not NAME : ::: 2561
[ STRING ] == STRING : ::: 2560
. NAME ( None , NAME ::: 2560
NAME ) ] NEWLINE NAME = ::: 2560
NUMBER ] for NAME in NAME ::: 2559
+ NUMBER ) ) NEWLINE NAME ::: 2559
) ) , NAME ( STRING ::: 2559
raise NAME NEWLINE DEDENT def NAME ::: 2559
NAME : NEWLINE INDENT STRING NEWLINE ::: 2558
NAME = STRING NEWLINE class NAME ::: 2558
NAME . NAME ) ] NEWLINE ::: 2558
. NAME , STRING : STRING ::: 2557
INDENT if NAME in NAME . ::: 2557
INDENT raise NAME ( STRING . ::: 2557
= NAME NEWLINE NAME = STRING ::: 2556
INDENT NAME = ( STRING , ::: 2555
not NAME ( NAME . NAME ::: 2555
NAME , ( NAME . NAME ::: 2552
NAME . NAME , NAME : ::: 2551
DEDENT DEDENT elif NAME . NAME ::: 2551
. NAME , NAME = False ::: 2551
NAME ( NAME ) - NUMBER ::: 2550
NEWLINE INDENT NAME [ NAME . ::: 2549
( ) : NEWLINE INDENT for ::: 2549
INDENT NAME [ NAME . NAME ::: 2549
: NAME . NAME , NAME ::: 2549
NUMBER : NEWLINE INDENT NAME ( ::: 2548
( NAME = STRING ) ) ::: 2548
NUMBER ) . NAME ( ) ::: 2547
. NAME - NAME . NAME ::: 2547
= True ) NEWLINE def NAME ::: 2545
. NAME ( STRING STRING ) ::: 2545
NAME = True ) NEWLINE def ::: 2544
) ) NEWLINE if NAME : ::: 2544
. NAME ) NEWLINE NAME [ ::: 2543
+ STRING + NAME + STRING ::: 2543
NAME ( ) NEWLINE with NAME ::: 2542
, NUMBER ) ) ) NEWLINE ::: 2540
NAME = ( ( STRING , ::: 2540
NAME . NAME ( [ ( ::: 2540
( ) NEWLINE assert NAME . ::: 2537
[ NAME [ NUMBER ] ] ::: 2536
( STRING , { } ) ::: 2535
= NAME [ STRING ] . ::: 2535
and NAME . NAME is not ::: 2535
NAME , NAME ) , STRING ::: 2533
NAME , [ ] ) NEWLINE ::: 2533
STRING ] == STRING : NEWLINE ::: 2532
( NUMBER , NUMBER ) ] ::: 2531
NAME ( ( STRING , STRING ::: 2531
+ STRING ) NEWLINE NAME . ::: 2530
) . NAME . NAME ( ::: 2528
INDENT NAME . NAME = { ::: 2527
NAME = NAME ( [ STRING ::: 2527
DEDENT elif NAME : NEWLINE INDENT ::: 2526
NAME NEWLINE DEDENT DEDENT else : ::: 2526
NAME NEWLINE DEDENT DEDENT if NAME ::: 2525
NAME = NAME - NAME NEWLINE ::: 2524
] = NAME ( NAME . ::: 2524
NEWLINE for NAME , NAME , ::: 2524
NEWLINE DEDENT DEDENT DEDENT NAME . ::: 2523
STRING , STRING , ) NEWLINE ::: 2523
NEWLINE NAME = NUMBER NEWLINE def ::: 2522
, ( NAME , NAME , ::: 2522
= { STRING : [ STRING ::: 2521
NAME ( NAME = [ NAME ::: 2519
: { STRING : NUMBER , ::: 2519
( NAME ( STRING , STRING ::: 2518
[ STRING ] ) , NAME ::: 2517
, NAME . NAME = NAME ::: 2516
True NEWLINE NAME = True NEWLINE ::: 2516
NEWLINE assert NAME [ NUMBER ] ::: 2516
NAME , NAME . NAME NEWLINE ::: 2514
= STRING NEWLINE DEDENT elif NAME ::: 2513
= True NEWLINE NAME = True ::: 2513
. NAME import NAME NEWLINE DEDENT ::: 2511
STRING , NAME ( NAME = ::: 2510
NAME , NAME ) and NAME ::: 2509
] NEWLINE NAME = NUMBER NEWLINE ::: 2509
if NAME != NAME : NEWLINE ::: 2508
, NAME ) for NAME , ::: 2507
NEWLINE import NAME NEWLINE NAME . ::: 2506
NAME . NAME - NAME . ::: 2505
] . NAME ( NAME . ::: 2505
) ) NEWLINE return NAME . ::: 2504
. NAME [ NUMBER : ] ::: 2502
) , NAME = NUMBER , ::: 2501
. NAME ( ) ] ) ::: 2500
[ NAME ( NAME ) ] ::: 2500
NAME = STRING NEWLINE DEDENT elif ::: 2497
STRING ] = STRING NEWLINE DEDENT ::: 2497
( STRING ) NEWLINE NAME [ ::: 2497
, NAME = NUMBER ) , ::: 2496
NAME ( STRING , ( NUMBER ::: 2495
: NEWLINE INDENT return { STRING ::: 2494
( NAME , STRING ) and ::: 2492
[ NUMBER ] ) , NAME ::: 2491
INDENT continue NEWLINE DEDENT if NAME ::: 2489
return NAME , NAME , NAME ::: 2488
, NUMBER , NUMBER ] ] ::: 2488
] , NAME [ NAME ] ::: 2488
, NAME ) ) ) NEWLINE ::: 2488
NAME = STRING , ) NEWLINE ::: 2487
, NAME ( ) , NAME ::: 2486
NAME . NAME ] , NAME ::: 2486
. NAME ( ) + NAME ::: 2486
) NEWLINE DEDENT DEDENT DEDENT return ::: 2486
[ STRING ] , NUMBER ) ::: 2485
( ) as NAME : NEWLINE ::: 2484
return None NEWLINE DEDENT NAME = ::: 2484
NAME ( ) as NAME : ::: 2484
NEWLINE assert NAME ( NAME ( ::: 2484
( NUMBER , NUMBER , NAME ::: 2483
, NUMBER , - NUMBER ) ::: 2482
DEDENT return NAME , NAME NEWLINE ::: 2482
return NAME . NAME NEWLINE def ::: 2482
NAME , NAME = ( NAME ::: 2481
NAME . NAME = NAME or ::: 2481
NEWLINE INDENT return { STRING : ::: 2480
None NEWLINE DEDENT DEDENT def NAME ::: 2477
) ] NEWLINE DEDENT def NAME ::: 2477
( NAME = True ) ) ::: 2476
NUMBER ) NEWLINE DEDENT NAME . ::: 2476
) NEWLINE NAME [ NUMBER ] ::: 2476
NUMBER ) ) , ( STRING ::: 2475
None NEWLINE NAME = NAME . ::: 2474
INDENT pass NEWLINE DEDENT NAME = ::: 2474
NEWLINE @ NAME . NAME NEWLINE ::: 2472
NEWLINE INDENT NAME += STRING NEWLINE ::: 2471
NAME , STRING ) NEWLINE if ::: 2471
NEWLINE assert not NAME . NAME ::: 2471
[ [ NUMBER , NUMBER , ::: 2470
NAME : NEWLINE INDENT yield NAME ::: 2468
None NEWLINE DEDENT else : NEWLINE ::: 2464
NAME = [ ] , NAME ::: 2464
in NAME ( NUMBER , NUMBER ::: 2463
= NAME , NAME = False ::: 2463
== NUMBER NEWLINE DEDENT def NAME ::: 2461
if NAME [ STRING ] : ::: 2460
= STRING . NAME ( [ ::: 2459
DEDENT except NAME . NAME as ::: 2459
except NAME . NAME as NAME ::: 2458
, NAME = NAME ( NUMBER ::: 2458
or NAME . NAME . NAME ::: 2458
NUMBER ] , NAME = NAME ::: 2458
NAME . NAME ( [ ] ::: 2457
NEWLINE NAME = None NEWLINE if ::: 2457
class NAME : NEWLINE INDENT STRING ::: 2456
INDENT NAME ( STRING % ( ::: 2454
] . NAME ( ) , ::: 2453
[ NAME ] NEWLINE DEDENT except ::: 2453
STRING : NAME ( NAME ) ::: 2452
} NEWLINE for NAME , NAME ::: 2452
= [ NAME . NAME , ::: 2452
NEWLINE def NAME ( * NAME ::: 2450
NAME . NAME , [ NAME ::: 2449
STRING ) , ] NEWLINE NAME ::: 2448
> NAME : NEWLINE INDENT NAME ::: 2446
NAME , NAME ) NEWLINE def ::: 2446
NAME , STRING ) , STRING ::: 2445
] = NAME NEWLINE DEDENT return ::: 2445
STRING ) NEWLINE NAME , NAME ::: 2444
NAME [ STRING ] = [ ::: 2444
INDENT return None NEWLINE DEDENT NAME ::: 2441
NAME . NAME ( False ) ::: 2441
NAME , STRING ) and NAME ::: 2441
) : NEWLINE INDENT return { ::: 2440
DEDENT NAME = STRING NEWLINE NAME ::: 2438
INDENT STRING NEWLINE if NAME : ::: 2438
NUMBER ] ) ) NEWLINE DEDENT ::: 2437
, NAME = ( NAME . ::: 2437
= [ ] , NAME = ::: 2436
, STRING , STRING , ) ::: 2436
: [ ] , STRING : ::: 2436
NAME = [ NAME ( STRING ::: 2435
= { } NEWLINE if NAME ::: 2435
NAME ) ) NEWLINE DEDENT elif ::: 2434
STRING : [ ] , STRING ::: 2433
NAME ( NAME = False , ::: 2432
( NAME ) == NUMBER NEWLINE ::: 2432
[ NAME , NAME ] , ::: 2431
, None , None , None ::: 2430
: [ { STRING : STRING ::: 2430
] [ NUMBER ] NEWLINE NAME ::: 2430
: NAME . NAME , } ::: 2430
] ) NEWLINE DEDENT DEDENT DEDENT ::: 2427
STRING ) NEWLINE DEDENT DEDENT EOS ::: 2427
. NAME + STRING + NAME ::: 2426
and NAME : NEWLINE INDENT NAME ::: 2424
NUMBER ] . NAME ) NEWLINE ::: 2423
NAME ( STRING ) ] NEWLINE ::: 2422
NUMBER NEWLINE DEDENT DEDENT def NAME ::: 2422
STRING ] , NAME = [ ::: 2422
import NAME as NAME NEWLINE NAME ::: 2421
DEDENT NAME . NAME ( NUMBER ::: 2421
DEDENT NAME . NAME [ NAME ::: 2419
NEWLINE ( NAME , NAME ) ::: 2419
, NAME . NAME ( [ ::: 2418
NAME ) : NEWLINE INDENT yield ::: 2417
NEWLINE DEDENT return True NEWLINE DEDENT ::: 2417
) ] ) NEWLINE DEDENT def ::: 2416
== NUMBER : NEWLINE INDENT if ::: 2414
NAME ) == NAME ( NAME ::: 2413
] ) NEWLINE DEDENT if NAME ::: 2411
, STRING ) , STRING ) ::: 2409
NAME [ STRING ] = True ::: 2408
, STRING ) NEWLINE DEDENT if ::: 2408
INDENT STRING NEWLINE raise NAME ( ::: 2408
NAME ) NEWLINE with NAME . ::: 2408
NEWLINE NAME = None NEWLINE def ::: 2407
STRING ] = NUMBER NEWLINE NAME ::: 2406
NAME ( NAME . NAME == ::: 2406
: NEWLINE INDENT STRING NEWLINE assert ::: 2405
INDENT return STRING NEWLINE DEDENT DEDENT ::: 2405
{ STRING : [ STRING , ::: 2405
} NEWLINE NAME . NAME . ::: 2404
elif NAME . NAME ( STRING ::: 2404
] = NAME [ NUMBER ] ::: 2404
: ] NEWLINE NAME = NAME ::: 2403
NUMBER ] . NAME ( NAME ::: 2402
NAME ) , ( NAME , ::: 2401
NAME += NUMBER NEWLINE DEDENT DEDENT ::: 2401
STRING NEWLINE if not NAME ( ::: 2401
NAME [ NUMBER ] : NEWLINE ::: 2400
STRING , NAME ) NEWLINE return ::: 2400
] [ NUMBER ] [ STRING ::: 2399
) , NAME ( NAME , ::: 2399
NAME ] ) ) NEWLINE DEDENT ::: 2397
NUMBER + NUMBER ) ) NEWLINE ::: 2396
in NAME . NAME ) NEWLINE ::: 2396
( STRING % NAME , NAME ::: 2396
, STRING , STRING ) : ::: 2395
, STRING ) , NAME = ::: 2394
] ) ) NEWLINE DEDENT DEDENT ::: 2392
INDENT return True NEWLINE DEDENT DEDENT ::: 2392
( NAME = False , NAME ::: 2392
NAME ( NAME , [ ] ::: 2392
[ STRING ] NEWLINE DEDENT DEDENT ::: 2391
NAME , NAME = [ STRING ::: 2390
( { STRING : NAME , ::: 2390
] , NAME . NAME . ::: 2390
] ) , NAME . NAME ::: 2389
. NAME NEWLINE NAME = [ ::: 2388
NAME ( [ [ NUMBER , ::: 2387
. NAME ( STRING STRING STRING ::: 2386
NAME . NAME , ( NAME ::: 2385
NAME . NAME , STRING % ::: 2385
NAME , STRING ) , NAME ::: 2385
STRING : NEWLINE INDENT NAME [ ::: 2384
NAME = NAME , ) NEWLINE ::: 2383
( ) NEWLINE return NAME ( ::: 2383
. NAME NEWLINE assert NAME . ::: 2382
NAME NEWLINE @ NAME . NAME ::: 2382
. NAME . NAME import * ::: 2378
= NAME . NAME ) ) ::: 2376
and not NAME : NEWLINE INDENT ::: 2376
) , NAME ( NAME ( ::: 2375
( NAME = NAME ) ) ::: 2374
NEWLINE DEDENT NAME = None NEWLINE ::: 2374
NEWLINE if NAME in NAME . ::: 2373
= NUMBER , NAME = False ::: 2373
NEWLINE INDENT break NEWLINE DEDENT NAME ::: 2373
return NAME ( STRING , NAME ::: 2372
NUMBER ) NEWLINE DEDENT DEDENT def ::: 2371
NAME NEWLINE DEDENT return NAME ( ::: 2371
STRING ] [ NUMBER ] [ ::: 2371
NAME , NAME , NUMBER , ::: 2370
NEWLINE NAME ( STRING % NAME ::: 2370
[ NUMBER ] , STRING ) ::: 2369
: ( STRING , STRING , ::: 2367
= NAME ( NAME , NUMBER ::: 2366
NAME = NUMBER NEWLINE if NAME ::: 2365
. NAME ) , STRING : ::: 2365
= NAME NEWLINE DEDENT @ NAME ::: 2365
= NAME . NAME + NAME ::: 2364
) NEWLINE DEDENT if STRING in ::: 2364
NEWLINE INDENT return NAME ( ) ::: 2363
[ NAME ] , NAME [ ::: 2363
NAME == NUMBER NEWLINE assert NAME ::: 2363
. NAME == NUMBER NEWLINE assert ::: 2363
in NAME : NEWLINE INDENT try ::: 2362
( STRING + NAME ) NEWLINE ::: 2361
STRING , NUMBER ) ) NEWLINE ::: 2361
>= NUMBER : NEWLINE INDENT NAME ::: 2359
NAME , NAME NEWLINE DEDENT DEDENT ::: 2358
STRING STRING ) NEWLINE NAME = ::: 2356
, NAME . NAME ] NEWLINE ::: 2356
( NAME . NAME , None ::: 2356
INDENT raise NAME ( NAME ) ::: 2355
, NUMBER ] NEWLINE NAME = ::: 2354
. NAME ( NAME + NAME ::: 2354
STRING ) ( NAME = True ::: 2353
NEWLINE INDENT return NEWLINE DEDENT if ::: 2352
, NUMBER ] , NAME = ::: 2352
NEWLINE return NEWLINE DEDENT NAME = ::: 2351
( NAME ) NEWLINE DEDENT EOS ::: 2348
: NEWLINE INDENT NAME [ NUMBER ::: 2348
, NAME ) in NAME . ::: 2347
STRING NEWLINE DEDENT DEDENT def NAME ::: 2347
] = NAME ( NAME , ::: 2346
NAME , NAME ] NEWLINE NAME ::: 2346
NAME ) NEWLINE NAME += NAME ::: 2345
( NAME ) ) , NAME ::: 2345
= NAME ( NAME = True ::: 2343
if NAME [ NUMBER ] == ::: 2343
] , NAME = NAME , ::: 2343
NAME ( ) NEWLINE class NAME ::: 2342
NAME >= NUMBER : NEWLINE INDENT ::: 2341
) , ( STRING , [ ::: 2340
, STRING ) , NAME . ::: 2339
( STRING ) NEWLINE DEDENT @ ::: 2338
) NEWLINE NAME = False NEWLINE ::: 2337
NEWLINE NAME = STRING NEWLINE if ::: 2335
] = NAME NEWLINE DEDENT def ::: 2335
STRING : STRING , } , ::: 2332
( NAME + STRING ) NEWLINE ::: 2332
, ) NEWLINE DEDENT def NAME ::: 2329
( NUMBER , STRING ) NEWLINE ::: 2329
) and NAME . NAME ( ::: 2329
] NEWLINE DEDENT return NAME NEWLINE ::: 2323
NEWLINE if NAME == NAME . ::: 2323
STRING , STRING ) NEWLINE if ::: 2321
NAME , NAME ] , NAME ::: 2321
, NAME = [ ( STRING ::: 2319
, STRING , NAME , STRING ::: 2319
INDENT if STRING in NAME : ::: 2318
( STRING , [ STRING , ::: 2317
NAME = True ) ) NEWLINE ::: 2317
if NAME . NAME in NAME ::: 2316
= NAME NEWLINE if NAME . ::: 2315
NAME = yield NAME . NAME ::: 2315
NEWLINE NAME = STRING + NAME ::: 2314
NAME , NAME = [ NAME ::: 2314
, STRING : [ { STRING ::: 2313
( NAME , NUMBER , NUMBER ::: 2313
[ NAME [ STRING ] ] ::: 2312
) : NEWLINE INDENT return NUMBER ::: 2312
) : NEWLINE INDENT global NAME ::: 2311
. NAME . NAME == STRING ::: 2311
NUMBER , NUMBER ) ) , ::: 2311
if ( NAME . NAME ) ::: 2311
and NAME . NAME ( NAME ::: 2310
: NEWLINE INDENT global NAME NEWLINE ::: 2309
[ NUMBER ] . NAME [ ::: 2309
NUMBER , NUMBER , NAME = ::: 2309
STRING NEWLINE return NAME NEWLINE DEDENT ::: 2309
= ( NAME . NAME . ::: 2308
import NAME as NAME NEWLINE DEDENT ::: 2306
) + NAME . NAME ( ::: 2305
except NAME : NEWLINE INDENT from ::: 2304
NAME . NAME , ** NAME ::: 2304
NEWLINE NAME = NAME * NAME ::: 2304
STRING , NUMBER , NUMBER ) ::: 2303
[ STRING ] NEWLINE DEDENT def ::: 2302
) NEWLINE @ NAME NEWLINE def ::: 2302
STRING ) ) ) NEWLINE NAME ::: 2300
, STRING , NUMBER ) NEWLINE ::: 2299
STRING NEWLINE NAME . NAME [ ::: 2298
= NAME ( NAME ) ) ::: 2298
= STRING ) . NAME ( ::: 2298
( STRING , NAME [ NUMBER ::: 2297
, NAME = { } , ::: 2296
DEDENT DEDENT if NAME ( NAME ::: 2296
NAME ( STRING + NAME . ::: 2296
] NEWLINE return NAME NEWLINE DEDENT ::: 2295
] ) for NAME in NAME ::: 2295
= STRING NEWLINE class NAME ( ::: 2295
, NAME = lambda NAME : ::: 2293
assert NAME . NAME ( STRING ::: 2293
= NAME ) NEWLINE DEDENT else ::: 2292
NUMBER , - NUMBER ) , ::: 2291
] = NAME NEWLINE return NAME ::: 2290
( NAME [ STRING ] . ::: 2288
. NAME ( NAME = { ::: 2287
( NUMBER + NUMBER ) ) ::: 2287
NEWLINE DEDENT DEDENT return NAME . ::: 2287
NUMBER , NAME ( NAME . ::: 2286
( NAME . NAME ) > ::: 2286
NAME . NAME . NAME is ::: 2284
NEWLINE NAME = ( NAME , ::: 2283
( NAME . NAME ( [ ::: 2282
NAME import NAME NEWLINE NAME ( ::: 2282
NAME ] for NAME in NAME ::: 2281
, NAME ) NEWLINE NAME , ::: 2279
NUMBER ] ) : NEWLINE INDENT ::: 2276
raise NAME ( STRING STRING % ::: 2275
NAME NEWLINE NAME = [ ] ::: 2275
: NAME } NEWLINE NAME = ::: 2274
[ - NUMBER ] . NAME ::: 2274
( [ NUMBER , NUMBER ] ::: 2273
INDENT NAME = [ NAME ] ::: 2273
) NEWLINE ( NAME , NAME ::: 2272
NAME ( STRING ) or NAME ::: 2270
DEDENT @ NAME ( NAME = ::: 2269
= NAME . NAME [ : ::: 2268
] for NAME in NAME . ::: 2268
. NAME ( NUMBER ) . ::: 2267
if NAME : NEWLINE INDENT for ::: 2267
( ) NEWLINE for NAME , ::: 2267
STRING : NEWLINE INDENT raise NAME ::: 2266
= STRING , NAME = { ::: 2266
{ STRING : NUMBER } ) ::: 2265
NAME ( STRING STRING % ( ::: 2265
NAME ) ) NEWLINE DEDENT @ ::: 2264
NAME } NEWLINE NAME = NAME ::: 2262
NAME ( ) . NAME NEWLINE ::: 2262
. NAME [ NUMBER ] == ::: 2260
= [ STRING ] NEWLINE DEDENT ::: 2259
False , NAME = True , ::: 2259
( NUMBER ) , NAME = ::: 2259
( NAME ) , STRING : ::: 2258
DEDENT if NAME == NUMBER : ::: 2258
, False ) NEWLINE NAME . ::: 2257
, ( NUMBER + NUMBER ) ::: 2257
NAME NEWLINE DEDENT try : NEWLINE ::: 2257
, STRING : ( NUMBER , ::: 2256
) NEWLINE if not NAME ( ::: 2255
, NAME . NAME ] ) ::: 2255
- NUMBER , NUMBER , - ::: 2254
NAME . NAME . NAME + ::: 2253
) NEWLINE DEDENT with NAME . ::: 2251
INDENT del NAME . NAME [ ::: 2251
% NAME . NAME ( NAME ::: 2251
[ NUMBER : ] ) NEWLINE ::: 2251
NAME . NAME NEWLINE NAME ( ::: 2250
= NAME ) NEWLINE DEDENT except ::: 2250
NAME . NAME NEWLINE class NAME ::: 2247
NEWLINE DEDENT DEDENT @ NAME ( ::: 2247
as NAME : NEWLINE INDENT if ::: 2247
NAME . NAME ( lambda NAME ::: 2246
NAME ] NEWLINE DEDENT NAME = ::: 2246
: STRING , } NEWLINE NAME ::: 2246
( STRING ) ) , NAME ::: 2244
( STRING , STRING , NUMBER ::: 2243
] NEWLINE NAME = { STRING ::: 2242
NEWLINE NAME = STRING NEWLINE class ::: 2240
STRING NEWLINE NAME = True NEWLINE ::: 2240
. NAME ) ) NEWLINE if ::: 2240
) [ NUMBER ] ) NEWLINE ::: 2239
NAME } ) NEWLINE NAME . ::: 2239
] = NAME . NAME [ ::: 2239
NAME , { STRING : STRING ::: 2239
STRING } NEWLINE NAME . NAME ::: 2238
NAME NEWLINE return NAME ( NAME ::: 2237
NUMBER ] , STRING ) NEWLINE ::: 2236
) NEWLINE DEDENT for NAME , ::: 2236
= NAME ( { STRING : ::: 2236
NAME ( ) == STRING : ::: 2235
( STRING , STRING , { ::: 2235
STRING , NUMBER , NUMBER , ::: 2235
NAME ) , NAME ( STRING ::: 2234
NEWLINE INDENT NAME ( NAME ( ::: 2234
: NEWLINE INDENT STRING NEWLINE @ ::: 2234
) ) NEWLINE assert NAME ( ::: 2234
NEWLINE INDENT STRING NEWLINE @ NAME ::: 2234
NUMBER , STRING : STRING } ::: 2233
STRING ] NEWLINE DEDENT else : ::: 2232
- NUMBER ] NEWLINE NAME = ::: 2228
INDENT NAME = STRING NEWLINE def ::: 2227
STRING ] for NAME in NAME ::: 2227
DEDENT return NAME NEWLINE DEDENT EOS ::: 2226
NEWLINE NAME ( STRING , STRING ::: 2226
) ) NEWLINE DEDENT for NAME ::: 2224
STRING , STRING : [ STRING ::: 2224
. NAME NEWLINE if not NAME ::: 2224
NAME = NAME + STRING + ::: 2224
False , NAME = None , ::: 2224
NAME = NAME ( { STRING ::: 2223
INDENT return NEWLINE DEDENT NAME . ::: 2223
( NAME = NAME ) . ::: 2222
+ NAME . NAME ) NEWLINE ::: 2222
] . NAME ) NEWLINE NAME ::: 2220
NAME ( ) ] ) NEWLINE ::: 2220
[ STRING ] for NAME in ::: 2218
STRING , STRING ) NEWLINE def ::: 2217
NAME ( ) , NAME , ::: 2217
+ NAME . NAME ( ) ::: 2216
[ NUMBER ] for NAME in ::: 2216
False NEWLINE DEDENT DEDENT def NAME ::: 2215
( STRING , NAME ( ) ::: 2214
NAME . NAME ) > NUMBER ::: 2212
NAME = NAME ( lambda NAME ::: 2212
, NUMBER , NAME ) NEWLINE ::: 2211
NAME ( ) ) NEWLINE return ::: 2211
STRING NEWLINE NAME = False NEWLINE ::: 2209
. NAME = NAME [ NUMBER ::: 2208
NAME : NEWLINE INDENT import NAME ::: 2208
STRING ) NEWLINE DEDENT if not ::: 2208
. NAME , NAME ) , ::: 2208
NUMBER : ( STRING , STRING ::: 2207
( ) == STRING : NEWLINE ::: 2207
. NAME ( lambda NAME : ::: 2207
return NAME ( STRING ) NEWLINE ::: 2205
[ NAME ( NAME , NAME ::: 2205
NAME ] , NAME ) NEWLINE ::: 2205
- NUMBER : NEWLINE INDENT NAME ::: 2204
NAME . NAME NEWLINE if not ::: 2204
NUMBER ) NEWLINE NAME = ( ::: 2203
( ) ) NEWLINE if NAME ::: 2202
STRING , STRING ) ] ) ::: 2201
NAME : NEWLINE INDENT return True ::: 2201
, NAME ) ) NEWLINE if ::: 2201
( NAME ) == NAME ( ::: 2199
. NAME [ NAME ] , ::: 2198
NAME . NAME ) for NAME ::: 2197
return NAME NEWLINE DEDENT DEDENT DEDENT ::: 2197
STRING : NAME } NEWLINE DEDENT ::: 2195
( STRING ) , NAME ) ::: 2195
: NEWLINE INDENT if NAME != ::: 2195
NUMBER , NAME = None , ::: 2194
NEWLINE INDENT STRING NEWLINE with NAME ::: 2193
= { } NEWLINE NAME [ ::: 2193
( STRING ) NEWLINE DEDENT elif ::: 2193
: NEWLINE INDENT STRING NEWLINE with ::: 2193
( STRING + NAME + STRING ::: 2193
= NAME NEWLINE DEDENT DEDENT NAME ::: 2192
) , ) NEWLINE NAME = ::: 2191
INDENT NAME = None NEWLINE NAME ::: 2190
. NAME NEWLINE class NAME ( ::: 2189
NAME = STRING NEWLINE for NAME ::: 2189
NAME [ STRING ] == NAME ::: 2188
, STRING : NUMBER } NEWLINE ::: 2188
NAME NEWLINE import NAME NEWLINE def ::: 2187
, None ) NEWLINE DEDENT def ::: 2187
NAME [ NAME ] ) ) ::: 2187
STRING , STRING : NUMBER } ::: 2186
[ STRING ] NEWLINE DEDENT NAME ::: 2185
[ NUMBER ] NEWLINE DEDENT def ::: 2184
] ) NEWLINE DEDENT return NAME ::: 2184
NEWLINE if NAME == NAME : ::: 2184
. NAME : NEWLINE INDENT try ::: 2182
NEWLINE DEDENT if NAME == NUMBER ::: 2181
NAME in NAME . NAME ) ::: 2180
None , STRING : None , ::: 2180
STRING % NAME NEWLINE NAME = ::: 2179
: STRING } NEWLINE NAME . ::: 2178
None , None , None , ::: 2177
, NAME NEWLINE def NAME ( ::: 2177
= NAME NEWLINE DEDENT DEDENT class ::: 2177
for NAME in [ STRING , ::: 2175
!= NUMBER : NEWLINE INDENT raise ::: 2175
NEWLINE INDENT NAME STRING NEWLINE NAME ::: 2175
NAME = NAME ( STRING STRING ::: 2173
: NUMBER } ) NEWLINE NAME ::: 2173
STRING NEWLINE NAME = NAME [ ::: 2172
STRING : { STRING : [ ::: 2172
STRING , NAME = None ) ::: 2170
None , NAME = STRING ) ::: 2169
= lambda NAME : NAME . ::: 2169
] ) NEWLINE for NAME in ::: 2169
) ) NEWLINE DEDENT DEDENT else ::: 2167
[ NAME , NAME ] NEWLINE ::: 2166
) ) NEWLINE if not NAME ::: 2164
NEWLINE DEDENT NAME = { } ::: 2164
lambda NAME , NAME : NAME ::: 2163
if NAME != STRING : NEWLINE ::: 2163
( [ [ NUMBER , NUMBER ::: 2163
* NAME + NAME * NAME ::: 2163
NEWLINE try : NEWLINE INDENT if ::: 2163
( STRING , ( NUMBER + ::: 2163
== NAME . NAME NEWLINE DEDENT ::: 2162
, STRING , STRING ] : ::: 2162
NAME + STRING + NAME + ::: 2161
NEWLINE INDENT if NAME [ NUMBER ::: 2161
NAME } NEWLINE NAME . NAME ::: 2159
NEWLINE INDENT NAME [ NUMBER ] ::: 2159
False , NAME = True ) ::: 2157
STRING , NAME ( STRING , ::: 2157
with NAME . NAME ( STRING ::: 2156
[ ( NAME , NAME ) ::: 2156
NUMBER , NAME ) NEWLINE DEDENT ::: 2156
NEWLINE DEDENT DEDENT return NAME ( ::: 2155
. NAME in NAME . NAME ::: 2155
None , NAME = NUMBER , ::: 2154
. NAME ) NEWLINE if not ::: 2154
NAME NEWLINE @ NAME NEWLINE def ::: 2154
NAME = NAME ( ) , ::: 2153
] [ STRING ] , STRING ::: 2152
NAME ( STRING , [ NAME ::: 2151
[ NUMBER ] . NAME NEWLINE ::: 2151
, NAME ] ) NEWLINE DEDENT ::: 2151
NAME , NAME NEWLINE def NAME ::: 2151
] . NAME ( STRING , ::: 2151
STRING , ( NUMBER + NUMBER ::: 2150
, NAME = NAME ) . ::: 2150
NAME * NAME + NAME * ::: 2150
DEDENT if NAME [ STRING ] ::: 2150
. NAME NEWLINE if NAME is ::: 2149
: STRING } ) NEWLINE DEDENT ::: 2149
. NAME and not NAME . ::: 2149
DEDENT else : NEWLINE INDENT for ::: 2149
[ NUMBER ] NEWLINE DEDENT DEDENT ::: 2148
[ NAME ] ) ) NEWLINE ::: 2148
: NEWLINE INDENT return [ ] ::: 2147
STRING , STRING , NUMBER ) ::: 2147
= NAME + STRING + NAME ::: 2147
NEWLINE if NAME > NUMBER : ::: 2147
NUMBER ) NEWLINE assert NAME ( ::: 2146
[ NAME . NAME ] , ::: 2146
( NAME , [ ] ) ::: 2146
% NAME ) NEWLINE NAME = ::: 2145
, STRING : STRING } ] ::: 2145
NAME ) != NUMBER : NEWLINE ::: 2144
NAME ( ) ) . NAME ::: 2144
NAME and NAME . NAME == ::: 2143
) . NAME ( ** NAME ::: 2143
NAME NEWLINE NAME = [ NAME ::: 2142
( ) NEWLINE NAME ( STRING ::: 2141
= NAME + STRING NEWLINE NAME ::: 2141
+ NAME ( NAME ) NEWLINE ::: 2140
: STRING , STRING : True ::: 2140
NEWLINE DEDENT elif NAME : NEWLINE ::: 2140
NAME [ NUMBER ] , NUMBER ::: 2139
NAME = STRING NEWLINE DEDENT if ::: 2139
NAME for NAME , NAME in ::: 2137
, NAME ) , NAME . ::: 2137
NEWLINE return NAME ( NAME ( ::: 2137
and NAME . NAME ( ) ::: 2136
, NAME , STRING , STRING ::: 2136
NAME ) NEWLINE DEDENT try : ::: 2136
INDENT yield NAME NEWLINE DEDENT DEDENT ::: 2134
NUMBER ) NEWLINE for NAME in ::: 2132
STRING , STRING : NAME , ::: 2131
elif NAME == NAME . NAME ::: 2130
NEWLINE DEDENT DEDENT elif NAME . ::: 2129
NAME >> NAME . NAME , ::: 2129
( NAME ( NAME = NAME ::: 2129
NEWLINE INDENT STRING NEWLINE DEDENT class ::: 2128
+ NAME . NAME + STRING ::: 2128
INDENT STRING NEWLINE DEDENT class NAME ::: 2128
. NAME ) for NAME in ::: 2128
] NEWLINE DEDENT DEDENT class NAME ::: 2127
NAME + STRING ) NEWLINE DEDENT ::: 2126
( NUMBER ) . NAME ( ::: 2125
( NAME ) NEWLINE DEDENT for ::: 2124
{ STRING : True , STRING ::: 2123
INDENT NAME . NAME ( { ::: 2121
STRING NEWLINE assert NAME ( NAME ::: 2121
] = NAME ( NAME [ ::: 2121
[ - NUMBER ] NEWLINE NAME ::: 2119
] ) , NAME ( NAME ::: 2118
( NAME = STRING ) , ::: 2117
NAME . NAME in NAME . ::: 2117
NEWLINE INDENT NAME += NAME . ::: 2116
NUMBER , NUMBER ] ] ) ::: 2116
INDENT NAME += NAME . NAME ::: 2116
NAME = NAME NEWLINE DEDENT @ ::: 2116
, NAME = False ) , ::: 2115
NAME == NAME . NAME ) ::: 2114
NAME NEWLINE DEDENT for NAME in ::: 2113
INDENT NAME += NUMBER NEWLINE DEDENT ::: 2113
NEWLINE @ NAME . NAME . ::: 2112
NUMBER ] ] ) NEWLINE NAME ::: 2112
STRING ] ) : NEWLINE INDENT ::: 2112
NAME = { NAME . NAME ::: 2112
else : NEWLINE INDENT for NAME ::: 2112
) < NUMBER : NEWLINE INDENT ::: 2111
STRING NEWLINE with NAME . NAME ::: 2110
as NAME : NEWLINE INDENT raise ::: 2108
NAME ) NEWLINE if NAME != ::: 2108
[ NUMBER ] NEWLINE DEDENT else ::: 2107
% NAME . NAME ( ) ::: 2106
] , NAME = True ) ::: 2106
INDENT NAME = NAME + NAME ::: 2105
STRING STRING STRING ) NEWLINE NAME ::: 2104
= True , NAME = None ::: 2104
( NAME , STRING % NAME ::: 2104
NAME NEWLINE assert NAME ( NAME ::: 2103
. import NAME NEWLINE from . ::: 2102
] . NAME [ NUMBER ] ::: 2101
. NAME * NAME . NAME ::: 2101
NAME . NAME ) + STRING ::: 2100
. NAME ( NAME ) == ::: 2099
NEWLINE if NAME [ NUMBER ] ::: 2098
, { STRING : { STRING ::: 2098
, ) NEWLINE def NAME ( ::: 2098
STRING : NUMBER } NEWLINE NAME ::: 2097
NAME [ NAME . NAME . ::: 2096
. NAME as NAME NEWLINE from ::: 2096
NAME [ STRING ] for NAME ::: 2093
NUMBER ) : NEWLINE INDENT if ::: 2090
if not NAME ( NAME ) ::: 2090
None ) NEWLINE if NAME is ::: 2089
) NEWLINE if NAME not in ::: 2088
, NAME ) NEWLINE try : ::: 2088
NAME . NAME ) and NAME ::: 2088
. NAME . NAME = True ::: 2086
NAME = False ) , NAME ::: 2086
: [ NUMBER , NUMBER , ::: 2086
. NAME ( [ [ NUMBER ::: 2086
return NAME ( NAME , STRING ::: 2085
STRING NEWLINE DEDENT DEDENT class NAME ::: 2085
, NAME , NAME ] NEWLINE ::: 2085
{ } NEWLINE for NAME , ::: 2084
, NAME , NAME ] ) ::: 2084
) NEWLINE if ( NAME . ::: 2083
] ) NEWLINE DEDENT except NAME ::: 2083
NAME ( NAME ) != NUMBER ::: 2082
INDENT STRING NEWLINE DEDENT def NAME ::: 2082
NEWLINE INDENT STRING NEWLINE DEDENT def ::: 2082
DEDENT return False NEWLINE DEDENT def ::: 2080
NAME ) NEWLINE DEDENT finally : ::: 2079
NEWLINE DEDENT elif NAME == NUMBER ::: 2079
[ NAME ] NEWLINE DEDENT else ::: 2078
INDENT if NAME [ NUMBER ] ::: 2078
NEWLINE return NEWLINE DEDENT NAME . ::: 2077
. NAME ) ) NEWLINE return ::: 2077
elif NAME . NAME . NAME ::: 2075
NAME . NAME * NAME . ::: 2075
. NAME is not None and ::: 2074
: NEWLINE INDENT NAME STRING , ::: 2074
NAME ( [ NAME ] , ::: 2073
: NEWLINE INDENT del NAME [ ::: 2072
STRING , STRING , { STRING ::: 2072
[ ( STRING , NAME ) ::: 2072
NAME [ NAME [ NUMBER ] ::: 2072
, NAME . NAME ) ] ::: 2072
= NAME ( NUMBER , NAME ::: 2070
NEWLINE NAME = [ ( NAME ::: 2070
NAME NEWLINE DEDENT elif NAME ( ::: 2069
NAME , ) NEWLINE NAME = ::: 2068
[ NUMBER : ] NEWLINE DEDENT ::: 2068
NAME : NEWLINE INDENT assert NAME ::: 2067
NUMBER ] [ STRING ] , ::: 2067
( NAME ( ) , NAME ::: 2067
DEDENT DEDENT if not NAME : ::: 2067
NAME NEWLINE DEDENT if NAME == ::: 2066
== STRING NEWLINE assert NAME . ::: 2065
NAME , NAME , ) NEWLINE ::: 2064
NEWLINE INDENT NAME STRING NEWLINE DEDENT ::: 2063
] . NAME . NAME ( ::: 2063
NEWLINE INDENT return [ ] NEWLINE ::: 2062
NAME : NEWLINE INDENT with NAME ::: 2062
INDENT return [ ] NEWLINE DEDENT ::: 2062
NEWLINE raise NAME . NAME ( ::: 2062
- NUMBER ) : NEWLINE INDENT ::: 2061
STRING ) ) NEWLINE DEDENT NAME ::: 2060
[ STRING ] NEWLINE DEDENT if ::: 2059
DEDENT NAME = STRING . NAME ::: 2059
( - NUMBER , NUMBER ) ::: 2058
NAME NEWLINE DEDENT if NAME ( ::: 2058
= False NEWLINE NAME = NAME ::: 2058
: STRING } , NAME = ::: 2057
NAME , NAME , NAME [ ::: 2057
STRING NEWLINE @ NAME NEWLINE def ::: 2056
NAME [ NAME + NUMBER ] ::: 2055
NAME [ STRING ] ( NAME ::: 2054
) == STRING NEWLINE assert NAME ::: 2054
, STRING : STRING } } ::: 2054
NEWLINE for ( NAME , NAME ::: 2054
( * NAME ) NEWLINE DEDENT ::: 2053
( ) , NAME ( ) ::: 2053
STRING ] : NEWLINE INDENT if ::: 2052
NAME NEWLINE DEDENT DEDENT DEDENT DEDENT ::: 2052
[ NUMBER ] , NUMBER ) ::: 2052
NAME ( * NAME . NAME ::: 2052
{ STRING : NAME [ STRING ::: 2052
{ } NEWLINE DEDENT def NAME ::: 2051
STRING . NAME ( [ STRING ::: 2050
= [ { STRING : STRING ::: 2050
= NAME ( NAME ( STRING ::: 2049
DEDENT elif NAME . NAME . ::: 2049
not NAME ( NAME ) : ::: 2049
NAME , NAME = { } ::: 2049
) . NAME ( ) : ::: 2049
NAME : NEWLINE INDENT del NAME ::: 2048
NAME ( * NAME ) : ::: 2046
INDENT import NAME NEWLINE NAME = ::: 2045
INDENT raise NAME ( NAME . ::: 2045
. NAME if NAME . NAME ::: 2044
None NEWLINE NAME . NAME ( ::: 2043
NAME = ( STRING STRING ) ::: 2043
STRING STRING % ( NAME , ::: 2043
NAME = NAME . NAME = ::: 2043
NEWLINE DEDENT return False NEWLINE DEDENT ::: 2041
NUMBER , NUMBER ] , STRING ::: 2041
[ STRING , STRING ] : ::: 2040
STRING ] ) NEWLINE DEDENT NAME ::: 2038
) NEWLINE DEDENT NAME ( STRING ::: 2037
DEDENT return True NEWLINE DEDENT def ::: 2037
DEDENT NAME ( NAME ) NEWLINE ::: 2037
[ STRING ] NEWLINE DEDENT else ::: 2037
( NAME . NAME + STRING ::: 2036
NAME ( NAME ) and NAME ::: 2035
NAME , * NAME ) NEWLINE ::: 2035
INDENT NAME += STRING NEWLINE DEDENT ::: 2035
INDENT STRING NEWLINE from NAME . ::: 2033
from NAME import NAME NEWLINE def ::: 2032
NEWLINE NAME = [ NUMBER , ::: 2032
STRING , STRING , ] , ::: 2031
STRING , ( NUMBER , NUMBER ::: 2030
STRING STRING STRING STRING ) NEWLINE ::: 2029
. NAME ( ) , [ ::: 2029
NAME ) and NAME ( NAME ::: 2028
DEDENT elif NAME == NAME . ::: 2028
= STRING NEWLINE DEDENT if NAME ::: 2027
= NAME ( lambda NAME : ::: 2026
NAME = NAME ( * NAME ::: 2024
INDENT if NAME == NAME . ::: 2023
is NAME : NEWLINE INDENT NAME ::: 2022
== NAME NEWLINE DEDENT def NAME ::: 2021
, NAME ) ) NEWLINE return ::: 2021
INDENT pass NEWLINE DEDENT DEDENT DEDENT ::: 2021
DEDENT if NAME ( NAME . ::: 2020
= NUMBER ) NEWLINE DEDENT def ::: 2020
NAME . NAME + STRING ) ::: 2020
NAME NEWLINE NAME = ( NAME ::: 2020
( [ NAME . NAME . ::: 2020
NAME ( NAME ) ] ) ::: 2019
NUMBER ) ] NEWLINE NAME = ::: 2018
( STRING , ( STRING , ::: 2016
NAME [ NUMBER ] == NAME ::: 2016
STRING not in NAME . NAME ::: 2015
NEWLINE NAME ( STRING % ( ::: 2015
NEWLINE NAME . NAME [ NUMBER ::: 2015
STRING : ( NUMBER , NUMBER ::: 2015
NAME , NAME ) ] NEWLINE ::: 2014
STRING , NAME . NAME [ ::: 2013
= NUMBER NEWLINE DEDENT def NAME ::: 2012
NEWLINE NAME = [ NAME [ ::: 2011
* NAME NEWLINE NAME = NAME ::: 2011
= [ ] NEWLINE DEDENT def ::: 2010
= NAME . NAME NEWLINE def ::: 2010
) NEWLINE NAME = [ ( ::: 2010
[ : - NUMBER ] NEWLINE ::: 2008
) , NAME , NAME , ::: 2008
NUMBER ) ) NEWLINE NAME ( ::: 2008
NEWLINE assert NAME . NAME [ ::: 2007
NEWLINE NAME = NAME ( { ::: 2007
STRING ) NEWLINE return NAME . ::: 2007
NEWLINE if NAME . NAME [ ::: 2006
[ ( NUMBER , NUMBER ) ::: 2006
and not NAME . NAME ( ::: 2006
[ STRING ] NEWLINE NAME [ ::: 2004
STRING ] ) NEWLINE def NAME ::: 2004
NAME import NAME NEWLINE try : ::: 2004
INDENT return NAME NEWLINE DEDENT else ::: 2004
) NEWLINE assert NAME == NAME ::: 2003
NAME = None NEWLINE for NAME ::: 2003
. NAME , STRING ) , ::: 2003
NAME ) ] ) NEWLINE DEDENT ::: 2003
NAME ] ) NEWLINE DEDENT NAME ::: 2002
NAME . NAME = [ STRING ::: 2002
NUMBER ) . NAME ( NAME ::: 2001
( True ) NEWLINE NAME . ::: 2001
. NAME ( STRING ) and ::: 2000
+= NUMBER NEWLINE NAME . NAME ::: 1999
, STRING : [ NUMBER , ::: 1999
, ) ) NEWLINE NAME = ::: 1998
, } NEWLINE NAME . NAME ::: 1997
NAME . NAME if NAME . ::: 1996
. NAME [ STRING ] : ::: 1996
NAME = None ) NEWLINE NAME ::: 1995
NAME . NAME not in NAME ::: 1993
= STRING NEWLINE if NAME . ::: 1992
] NEWLINE NAME , NAME = ::: 1991
INDENT if NAME . NAME [ ::: 1990
NAME ( STRING STRING % NAME ::: 1990
NAME : STRING , NAME : ::: 1990
NUMBER : NEWLINE INDENT NAME [ ::: 1990
( ) . NAME . NAME ::: 1989
NAME + STRING + NAME . ::: 1989
. NAME NEWLINE if NAME : ::: 1988
( NAME . NAME + NAME ::: 1988
NEWLINE return STRING . NAME ( ::: 1988
] ) ) NEWLINE DEDENT def ::: 1987
INDENT NAME = [ ( STRING ::: 1986
, NAME , NAME , STRING ::: 1986
NAME ( ) . NAME . ::: 1986
False , NAME = STRING , ::: 1984
NAME NEWLINE NAME = ( STRING ::: 1982
{ } NEWLINE NAME [ STRING ::: 1982
STRING ) NEWLINE return NEWLINE DEDENT ::: 1981
( STRING STRING STRING STRING STRING ::: 1978
( NAME , NAME = [ ::: 1978
( * NAME ) : NEWLINE ::: 1978
NAME = NAME ) NEWLINE assert ::: 1977
NEWLINE import NAME , NAME NEWLINE ::: 1975
= NUMBER NEWLINE DEDENT else : ::: 1973
= NAME ( NAME ) , ::: 1973
NEWLINE import NAME NEWLINE from . ::: 1973
NAME ( STRING + NAME + ::: 1972
= NAME ( [ STRING , ::: 1971
except : NEWLINE INDENT NAME = ::: 1971
, STRING : [ ] , ::: 1971
NAME ( NAME ) if NAME ::: 1971
NAME , ) ) NEWLINE NAME ::: 1971
= NUMBER ) ) , ( ::: 1970
NEWLINE if STRING in NAME . ::: 1970
, } NEWLINE def NAME ( ::: 1969
. NAME ( ) == NUMBER ::: 1968
None NEWLINE if NAME . NAME ::: 1966
NAME = NAME ( ) ) ::: 1966
DEDENT @ NAME NEWLINE @ NAME ::: 1966
] ) NEWLINE NAME [ STRING ::: 1965
INDENT NAME = ( NAME . ::: 1965
DEDENT DEDENT return NAME ( NAME ::: 1962
NEWLINE INDENT return NAME [ NAME ::: 1962
NUMBER ] [ NUMBER ] , ::: 1961
NUMBER , NUMBER ) , NUMBER ::: 1960
STRING ] , NUMBER ) NEWLINE ::: 1960
from . import NAME NEWLINE from ::: 1960
[ STRING ] ) NEWLINE if ::: 1959
NAME ( NAME + STRING , ::: 1958
True , NAME = False ) ::: 1958
= NAME ( ) , NAME ::: 1957
( NAME ( NUMBER ) ) ::: 1957
, ) NEWLINE NAME = ( ::: 1956
] = NUMBER NEWLINE NAME [ ::: 1956
DEDENT DEDENT try : NEWLINE INDENT ::: 1956
STRING , STRING : NAME ( ::: 1955
. NAME ( NAME = ( ::: 1955
( STRING STRING ) NEWLINE NAME ::: 1955
) NEWLINE if NAME [ STRING ::: 1955
else : NEWLINE INDENT try : ::: 1955
) NEWLINE @ NAME ( STRING ::: 1954
NUMBER ) , NUMBER ) NEWLINE ::: 1953
STRING ) NEWLINE if NAME ( ::: 1952
NAME ( STRING STRING STRING STRING ::: 1952
NAME ( ( STRING , NAME ::: 1952
or NAME . NAME ( STRING ::: 1952
= NAME . NAME NEWLINE for ::: 1951
NAME = NAME ( [ ( ::: 1951
, STRING ) and NAME . ::: 1950
NAME , [ NAME . NAME ::: 1950
NAME = None NEWLINE DEDENT if ::: 1950
return STRING % NAME . NAME ::: 1949
] ) NEWLINE DEDENT @ NAME ::: 1949
= NAME . NAME ) . ::: 1948
INDENT NAME = NAME ( NUMBER ::: 1947
NEWLINE INDENT if ( NAME . ::: 1947
( NAME , STRING , NUMBER ::: 1947
INDENT if ( NAME . NAME ::: 1947
( NAME ) NEWLINE NAME += ::: 1946
DEDENT else : NEWLINE INDENT try ::: 1943
) ) ) NEWLINE NAME ( ::: 1940
NAME and NAME . NAME : ::: 1940
NEWLINE DEDENT DEDENT if NAME ( ::: 1939
return NEWLINE DEDENT def NAME ( ::: 1939
NAME ) . NAME ( ** ::: 1939
( STRING , False ) NEWLINE ::: 1939
] , NAME = { STRING ::: 1938
NEWLINE NAME = ( STRING STRING ::: 1938
, NAME ( NUMBER ) ) ::: 1937
) NEWLINE DEDENT if ( NAME ::: 1936
else : NEWLINE INDENT return STRING ::: 1936
NAME [ NAME : NAME + ::: 1936
% ( NAME , NAME ( ::: 1936
: NAME ( NAME , NAME ::: 1935
elif NAME . NAME : NEWLINE ::: 1935
elif NAME . NAME == NAME ::: 1935
( [ NAME ] ) NEWLINE ::: 1934
DEDENT elif NAME . NAME : ::: 1934
: STRING , NAME : STRING ::: 1934
= True ) NEWLINE DEDENT def ::: 1933
( NAME ) ] NEWLINE NAME ::: 1933
( STRING , NUMBER , NAME ::: 1933
. NAME , NAME : NEWLINE ::: 1933
STRING } ) NEWLINE NAME = ::: 1932
= NAME , NAME = None ::: 1931
= NAME . NAME ) : ::: 1930
DEDENT return None NEWLINE DEDENT def ::: 1930
NAME NEWLINE DEDENT DEDENT NAME . ::: 1929
NAME . NAME [ : ] ::: 1928
= [ NAME ] NEWLINE NAME ::: 1927
NAME + NAME . NAME ( ::: 1927
, NUMBER ] , STRING : ::: 1926
DEDENT NAME = NAME [ NAME ::: 1925
STRING ) or NAME . NAME ::: 1925
NAME = NAME NEWLINE DEDENT return ::: 1925
) : NEWLINE INDENT return None ::: 1924
NAME = NAME [ : - ::: 1923
NAME = NAME [ : NAME ::: 1923
None : NEWLINE INDENT NAME ( ::: 1922
) NEWLINE DEDENT DEDENT NAME ( ::: 1921
) ) NEWLINE NAME [ STRING ::: 1920
) , STRING : ( NUMBER ::: 1920
STRING + NAME . NAME + ::: 1919
. NAME ) , NAME ) ::: 1919
] ) NEWLINE NAME = [ ::: 1919
INDENT NAME = True NEWLINE NAME ::: 1918
DEDENT if ( NAME . NAME ::: 1918
( STRING % ( NAME ( ::: 1918
( NAME [ NUMBER : ] ::: 1917
NEWLINE DEDENT DEDENT NAME = [ ::: 1917
STRING % NAME . NAME , ::: 1916
NEWLINE INDENT STRING NEWLINE assert NAME ::: 1914
STRING , NAME , NAME . ::: 1914
NEWLINE INDENT NAME += STRING % ::: 1914
NUMBER ) NEWLINE DEDENT if NAME ::: 1914
( ) NEWLINE NAME ( ) ::: 1913
, STRING , ) NEWLINE NAME ::: 1913
+ STRING . NAME ( NAME ::: 1913
NAME [ - NUMBER ] ) ::: 1913
INDENT return NAME NEWLINE DEDENT return ::: 1911
( NAME . NAME ) ] ::: 1911
NAME [ NUMBER , NUMBER ] ::: 1911
NAME * NAME . NAME ( ::: 1911
pass NEWLINE DEDENT NAME . NAME ::: 1911
NUMBER ] [ NUMBER ] NEWLINE ::: 1911
= STRING NEWLINE DEDENT def NAME ::: 1910
assert NAME ( NAME ( NAME ::: 1910
del NAME [ STRING ] NEWLINE ::: 1909
) NEWLINE DEDENT NAME [ STRING ::: 1909
NEWLINE NAME . NAME ( True ::: 1908
INDENT return STRING NEWLINE DEDENT def ::: 1908
NAME NEWLINE if NAME is not ::: 1906
, STRING , NAME ( NAME ::: 1906
STRING ) ) . NAME ( ::: 1905
] NEWLINE DEDENT class NAME ( ::: 1905
, NUMBER , NUMBER , - ::: 1905
( STRING , NAME = False ::: 1904
NUMBER ] , NUMBER ) NEWLINE ::: 1904
NAME ) , NAME ) ) ::: 1904
) ) NEWLINE try : NEWLINE ::: 1903
BOS NEWLINE NAME = STRING NEWLINE ::: 1903
) == NAME ( NAME ) ::: 1903
) == NAME : NEWLINE INDENT ::: 1902
NEWLINE NAME STRING NEWLINE NAME STRING ::: 1901
NEWLINE INDENT if NAME [ NAME ::: 1901
= NAME ) NEWLINE DEDENT if ::: 1900
, NUMBER ) ] ) NEWLINE ::: 1897
, NAME = { } ) ::: 1897
NAME = ( STRING STRING STRING ::: 1895
( STRING , None ) , ::: 1894
NAME = NUMBER NEWLINE DEDENT def ::: 1893
NAME = ( NAME , ) ::: 1893
, NUMBER , STRING ) NEWLINE ::: 1893
) NEWLINE NAME . NAME += ::: 1893
NAME = { } , NAME ::: 1891
NAME , STRING , NUMBER ) ::: 1890
DEDENT DEDENT finally : NEWLINE INDENT ::: 1889
NAME ) : NEWLINE INDENT import ::: 1889
NUMBER , NUMBER ] ) , ::: 1889
STRING ) ) NEWLINE NAME ( ::: 1888
= NAME ( ) NEWLINE def ::: 1888
INDENT return NAME ( NAME = ::: 1888
, NAME NEWLINE NAME . NAME ::: 1888
NAME . NAME } NEWLINE NAME ::: 1888
( NAME = None ) : ::: 1888
) , STRING : ( NAME ::: 1887
NAME . NAME : NAME , ::: 1887
. NAME NEWLINE import NAME NEWLINE ::: 1886
= { } , NAME = ::: 1885
from NAME . NAME import ( ::: 1885
== NUMBER NEWLINE NAME = NAME ::: 1885
, NAME ] NEWLINE NAME = ::: 1884
= [ NAME ( NAME = ::: 1882
= NAME ) NEWLINE DEDENT @ ::: 1882
: NEWLINE INDENT class NAME : ::: 1882
NAME = NUMBER NEWLINE DEDENT DEDENT ::: 1882
STRING ) ( NAME = NUMBER ::: 1882
assert NAME [ STRING ] == ::: 1880
True , NAME = NAME . ::: 1880
NAME == STRING NEWLINE assert NAME ::: 1879
INDENT if NAME . NAME != ::: 1879
= [ NUMBER , NUMBER ] ::: 1879
DEDENT NAME = NAME [ STRING ::: 1879
NAME NEWLINE DEDENT DEDENT @ NAME ::: 1878
** NAME ) NEWLINE if NAME ::: 1878
* NAME * NAME * NAME ::: 1878
) ) NEWLINE return NAME ( ::: 1877
{ } ) NEWLINE NAME . ::: 1876
DEDENT DEDENT DEDENT DEDENT class NAME ::: 1876
= STRING NEWLINE for NAME in ::: 1875
NEWLINE NAME . NAME ( None ::: 1875
NAME , STRING : NAME ( ::: 1873
else : NEWLINE INDENT NAME , ::: 1873
= ( NAME , NAME , ::: 1872
. NAME ( STRING STRING , ::: 1872
] [ NUMBER ] ) NEWLINE ::: 1872
and NAME . NAME ( STRING ::: 1872
NAME = False NEWLINE if NAME ::: 1870
( [ NAME ( NAME ) ::: 1870
( [ NAME . NAME , ::: 1870
( STRING in NAME . NAME ::: 1869
NAME ( NAME ) * NAME ::: 1868
, NUMBER ) NEWLINE if NAME ::: 1868
: True , STRING : STRING ::: 1867
NEWLINE if NAME < NUMBER : ::: 1867
False NEWLINE DEDENT NAME = NAME ::: 1867
NEWLINE INDENT class NAME : NEWLINE ::: 1865
INDENT class NAME : NEWLINE INDENT ::: 1865
NUMBER , NUMBER : NUMBER , ::: 1864
, STRING ] NEWLINE NAME . ::: 1864
NAME STRING NEWLINE NAME STRING NEWLINE ::: 1864
) NEWLINE NAME += NAME . ::: 1862
= None NEWLINE if NAME . ::: 1862
DEDENT return NAME NEWLINE DEDENT class ::: 1861
= False NEWLINE def NAME ( ::: 1859
NUMBER ] NEWLINE NAME = [ ::: 1858
NAME , STRING ) . NAME ::: 1858
True , NAME = False , ::: 1857
NAME NEWLINE DEDENT if not NAME ::: 1855
NEWLINE import NAME NEWLINE try : ::: 1855
, STRING , NAME = NUMBER ::: 1854
INDENT return NAME NEWLINE DEDENT if ::: 1853
) , STRING : STRING , ::: 1853
NAME = False NEWLINE def NAME ::: 1852
( ) : NEWLINE INDENT raise ::: 1852
NEWLINE return STRING % ( NAME ::: 1852
. NAME NEWLINE NAME ( NAME ::: 1851
STRING , STRING ] NEWLINE DEDENT ::: 1851
NAME ( ) [ STRING ] ::: 1850
, NAME , NAME , ) ::: 1850
DEDENT NAME = NAME [ NUMBER ::: 1849
( NAME ) + STRING + ::: 1848
for NAME in ( STRING , ::: 1847
NAME [ STRING ] = { ::: 1847
= NAME or NAME . NAME ::: 1847
NEWLINE NAME [ NAME . NAME ::: 1846
, NAME , NAME , * ::: 1846
INDENT NAME = NAME + STRING ::: 1844
= NAME ) ) NEWLINE NAME ::: 1844
STRING STRING STRING STRING STRING ) ::: 1844
NAME ( - NUMBER , NUMBER ::: 1844
( NAME ( NAME ) . ::: 1844
NAME . NAME , [ STRING ::: 1843
NAME : NEWLINE INDENT if STRING ::: 1843
continue NEWLINE DEDENT NAME . NAME ::: 1842
NEWLINE INDENT NAME STRING , NAME ::: 1842
: NEWLINE INDENT yield NAME . ::: 1841
NEWLINE NAME ( ) NEWLINE DEDENT ::: 1840
NEWLINE INDENT yield NAME . NAME ::: 1840
NEWLINE DEDENT if NAME [ STRING ::: 1840
, STRING : NUMBER } ) ::: 1840
. NAME ( ) + STRING ::: 1840
NAME = [ ( NAME , ::: 1839
if NAME . NAME not in ::: 1838
NAME NEWLINE NAME = None NEWLINE ::: 1838
STRING , NAME ( ) ) ::: 1837
NAME [ NAME - NUMBER ] ::: 1836
( STRING ) NEWLINE if not ::: 1836
if NAME . NAME [ NUMBER ::: 1836
INDENT import NAME NEWLINE DEDENT except ::: 1835
NAME = NAME or NAME . ::: 1834
== NUMBER NEWLINE assert NAME ( ::: 1834
, ** NAME ) NEWLINE if ::: 1833
, - NUMBER ) , ( ::: 1833
STRING % NAME [ STRING ] ::: 1833
NUMBER ) , NAME ( NAME ::: 1832
== STRING NEWLINE assert NAME ( ::: 1831
NEWLINE NAME . NAME += NUMBER ::: 1830
, STRING ) NEWLINE DEDENT @ ::: 1830
NAME = True NEWLINE DEDENT NAME ::: 1830
= [ NAME , NAME ] ::: 1829
NAME [ - NUMBER ] . ::: 1829
NEWLINE DEDENT return None NEWLINE DEDENT ::: 1828
) ) NEWLINE return NEWLINE DEDENT ::: 1828
NEWLINE INDENT NAME STRING % NAME ::: 1828
[ NAME ] for NAME in ::: 1828
NAME in NAME . NAME if ::: 1827
NAME ( STRING , True ) ::: 1825
STRING NEWLINE NAME STRING NEWLINE NAME ::: 1825
NAME ( STRING , ( NAME ::: 1824
NAME += NUMBER NEWLINE NAME . ::: 1824
NEWLINE NAME = NAME NEWLINE def ::: 1823
STRING , { } ) NEWLINE ::: 1823
STRING ) NEWLINE if NAME is ::: 1823
. NAME == STRING NEWLINE assert ::: 1823
} NEWLINE NAME = { } ::: 1823
) ) , NAME = NAME ::: 1821
- NAME . NAME ( NAME ::: 1820
) NEWLINE raise NAME . NAME ::: 1820
= [ NAME , NAME , ::: 1820
( [ NAME , NAME , ::: 1820
STRING ) NEWLINE return NAME ( ::: 1820
. NAME , NUMBER , NAME ::: 1820
NEWLINE while NAME : NEWLINE INDENT ::: 1820
def NAME ( * NAME ) ::: 1819
, NUMBER ) , NAME . ::: 1817
, ) , ( STRING , ::: 1817
( STRING ) NEWLINE class NAME ::: 1817
DEDENT return NAME ( NAME . ::: 1816
( ) ) NEWLINE NAME ( ::: 1816
NAME ( NUMBER ) NEWLINE if ::: 1816
INDENT return NAME ( ) NEWLINE ::: 1816
( ) : NEWLINE INDENT try ::: 1815
: NAME , NAME . NAME ::: 1813
, NAME = ( NAME , ::: 1812
( NAME , [ STRING , ::: 1812
, [ ] ) NEWLINE DEDENT ::: 1811
, } , STRING : { ::: 1810
if ( NAME . NAME ( ::: 1810
return False NEWLINE DEDENT DEDENT def ::: 1810
NAME . NAME , ) ) ::: 1809
NAME [ NUMBER ] for NAME ::: 1809
. NAME ( ) as NAME ::: 1809
return False NEWLINE DEDENT NAME = ::: 1808
if NAME : NEWLINE INDENT raise ::: 1808
True NEWLINE NAME . NAME . ::: 1808
False ) : NEWLINE INDENT if ::: 1808
} NEWLINE NAME = [ STRING ::: 1808
( [ STRING ] ) NEWLINE ::: 1807
( NAME [ - NUMBER ] ::: 1807
NAME ( { STRING : NUMBER ::: 1806
= NAME ( ( NAME , ::: 1805
= [ NAME . NAME for ::: 1805
. NAME ( STRING , True ::: 1804
( NAME ) != NUMBER : ::: 1804
NAME [ NUMBER ] + NAME ::: 1804
NAME + STRING + NAME NEWLINE ::: 1804
. NAME . NAME NEWLINE def ::: 1804
STRING ] NEWLINE NAME [ STRING ::: 1803
, NUMBER , NUMBER , STRING ::: 1802
STRING ) NEWLINE @ NAME ( ::: 1802
NAME ) NEWLINE if ( NAME ::: 1801
STRING , STRING : NAME } ::: 1801
[ STRING ] == STRING NEWLINE ::: 1800
= NAME [ NUMBER ] [ ::: 1800
: NUMBER } , STRING : ::: 1800
NAME ( NUMBER , NAME , ::: 1799
INDENT return NAME ( STRING ) ::: 1798
STRING : NUMBER } , STRING ::: 1798
INDENT return NAME NEWLINE DEDENT def ::: 1798
STRING , } NEWLINE NAME = ::: 1797
NAME , NAME = [ ] ::: 1797
INDENT pass NEWLINE DEDENT NAME . ::: 1796
. NAME != STRING : NEWLINE ::: 1796
NAME NEWLINE if not NAME : ::: 1796
= NUMBER ) NEWLINE NAME ( ::: 1796
STRING + NAME ) NEWLINE DEDENT ::: 1796
( NAME , NUMBER ) ) ::: 1796
NAME * NAME * NAME * ::: 1795
) NEWLINE if NAME != NAME ::: 1794
NUMBER ] . NAME [ NUMBER ::: 1794
STRING NEWLINE NAME = STRING % ::: 1794
. NAME NEWLINE from NAME . ::: 1793
NAME , None ) NEWLINE if ::: 1793
, STRING ) ] ) NEWLINE ::: 1792
NAME ( STRING ) NEWLINE class ::: 1792
] NEWLINE DEDENT @ NAME NEWLINE ::: 1792
INDENT return NEWLINE DEDENT if NAME ::: 1792
with NAME . NAME : NEWLINE ::: 1791
( NAME ) . NAME NEWLINE ::: 1791
NEWLINE NAME = [ NAME , ::: 1791
DEDENT return STRING . NAME ( ::: 1790
NUMBER , NUMBER ) ] ) ::: 1790
import NAME . NAME NEWLINE from ::: 1790
. NAME . NAME ( * ::: 1790
, NAME = [ NAME ( ::: 1789
, STRING ) NEWLINE for NAME ::: 1789
NAME ) NEWLINE return NAME , ::: 1788
NUMBER ] = NAME . NAME ::: 1788
NAME = STRING + NAME NEWLINE ::: 1788
= NUMBER ) , NAME = ::: 1787
NAME , NAME ( ) ) ::: 1786
= [ NAME ( STRING , ::: 1785
pass NEWLINE DEDENT NAME = NAME ::: 1785
NEWLINE DEDENT if NAME in NAME ::: 1785
: NEWLINE INDENT if NAME and ::: 1784
NAME ( NAME ) - NAME ::: 1784
. NAME , NAME [ STRING ::: 1783
STRING , NAME : STRING , ::: 1782
NAME ( NAME [ - NUMBER ::: 1782
NEWLINE return NAME ( NAME = ::: 1780
NEWLINE DEDENT NAME = STRING % ::: 1780
return NUMBER NEWLINE DEDENT def NAME ::: 1780
DEDENT except : NEWLINE INDENT return ::: 1779
NAME ( ) ] NEWLINE NAME ::: 1778
, STRING ) NEWLINE DEDENT else ::: 1778
( STRING STRING STRING ) NEWLINE ::: 1778
: NEWLINE INDENT @ NAME . ::: 1778
NEWLINE INDENT @ NAME . NAME ::: 1778
NAME ( STRING ) == STRING ::: 1776
INDENT NAME ( NAME , STRING ::: 1775
NAME . NAME ( NAME - ::: 1773
** NAME . NAME ) NEWLINE ::: 1773
NAME STRING % ( NAME , ::: 1772
STRING ] ) NEWLINE NAME ( ::: 1771
[ NUMBER ] NEWLINE DEDENT NAME ::: 1771
NUMBER ) , STRING : ( ::: 1771
] ) NEWLINE DEDENT elif NAME ::: 1770
in NAME ( NAME ) ] ::: 1770
- NAME NEWLINE NAME = NAME ::: 1770
False NEWLINE DEDENT else : NEWLINE ::: 1770
= NAME . NAME ( None ::: 1770
= NUMBER ) ) NEWLINE NAME ::: 1769
NAME ( STRING STRING , NAME ::: 1769
] , STRING : STRING , ::: 1768
) NEWLINE NAME = NAME - ::: 1768
STRING ) ) , NAME ( ::: 1766
NEWLINE raise NAME ( NAME ) ::: 1765
NAME ] ) ) NEWLINE NAME ::: 1765
} NEWLINE if NAME . NAME ::: 1765
NAME ( STRING STRING STRING ) ::: 1765
elif NAME : NEWLINE INDENT NAME ::: 1764
NAME = STRING ) NEWLINE @ ::: 1764
= STRING ) NEWLINE @ NAME ::: 1764
[ ] NEWLINE def NAME ( ::: 1763
False NEWLINE def NAME ( NAME ::: 1763
NAME ) + NAME ( NAME ::: 1763
( ) ) . NAME ( ::: 1763
NUMBER ] , STRING : [ ::: 1763
NUMBER ] ) NEWLINE NAME ( ::: 1762
, NUMBER : NUMBER , NUMBER ::: 1761
[ NUMBER ] ) : NEWLINE ::: 1761
. NAME ( ) NEWLINE with ::: 1761
STRING , NAME ) , NAME ::: 1761
NAME and not NAME : NEWLINE ::: 1761
STRING ) : NEWLINE INDENT raise ::: 1759
in NAME ] ) NEWLINE NAME ::: 1756
for NAME in NAME [ NUMBER ::: 1756
NEWLINE NAME = lambda NAME : ::: 1756
and not NAME . NAME : ::: 1756
[ NAME [ STRING ] for ::: 1755
NAME . NAME ( ) as ::: 1755
NAME ( False ) NEWLINE NAME ::: 1755
INDENT return False NEWLINE DEDENT NAME ::: 1755
) ) , NUMBER ) NEWLINE ::: 1754
NAME + NAME NEWLINE NAME = ::: 1753
NEWLINE DEDENT DEDENT NAME ( NAME ::: 1753
NAME += NUMBER NEWLINE DEDENT NAME ::: 1752
( ( STRING , NAME . ::: 1752
in NAME . NAME ] ) ::: 1752
except NAME . NAME . NAME ::: 1752
, ( STRING , ) , ::: 1752
. NAME , NUMBER , NUMBER ::: 1751
NAME . NAME != STRING : ::: 1751
DEDENT except NAME . NAME . ::: 1749
. NAME > NUMBER : NEWLINE ::: 1749
NAME , STRING % NAME ) ::: 1749
, NAME = [ NAME ] ::: 1749
= [ ] NEWLINE def NAME ::: 1748
) [ NUMBER ] NEWLINE if ::: 1748
= NAME ( NAME ( ) ::: 1748
INDENT NAME . NAME += NUMBER ::: 1748
STRING , NUMBER , - NUMBER ::: 1748
NAME . NAME > NUMBER : ::: 1747
INDENT for NAME in NAME [ ::: 1746
] [ NUMBER ] , NAME ::: 1746
( NUMBER ) NEWLINE DEDENT def ::: 1746
NAME . NAME = STRING % ::: 1745
NAME = [ ] NEWLINE def ::: 1745
return STRING % ( NAME , ::: 1745
STRING + NAME + STRING NEWLINE ::: 1745
] ) . NAME ( ) ::: 1744
NAME + NUMBER ) NEWLINE NAME ::: 1744
. NAME . NAME = False ::: 1742
: - NUMBER ] NEWLINE DEDENT ::: 1742
STRING ) ] ) NEWLINE NAME ::: 1742
NAME = STRING NEWLINE import NAME ::: 1742
[ STRING ] ) : NEWLINE ::: 1740
, [ NAME , NAME ] ::: 1739
NAME . NAME ( { NAME ::: 1739
. NAME NEWLINE try : NEWLINE ::: 1739
) ) : NEWLINE INDENT raise ::: 1738
INDENT NAME = [ NAME ( ::: 1738
= NAME [ : - NUMBER ::: 1737
NAME ( ) == NAME . ::: 1737
and NAME ( NAME , NAME ::: 1737
( ) == NAME . NAME ::: 1737
( ) , NAME , NAME ::: 1737
= STRING NEWLINE DEDENT NAME . ::: 1737
NAME NEWLINE DEDENT except : NEWLINE ::: 1734
( ) : NEWLINE INDENT assert ::: 1734
NEWLINE DEDENT from NAME . NAME ::: 1733
, [ NAME . NAME ( ::: 1733
= NUMBER NEWLINE NAME = [ ::: 1732
else : NEWLINE INDENT return None ::: 1732
= True NEWLINE DEDENT def NAME ::: 1731
NEWLINE INDENT return ( NAME . ::: 1731
INDENT return ( NAME . NAME ::: 1731
, NAME , NAME NEWLINE class ::: 1731
NEWLINE DEDENT if ( NAME . ::: 1731
STRING NEWLINE for NAME , NAME ::: 1730
) NEWLINE raise NAME ( NAME ::: 1730
NAME = STRING NEWLINE DEDENT def ::: 1730
NAME : NAME , NAME . ::: 1730
NEWLINE DEDENT NAME = [ STRING ::: 1730
NEWLINE class NAME ( NAME , ::: 1730
NAME = NUMBER NEWLINE DEDENT else ::: 1729
* NAME . NAME ) NEWLINE ::: 1729
) , [ STRING , STRING ::: 1728
= STRING + NAME . NAME ::: 1728
NAME = NAME [ NAME : ::: 1728
] [ NUMBER ] . NAME ::: 1728
NAME [ NAME [ STRING ] ::: 1726
else : NEWLINE INDENT NAME += ::: 1726
: NAME ( NAME ) , ::: 1726
, NAME ] , NAME = ::: 1726
) NEWLINE DEDENT NAME [ NAME ::: 1725
STRING ) NEWLINE DEDENT DEDENT if ::: 1725
STRING % STRING . NAME ( ::: 1724
None , NAME = True , ::: 1724
= NAME ) NEWLINE assert NAME ::: 1724
NAME as NAME NEWLINE class NAME ::: 1723
raise NAME , STRING NEWLINE DEDENT ::: 1722
@ NAME ( NAME . NAME ::: 1722
NAME ( NAME ) != NAME ::: 1722
return NAME [ NAME ] NEWLINE ::: 1721
( NAME ) ] NEWLINE DEDENT ::: 1721
% NAME . NAME NEWLINE NAME ::: 1721
( NAME , NAME = { ::: 1720
: True , STRING : True ::: 1720
) ) NEWLINE NAME = { ::: 1720
NEWLINE DEDENT DEDENT if NAME is ::: 1719
, NUMBER ) NEWLINE assert NAME ::: 1719
NEWLINE DEDENT DEDENT DEDENT @ NAME ::: 1719
NEWLINE NAME = STRING NEWLINE import ::: 1718
{ } NEWLINE NAME = { ::: 1718
( STRING , NUMBER , - ::: 1718
. NAME . NAME ) . ::: 1717
: NEWLINE INDENT NAME >> NAME ::: 1717
( STRING ) or NAME . ::: 1717
DEDENT NAME = NUMBER NEWLINE NAME ::: 1717
NEWLINE INDENT NAME STRING % ( ::: 1717
NAME . NAME ( ) } ::: 1717
NAME ( NAME ) is NAME ::: 1716
NAME = False NEWLINE for NAME ::: 1716
DEDENT except NAME . NAME , ::: 1715
. NAME in NAME : NEWLINE ::: 1714
in NAME if NAME . NAME ::: 1714
if not NAME ( NAME . ::: 1714
= NAME + NAME NEWLINE NAME ::: 1713
NUMBER ) NEWLINE DEDENT @ NAME ::: 1713
} , { STRING : NUMBER ::: 1712
NAME in NAME if NAME . ::: 1712
{ STRING : [ { STRING ::: 1712
STRING ] ) NEWLINE if NAME ::: 1711
NAME ) NEWLINE if NAME and ::: 1710
] , STRING : [ NUMBER ::: 1710
STRING ) ) ) NEWLINE DEDENT ::: 1710
STRING : NAME . NAME [ ::: 1710
NEWLINE assert NAME . NAME is ::: 1710
DEDENT @ NAME ( STRING , ::: 1709
NAME [ NUMBER ] == NUMBER ::: 1709
, NAME ( NAME [ NUMBER ::: 1708
) : NEWLINE INDENT ( NAME ::: 1707
NAME ( ) ] NEWLINE DEDENT ::: 1707
) , ( STRING , ) ::: 1707
NEWLINE NAME = [ { STRING ::: 1707
NAME NEWLINE class NAME : NEWLINE ::: 1706
. NAME NEWLINE return NAME NEWLINE ::: 1706
( ) ) NEWLINE return NAME ::: 1705
NAME ) NEWLINE DEDENT except ( ::: 1704
NAME , NUMBER ) ) NEWLINE ::: 1703
STRING ] NEWLINE for NAME in ::: 1703
NAME ) NEWLINE assert NAME == ::: 1703
NEWLINE DEDENT if NAME and NAME ::: 1703
NEWLINE with NAME . NAME . ::: 1703
None NEWLINE for NAME in NAME ::: 1702
, NAME . NAME NEWLINE DEDENT ::: 1701
in NAME ) NEWLINE NAME . ::: 1701
NAME = ( NAME ( NAME ::: 1701
STRING ) , NAME = NUMBER ::: 1701
STRING ) NEWLINE with NAME . ::: 1701
) in NAME : NEWLINE INDENT ::: 1701
NEWLINE INDENT STRING NEWLINE return STRING ::: 1700
, NAME ) NEWLINE DEDENT EOS ::: 1700
) NEWLINE NAME ( NUMBER , ::: 1700
if NAME ( NAME , ( ::: 1699
NAME . NAME ( NAME * ::: 1698
( STRING STRING . NAME ( ::: 1698
NEWLINE raise NAME ( STRING ) ::: 1697
] NEWLINE assert NAME . NAME ::: 1697
, NAME , STRING ) , ::: 1696
NAME . NAME , } NEWLINE ::: 1695
( { STRING : NAME } ::: 1694
STRING , ( STRING , STRING ::: 1694
. NAME ( NAME ( [ ::: 1693
] ) . NAME ( NAME ::: 1693
STRING , NAME = [ ( ::: 1693
, NAME = True , ) ::: 1692
, STRING ] NEWLINE def NAME ::: 1692
% NAME ) NEWLINE DEDENT if ::: 1692
NAME : NAME . NAME . ::: 1692
NAME ( NAME ) + NUMBER ::: 1692
= NAME NEWLINE if NAME is ::: 1692
NAME [ STRING ] , NUMBER ::: 1692
STRING + STRING . NAME ( ::: 1692
. NAME ( - NUMBER , ::: 1690
, NAME : STRING , NAME ::: 1690
NAME . NAME + STRING NEWLINE ::: 1689
} ) , ( STRING , ::: 1688
NAME ) ) for NAME in ::: 1687
while NAME : NEWLINE INDENT NAME ::: 1687
NAME NEWLINE NAME = NAME + ::: 1686
NAME ) NEWLINE DEDENT NAME [ ::: 1685
, NAME ( NAME = NAME ::: 1685
NAME , { } ) NEWLINE ::: 1685
DEDENT if STRING not in NAME ::: 1684
NAME ] NEWLINE for NAME in ::: 1683
. NAME ( ) NEWLINE while ::: 1683
. NAME ( ) ) . ::: 1683
. NAME = [ NAME ( ::: 1683
True NEWLINE NAME = NAME . ::: 1683
) , NAME ( NUMBER ) ::: 1682
) NEWLINE while True : NEWLINE ::: 1682
( STRING , ) , ( ::: 1681
is None : NEWLINE INDENT if ::: 1681
DEDENT NAME . NAME = True ::: 1680
NAME NEWLINE if NAME == STRING ::: 1680
} ) : NEWLINE INDENT NAME ::: 1680
INDENT NAME = [ STRING ] ::: 1680
NAME [ NAME ] for NAME ::: 1680
NAME ( [ STRING ] , ::: 1679
NAME NEWLINE NAME = True NEWLINE ::: 1679
NAME ( NAME - NAME ) ::: 1678
STRING , STRING ] NEWLINE def ::: 1678
( STRING in NAME ) NEWLINE ::: 1678
= NAME NEWLINE NAME = [ ::: 1677
NAME . NAME ( ) and ::: 1677
NEWLINE INDENT raise NEWLINE DEDENT DEDENT ::: 1677
( ) NEWLINE class NAME ( ::: 1676
INDENT raise NAME NEWLINE DEDENT DEDENT ::: 1676
, [ ( STRING , STRING ::: 1676
NAME += NAME ( NAME ) ::: 1675
True , NAME = NAME ) ::: 1675
, NUMBER ) ] NEWLINE NAME ::: 1675
( NAME , NAME , None ::: 1675
INDENT return STRING % NAME . ::: 1675
INDENT NAME STRING % ( NAME ::: 1675
= yield NAME . NAME ( ::: 1674
NAME ) : NAME . NAME ::: 1674
% ( NAME [ STRING ] ::: 1674
] ) NEWLINE DEDENT DEDENT class ::: 1673
NEWLINE NAME = None NEWLINE DEDENT ::: 1673
[ NUMBER , NUMBER ] ] ::: 1673
NEWLINE DEDENT NAME = STRING . ::: 1672
NAME ) NEWLINE if NAME in ::: 1672
. NAME ( [ NAME [ ::: 1672
except NAME . NAME , NAME ::: 1671
] . NAME ( NAME [ ::: 1671
DEDENT NAME = NAME NEWLINE def ::: 1671
, NAME [ NAME ] , ::: 1671
STRING : NAME } , NAME ::: 1670
= NAME [ - NUMBER ] ::: 1669
[ [ NUMBER , NUMBER ] ::: 1669
NUMBER ] . NAME , NAME ::: 1668
, NAME [ NUMBER ] . ::: 1668
+ STRING NEWLINE NAME . NAME ::: 1668
NEWLINE NAME = ( NUMBER , ::: 1668
and NAME is not None : ::: 1668
NUMBER ) NEWLINE assert NAME . ::: 1667
] , NAME ) ) NEWLINE ::: 1667
NAME . NAME and NAME ( ::: 1666
( NAME = [ STRING , ::: 1666
) NEWLINE NAME = ( NUMBER ::: 1666
= None NEWLINE for NAME in ::: 1666
. NAME : NAME , NAME ::: 1665
NAME ) NEWLINE with NAME ( ::: 1665
( ( NAME . NAME ( ::: 1665
, NAME . NAME ) and ::: 1664
NAME = False NEWLINE DEDENT DEDENT ::: 1664
>> NAME . NAME , STRING ::: 1663
NEWLINE NAME . NAME , NAME ::: 1661
NAME ) : NEWLINE INDENT continue ::: 1660
NAME NEWLINE if not NAME . ::: 1660
. NAME , ** NAME ) ::: 1660
( NAME = [ STRING ] ::: 1659
NEWLINE NAME = NUMBER NEWLINE while ::: 1659
[ ] ) : NEWLINE INDENT ::: 1659
= [ ] NEWLINE DEDENT NAME ::: 1659
NAME = True NEWLINE DEDENT def ::: 1657
, NAME , NAME ] , ::: 1657
, NAME ) in NAME ( ::: 1657
STRING + NAME + STRING ) ::: 1656
False NEWLINE NAME . NAME ( ::: 1655
NEWLINE DEDENT elif STRING in NAME ::: 1655
NAME = STRING + NAME . ::: 1654
DEDENT DEDENT elif NAME ( NAME ::: 1654
NEWLINE INDENT NAME ( STRING . ::: 1653
= STRING , NAME = ( ::: 1653
, { STRING : NUMBER } ::: 1653
INDENT NAME ( STRING . NAME ::: 1653
= NAME - NAME NEWLINE NAME ::: 1653
NAME STRING NEWLINE NAME . NAME ::: 1653
. NAME NEWLINE if NAME ( ::: 1652
NAME ( NAME , { } ::: 1652
NEWLINE INDENT if NAME == NUMBER ::: 1652
) NEWLINE NAME ( NAME = ::: 1651
STRING ) NEWLINE assert NAME ( ::: 1651
NAME ) in NAME ( NAME ::: 1651
NAME == None : NEWLINE INDENT ::: 1650
NAME ) NEWLINE continue NEWLINE DEDENT ::: 1649
NAME . NAME [ : NUMBER ::: 1649
NAME or NAME . NAME ( ::: 1648
NEWLINE if STRING not in NAME ::: 1648
NAME , [ STRING ] ) ::: 1646
if NAME != NUMBER : NEWLINE ::: 1646
. NAME , STRING ) : ::: 1646
* NAME ) NEWLINE NAME = ::: 1645
= None NEWLINE DEDENT if NAME ::: 1644
NEWLINE DEDENT DEDENT try : NEWLINE ::: 1644
NUMBER ) NEWLINE NAME = [ ::: 1644
NAME , True ) NEWLINE NAME ::: 1644
DEDENT NAME = NAME NEWLINE NAME ::: 1643
NAME ( NAME ) < NUMBER ::: 1642
= NAME . NAME + STRING ::: 1642
) NEWLINE DEDENT if NAME [ ::: 1642
DEDENT NAME = NAME NEWLINE DEDENT ::: 1641
STRING STRING ) NEWLINE DEDENT NAME ::: 1641
NAME . NAME in NAME : ::: 1641
for NAME in NAME [ NAME ::: 1641
NEWLINE @ NAME ( STRING ) ::: 1640
NAME = NAME [ - NUMBER ::: 1640
if NAME > NAME : NEWLINE ::: 1639
NAME . NAME NEWLINE try : ::: 1639
( NAME ( NAME = STRING ::: 1639
( ) NEWLINE with NAME . ::: 1639
{ STRING : NAME } , ::: 1638
NAME . NAME . NAME } ::: 1638
= STRING , ) NEWLINE NAME ::: 1638
) ) NEWLINE NAME = ( ::: 1638
NEWLINE DEDENT @ NAME NEWLINE @ ::: 1637
if NAME ( NAME ) < ::: 1636
( STRING , NAME ) ] ::: 1636
NUMBER NEWLINE assert NAME ( NAME ::: 1635
( NAME ( NUMBER ) , ::: 1634
NAME NEWLINE DEDENT NAME = [ ::: 1633
= None NEWLINE DEDENT else : ::: 1633
. NAME , NAME , STRING ::: 1632
STRING % ( NAME [ STRING ::: 1631
, STRING : NUMBER , } ::: 1630
= NAME [ STRING ] ( ::: 1630
NAME = - NUMBER , NAME ::: 1629
return ( NAME , NAME ) ::: 1629
NAME in NAME [ NAME ] ::: 1628
= - NUMBER , NAME = ::: 1628
in NAME . NAME [ STRING ::: 1628
NAME for NAME in NAME ( ::: 1627
. NAME ) NEWLINE try : ::: 1627
from NAME import * NEWLINE from ::: 1627
INDENT raise NAME , STRING NEWLINE ::: 1627
STRING , [ ] ) NEWLINE ::: 1626
@ NAME NEWLINE @ NAME NEWLINE ::: 1625
return NAME NEWLINE DEDENT DEDENT NAME ::: 1625
NAME . NAME ] . NAME ::: 1625
NAME , NAME , None ) ::: 1624
return NAME [ NUMBER ] NEWLINE ::: 1624
NAME ) ] NEWLINE NAME . ::: 1622
] = NAME NEWLINE DEDENT else ::: 1622
. NAME [ STRING ] == ::: 1620
= False NEWLINE DEDENT def NAME ::: 1620
} NEWLINE NAME = STRING NEWLINE ::: 1619
, } NEWLINE NAME = { ::: 1619
= NAME + NAME . NAME ::: 1618
= STRING ) NEWLINE DEDENT DEDENT ::: 1617
. NAME . NAME ( ** ::: 1617
INDENT NAME = [ NAME for ::: 1617
. NAME [ : NUMBER ] ::: 1616
DEDENT DEDENT except : NEWLINE INDENT ::: 1616
INDENT if NAME [ NAME ] ::: 1616
: return NUMBER NEWLINE if NAME ::: 1615
NEWLINE DEDENT if NAME == NAME ::: 1614
STRING ) ] NEWLINE NAME = ::: 1614
NAME [ NUMBER ] ) : ::: 1614
NAME . NAME . NAME and ::: 1614
, NAME [ NUMBER ] [ ::: 1613
NUMBER NEWLINE NAME [ STRING ] ::: 1613
, STRING ) NEWLINE assert NAME ::: 1613
if NAME . NAME [ STRING ::: 1613
, NUMBER , NAME = NAME ::: 1613
NUMBER , NAME = None ) ::: 1612
NAME += NUMBER NEWLINE NAME = ::: 1612
= True ) NEWLINE DEDENT DEDENT ::: 1612
= NAME NEWLINE NAME = ( ::: 1611
NAME . NAME ) NEWLINE try ::: 1610
NAME , ( NUMBER , NUMBER ::: 1610
NAME = [ NAME ] ) ::: 1610
DEDENT NAME , NAME , NAME ::: 1610
) NEWLINE DEDENT return NAME , ::: 1610
STRING NEWLINE NAME , NAME , ::: 1609
NAME = NUMBER ) . NAME ::: 1608
] NEWLINE NAME ( NAME , ::: 1608
as NAME NEWLINE class NAME ( ::: 1608
STRING NEWLINE raise NAME NEWLINE DEDENT ::: 1607
- NUMBER ] . NAME ( ::: 1607
= NAME NEWLINE for NAME in ::: 1607
NUMBER ) NEWLINE DEDENT except NAME ::: 1606
. NAME , NAME ( STRING ::: 1606
+ NAME NEWLINE NAME . NAME ::: 1605
NAME += NAME . NAME NEWLINE ::: 1605
STRING , NAME , NAME ( ::: 1605
in NAME . NAME if NAME ::: 1605
] NEWLINE NAME . NAME [ ::: 1605
NEWLINE import NAME , NAME , ::: 1605
[ NUMBER : - NUMBER ] ::: 1605
import NAME NEWLINE NAME ( NAME ::: 1604
None NEWLINE DEDENT NAME . NAME ::: 1604
NAME ] , NAME , NAME ::: 1604
: NEWLINE INDENT return NAME , ::: 1603
DEDENT DEDENT except NAME as NAME ::: 1603
NEWLINE if NAME != NAME : ::: 1602
. NAME , STRING % NAME ::: 1601
NAME = False NEWLINE DEDENT def ::: 1601
NAME + NAME . NAME NEWLINE ::: 1601
STRING STRING STRING ) NEWLINE DEDENT ::: 1600
= STRING % NAME NEWLINE DEDENT ::: 1599
NAME ) . NAME NEWLINE NAME ::: 1599
NAME : return NUMBER NEWLINE if ::: 1599
NAME import NAME NEWLINE if NAME ::: 1599
STRING % NAME , NAME = ::: 1598
) , NAME ( NAME [ ::: 1598
. NAME and NAME ( NAME ::: 1598
. NAME ) == NUMBER : ::: 1598
INDENT NAME = STRING NEWLINE if ::: 1596
is not None and NAME . ::: 1595
not None and NAME . NAME ::: 1595
NAME : NEWLINE INDENT NAME NAME ::: 1595
NAME ( None ) NEWLINE NAME ::: 1595
] . NAME ( ) : ::: 1595
NEWLINE DEDENT raise NAME ( STRING ::: 1594
STRING , NAME ) : NEWLINE ::: 1594
DEDENT @ NAME ( NAME ) ::: 1593
NAME ) == NUMBER NEWLINE assert ::: 1593
) NEWLINE NAME STRING NEWLINE NAME ::: 1591
= None NEWLINE DEDENT NAME = ::: 1590
NAME ( STRING in NAME ) ::: 1590
, NAME : NAME . NAME ::: 1589
NUMBER : NEWLINE INDENT NAME += ::: 1589
NAME , NAME ) : NAME ::: 1588
] , NAME = NUMBER ) ::: 1588
[ NUMBER ] NEWLINE NAME [ ::: 1587
) NEWLINE assert not NAME . ::: 1586
NAME import NAME NEWLINE @ NAME ::: 1585
NUMBER ) NEWLINE DEDENT DEDENT DEDENT ::: 1585
NUMBER } , { STRING : ::: 1585
NAME ) < NUMBER : NEWLINE ::: 1585
) NEWLINE DEDENT NAME = NUMBER ::: 1585
NAME ( STRING , None , ::: 1585
. NAME ( ) [ STRING ::: 1585
) ) NEWLINE assert NAME . ::: 1584
NUMBER ] NEWLINE DEDENT NAME = ::: 1584
% NAME NEWLINE NAME . NAME ::: 1584
= NAME NEWLINE DEDENT class NAME ::: 1583
INDENT try : NEWLINE INDENT if ::: 1583
, STRING ) , ) NEWLINE ::: 1582
] = NUMBER NEWLINE NAME . ::: 1582
, NAME = - NUMBER ) ::: 1582
) , STRING : NAME , ::: 1582
return NAME NEWLINE DEDENT NAME . ::: 1582
= True NEWLINE DEDENT else : ::: 1581
NAME , STRING ) : ( ::: 1581
] != STRING : NEWLINE INDENT ::: 1581
] [ NAME ] = NAME ::: 1580
else : NEWLINE INDENT NAME STRING ::: 1580
None , NAME = True ) ::: 1579
= True NEWLINE def NAME ( ::: 1579
NAME ) NEWLINE NAME = None ::: 1578
return None NEWLINE DEDENT DEDENT def ::: 1577
( ) NEWLINE NAME = NUMBER ::: 1576
= NAME [ NAME ] [ ::: 1576
) ) NEWLINE NAME , NAME ::: 1575
) : NAME . NAME ( ::: 1575
NAME ) ] ) NEWLINE NAME ::: 1575
NUMBER , NAME = False ) ::: 1575
NAME ( [ ] ) NEWLINE ::: 1575
NAME = NAME NEWLINE for NAME ::: 1574
. NAME ( STRING STRING % ::: 1574
= NAME , NAME = [ ::: 1574
INDENT STRING NEWLINE raise NAME NEWLINE ::: 1574
[ NAME ] , NAME . ::: 1573
in NAME . NAME NEWLINE DEDENT ::: 1573
( ( STRING , STRING , ::: 1571
NAME ( NAME + NAME ) ::: 1571
in NAME ) : NEWLINE INDENT ::: 1571
= NAME NEWLINE if NAME : ::: 1571
NAME <= NUMBER : NEWLINE INDENT ::: 1571
, NAME = False ) ) ::: 1570
) ) . NAME ( STRING ::: 1569
in NAME ] ) NEWLINE DEDENT ::: 1569
NUMBER ) ] ) NEWLINE NAME ::: 1569
% NAME ( NAME . NAME ::: 1569
] = STRING NEWLINE NAME = ::: 1569
NAME , [ NAME ] ) ::: 1569
NUMBER , STRING , STRING ) ::: 1569
) ) ) : NEWLINE INDENT ::: 1568
NAME ) NEWLINE DEDENT DEDENT for ::: 1568
= NUMBER NEWLINE DEDENT NAME = ::: 1568
) NEWLINE DEDENT DEDENT DEDENT else ::: 1568
NAME = NAME + NAME . ::: 1567
NAME NEWLINE NAME [ NAME ] ::: 1567
NEWLINE DEDENT NAME ( NAME ) ::: 1567
NAME = True NEWLINE def NAME ::: 1566
DEDENT DEDENT DEDENT if NAME == ::: 1565
] ) NEWLINE NAME = STRING ::: 1565
STRING NEWLINE NAME = NAME + ::: 1564
NUMBER ] ) NEWLINE if NAME ::: 1564
NAME ( ) NEWLINE @ NAME ::: 1564
( NAME . NAME - NAME ::: 1564
= { } NEWLINE DEDENT def ::: 1563
( NAME , STRING . NAME ::: 1563
NAME ) + STRING ) NEWLINE ::: 1563
, NUMBER , STRING , STRING ::: 1563
. NAME , NAME = ( ::: 1562
+ NAME + STRING ) NEWLINE ::: 1562
) ) NEWLINE DEDENT NAME ( ::: 1562
INDENT raise NAME ( NAME ( ::: 1560
STRING , STRING ) ) , ::: 1560
STRING : NUMBER } , { ::: 1560
DEDENT DEDENT elif NAME == STRING ::: 1560
@ NAME ( STRING , NAME ::: 1560
STRING , ) , ( STRING ::: 1559
or NAME . NAME ( NAME ::: 1559
( None , NAME . NAME ::: 1558
. NAME += NUMBER NEWLINE NAME ::: 1556
NAME } ) NEWLINE NAME = ::: 1556
) [ - NUMBER ] NEWLINE ::: 1555
pass NEWLINE DEDENT DEDENT def NAME ::: 1555
= True ) NEWLINE NAME ( ::: 1555
- NUMBER ) NEWLINE NAME . ::: 1554
NUMBER ] = NUMBER NEWLINE NAME ::: 1554
NUMBER ] ) NEWLINE DEDENT NAME ::: 1554
( STRING , ( NUMBER , ::: 1554
( NAME ) ) . NAME ::: 1554
NAME = NUMBER NEWLINE while NAME ::: 1553
NAME ) NEWLINE if NAME [ ::: 1553
NAME = { STRING : ( ::: 1553
= NAME NEWLINE NAME ( NAME ::: 1553
NAME ( NAME + NUMBER ) ::: 1553
True ) NEWLINE NAME ( NAME ::: 1552
NAME ] NEWLINE DEDENT if NAME ::: 1552
NAME , NUMBER , NAME ) ::: 1552
] . NAME ( NAME , ::: 1552
+ STRING ) NEWLINE NAME = ::: 1552
INDENT if NAME == NAME : ::: 1551
- NUMBER ) NEWLINE NAME = ::: 1551
. NAME ( NAME ) as ::: 1550
+ NAME . NAME NEWLINE DEDENT ::: 1550
STRING ] , NAME = True ::: 1550
STRING , False ) NEWLINE NAME ::: 1550
( NUMBER ) ) NEWLINE DEDENT ::: 1549
NEWLINE INDENT return NAME [ NUMBER ::: 1549
with NAME ( NAME ) as ::: 1549
} NEWLINE if NAME : NEWLINE ::: 1549
. NAME , NAME = [ ::: 1548
NAME ( STRING ) , NUMBER ::: 1548
+= NAME ( NAME ) NEWLINE ::: 1547
NAME , NAME ) ) , ::: 1547
DEDENT NAME = [ STRING , ::: 1547
= False ) NEWLINE DEDENT def ::: 1547
= ( ( STRING , STRING ::: 1546
, NAME ) NEWLINE DEDENT class ::: 1546
= STRING ) ) , ( ::: 1545
NAME , [ NUMBER , NUMBER ::: 1545
: NUMBER } , { STRING ::: 1544
[ NAME ( STRING , NAME ::: 1544
, NAME , NAME , NUMBER ::: 1544
NAME = NAME NEWLINE DEDENT class ::: 1544
, NUMBER ] ] ) NEWLINE ::: 1542
) NEWLINE DEDENT elif NAME [ ::: 1542
NAME ( STRING ) as NAME ::: 1542
NAME , ) NEWLINE NAME . ::: 1540
. NAME : return NUMBER NEWLINE ::: 1540
NAME . NAME : return NUMBER ::: 1540
( NAME , NAME + NUMBER ::: 1539
NAME [ STRING ] = ( ::: 1539
NAME ) NEWLINE raise NAME ( ::: 1539
{ STRING : STRING , } ::: 1538
) ) , NAME ) NEWLINE ::: 1538
) and NAME . NAME is ::: 1537
NEWLINE NAME ( NAME = STRING ::: 1537
import * NEWLINE from NAME import ::: 1536
) NEWLINE NAME = ( ( ::: 1536
, NAME = [ ] ) ::: 1534
NAME in NAME ) NEWLINE NAME ::: 1534
. NAME ( [ ( STRING ::: 1534
INDENT ( NAME , NAME ) ::: 1534
, NAME ( NAME , STRING ::: 1533
. NAME . NAME ] ) ::: 1533
as NAME NEWLINE NAME = NAME ::: 1533
NAME , NAME ( STRING , ::: 1532
NUMBER , NAME = NAME ( ::: 1532
) , ) , NAME . ::: 1531
NAME ( NAME [ : , ::: 1531
{ STRING : ( STRING , ::: 1531
. NAME : NEWLINE INDENT pass ::: 1530
NAME * NAME NEWLINE NAME = ::: 1529
NAME , NAME ) NEWLINE try ::: 1529
INDENT return False NEWLINE DEDENT if ::: 1528
!= NAME . NAME : return ::: 1528
NAME = NAME NEWLINE NAME ( ::: 1528
NEWLINE DEDENT DEDENT DEDENT DEDENT class ::: 1528
, NAME , NAME = [ ::: 1528
INDENT return False NEWLINE DEDENT return ::: 1527
NAME + NAME . NAME ) ::: 1527
True NEWLINE def NAME ( NAME ::: 1527
, STRING ) ) ) NEWLINE ::: 1527
( NUMBER ) NEWLINE NAME ( ::: 1526
NUMBER ) NEWLINE NAME , NAME ::: 1526
, NAME = - NUMBER , ::: 1526
NAME . NAME == NAME ) ::: 1526
NUMBER ) NEWLINE DEDENT DEDENT class ::: 1526
STRING , None , None , ::: 1525
DEDENT NAME ( NAME . NAME ::: 1525
NAME ( [ STRING , NAME ::: 1523
) ) NEWLINE if NAME ( ::: 1523
@ NAME NEWLINE class NAME ( ::: 1521
NEWLINE INDENT import NAME as NAME ::: 1521
False , NAME = None ) ::: 1521
. NAME = ( NAME . ::: 1521
. NAME import NAME NEWLINE if ::: 1521
: NEWLINE INDENT import NAME as ::: 1521
. NAME ( NAME ) and ::: 1521
NAME , NUMBER , NAME . ::: 1520
) . NAME ) NEWLINE NAME ::: 1520
STRING , NAME ( NAME , ::: 1519
( NAME ) ] ) NEWLINE ::: 1519
] ] ) NEWLINE NAME = ::: 1518
NAME ( NAME ) ) . ::: 1518
INDENT import NAME as NAME NEWLINE ::: 1518
STRING ] . NAME . NAME ::: 1518
NAME += NUMBER NEWLINE if NAME ::: 1517
, NAME , NUMBER , NUMBER ::: 1517
return NAME ( * NAME , ::: 1516
STRING : STRING , } ) ::: 1516
NEWLINE continue NEWLINE DEDENT if NAME ::: 1516
NAME - NAME NEWLINE NAME = ::: 1516
, NUMBER , NUMBER ) ] ::: 1516
> NUMBER : NEWLINE INDENT raise ::: 1516
DEDENT else : NEWLINE INDENT assert ::: 1516
[ STRING ] . NAME . ::: 1515
== NUMBER : NEWLINE INDENT raise ::: 1513
STRING , STRING ) , ) ::: 1513
, STRING ) NEWLINE @ NAME ::: 1513
) NEWLINE continue NEWLINE DEDENT if ::: 1512
. NAME ) and NAME . ::: 1511
NEWLINE NAME ( STRING . NAME ::: 1511
NAME [ STRING ] ] NEWLINE ::: 1511
NAME , STRING , NAME ( ::: 1511
= [ NAME [ STRING ] ::: 1510
NAME [ NAME ] = [ ::: 1509
NAME ( NAME ) ) is ::: 1508
= NAME . NAME , ) ::: 1508
, False ) : NEWLINE INDENT ::: 1508
: NEWLINE INDENT NAME NAME NEWLINE ::: 1508
: ( NUMBER , NUMBER , ::: 1506
, NUMBER ) . NAME ( ::: 1506
BOS NEWLINE import NAME , NAME ::: 1506
NEWLINE DEDENT NAME += NUMBER NEWLINE ::: 1505
NAME NEWLINE NAME = STRING % ::: 1505
. NAME ) , STRING ) ::: 1505
NAME : NEWLINE INDENT return [ ::: 1504
NAME ( NAME ) ) for ::: 1504
[ NUMBER ] . NAME == ::: 1503
. NAME ( STRING ) + ::: 1502
STRING , NUMBER ) NEWLINE DEDENT ::: 1501
{ NAME . NAME : NAME ::: 1501
NAME , STRING , False ) ::: 1501
. NAME NEWLINE DEDENT DEDENT DEDENT ::: 1500
NAME ) NEWLINE if STRING in ::: 1500
NAME = { NAME : NAME ::: 1500
( NAME , NAME ( ) ::: 1499
NEWLINE NAME = NAME ( lambda ::: 1499
) ) ) ) NEWLINE DEDENT ::: 1499
NEWLINE assert ( NAME . NAME ::: 1498
( STRING ) as NAME : ::: 1498
STRING ) , ) NEWLINE NAME ::: 1497
{ STRING : NAME ( STRING ::: 1497
] NEWLINE DEDENT if NAME . ::: 1497
, * NAME ) NEWLINE DEDENT ::: 1497
= NAME ( NAME ( NUMBER ::: 1497
NAME = None NEWLINE DEDENT else ::: 1496
< NUMBER : NEWLINE INDENT raise ::: 1496
None : NEWLINE INDENT return None ::: 1496
NAME != None : NEWLINE INDENT ::: 1495
INDENT STRING NEWLINE if NAME == ::: 1495
] ) ) NEWLINE DEDENT NAME ::: 1495
NAME . NAME == NAME NEWLINE ::: 1494
NEWLINE DEDENT if STRING not in ::: 1494
] = STRING . NAME ( ::: 1494
STRING ) NEWLINE DEDENT NAME ( ::: 1493
, NAME = NAME [ NAME ::: 1493
] NEWLINE DEDENT for NAME in ::: 1493
( NAME . NAME ( ( ::: 1493
NAME in NAME ) NEWLINE DEDENT ::: 1492
) NEWLINE assert STRING in NAME ::: 1492
elif NAME == NAME : NEWLINE ::: 1491
, ) , ( NUMBER , ::: 1491
NUMBER , NAME , NAME ) ::: 1491
) , ( STRING , ( ::: 1491
NEWLINE return ( NAME , NAME ::: 1490
NAME = NAME . NAME - ::: 1490
in NAME . NAME [ NAME ::: 1490
DEDENT elif NAME == NAME : ::: 1490
NEWLINE yield NAME . NAME ( ::: 1489
if NAME and NAME : NEWLINE ::: 1489
) ) NEWLINE for NAME , ::: 1489
NAME ( STRING in NAME . ::: 1489
NAME ] NEWLINE if NAME . ::: 1489
. NAME , ) NEWLINE NAME ::: 1488
return NUMBER NEWLINE if NAME . ::: 1487
) and not NAME . NAME ::: 1486
INDENT if NAME == NUMBER : ::: 1486
, STRING , ] NEWLINE NAME ::: 1486
return None NEWLINE DEDENT return NAME ::: 1486
[ STRING ] = False NEWLINE ::: 1486
return NAME NEWLINE DEDENT elif NAME ::: 1484
. NAME + STRING ) NEWLINE ::: 1484
INDENT pass NEWLINE DEDENT DEDENT def ::: 1484
== STRING and NAME . NAME ::: 1484
STRING NEWLINE def NAME ( ) ::: 1484
not NAME : NEWLINE INDENT if ::: 1484
INDENT NAME += NUMBER NEWLINE NAME ::: 1483
NAME = STRING % NAME ( ::: 1483
[ ( NAME . NAME , ::: 1483
] NEWLINE return NAME . NAME ::: 1483
( ) NEWLINE DEDENT class NAME ::: 1482
= { NAME . NAME : ::: 1482
= NAME . NAME ) , ::: 1481
assert STRING in NAME . NAME ::: 1481
= NAME . NAME ( ** ::: 1480
[ ] ) NEWLINE NAME = ::: 1479
NEWLINE DEDENT with NAME ( NAME ::: 1479
NAME = NAME ( STRING % ::: 1478
NEWLINE DEDENT NAME , NAME , ::: 1477
INDENT ( NAME , NAME , ::: 1477
[ NAME ] = NUMBER NEWLINE ::: 1476
NEWLINE DEDENT NAME = NAME + ::: 1476
NEWLINE del NAME . NAME [ ::: 1476
. NAME , STRING . NAME ::: 1476
NEWLINE return NAME . NAME [ ::: 1475
) in NAME . NAME ( ::: 1475
STRING ] , STRING : STRING ::: 1475
NEWLINE raise NAME ( ) NEWLINE ::: 1474
. NAME ) NEWLINE NAME , ::: 1474
) NEWLINE raise NAME ( STRING ::: 1474
NAME [ NAME ] = NUMBER ::: 1473
DEDENT DEDENT NAME = NAME NEWLINE ::: 1473
= NAME . NAME ( * ::: 1473
if NAME is NAME : NEWLINE ::: 1472
[ - NUMBER , - NUMBER ::: 1471
) : NEWLINE INDENT del NAME ::: 1470
DEDENT NAME . NAME = [ ::: 1469
NAME , STRING : STRING } ::: 1468
[ NUMBER ] , [ NUMBER ::: 1468
] , NAME = False ) ::: 1467
NAME . NAME == STRING and ::: 1467
, ( STRING , ) ) ::: 1467
) NEWLINE @ NAME ( NAME ::: 1467
( [ NAME ] , NAME ::: 1466
) NEWLINE return None NEWLINE DEDENT ::: 1466
NAME = NAME * NAME NEWLINE ::: 1466
STRING ) , NAME = False ::: 1466
NEWLINE DEDENT NAME = ( NAME ::: 1466
del NAME [ NAME ] NEWLINE ::: 1466
NAME . NAME ( NAME == ::: 1465
NAME . NAME ) as NAME ::: 1465
STRING ) ) NEWLINE if NAME ::: 1465
] NEWLINE class NAME ( NAME ::: 1464
NAME , [ NAME , NAME ::: 1463
, NAME ) NEWLINE NAME += ::: 1462
NEWLINE DEDENT DEDENT DEDENT DEDENT NAME ::: 1462
NAME and NAME ( NAME . ::: 1461
) . NAME ( ) [ ::: 1460
NAME , STRING ) NEWLINE return ::: 1460
DEDENT if NAME . NAME != ::: 1459
return False NEWLINE DEDENT if NAME ::: 1459
from . . NAME . NAME ::: 1458
INDENT return [ NAME . NAME ::: 1458
NAME [ NUMBER ] - NAME ::: 1458
STRING STRING % NAME ) NEWLINE ::: 1458
NEWLINE INDENT return [ NAME . ::: 1458
NAME = NAME ( NAME + ::: 1457
NAME + STRING + NAME ( ::: 1457
NAME ) , NAME = True ::: 1457
STRING + NAME . NAME . ::: 1456
return [ NAME . NAME ( ::: 1456
: NEWLINE INDENT if NAME < ::: 1456
, STRING ) ) : NEWLINE ::: 1455
] ) NEWLINE DEDENT DEDENT NAME ::: 1454
yield NAME . NAME . NAME ::: 1454
STRING , NAME = STRING STRING ::: 1454
{ } ) : NEWLINE INDENT ::: 1453
NAME ( [ NAME for NAME ::: 1453
NAME NEWLINE DEDENT @ NAME ( ::: 1452
else : NEWLINE INDENT return False ::: 1452
, STRING : NAME } , ::: 1452
STRING NEWLINE NAME = ( NAME ::: 1452
= False NEWLINE for NAME in ::: 1452
( NAME [ NAME ] [ ::: 1452
NEWLINE pass NEWLINE DEDENT class NAME ::: 1451
. NAME NEWLINE NAME , NAME ::: 1451
NAME ) or NAME ( NAME ::: 1450
NAME ( STRING STRING . NAME ::: 1450
NAME [ STRING ] ) : ::: 1449
NUMBER ) : NEWLINE INDENT return ::: 1449
) . NAME NEWLINE NAME . ::: 1449
( ( NAME , STRING ) ::: 1449
NUMBER ] , [ NUMBER ] ::: 1448
) NEWLINE yield NAME . NAME ::: 1448
) NEWLINE from NAME import NAME ::: 1448
( ( NAME , NAME . ::: 1447
STRING + NAME ) NEWLINE NAME ::: 1446
NEWLINE DEDENT DEDENT finally : NEWLINE ::: 1445
, STRING , NUMBER ) , ::: 1444
( STRING , STRING , ) ::: 1444
% STRING . NAME ( NAME ::: 1444
if NAME : NAME . NAME ::: 1443
( NAME ( NAME ) for ::: 1443
. NAME ) as NAME : ::: 1443
+ NAME . NAME NEWLINE NAME ::: 1442
( NAME , STRING ) . ::: 1442
NAME , STRING % NAME . ::: 1442
NAME ] [ NAME ] = ::: 1442
NEWLINE return NAME ( STRING , ::: 1442
True NEWLINE DEDENT NAME = NAME ::: 1442
NUMBER ) ) NEWLINE DEDENT DEDENT ::: 1441
NAME ( NUMBER ) NEWLINE assert ::: 1441
NAME ] ) : NEWLINE INDENT ::: 1441
( STRING ) NEWLINE return NEWLINE ::: 1441
if NAME . NAME != STRING ::: 1440
NAME ) or NAME . NAME ::: 1440
= NAME ( [ NAME . ::: 1440
NAME . NAME , STRING . ::: 1440
NEWLINE return True NEWLINE DEDENT def ::: 1439
) + STRING ) NEWLINE DEDENT ::: 1438
or NAME . NAME ( ) ::: 1438
: { STRING : NAME . ::: 1438
NUMBER } , STRING : { ::: 1438
( NAME + NUMBER , NAME ::: 1437
INDENT return None NEWLINE DEDENT return ::: 1437
> NAME . NAME : NEWLINE ::: 1436
STRING , STRING ] ) , ::: 1435
= NAME ) NEWLINE DEDENT return ::: 1435
= NAME [ NUMBER ] , ::: 1435
NUMBER , NUMBER , STRING , ::: 1434
STRING , STRING , [ STRING ::: 1434
NAME + NAME ( NAME ) ::: 1434
. NAME . NAME ] NEWLINE ::: 1433
] : NEWLINE INDENT NAME ( ::: 1433
: STRING , STRING : False ::: 1432
STRING , ] NEWLINE NAME = ::: 1432
, NAME ( NAME = NUMBER ::: 1432
. NAME ) > NUMBER : ::: 1431
NEWLINE NAME . NAME += NAME ::: 1431
[ NUMBER : ] NEWLINE NAME ::: 1431
[ STRING ] . NAME = ::: 1430
] ] NEWLINE NAME = NAME ::: 1430
NEWLINE NAME = [ NAME ] ::: 1430
NEWLINE NAME += NAME ( NAME ::: 1430
, NUMBER , NAME = NUMBER ::: 1430
) , NAME , NAME = ::: 1429
NUMBER ) ) ) NEWLINE DEDENT ::: 1429
) NEWLINE return NAME ( STRING ::: 1429
STRING NEWLINE DEDENT elif NAME == ::: 1429
STRING STRING ) NEWLINE DEDENT DEDENT ::: 1428
True ) : NEWLINE INDENT if ::: 1428
) NEWLINE for NAME in [ ::: 1428
NAME = NAME [ : , ::: 1427
in NAME ] NEWLINE NAME . ::: 1427
NUMBER * NAME . NAME ( ::: 1427
] : NEWLINE INDENT raise NAME ::: 1427
NAME [ NAME : NAME ] ::: 1426
STRING , STRING . NAME ( ::: 1426
) NEWLINE return NUMBER NEWLINE DEDENT ::: 1424
) NEWLINE DEDENT with NAME ( ::: 1424
return NAME . NAME ( * ::: 1423
NUMBER ] [ STRING ] ) ::: 1422
NAME == STRING or NAME == ::: 1422
: NAME } , NAME = ::: 1422
NAME = NAME ( [ NUMBER ::: 1421
False NEWLINE for NAME in NAME ::: 1421
NAME ) NEWLINE NAME += NUMBER ::: 1421
NEWLINE DEDENT DEDENT elif NAME ( ::: 1421
NAME = True NEWLINE DEDENT else ::: 1420
NAME ] NEWLINE DEDENT DEDENT DEDENT ::: 1420
= STRING NEWLINE import NAME NEWLINE ::: 1420
NEWLINE DEDENT NAME ( ) NEWLINE ::: 1419
, NAME = STRING ) . ::: 1419
( NAME [ NAME . NAME ::: 1419
, NAME ( NAME ) NEWLINE ::: 1418
None : NEWLINE INDENT return NEWLINE ::: 1418
NAME ] ) NEWLINE if NAME ::: 1418
, STRING ) NEWLINE DEDENT except ::: 1418
True , STRING : True , ::: 1417
STRING ] ) NEWLINE NAME [ ::: 1416
INDENT raise NAME ( STRING + ::: 1416
, STRING : ( NAME , ::: 1415
NAME = [ NAME [ STRING ::: 1415
NUMBER ) ) . NAME ( ::: 1415
NAME , NAME NEWLINE NAME . ::: 1415
( [ NAME . NAME for ::: 1414
DEDENT DEDENT return False NEWLINE DEDENT ::: 1414
NEWLINE INDENT NAME += NAME ( ::: 1414
, STRING , [ STRING ] ::: 1414
( STRING ) NEWLINE DEDENT class ::: 1413
NAME import NAME NEWLINE return NAME ::: 1413
, NAME . NAME ) . ::: 1413
. NAME , ) ) NEWLINE ::: 1413
. NAME ( NAME = None ::: 1413
NEWLINE assert NAME ( NUMBER , ::: 1412
. NAME NEWLINE DEDENT DEDENT NAME ::: 1412
= False , NAME = NUMBER ::: 1412
STRING , NAME = ( STRING ::: 1412
] , NAME , NAME ) ::: 1411
STRING NEWLINE pass NEWLINE DEDENT class ::: 1411
NAME = STRING NEWLINE return NAME ::: 1410
= NAME . NAME = NAME ::: 1410
INDENT return NAME ( STRING , ::: 1409
, NAME ( STRING , NUMBER ::: 1409
DEDENT DEDENT return None NEWLINE DEDENT ::: 1409
, NAME , None ) NEWLINE ::: 1408
( NAME , ( NAME . ::: 1407
INDENT pass NEWLINE DEDENT DEDENT NAME ::: 1406
NAME , NAME + NUMBER ) ::: 1406
- NUMBER ] ) NEWLINE NAME ::: 1406
NEWLINE return ( NAME . NAME ::: 1406
[ NAME [ NUMBER ] for ::: 1405
) , NAME ( ) , ::: 1404
, STRING , ( STRING , ::: 1404
NAME = lambda NAME , NAME ::: 1404
STRING , [ STRING ] , ::: 1404
% NAME NEWLINE NAME = NAME ::: 1404
STRING % ( NAME ) ) ::: 1404
== STRING ) : NEWLINE INDENT ::: 1403
) , NAME = False , ::: 1403
= NUMBER , NAME = [ ::: 1403
: NEWLINE INDENT NAME += [ ::: 1403
, STRING % ( NAME . ::: 1402
STRING % NAME ( NAME . ::: 1402
[ NUMBER ] , STRING , ::: 1402
INDENT NAME = False NEWLINE NAME ::: 1401
NUMBER , NUMBER ] ) ) ::: 1401
( NAME = STRING ) . ::: 1401
= NUMBER , NAME = ( ::: 1401
NAME , NAME : NAME . ::: 1401
, NAME = STRING % NAME ::: 1401
) ) NEWLINE continue NEWLINE DEDENT ::: 1401
NUMBER , - NUMBER ] , ::: 1401
= STRING ) NEWLINE DEDENT NAME ::: 1400
or NAME ( NAME , NAME ::: 1400
NAME [ NAME + NUMBER : ::: 1400
= NAME [ NAME ] . ::: 1400
] , [ NAME . NAME ::: 1399
STRING , STRING ] ) ) ::: 1399
, NUMBER ) [ NUMBER ] ::: 1398
{ STRING : False , STRING ::: 1398
NAME ( NAME , [ NUMBER ::: 1398
. NAME ( NAME ) or ::: 1396
] == NAME : NEWLINE INDENT ::: 1396
NAME = True NEWLINE DEDENT if ::: 1396
NAME [ STRING ] = False ::: 1395
STRING ) , ) , ( ::: 1395
if NAME in ( STRING , ::: 1395
@ NAME ( NAME = STRING ::: 1395
None NEWLINE try : NEWLINE INDENT ::: 1394
, NAME , NAME = { ::: 1394
NEWLINE from . . NAME . ::: 1394
return NEWLINE DEDENT if NAME . ::: 1394
STRING ] = { STRING : ::: 1393
NAME [ NUMBER ] * NAME ::: 1393
+ NAME ) NEWLINE NAME = ::: 1392
INDENT return NAME [ NAME ] ::: 1392
: False , STRING : False ::: 1391
False NEWLINE NAME . NAME . ::: 1391
( STRING ) ) . NAME ::: 1391
NEWLINE with NAME ( NAME . ::: 1390
) , [ ] ) NEWLINE ::: 1390
INDENT if NAME . NAME and ::: 1390
NAME = STRING ) , ) ::: 1389
: - NUMBER , STRING : ::: 1389
[ STRING ] = { STRING ::: 1388
NAME . NAME , True ) ::: 1388
= NUMBER ) . NAME ( ::: 1388
) . NAME ( ) == ::: 1388
STRING ) for NAME in NAME ::: 1388
INDENT assert NAME ( NAME , ::: 1388
[ STRING , STRING , NAME ::: 1388
STRING , STRING : True , ::: 1387
. NAME ) ) . NAME ::: 1387
NAME ( STRING ) ] ) ::: 1387
) NEWLINE return NEWLINE DEDENT if ::: 1387
NAME . NAME , [ ] ::: 1387
NAME ) : NEWLINE INDENT while ::: 1386
NAME ( STRING ) and NAME ::: 1386
STRING : - NUMBER , STRING ::: 1385
] , NAME ) : NEWLINE ::: 1385
NEWLINE DEDENT DEDENT NAME = STRING ::: 1385
= NUMBER ) NEWLINE DEDENT DEDENT ::: 1385
NAME as NAME NEWLINE DEDENT except ::: 1385
. NAME ( - NUMBER ) ::: 1385
if NAME . NAME > NUMBER ::: 1385
INDENT def NAME ( ) : ::: 1384
NEWLINE INDENT def NAME ( ) ::: 1384
[ - NUMBER ] ) NEWLINE ::: 1384
NEWLINE INDENT if NAME and NAME ::: 1384
NAME ( STRING ) ) . ::: 1383
NAME ] NEWLINE DEDENT return NAME ::: 1383
( NAME ) ) NEWLINE for ::: 1383
= STRING ) , NAME . ::: 1383
NEWLINE if NAME and NAME . ::: 1382
) , ( STRING , None ::: 1382
NAME . NAME NEWLINE NAME , ::: 1382
INDENT return NAME [ NUMBER ] ::: 1382
NAME ( None ) NEWLINE DEDENT ::: 1382
( NAME ) ) for NAME ::: 1381
try : NEWLINE INDENT NAME [ ::: 1381
elif NAME . NAME ( ) ::: 1381
NAME ( NAME ) or NAME ::: 1380
NAME = True ) . NAME ::: 1378
= { } NEWLINE DEDENT NAME ::: 1378
NAME ( ( NAME ( NAME ::: 1378
, [ NAME , NAME , ::: 1378
NAME = STRING NEWLINE NAME ( ::: 1378
from . NAME import * NEWLINE ::: 1378
. NAME != NUMBER : NEWLINE ::: 1378
STRING , STRING ) ] , ::: 1377
+ NUMBER ) : NEWLINE INDENT ::: 1377
return NAME . NAME [ STRING ::: 1377
= NAME NEWLINE NAME = NUMBER ::: 1376
, NAME , NAME ( STRING ::: 1374
NEWLINE NAME = NAME + NUMBER ::: 1374
NAME in ( NAME . NAME ::: 1373
] NEWLINE assert NAME ( NAME ::: 1373
* NAME ) NEWLINE DEDENT def ::: 1373
, NAME , NAME = ( ::: 1373
( NUMBER ) , NAME . ::: 1373
NAME . NAME ) ) . ::: 1372
, } ) NEWLINE NAME . ::: 1372
NAME . NAME [ NAME [ ::: 1372
) NEWLINE NAME = NAME * ::: 1372
- NUMBER , - NUMBER ) ::: 1371
NAME . NAME != NUMBER : ::: 1370
NUMBER , NUMBER , STRING ) ::: 1370
% ( NAME ) ) NEWLINE ::: 1370
NAME ( NAME , None , ::: 1370
, NAME : NEWLINE INDENT raise ::: 1370
) ) ) ) NEWLINE NAME ::: 1370
: { } , STRING : ::: 1369
} ) NEWLINE def NAME ( ::: 1369
: NUMBER , STRING : NAME ::: 1369
and not NAME . NAME . ::: 1368
, ) ) NEWLINE DEDENT DEDENT ::: 1368
NAME ) NEWLINE NAME ( ) ::: 1368
NAME [ : , NAME ] ::: 1368
NUMBER NEWLINE for NAME , NAME ::: 1367
. . NAME . NAME import ::: 1367
NAME ( NUMBER ) ) ) ::: 1367
NEWLINE NAME = False NEWLINE def ::: 1366
NEWLINE with NAME ( NAME ) ::: 1366
NAME [ NUMBER : - NUMBER ::: 1366
( NUMBER ) NEWLINE if NAME ::: 1366
DEDENT DEDENT @ NAME ( NAME ::: 1366
. NAME = NAME ( NUMBER ::: 1365
NAME , NUMBER , NAME = ::: 1364
( ) NEWLINE NAME = ( ::: 1364
= True ) , NAME = ::: 1364
STRING : { } , STRING ::: 1364
, NAME = STRING STRING ) ::: 1364
NUMBER ) NEWLINE NAME = NUMBER ::: 1364
return True NEWLINE DEDENT else : ::: 1363
( NAME ) NEWLINE DEDENT class ::: 1362
STRING % NAME NEWLINE NAME . ::: 1362
STRING NEWLINE NAME = STRING . ::: 1361
NAME ( [ ] , NAME ::: 1361
, NUMBER ) NEWLINE DEDENT NAME ::: 1361
NUMBER ) , NAME = STRING ::: 1360
NAME = NAME . NAME or ::: 1360
] [ STRING ] NEWLINE DEDENT ::: 1359
= NAME + NUMBER NEWLINE DEDENT ::: 1359
: NUMBER } NEWLINE NAME = ::: 1359
NAME ( ) NEWLINE NAME STRING ::: 1358
NAME | NAME . NAME ) ::: 1357
( NAME ) NEWLINE with NAME ::: 1357
( STRING , ) NEWLINE NAME ::: 1355
return { STRING : NAME . ::: 1355
DEDENT if NAME . NAME and ::: 1355
- NUMBER ) , ( STRING ::: 1355
( ) NEWLINE assert NAME ( ::: 1355
. NAME ( [ ] , ::: 1354
NEWLINE STRING NEWLINE NAME . NAME ::: 1354
NEWLINE NAME = ( ( STRING ::: 1354
+ NUMBER NEWLINE NAME = NAME ::: 1353
NEWLINE NAME += STRING NEWLINE NAME ::: 1353
NAME ( NAME ) NEWLINE with ::: 1353
except NAME : NEWLINE INDENT import ::: 1352
NAME NEWLINE import NAME NEWLINE try ::: 1352
NAME , NAME = ( NUMBER ::: 1352
) , ] , NAME = ::: 1351
. NAME += NUMBER NEWLINE DEDENT ::: 1351
( NAME . NAME ) [ ::: 1351
. NAME , NAME = { ::: 1351
NAME NEWLINE DEDENT NAME = STRING ::: 1351
( ) NEWLINE DEDENT DEDENT if ::: 1351
NAME ( NAME ( STRING STRING ::: 1351
== - NUMBER : NEWLINE INDENT ::: 1351
NAME = True ) NEWLINE if ::: 1350
: NAME [ STRING ] } ::: 1350
NAME ( ) NEWLINE DEDENT class ::: 1350
. NAME . NAME == NUMBER ::: 1350
] ) NEWLINE return NAME NEWLINE ::: 1349
NUMBER ] [ NUMBER ] ) ::: 1349
STRING : NAME ( NAME = ::: 1349
INDENT continue NEWLINE DEDENT NAME . ::: 1348
NAME : NAME ( NAME , ::: 1348
[ NUMBER ] ) NEWLINE if ::: 1347
. NAME } ) NEWLINE NAME ::: 1347
NEWLINE NAME STRING % ( NAME ::: 1346
NAME = { } ) : ::: 1346
. NAME , STRING , None ::: 1346
STRING : STRING } } , ::: 1345
yield NAME NEWLINE DEDENT DEDENT DEDENT ::: 1345
NUMBER ) ) NEWLINE assert NAME ::: 1345
True , NAME = NUMBER ) ::: 1345
NEWLINE assert NAME == NAME NEWLINE ::: 1345
= { } ) : NEWLINE ::: 1345
return NAME ( NAME ( STRING ::: 1345
. NAME == STRING NEWLINE DEDENT ::: 1344
( STRING , True ) NEWLINE ::: 1344
NAME ) NEWLINE return True NEWLINE ::: 1343
] NEWLINE NAME [ NAME ] ::: 1343
. NAME NEWLINE DEDENT DEDENT EOS ::: 1343
, ** NAME . NAME ) ::: 1342
: STRING , STRING : None ::: 1342
: NEWLINE INDENT STRING NEWLINE class ::: 1342
NEWLINE INDENT STRING NEWLINE class NAME ::: 1342
NAME ( NAME ( [ NAME ::: 1341
NUMBER , NUMBER , NAME . ::: 1341
) == NAME . NAME ( ::: 1341
, NAME ) ] ) NEWLINE ::: 1341
INDENT if NAME . NAME in ::: 1341
) : NEWLINE INDENT return not ::: 1341
NAME ] NEWLINE DEDENT NAME . ::: 1340
] ] ) NEWLINE NAME . ::: 1340
NEWLINE if NAME != STRING : ::: 1340
NAME ) : NEWLINE INDENT ( ::: 1340
, NUMBER , NAME , NAME ::: 1340
NAME - NAME . NAME ) ::: 1339
NAME , True ) NEWLINE DEDENT ::: 1339
NUMBER ] ) NEWLINE DEDENT else ::: 1339
STRING ] NEWLINE NAME = { ::: 1339
] ) , NAME = NAME ::: 1338
INDENT import NAME NEWLINE NAME . ::: 1338
: NAME , } NEWLINE NAME ::: 1338
= NAME ( ) NEWLINE class ::: 1338
DEDENT NAME ( STRING ) NEWLINE ::: 1338
DEDENT if STRING in NAME . ::: 1338
NAME . NAME , ) , ::: 1337
, NUMBER ) , NUMBER ) ::: 1337
NAME NEWLINE for NAME , NAME ::: 1337
INDENT NAME [ STRING ] [ ::: 1336
= STRING NEWLINE NAME = True ::: 1336
= NAME NEWLINE DEDENT DEDENT return ::: 1336
STRING , STRING , None , ::: 1336
[ NAME . NAME ] . ::: 1336
NUMBER : NEWLINE INDENT NAME , ::: 1336
try : NEWLINE INDENT for NAME ::: 1336
NAME += STRING . NAME ( ::: 1336
NAME ( NAME ) / NAME ::: 1335
NAME = STRING + NAME + ::: 1335
: NAME } NEWLINE NAME . ::: 1335
== STRING or NAME == STRING ::: 1335
( STRING % ( NAME ) ::: 1335
[ STRING ] , [ STRING ::: 1335
NAME ) == NAME . NAME ::: 1335
NAME ( STRING % NAME [ ::: 1334
NUMBER , STRING ) NEWLINE DEDENT ::: 1333
, STRING ) NEWLINE try : ::: 1332
] = NAME NEWLINE if NAME ::: 1332
NAME ( NAME , lambda : ::: 1332
) NEWLINE break NEWLINE DEDENT DEDENT ::: 1332
in NAME : NEWLINE INDENT continue ::: 1331
False NEWLINE NAME = NAME . ::: 1330
INDENT STRING NEWLINE @ NAME NEWLINE ::: 1329
] == NUMBER : NEWLINE INDENT ::: 1329
{ STRING : NUMBER } , ::: 1329
INDENT NAME ( NAME ( NAME ::: 1329
) ) NEWLINE if NAME is ::: 1327
( STRING ) ) : NEWLINE ::: 1327
INDENT class NAME ( NAME . ::: 1327
NEWLINE NAME = STRING NEWLINE EOS ::: 1327
: ] NEWLINE NAME . NAME ::: 1326
if NAME != NAME . NAME ::: 1326
STRING ) NEWLINE if NAME == ::: 1326
NUMBER ] , [ - NUMBER ::: 1325
import NAME NEWLINE if NAME . ::: 1325
NAME = STRING ) NEWLINE if ::: 1325
, ) : NEWLINE INDENT NAME ::: 1325
NEWLINE NAME = { NAME : ::: 1325
NAME . NAME ] ) ) ::: 1324
STRING NEWLINE DEDENT if NAME . ::: 1324
) ) NEWLINE DEDENT if not ::: 1324
] , NAME . NAME , ::: 1324
NAME == NAME . NAME ( ::: 1324
. NAME import NAME NEWLINE return ::: 1324
[ STRING ] = None NEWLINE ::: 1324
NAME ( STRING ) ) : ::: 1324
= lambda NAME : NAME ( ::: 1323
NEWLINE NAME = NAME or NAME ::: 1323
NEWLINE INDENT global NAME NEWLINE NAME ::: 1322
NAME ( ) . NAME , ::: 1322
if NAME ( NAME ) is ::: 1321
NAME , } NEWLINE NAME = ::: 1321
NUMBER ) , NAME ( STRING ::: 1321
( NAME + STRING , NAME ::: 1321
STRING : NAME [ NUMBER ] ::: 1320
STRING in NAME . NAME ( ::: 1320
( ) ) NEWLINE DEDENT else ::: 1319
( NAME for NAME in NAME ::: 1318
NEWLINE return NAME , NAME , ::: 1318
NEWLINE return NAME NEWLINE DEDENT return ::: 1318
) NEWLINE if NAME > NUMBER ::: 1318
( [ NAME for NAME in ::: 1318
NAME : NEWLINE INDENT raise NEWLINE ::: 1317
, NAME + NUMBER ) NEWLINE ::: 1316
INDENT return { STRING : NAME ::: 1316
) , NAME [ STRING ] ::: 1316
: NEWLINE INDENT import NAME . ::: 1315
return ( NAME . NAME , ::: 1315
NEWLINE INDENT import NAME . NAME ::: 1315
] , STRING : [ ] ::: 1315
( NUMBER ) , NAME ( ::: 1315
( ) : NEWLINE INDENT def ::: 1314
] , STRING : NAME . ::: 1314
( ) NEWLINE DEDENT except : ::: 1314
NEWLINE DEDENT return STRING . NAME ::: 1314
NAME ) + NAME . NAME ::: 1314
DEDENT elif NAME [ STRING ] ::: 1313
pass NEWLINE DEDENT DEDENT class NAME ::: 1313
( NAME , [ NAME ] ::: 1313
NEWLINE DEDENT DEDENT except : NEWLINE ::: 1312
NEWLINE INDENT NAME ( ) . ::: 1312
} } NEWLINE NAME = [ ::: 1312
NAME ( NUMBER ) , STRING ::: 1312
INDENT NAME ( ) . NAME ::: 1312
if NAME . NAME [ NAME ::: 1311
NAME or NAME . NAME NEWLINE ::: 1311
INDENT with NAME ( NAME , ::: 1311
= None NEWLINE try : NEWLINE ::: 1310
, NAME . NAME NEWLINE NAME ::: 1310
NEWLINE NAME ( NAME [ NUMBER ::: 1310
, STRING ) , ) , ::: 1310
NEWLINE NAME ( NUMBER ) NEWLINE ::: 1310
NAME == NAME NEWLINE DEDENT def ::: 1309
= ( STRING STRING ) NEWLINE ::: 1309
NAME ( [ ( NAME , ::: 1308
NEWLINE del NAME [ STRING ] ::: 1308
NEWLINE from . NAME import * ::: 1308
. NAME ( NAME - NAME ::: 1307
) , ) ) NEWLINE NAME ::: 1307
NAME ) ) NEWLINE NAME [ ::: 1307
( NAME , NAME ) or ::: 1307
) ) ) NEWLINE DEDENT else ::: 1306
. NAME NEWLINE NAME = { ::: 1306
( ( STRING , NAME ) ::: 1306
( STRING , STRING , None ::: 1306
, ] NEWLINE NAME = NAME ::: 1305
if NAME < NAME : NEWLINE ::: 1305
[ NAME ] , NAME , ::: 1305
[ NAME . NAME [ NAME ::: 1305
in NAME ( NUMBER ) ] ::: 1305
NAME ( STRING ) % NAME ::: 1304
+ NAME ) NEWLINE NAME . ::: 1304
NAME = None NEWLINE try : ::: 1303
. NAME ] = NAME . ::: 1303
+ NAME . NAME ( STRING ::: 1303
NAME , NAME ( NAME ( ::: 1303
[ ] NEWLINE DEDENT NAME = ::: 1303
NAME [ : ] NEWLINE NAME ::: 1303
INDENT raise NAME ( STRING , ::: 1302
= NAME ( ) ) NEWLINE ::: 1302
, STRING ) NEWLINE class NAME ::: 1302
( STRING ) NEWLINE try : ::: 1302
or NAME == STRING : NEWLINE ::: 1301
global NAME NEWLINE NAME = NAME ::: 1300
, ] NEWLINE NAME . NAME ::: 1300
] NEWLINE NAME = NAME NEWLINE ::: 1300
NEWLINE return { STRING : NAME ::: 1300
NAME ( STRING ) NEWLINE try ::: 1300
. NAME [ : ] NEWLINE ::: 1299
except NAME : NEWLINE INDENT if ::: 1299
. NAME . NAME ( None ::: 1298
( NAME , NAME = ( ::: 1298
[ ] NEWLINE if NAME . ::: 1298
( NAME , { } ) ::: 1298
{ } ) NEWLINE NAME = ::: 1297
DEDENT DEDENT except NAME . NAME ::: 1296
, True ) NEWLINE NAME = ::: 1296
[ STRING ] = STRING . ::: 1296
STRING ] = STRING . NAME ::: 1296
NAME ( NAME ) : pass ::: 1295
NEWLINE assert STRING in NAME . ::: 1295
( NAME ) : pass NEWLINE ::: 1295
NAME : NEWLINE INDENT if ( ::: 1294
None and NAME is not None ::: 1294
] ) , NUMBER ) NEWLINE ::: 1294
[ STRING % ( NAME , ::: 1294
NUMBER : ] : NEWLINE INDENT ::: 1294
NAME ) ) , NAME = ::: 1294
== NAME . NAME ( ) ::: 1293
and NAME . NAME != NAME ::: 1293
is not None and NAME is ::: 1293
. NAME , True ) NEWLINE ::: 1293
NAME = None NEWLINE STRING NEWLINE ::: 1292
= NAME [ : NAME ] ::: 1292
NEWLINE INDENT NAME = NAME - ::: 1291
as NAME NEWLINE import NAME as ::: 1291
. NAME ( * NAME . ::: 1291
) NEWLINE NAME += NAME NEWLINE ::: 1291
. NAME ] : NEWLINE INDENT ::: 1291
NAME ( STRING ) [ - ::: 1291
NUMBER ) , NAME = NUMBER ::: 1290
( STRING ) [ - NUMBER ::: 1289
NAME ( None , NAME . ::: 1289
NUMBER , NAME = False , ::: 1289
+ STRING + STRING + STRING ::: 1288
. NAME = NAME NEWLINE def ::: 1288
None ) NEWLINE if NAME : ::: 1287
NEWLINE DEDENT DEDENT NAME = { ::: 1287
NAME and NAME . NAME != ::: 1287
NAME . NAME = NAME + ::: 1287
) ( NAME = True , ::: 1287
NAME ( ) NEWLINE DEDENT for ::: 1286
NAME ) ) NEWLINE assert NAME ::: 1286
import NAME as NAME NEWLINE class ::: 1285
NEWLINE NAME = False NEWLINE DEDENT ::: 1285
STRING ] = True NEWLINE NAME ::: 1285
( ) NEWLINE DEDENT for NAME ::: 1284
, NUMBER : NAME . NAME ::: 1283
NAME NEWLINE from NAME import * ::: 1283
DEDENT NAME = STRING % ( ::: 1282
, NAME . NAME | NAME ::: 1282
NUMBER ) , NAME ) NEWLINE ::: 1282
) NEWLINE NAME += NAME ( ::: 1282
NEWLINE NAME += NUMBER NEWLINE NAME ::: 1282
if NAME is None or NAME ::: 1281
: NEWLINE INDENT NAME = - ::: 1281
, [ NAME . NAME ] ::: 1281
NAME ] NEWLINE DEDENT DEDENT def ::: 1281
NUMBER ] , NAME = STRING ::: 1280
BOS NEWLINE import NAME as NAME ::: 1279
NAME , STRING ) , ) ::: 1279
NAME . NAME ] : NEWLINE ::: 1279
< NAME . NAME : NEWLINE ::: 1279
NAME = NUMBER NEWLINE DEDENT if ::: 1279
NAME . NAME ( ) != ::: 1278
( NAME , STRING , False ::: 1278
NEWLINE NAME = NAME / NAME ::: 1278
NEWLINE DEDENT DEDENT except NAME as ::: 1278
DEDENT NAME . NAME = STRING ::: 1278
[ - NUMBER ] NEWLINE DEDENT ::: 1278
NAME . NAME ] NEWLINE if ::: 1277
} } NEWLINE NAME . NAME ::: 1277
STRING ] , [ STRING ] ::: 1277
STRING in NAME ) NEWLINE NAME ::: 1277
True NEWLINE DEDENT NAME . NAME ::: 1276
- NUMBER NEWLINE NAME = NAME ::: 1276
STRING ) NEWLINE NAME = NUMBER ::: 1275
NEWLINE NAME ( NAME , NUMBER ::: 1275
STRING : STRING } NEWLINE DEDENT ::: 1275
NAME ) : NEWLINE INDENT global ::: 1274
NUMBER ] NEWLINE if NAME . ::: 1274
** NAME ) NEWLINE DEDENT except ::: 1274
STRING NEWLINE DEDENT elif NAME . ::: 1273
( STRING , NUMBER ) [ ::: 1273
} NEWLINE DEDENT else : NEWLINE ::: 1273
try : NEWLINE INDENT with NAME ::: 1273
, STRING : - NUMBER , ::: 1273
NAME [ NUMBER ] ] NEWLINE ::: 1273
NUMBER : ] ) NEWLINE DEDENT ::: 1273
) NEWLINE DEDENT DEDENT if not ::: 1272
True , NAME = NUMBER , ::: 1272
NAME = False , ** NAME ::: 1272
NEWLINE INDENT STRING NEWLINE return [ ::: 1272
if NAME >= NUMBER : NEWLINE ::: 1271
) NEWLINE DEDENT elif NAME in ::: 1271
True , NAME = None , ::: 1270
NUMBER : ] NEWLINE NAME = ::: 1270
INDENT NAME [ NUMBER ] = ::: 1270
NAME . NAME == STRING ) ::: 1270
. NAME , ) NEWLINE DEDENT ::: 1270
: STRING , } ) NEWLINE ::: 1269
NUMBER , NAME ) : NEWLINE ::: 1269
NEWLINE assert STRING in NAME NEWLINE ::: 1268
NEWLINE DEDENT if NAME not in ::: 1268
( ) NEWLINE DEDENT NAME ( ::: 1267
NAME ] [ STRING ] = ::: 1267
% NAME ) NEWLINE DEDENT def ::: 1267
= [ ( NAME , NAME ::: 1267
NUMBER : NAME . NAME . ::: 1267
= NAME ( STRING STRING ) ::: 1266
raise NAME ( STRING + NAME ::: 1266
( NAME , lambda : NAME ::: 1266
( ) , NAME = True ::: 1266
NEWLINE NAME = yield NAME . ::: 1265
INDENT STRING NEWLINE with NAME . ::: 1265
NAME STRING . NAME ( NAME ::: 1265
. NAME ( NAME + NUMBER ::: 1265
NEWLINE NAME ( ) . NAME ::: 1264
NEWLINE INDENT NAME >> NAME . ::: 1264
[ NAME ( NAME = STRING ::: 1264
None , NAME = NUMBER ) ::: 1264
INDENT NAME >> NAME . NAME ::: 1264
. NAME , STRING ) as ::: 1263
( STRING , ( NAME , ::: 1262
: NAME . NAME = NAME ::: 1262
STRING ) ) NEWLINE def NAME ::: 1262
False NEWLINE DEDENT NAME . NAME ::: 1262
NEWLINE NAME = None NEWLINE for ::: 1261
INDENT NAME ( ) NEWLINE NAME ::: 1261
STRING ] NEWLINE DEDENT NAME = ::: 1261
NAME ) . NAME ( NUMBER ::: 1260
as NAME NEWLINE DEDENT except NAME ::: 1260
: NAME . NAME [ STRING ::: 1259
] == STRING NEWLINE assert NAME ::: 1259
NAME ) in NAME : NEWLINE ::: 1259
] NEWLINE if NAME == STRING ::: 1258
. NAME NEWLINE return NAME . ::: 1258
] . NAME NEWLINE NAME = ::: 1258
NAME ] NEWLINE if NAME ( ::: 1258
NAME ] = NAME NEWLINE return ::: 1258
is not NAME : NEWLINE INDENT ::: 1257
) NEWLINE del NAME . NAME ::: 1257
NEWLINE INDENT NAME = ( ( ::: 1257
STRING in NAME . NAME NEWLINE ::: 1257
] NEWLINE return NAME ( NAME ::: 1256
( NAME ( NAME [ NAME ::: 1256
raise NAME ( STRING , NAME ::: 1256
, NAME = STRING . NAME ::: 1256
, NAME = [ NUMBER , ::: 1256
NAME , NAME = lambda NAME ::: 1256
: NEWLINE INDENT @ NAME ( ::: 1256
. NAME = [ NAME ] ::: 1255
: NUMBER ] NEWLINE NAME = ::: 1255
, NAME ( NAME ) ] ::: 1255
NAME ) ) ) ) NEWLINE ::: 1255
INDENT NAME = ( STRING STRING ::: 1255
INDENT NAME [ NAME ] . ::: 1253
STRING + STRING + STRING + ::: 1253
( False ) NEWLINE NAME . ::: 1253
NAME [ - NUMBER : ] ::: 1253
NAME == STRING and NAME . ::: 1252
{ } NEWLINE def NAME ( ::: 1252
NAME [ STRING ] = None ::: 1252
. NAME import NAME NEWLINE @ ::: 1251
NAME STRING NEWLINE NAME = NAME ::: 1251
: NEWLINE INDENT if NAME > ::: 1251
= False , ** NAME ) ::: 1251
( { STRING : { STRING ::: 1251
] NEWLINE if not NAME : ::: 1250
NEWLINE break NEWLINE DEDENT DEDENT DEDENT ::: 1250
( NAME ( NAME ) + ::: 1250
. NAME ( ) and NAME ::: 1250
STRING ) NEWLINE DEDENT for NAME ::: 1250
: [ STRING ] } , ::: 1249
) NEWLINE DEDENT NAME = ( ::: 1249
NEWLINE DEDENT DEDENT DEDENT except NAME ::: 1249
( ) + NAME . NAME ::: 1249
( NAME ) , STRING , ::: 1249
NAME [ NAME ] = ( ::: 1249
* NAME ) NEWLINE NAME . ::: 1248
) NEWLINE NAME = lambda NAME ::: 1248
DEDENT NAME . NAME ( ( ::: 1248
, NAME ) ] NEWLINE DEDENT ::: 1248
NAME ( ) + NAME . ::: 1248
. NAME = NAME ( [ ::: 1248
NAME ) ) NEWLINE DEDENT for ::: 1247
. NAME ( ) NEWLINE EOS ::: 1247
NAME ) * NAME ( NAME ::: 1247
NUMBER , NAME [ NUMBER ] ::: 1247
] NEWLINE NAME = { } ::: 1247
= STRING + NAME + STRING ::: 1246
) == NUMBER NEWLINE DEDENT def ::: 1246
raise NAME ( STRING STRING STRING ::: 1246
import NAME , NAME NEWLINE def ::: 1246
) . NAME ) NEWLINE DEDENT ::: 1246
STRING , False ) : NEWLINE ::: 1245
: NEWLINE INDENT if STRING not ::: 1245
STRING , True ) NEWLINE NAME ::: 1245
NEWLINE INDENT if STRING not in ::: 1245
NUMBER ] NEWLINE DEDENT if NAME ::: 1245
NAME ( NUMBER , NAME [ ::: 1244
STRING ) NEWLINE DEDENT try : ::: 1244
NEWLINE INDENT STRING NEWLINE NAME [ ::: 1244
DEDENT DEDENT for NAME , NAME ::: 1243
] ) NEWLINE if NAME . ::: 1243
) NEWLINE if NAME < NUMBER ::: 1243
NUMBER ) ) : NEWLINE INDENT ::: 1243
NAME . NAME ( ) is ::: 1243
INDENT yield NAME . NAME ( ::: 1243
import NAME NEWLINE NAME = { ::: 1243
. NAME NEWLINE DEDENT class NAME ::: 1242
NAME ( NAME , True ) ::: 1242
, NAME ) : NAME . ::: 1242
STRING ) [ - NUMBER ] ::: 1242
= True NEWLINE DEDENT if NAME ::: 1242
NAME . NAME += NAME NEWLINE ::: 1241
% NAME ) NEWLINE DEDENT return ::: 1241
INDENT if STRING not in NAME ::: 1240
NAME ) . NAME NEWLINE DEDENT ::: 1240
, ] , STRING : [ ::: 1240
= { } NEWLINE def NAME ::: 1240
, NAME = False , ** ::: 1239
STRING ) NEWLINE DEDENT DEDENT else ::: 1239
NAME ( NAME + NUMBER , ::: 1239
NAME = { } NEWLINE def ::: 1239
NAME } ) NEWLINE DEDENT DEDENT ::: 1239
[ NUMBER : NUMBER ] ) ::: 1238
{ } NEWLINE NAME = [ ::: 1238
) + NAME ( NAME ) ::: 1238
NAME . NAME + STRING , ::: 1238
( STRING ) NEWLINE NAME , ::: 1238
NEWLINE return NEWLINE DEDENT if NAME ::: 1238
INDENT if STRING in NAME . ::: 1238
, NAME : NEWLINE INDENT if ::: 1237
, ] , NAME = { ::: 1237
NEWLINE INDENT NAME += NAME NEWLINE ::: 1236
= STRING NEWLINE NAME ( NAME ::: 1236
, - NUMBER ) NEWLINE NAME ::: 1236
, ( STRING , NAME , ::: 1235
: False , STRING : STRING ::: 1235
NAME , NAME . NAME + ::: 1234
, NAME . NAME , None ::: 1234
NAME and NAME ( NAME ) ::: 1234
, ) , ( NAME , ::: 1234
= NAME ( STRING ) . ::: 1233
NEWLINE INDENT for NAME in [ ::: 1232
is NAME . NAME : NEWLINE ::: 1232
NAME ( { STRING : { ::: 1232
. NAME == NUMBER NEWLINE DEDENT ::: 1232
) ) , STRING : NAME ::: 1232
NEWLINE if NAME . NAME in ::: 1232
, NAME ) , NAME , ::: 1232
NUMBER ) NEWLINE NAME = STRING ::: 1232
. NAME . NAME , [ ::: 1231
= { STRING : NUMBER } ::: 1231
raise NAME . NAME . NAME ::: 1231
STRING , STRING ) ] NEWLINE ::: 1230
return NAME NEWLINE DEDENT DEDENT return ::: 1229
STRING NEWLINE import NAME NEWLINE NAME ::: 1229
if NAME : NEWLINE INDENT try ::: 1229
** NAME ) NEWLINE DEDENT else ::: 1229
: NAME = NAME . NAME ::: 1229
NEWLINE DEDENT DEDENT DEDENT DEDENT EOS ::: 1229
, NUMBER ) ) , NAME ::: 1229
NAME ( NAME ) NEWLINE raise ::: 1229
** NAME ) NEWLINE DEDENT NAME ::: 1228
NUMBER ] ) . NAME ( ::: 1228
True , NAME = NAME , ::: 1228
NAME if NAME . NAME ( ::: 1228
( NAME , NUMBER ) , ::: 1228
) NEWLINE DEDENT raise NAME ( ::: 1228
NAME ) NEWLINE DEDENT if ( ::: 1227
!= NAME : NEWLINE INDENT raise ::: 1227
( NAME ) < NUMBER : ::: 1227
) and NAME . NAME . ::: 1227
INDENT return NUMBER NEWLINE DEDENT DEDENT ::: 1226
[ NUMBER : ] : NEWLINE ::: 1226
] for NAME in NAME ( ::: 1226
: NAME . NAME ( NUMBER ::: 1226
( NAME ) NEWLINE NAME STRING ::: 1226
) ) [ NUMBER ] NEWLINE ::: 1226
NEWLINE NAME = ( NAME ( ::: 1226
NAME NEWLINE import NAME , NAME ::: 1225
NAME in NAME [ NUMBER : ::: 1225
NEWLINE DEDENT NAME ( NAME . ::: 1225
) NEWLINE NAME ( STRING . ::: 1224
NAME or NAME : NEWLINE INDENT ::: 1224
NAME + NAME ) NEWLINE NAME ::: 1224
INDENT NAME . NAME = ( ::: 1224
STRING % NAME ) NEWLINE return ::: 1224
. NAME . NAME NEWLINE import ::: 1223
NUMBER , STRING : - NUMBER ::: 1223
( NUMBER , NAME , NAME ::: 1223
( ) . NAME NEWLINE NAME ::: 1222
STRING ] ) NEWLINE DEDENT if ::: 1222
NAME ( STRING ) + NAME ::: 1222
NAME or NAME . NAME . ::: 1222
. NAME , ( NAME , ::: 1221
INDENT NAME = ( NAME , ::: 1221
NAME as NAME NEWLINE def NAME ::: 1220
NAME = False NEWLINE DEDENT NAME ::: 1220
NEWLINE NAME = STRING NEWLINE for ::: 1220
as NAME NEWLINE def NAME ( ::: 1220
NAME [ : NAME ] NEWLINE ::: 1220
STRING ) : ( ( NAME ::: 1219
import NAME NEWLINE NAME = NUMBER ::: 1219
@ NAME . NAME ( ) ::: 1219
NAME ( NAME = ( NUMBER ::: 1219
: NAME , NAME : NAME ::: 1218
) for NAME in NAME [ ::: 1218
NEWLINE raise NAME NEWLINE DEDENT def ::: 1218
[ STRING ] NEWLINE DEDENT except ::: 1218
DEDENT NAME = [ NAME . ::: 1218
, False ) NEWLINE NAME = ::: 1217
) NEWLINE assert ( NAME . ::: 1217
NUMBER } ) NEWLINE NAME . ::: 1217
% ( NAME . NAME ) ::: 1217
NAME : NAME , NAME : ::: 1217
STRING ] ) . NAME ( ::: 1217
NAME . NAME [ : , ::: 1216
) : ( ( NAME , ::: 1216
NAME ( [ NUMBER ] ) ::: 1216
NAME = NAME , NAME NEWLINE ::: 1216
NAME += STRING % ( NAME ::: 1215
] [ STRING ] [ NUMBER ::: 1215
INDENT NAME [ NAME ] [ ::: 1215
( STRING % ( NAME [ ::: 1214
STRING : STRING } } NEWLINE ::: 1214
!= None : NEWLINE INDENT NAME ::: 1214
== None : NEWLINE INDENT NAME ::: 1214
[ STRING ] , NAME , ::: 1214
NAME ( STRING , ( ( ::: 1213
( ) ) NEWLINE DEDENT if ::: 1212
in ( NAME . NAME , ::: 1212
NUMBER , NAME = ( NUMBER ::: 1212
) NEWLINE continue NEWLINE DEDENT NAME ::: 1212
+ STRING ) NEWLINE DEDENT DEDENT ::: 1212
NAME . NAME NEWLINE DEDENT class ::: 1212
) , ) , ( NAME ::: 1212
NAME ( NAME [ NAME . ::: 1212
) NEWLINE if NAME [ NUMBER ::: 1212
NAME = NAME ) NEWLINE for ::: 1212
NAME , NUMBER : NAME . ::: 1212
( NAME == NAME ) NEWLINE ::: 1211
, NAME ) NEWLINE class NAME ::: 1210
STRING ) NEWLINE with NAME ( ::: 1210
NUMBER ) NEWLINE DEDENT DEDENT EOS ::: 1210
if NAME and NAME ( NAME ::: 1209
STRING NEWLINE raise NAME ( ) ::: 1209
, NAME ) ] NEWLINE NAME ::: 1209
% ( NAME ( NAME . ::: 1209
[ NUMBER ] = NAME [ ::: 1209
= NAME ) NEWLINE def NAME ::: 1208
NAME ( NAME ) ) ] ::: 1208
NAME = NAME ) NEWLINE def ::: 1208
( STRING , NAME ) : ::: 1207
NAME ( NAME ) > NAME ::: 1207
, NUMBER ] ) NEWLINE DEDENT ::: 1207
) } } NEWLINE NAME = ::: 1207
( NAME ) + STRING ) ::: 1207
NAME ] ) NEWLINE DEDENT else ::: 1206
DEDENT if NAME [ NUMBER ] ::: 1206
NAME . NAME , NUMBER : ::: 1206
NAME . NAME ) ] ) ::: 1206
as NAME : NEWLINE INDENT for ::: 1206
] , NUMBER ) NEWLINE DEDENT ::: 1206
NEWLINE NAME = NUMBER NEWLINE if ::: 1205
: ( ( NAME , STRING ::: 1204
, STRING ) : ( ( ::: 1204
+= STRING . NAME ( NAME ::: 1204
NAME . NAME , STRING NEWLINE ::: 1204
NAME . NAME ) [ NUMBER ::: 1204
] [ NUMBER ] NEWLINE DEDENT ::: 1203
NAME ) * NAME . NAME ::: 1203
( NAME ( NAME ) - ::: 1203
NAME ( NAME = ( NAME ::: 1202
. NAME , NUMBER : NAME ::: 1202
- NUMBER ] ) NEWLINE DEDENT ::: 1202
NEWLINE NAME ( NAME [ STRING ::: 1201
STRING + NAME . NAME NEWLINE ::: 1201
STRING NEWLINE if NAME is not ::: 1201
] NEWLINE DEDENT DEDENT NAME = ::: 1201
= True NEWLINE NAME = STRING ::: 1200
[ ] , STRING : [ ::: 1200
NAME NEWLINE DEDENT NAME ( NAME ::: 1200
NAME , False ) NEWLINE NAME ::: 1199
: NEWLINE INDENT NAME = lambda ::: 1199
in NAME ) NEWLINE NAME = ::: 1199
. NAME ) ] NEWLINE NAME ::: 1199
NUMBER ) NEWLINE NAME ( STRING ::: 1199
NAME . NAME [ NAME , ::: 1199
NEWLINE DEDENT if NAME [ NUMBER ::: 1199
, STRING , STRING ) ] ::: 1198
) , STRING ) ) NEWLINE ::: 1198
NUMBER NEWLINE NAME = NAME [ ::: 1197
. NAME != NAME : NEWLINE ::: 1197
NUMBER NEWLINE return NAME NEWLINE DEDENT ::: 1197
. NAME ] NEWLINE DEDENT def ::: 1196
DEDENT @ NAME ( NAME . ::: 1196
= NAME ) NEWLINE for NAME ::: 1196
STRING : [ ( STRING , ::: 1196
NUMBER NEWLINE DEDENT return NAME NEWLINE ::: 1196
NAME = STRING + NAME ( ::: 1196
NAME [ NAME ] = { ::: 1196
) NEWLINE DEDENT elif NAME : ::: 1195
( NUMBER ) NEWLINE assert NAME ::: 1195
return STRING % NAME NEWLINE DEDENT ::: 1195
, None ) NEWLINE DEDENT DEDENT ::: 1195
) ] NEWLINE for NAME in ::: 1195
NAME = NAME ( None , ::: 1195
( [ STRING ] , NAME ::: 1194
INDENT assert NAME . NAME ( ::: 1194
NEWLINE if NAME != NUMBER : ::: 1194
) NEWLINE DEDENT elif NAME is ::: 1194
NAME += STRING NEWLINE NAME += ::: 1193
NAME NEWLINE NAME = { } ::: 1193
( NAME , ) NEWLINE DEDENT ::: 1193
NUMBER : NEWLINE INDENT NAME STRING ::: 1193
NEWLINE ( NAME , NAME , ::: 1192
DEDENT DEDENT return True NEWLINE DEDENT ::: 1192
NEWLINE DEDENT assert NAME . NAME ::: 1192
STRING , ] , NAME = ::: 1191
NAME [ NAME : ] NEWLINE ::: 1191
True ) , NAME . NAME ::: 1190
. NAME ( NAME * NAME ::: 1190
STRING ) ) NEWLINE return NAME ::: 1190
) ] = NAME NEWLINE DEDENT ::: 1190
NAME for NAME in NAME ) ::: 1189
. NAME = [ STRING , ::: 1189
, None ) : NEWLINE INDENT ::: 1189
. NAME ( NAME , True ::: 1189
NAME ) NEWLINE return False NEWLINE ::: 1188
. NAME ( [ ] ) ::: 1188
NEWLINE INDENT STRING NEWLINE import NAME ::: 1188
= [ NAME [ NUMBER ] ::: 1188
] ) ) , ( STRING ::: 1188
: NEWLINE INDENT STRING NEWLINE import ::: 1188
, NAME ) , STRING : ::: 1188
BOS NEWLINE from . NAME import ::: 1188
] , STRING , STRING ) ::: 1188
DEDENT if NAME not in NAME ::: 1187
None , NAME = NAME , ::: 1187
STRING ] [ NUMBER ] NEWLINE ::: 1187
( ) [ NUMBER ] ) ::: 1187
INDENT raise NAME NEWLINE DEDENT def ::: 1187
not None and NAME is not ::: 1186
break NEWLINE DEDENT DEDENT else : ::: 1186
STRING + NAME . NAME ) ::: 1186
NAME . NAME ( { } ::: 1185
STRING : NEWLINE INDENT import NAME ::: 1185
NAME . NAME + NUMBER ) ::: 1184
NAME ( True ) NEWLINE DEDENT ::: 1184
STRING , ( STRING , ) ::: 1184
. NAME = NAME [ NAME ::: 1183
) ) , STRING ) NEWLINE ::: 1183
) NEWLINE DEDENT DEDENT DEDENT @ ::: 1183
assert NAME . NAME [ NUMBER ::: 1183
NUMBER ) NEWLINE DEDENT elif NAME ::: 1183
( ) ) NEWLINE DEDENT return ::: 1182
, NUMBER ) , ( NAME ::: 1182
, STRING ) , NAME ) ::: 1182
NUMBER , NAME , NAME , ::: 1181
= NAME , NAME = ( ::: 1181
raise NAME ( NAME ( STRING ::: 1180
NEWLINE DEDENT elif NAME in NAME ::: 1180
NUMBER , NAME ) ) NEWLINE ::: 1180
== STRING NEWLINE assert NAME [ ::: 1180
NAME . NAME . NAME != ::: 1180
[ NUMBER , NUMBER ] NEWLINE ::: 1180
[ { STRING : STRING } ::: 1179
[ STRING . NAME ( NAME ::: 1179
} } , STRING : { ::: 1179
) NEWLINE DEDENT if NAME and ::: 1179
DEDENT elif NAME [ NUMBER ] ::: 1178
( NAME = ( NUMBER , ::: 1178
@ NAME ( NAME , NAME ::: 1178
NEWLINE INDENT return NAME ( * ::: 1178
) ) NEWLINE DEDENT class NAME ::: 1178
NAME , False ) NEWLINE DEDENT ::: 1178
[ NAME ( STRING ) , ::: 1177
) ) NEWLINE NAME = NUMBER ::: 1177
[ STRING , STRING , ] ::: 1177
. NAME == STRING and NAME ::: 1177
** NAME ) NEWLINE DEDENT return ::: 1176
INDENT NAME [ STRING ] . ::: 1176
} NEWLINE DEDENT NAME = NAME ::: 1176
, NAME ] , [ NAME ::: 1176
DEDENT return NAME NEWLINE DEDENT return ::: 1175
from NAME import ( NAME , ::: 1175
lambda : NAME . NAME ( ::: 1175
. NAME . NAME and NAME ::: 1175
[ STRING ] NEWLINE DEDENT EOS ::: 1175
= NUMBER NEWLINE DEDENT if NAME ::: 1175
NAME = STRING ) NEWLINE assert ::: 1174
DEDENT elif STRING in NAME : ::: 1174
elif STRING in NAME : NEWLINE ::: 1174
} ) ) NEWLINE NAME . ::: 1173
= [ NAME ] ) NEWLINE ::: 1173
| NAME . NAME ) NEWLINE ::: 1172
NAME == STRING NEWLINE DEDENT def ::: 1172
. NAME ] , NAME = ::: 1172
< NUMBER : NEWLINE INDENT return ::: 1172
in NAME [ NAME ] : ::: 1172
INDENT NAME += STRING % NAME ::: 1171
[ NUMBER ] , STRING : ::: 1171
import NAME NEWLINE class NAME : ::: 1171
NAME ) NEWLINE if NAME < ::: 1171
NAME , NAME ) or NAME ::: 1171
NEWLINE INDENT return NAME ( [ ::: 1170
NAME . NAME ( NUMBER * ::: 1170
NEWLINE NAME [ NUMBER ] . ::: 1170
, None , NAME . NAME ::: 1170
NAME in ( NAME , NAME ::: 1170
. NAME : NEWLINE INDENT continue ::: 1169
( STRING , NUMBER , STRING ::: 1169
NUMBER ] . NAME NEWLINE NAME ::: 1168
, STRING ) NEWLINE NAME [ ::: 1168
. NAME ( [ STRING % ::: 1168
= None NEWLINE STRING NEWLINE NAME ::: 1168
STRING } NEWLINE NAME = { ::: 1168
] ) NEWLINE if NAME : ::: 1167
!= STRING : NEWLINE INDENT raise ::: 1167
) and NAME ( NAME , ::: 1167
) NEWLINE DEDENT NAME ( ) ::: 1167
) NEWLINE NAME = STRING + ::: 1166
. NAME , [ ] ) ::: 1166
, ( ( NUMBER , NUMBER ::: 1166
[ STRING , STRING ] } ::: 1166
( NAME ) + STRING NEWLINE ::: 1166
NAME ) , NAME = NUMBER ::: 1165
NAME NEWLINE DEDENT DEDENT DEDENT class ::: 1165
NUMBER ) , NAME = True ::: 1165
== NUMBER NEWLINE NAME . NAME ::: 1165
[ NAME , NAME ] = ::: 1165
STRING ] NEWLINE DEDENT if NAME ::: 1165
. NAME NEWLINE if NAME == ::: 1164
, NUMBER , NUMBER ) : ::: 1164
NAME , ** NAME . NAME ::: 1164
% NAME . NAME , NAME ::: 1164
STRING % NAME NEWLINE DEDENT NAME ::: 1164
NAME ( - NUMBER ) NEWLINE ::: 1164
. NAME ( [ NUMBER ] ::: 1164
, NAME , NUMBER , NAME ::: 1164
: - NUMBER ] ) NEWLINE ::: 1163
, NUMBER ) ) , ( ::: 1163
NAME ) ) , NAME ( ::: 1163
STRING in NAME [ STRING ] ::: 1163
) ) ) NEWLINE DEDENT return ::: 1162
. NAME import NAME NEWLINE try ::: 1162
NAME [ : NUMBER ] NEWLINE ::: 1162
[ STRING ] ) . NAME ::: 1162
* NAME . NAME . NAME ::: 1161
STRING , ) NEWLINE NAME . ::: 1161
] , NAME = NAME ( ::: 1161
. NAME ) [ NUMBER ] ::: 1161
) , STRING . NAME ( ::: 1160
] = NUMBER NEWLINE NAME = ::: 1160
> NUMBER : NEWLINE INDENT return ::: 1160
NAME ( STRING ) , ) ::: 1160
NAME = STRING NEWLINE @ NAME ::: 1160
NAME ( STRING , ( STRING ::: 1160
STRING : { STRING : True ::: 1160
for NAME , ( NAME , ::: 1159
NAME ( { STRING : [ ::: 1159
NEWLINE NAME . NAME ( lambda ::: 1159
. NAME . NAME = None ::: 1159
= NUMBER NEWLINE NAME = ( ::: 1158
DEDENT NAME . NAME [ STRING ::: 1158
( NAME ( NAME ) == ::: 1158
NAME + NAME . NAME + ::: 1157
= NAME ( [ NUMBER , ::: 1156
, STRING ] ) ) NEWLINE ::: 1156
+= NUMBER NEWLINE NAME = NAME ::: 1156
== STRING : NEWLINE INDENT import ::: 1155
( ) NEWLINE return NEWLINE DEDENT ::: 1155
NAME [ NAME . NAME [ ::: 1155
NAME ( ) . NAME ) ::: 1155
: STRING . NAME ( NAME ::: 1155
STRING NEWLINE raise NAME ( STRING ::: 1154
= NAME * NAME NEWLINE NAME ::: 1154
NUMBER ) , STRING ) NEWLINE ::: 1154
NEWLINE NAME = NAME NEWLINE if ::: 1154
( NAME ( ) . NAME ::: 1153
NUMBER ] == NAME . NAME ::: 1153
NUMBER ) , NAME = False ::: 1152
NEWLINE NAME ( NAME = NAME ::: 1152
NAME ) NEWLINE NAME [ NUMBER ::: 1152
elif NAME ( NAME ) == ::: 1152
= True ) . NAME ( ::: 1152
INDENT return None NEWLINE DEDENT if ::: 1151
NEWLINE from NAME import ( NAME ::: 1151
[ ] NEWLINE NAME = NUMBER ::: 1151
[ : - NUMBER ] ) ::: 1151
break NEWLINE DEDENT NAME = NAME ::: 1151
, NAME . NAME , [ ::: 1150
DEDENT DEDENT DEDENT if NAME : ::: 1150
NAME ( ) NEWLINE return NEWLINE ::: 1150
) + STRING ) NEWLINE NAME ::: 1150
. NAME ] ) ) NEWLINE ::: 1150
NAME = NAME ( ** NAME ::: 1150
+ NUMBER ) NEWLINE NAME = ::: 1150
NUMBER , NUMBER , NAME ) ::: 1149
] . NAME ) NEWLINE DEDENT ::: 1149
None , NAME = NAME . ::: 1149
DEDENT try : NEWLINE INDENT return ::: 1149
) NEWLINE return ( NAME , ::: 1149
STRING : STRING . NAME ( ::: 1148
= NAME NEWLINE NAME [ NAME ::: 1148
, ) NEWLINE NAME = STRING ::: 1148
: NEWLINE INDENT return NAME + ::: 1148
NAME ( NAME [ NAME : ::: 1148
if STRING not in NAME . ::: 1147
) , NAME = { STRING ::: 1147
[ STRING ] } ) NEWLINE ::: 1147
NAME [ - NUMBER ] [ ::: 1146
NAME , NAME ] NEWLINE DEDENT ::: 1146
) , None ) NEWLINE NAME ::: 1146
, [ ( NUMBER , NUMBER ::: 1146
INDENT raise NAME NEWLINE DEDENT NAME ::: 1146
NAME . NAME != NAME : ::: 1146
( ) ) NEWLINE DEDENT except ::: 1145
NAME , NUMBER ) , NAME ::: 1145
( STRING ) ] NEWLINE NAME ::: 1144
: - NUMBER ] NEWLINE NAME ::: 1144
} ) } } NEWLINE NAME ::: 1144
, NAME ) and NAME ( ::: 1144
] : NEWLINE INDENT for NAME ::: 1144
. NAME , [ STRING , ::: 1143
] NEWLINE NAME = [ NUMBER ::: 1143
INDENT NAME = NUMBER NEWLINE if ::: 1143
NUMBER ] , STRING , STRING ::: 1142
. NAME ) == NUMBER NEWLINE ::: 1141
NAME ) NEWLINE return ( NAME ::: 1140
( * NAME ) NEWLINE NAME ::: 1140
INDENT NAME += NAME ( NAME ::: 1140
) ) NEWLINE DEDENT DEDENT @ ::: 1140
continue NEWLINE DEDENT if NAME . ::: 1139
== NAME ( NAME . NAME ::: 1139
( NUMBER ) NEWLINE DEDENT if ::: 1139
[ STRING , NAME . NAME ::: 1139
[ NUMBER ] NEWLINE DEDENT except ::: 1139
NAME = STRING STRING ) NEWLINE ::: 1139
STRING : NEWLINE INDENT NAME += ::: 1139
NAME NEWLINE NAME , NAME , ::: 1139
NAME ) != NAME ( NAME ::: 1139
NEWLINE INDENT del NAME [ NAME ::: 1139
( NAME + STRING + NAME ::: 1139
return NAME . NAME == NAME ::: 1138
NAME ( STRING , STRING % ::: 1137
= NAME ( [ NAME , ::: 1137
== STRING NEWLINE NAME = NAME ::: 1137
NAME STRING , NAME . NAME ::: 1137
NEWLINE INDENT NAME += STRING + ::: 1136
STRING NEWLINE if STRING in NAME ::: 1136
) and NAME . NAME == ::: 1135
: NEWLINE INDENT NAME ( NUMBER ::: 1135
NAME . NAME [ NAME ( ::: 1135
NAME , NAME ] , [ ::: 1135
NEWLINE DEDENT elif NAME [ STRING ::: 1135
and not NAME ( NAME , ::: 1135
. NAME [ NAME ] : ::: 1135
NAME NEWLINE NAME ( NAME . ::: 1134
. NAME ( ) } NEWLINE ::: 1134
STRING : NAME ( NAME , ::: 1134
NEWLINE INDENT return NEWLINE DEDENT DEDENT ::: 1134
] NEWLINE DEDENT NAME = [ ::: 1133
) or NAME ( NAME , ::: 1133
STRING ) , { STRING : ::: 1132
( [ NAME . NAME ] ::: 1132
% ( NAME , NAME [ ::: 1132
= STRING ) ) NEWLINE DEDENT ::: 1132
/ NAME NEWLINE NAME = NAME ::: 1131
NEWLINE DEDENT NAME ( STRING ) ::: 1131
, NAME ( NAME [ STRING ::: 1130
@ NAME ( ) NEWLINE def ::: 1130
NUMBER ] ) , NAME ( ::: 1130
, STRING ) NEWLINE with NAME ::: 1130
NAME ] NEWLINE DEDENT elif NAME ::: 1129
DEDENT DEDENT DEDENT DEDENT if NAME ::: 1129
) NEWLINE return NEWLINE DEDENT DEDENT ::: 1129
) ) ) NEWLINE if NAME ::: 1129
, STRING , NAME = False ::: 1129
NAME ) if NAME . NAME ::: 1129
True NEWLINE NAME = STRING NEWLINE ::: 1129
NAME ( STRING ) NEWLINE raise ::: 1129
] = NAME ( ) NEWLINE ::: 1128
. . NAME import NAME , ::: 1128
, STRING : { } , ::: 1128
NAME ) . NAME ) NEWLINE ::: 1127
, { } ) NEWLINE DEDENT ::: 1127
NAME ( NAME ) ] = ::: 1127
= True ) ) NEWLINE NAME ::: 1127
NAME = { STRING : True ::: 1127
( NAME . NAME == STRING ::: 1127
= NUMBER ) NEWLINE def NAME ::: 1126
) NEWLINE NAME [ NAME . ::: 1126
NAME and NAME ( NAME , ::: 1126
NAME = NUMBER ) NEWLINE def ::: 1126
[ NUMBER ] = NAME . ::: 1126
, NAME . NAME ) for ::: 1125
( ) , NAME ( NAME ::: 1125
. NAME } ) NEWLINE DEDENT ::: 1125
( NAME , STRING , [ ::: 1125
( - NUMBER , NUMBER , ::: 1125
NAME ( NAME + STRING + ::: 1125
NEWLINE INDENT if NAME != NAME ::: 1125
( ) ) , NAME ( ::: 1125
NAME in NAME . NAME NEWLINE ::: 1125
( NAME - NAME ) NEWLINE ::: 1124
( STRING , STRING , [ ::: 1124
[ : : - NUMBER ] ::: 1124
= NAME , ) NEWLINE NAME ::: 1124
STRING NEWLINE if NAME == STRING ::: 1124
{ STRING : None , STRING ::: 1124
NAME . NAME , False ) ::: 1124
STRING , [ ( STRING , ::: 1123
NAME ) ] = NAME NEWLINE ::: 1123
STRING ) , NUMBER ) NEWLINE ::: 1123
= NAME NEWLINE DEDENT DEDENT if ::: 1123
INDENT raise NAME ( NAME , ::: 1122
NAME ) ) , ( STRING ::: 1122
NEWLINE DEDENT DEDENT return False NEWLINE ::: 1122
None , NAME = NAME ) ::: 1121
, STRING ) NEWLINE if not ::: 1121
) NEWLINE NAME = yield NAME ::: 1121
( NAME , NAME + NAME ::: 1121
NEWLINE DEDENT elif NAME [ NUMBER ::: 1121
NAME . NAME NEWLINE @ NAME ::: 1121
DEDENT @ NAME ( NAME , ::: 1120
, NAME ) , STRING ) ::: 1120
+ STRING + NAME NEWLINE NAME ::: 1120
STRING ) NEWLINE DEDENT DEDENT @ ::: 1119
return NAME [ STRING ] NEWLINE ::: 1119
. NAME . NAME ( True ::: 1119
] NEWLINE NAME = False NEWLINE ::: 1119
) ) ) NEWLINE DEDENT if ::: 1119
) is not None : NEWLINE ::: 1118
= STRING + NAME ( NAME ::: 1118
NAME ) NEWLINE if NAME > ::: 1118
INDENT NAME = NUMBER NEWLINE for ::: 1118
( NAME ) + NAME ( ::: 1118
} } NEWLINE NAME = NAME ::: 1118
NAME [ - NUMBER ] == ::: 1118
** NAME ) NEWLINE return NAME ::: 1117
NAME = NAME / NAME NEWLINE ::: 1117
NAME [ STRING ] + STRING ::: 1117
DEDENT if NAME . NAME [ ::: 1117
NAME in [ NAME . NAME ::: 1117
= None NEWLINE DEDENT NAME . ::: 1117
( STRING , STRING , ( ::: 1117
. NAME [ NUMBER ] = ::: 1117
NAME ] [ NUMBER ] NEWLINE ::: 1116
class NAME ( ) : NEWLINE ::: 1116
STRING : NAME , } ) ::: 1116
) ) , STRING : ( ::: 1116
= STRING ) NEWLINE if NAME ::: 1115
( STRING ) NEWLINE with NAME ::: 1115
= False NEWLINE NAME = STRING ::: 1115
STRING , STRING , NUMBER , ::: 1115
NAME [ NUMBER : ] : ::: 1115
NAME ( NUMBER ) ) , ::: 1114
) : NEWLINE INDENT break NEWLINE ::: 1114
[ NUMBER ] . NAME = ::: 1114
NAME = [ NAME [ NUMBER ::: 1114
] NEWLINE DEDENT DEDENT return NAME ::: 1114
] ) NEWLINE assert NAME . ::: 1113
not NAME : NEWLINE INDENT continue ::: 1113
, NAME [ NUMBER : ] ::: 1113
) , NAME [ NUMBER ] ::: 1113
== NAME ( NAME ) NEWLINE ::: 1113
NAME ) == NUMBER NEWLINE NAME ::: 1113
NAME ) ) NEWLINE if not ::: 1113
STRING , STRING , NAME ( ::: 1113
) : NAME . NAME = ::: 1112
NUMBER ) ) , NAME ( ::: 1112
] = { STRING : NAME ::: 1112
, None , None ) NEWLINE ::: 1112
STRING ) ) NEWLINE DEDENT if ::: 1112
NAME = True NEWLINE DEDENT elif ::: 1112
NAME . NAME . NAME or ::: 1112
, NAME = STRING ) ] ::: 1112
[ ] ) NEWLINE DEDENT def ::: 1111
NUMBER , NUMBER ] ] , ::: 1111
} , STRING : STRING , ::: 1111
NEWLINE DEDENT NAME = False NEWLINE ::: 1111
. NAME ( NAME ) & ::: 1111
elif NAME . NAME ( NAME ::: 1111
NAME ] . NAME ( STRING ::: 1110
) ) NEWLINE if ( NAME ::: 1110
STRING NEWLINE NAME += STRING NEWLINE ::: 1110
STRING ] ) NEWLINE DEDENT else ::: 1110
( STRING STRING % NAME ) ::: 1110
** NAME ) NEWLINE DEDENT @ ::: 1110
STRING NEWLINE NAME = [ ( ::: 1109
. NAME , NAME [ NUMBER ::: 1109
NUMBER ) NEWLINE if NAME . ::: 1109
= { STRING : NAME [ ::: 1108
NAME , NAME = - NUMBER ::: 1108
[ NAME ] NEWLINE DEDENT if ::: 1107
NEWLINE import NAME NEWLINE if NAME ::: 1107
STRING , NUMBER ) [ NUMBER ::: 1106
) NEWLINE DEDENT elif not NAME ::: 1106
) NEWLINE return STRING . NAME ::: 1106
NUMBER NEWLINE NAME = NAME NEWLINE ::: 1106
] , [ - NUMBER , ::: 1106
= NAME NEWLINE if not NAME ::: 1106
, STRING , NUMBER , NUMBER ::: 1105
DEDENT NAME += NUMBER NEWLINE DEDENT ::: 1105
as NAME : NEWLINE INDENT return ::: 1105
[ NAME ] = ( NAME ::: 1105
) , NAME = ( NUMBER ::: 1105
) NEWLINE def NAME ( * ::: 1104
) NEWLINE return { STRING : ::: 1103
NAME ( ) , STRING , ::: 1103
assert NAME ( NUMBER , NUMBER ::: 1103
( NAME + NAME ) NEWLINE ::: 1103
NEWLINE DEDENT DEDENT return None NEWLINE ::: 1103
NAME ( STRING ) NEWLINE with ::: 1102
INDENT return True NEWLINE DEDENT return ::: 1102
[ NAME . NAME ] [ ::: 1101
, STRING , None , None ::: 1101
NAME in NAME ( NAME [ ::: 1101
( ) : NEWLINE INDENT with ::: 1100
NAME , NAME ] = NAME ::: 1100
NAME ) == NAME : NEWLINE ::: 1100
NEWLINE INDENT NAME ( NAME = ::: 1099
STRING , STRING , ( STRING ::: 1099
NAME ) ] NEWLINE DEDENT def ::: 1099
False , ** NAME ) : ::: 1099
= NUMBER NEWLINE NAME [ STRING ::: 1099
NEWLINE DEDENT DEDENT DEDENT elif NAME ::: 1099
NEWLINE INDENT NAME . NAME , ::: 1099
break NEWLINE DEDENT NAME . NAME ::: 1099
] [ NUMBER ] [ NUMBER ::: 1099
STRING % NAME NEWLINE DEDENT DEDENT ::: 1098
NAME ) , ) NEWLINE DEDENT ::: 1098
( NUMBER , - NUMBER ) ::: 1098
( STRING , NUMBER ) ] ::: 1098
STRING in NAME . NAME . ::: 1098
. NAME . NAME is not ::: 1098
( [ ( STRING , STRING ::: 1097
[ STRING ] ( NAME , ::: 1097
NEWLINE INDENT if NAME is NAME ::: 1097
, STRING , NAME ) , ::: 1096
NAME ) NEWLINE DEDENT with NAME ::: 1096
( NUMBER , NUMBER , STRING ::: 1096
) , ] NEWLINE DEDENT EOS ::: 1096
NAME = NAME [ NAME ( ::: 1096
NAME ) NEWLINE NAME = True ::: 1096
. NAME = None NEWLINE if ::: 1095
. NAME NEWLINE NAME = ( ::: 1095
NEWLINE STRING NEWLINE NAME = NAME ::: 1095
NEWLINE INDENT NAME [ NAME [ ::: 1095
if NAME . NAME != NUMBER ::: 1094
NUMBER NEWLINE NAME = [ ] ::: 1094
- NUMBER ] NEWLINE NAME . ::: 1094
NAME = STRING , ** NAME ::: 1094
False ) , ( STRING , ::: 1093
NAME } ) NEWLINE DEDENT def ::: 1093
) ( NAME = True ) ::: 1093
} NEWLINE DEDENT NAME . NAME ::: 1093
DEDENT NAME . NAME = None ::: 1092
( NAME , STRING , { ::: 1092
, False ) , ( STRING ::: 1092
if NAME == None : NEWLINE ::: 1091
STRING ] = NAME NEWLINE return ::: 1091
NEWLINE INDENT return NAME , NAME ::: 1091
NAME = False ) ) , ::: 1091
DEDENT DEDENT return NAME , NAME ::: 1090
NAME . NAME ( NAME % ::: 1090
NAME + NAME ) NEWLINE DEDENT ::: 1090
= None ) NEWLINE NAME . ::: 1088
NUMBER ) , NAME = ( ::: 1088
. NAME ( ) NEWLINE raise ::: 1088
STRING , None ) NEWLINE DEDENT ::: 1088
. NAME ) + STRING + ::: 1088
. NAME ) ) , NAME ::: 1088
NUMBER ] = NAME [ NUMBER ::: 1088
NEWLINE INDENT STRING NEWLINE if STRING ::: 1088
NAME = NAME . NAME if ::: 1087
= NAME ( [ ( NAME ::: 1086
} ) NEWLINE NAME ( NAME ::: 1086
NUMBER , NUMBER ) NEWLINE assert ::: 1086
NAME , NAME NEWLINE DEDENT NAME ::: 1086
) == STRING NEWLINE DEDENT def ::: 1086
NAME ( NAME ) NEWLINE while ::: 1085
STRING , ) ) NEWLINE NAME ::: 1085
= True NEWLINE DEDENT elif NAME ::: 1085
INDENT STRING NEWLINE for NAME , ::: 1085
( ) ) NEWLINE for NAME ::: 1085
NAME = NAME . NAME * ::: 1084
NAME ( NAME * NAME ) ::: 1083
, lambda NAME : NAME . ::: 1082
( NAME = NAME ) , ::: 1082
NAME . NAME ( True , ::: 1082
] , NAME = [ NAME ::: 1082
STRING STRING % ( NAME . ::: 1082
INDENT return NAME ( * NAME ::: 1082
) , STRING , STRING ) ::: 1082
pass NEWLINE DEDENT try : NEWLINE ::: 1081
) ) , ] , NAME ::: 1081
= True ) , NAME . ::: 1081
STRING , { STRING : NUMBER ::: 1081
) NEWLINE NAME ( NUMBER ) ::: 1081
. NAME == NUMBER NEWLINE NAME ::: 1080
NAME + NUMBER ) : NEWLINE ::: 1080
* NUMBER NEWLINE NAME = NAME ::: 1080
INDENT pass NEWLINE DEDENT DEDENT class ::: 1079
NEWLINE DEDENT DEDENT DEDENT for NAME ::: 1079
== NAME . NAME NEWLINE assert ::: 1079
STRING , [ NAME . NAME ::: 1078
. NAME . NAME : NAME ::: 1078
NEWLINE DEDENT DEDENT except NAME . ::: 1078
== STRING : NEWLINE INDENT raise ::: 1078
BOS NEWLINE import NAME NEWLINE NAME ::: 1078
NEWLINE NAME = NUMBER * NAME ::: 1077
[ NUMBER ] = NAME NEWLINE ::: 1077
INDENT STRING NEWLINE class NAME ( ::: 1077
from . NAME import ( NAME ::: 1077
return True NEWLINE DEDENT return False ::: 1077
True NEWLINE DEDENT return False NEWLINE ::: 1077
INDENT NAME . NAME , NAME ::: 1077
. NAME ( ( NAME [ ::: 1076
NEWLINE INDENT pass NEWLINE DEDENT return ::: 1076
NEWLINE INDENT NAME = NAME * ::: 1076
[ STRING ] ) ) , ::: 1076
[ NAME ( NAME ) , ::: 1076
from . NAME . NAME import ::: 1076
NAME [ : NUMBER ] ) ::: 1076
NAME ( ) == NUMBER NEWLINE ::: 1075
NAME ) , STRING , NAME ::: 1075
. NAME ] NEWLINE if NAME ::: 1075
NAME is NAME . NAME : ::: 1075
NAME NEWLINE NAME = NAME - ::: 1075
( NAME + NUMBER ) NEWLINE ::: 1075
[ STRING ] NEWLINE def NAME ::: 1074
STRING ] : NEWLINE INDENT return ::: 1074
STRING ) [ NUMBER ] . ::: 1074
STRING NEWLINE NAME [ NUMBER ] ::: 1072
DEDENT from NAME . NAME import ::: 1072
NEWLINE for NAME in [ STRING ::: 1072
assert not NAME . NAME ( ::: 1072
NEWLINE from . NAME . NAME ::: 1072
NAME NEWLINE NAME = False NEWLINE ::: 1072
NUMBER NEWLINE DEDENT DEDENT class NAME ::: 1072
def NAME ( NAME = STRING ::: 1071
NAME + NUMBER ) NEWLINE DEDENT ::: 1071
= STRING NEWLINE NAME = False ::: 1071
STRING ] , NAME , NAME ::: 1071
NAME ( NAME ) NEWLINE EOS ::: 1071
INDENT NAME STRING % NAME NEWLINE ::: 1071
, STRING , STRING , [ ::: 1070
( [ ( NAME , NAME ::: 1070
= NUMBER NEWLINE DEDENT NAME . ::: 1070
NEWLINE continue NEWLINE DEDENT NAME = ::: 1069
import NAME . NAME NEWLINE NAME ::: 1069
NAME ) NEWLINE DEDENT if STRING ::: 1069
[ STRING ] NEWLINE assert NAME ::: 1069
( None ) NEWLINE NAME . ::: 1069
NAME = [ ( NUMBER , ::: 1069
STRING ] ) , NAME = ::: 1068
, NAME ( { STRING : ::: 1068
NUMBER ) [ NUMBER ] NEWLINE ::: 1068
NAME ] = NUMBER NEWLINE DEDENT ::: 1068
NAME [ : NUMBER ] == ::: 1068
, NUMBER , - NUMBER ] ::: 1068
) NEWLINE assert NAME [ STRING ::: 1067
= True NEWLINE DEDENT NAME = ::: 1067
DEDENT DEDENT DEDENT for NAME in ::: 1067
False NEWLINE NAME = STRING NEWLINE ::: 1067
* NAME ( NAME ) ) ::: 1067
, NAME ) NEWLINE with NAME ::: 1067
== NUMBER NEWLINE assert NAME [ ::: 1067
] , NAME = True , ::: 1066
, NAME ) NEWLINE DEDENT for ::: 1066
{ STRING : STRING } ] ::: 1066
, STRING , STRING , NUMBER ::: 1066
None : NEWLINE INDENT try : ::: 1066
) , STRING ) , ( ::: 1066
+ NAME ( NAME ( NAME ::: 1065
NAME [ NUMBER : ] , ::: 1065
NEWLINE INDENT while True : NEWLINE ::: 1064
NAME ( None , NAME ) ::: 1064
: NEWLINE INDENT while True : ::: 1064
in NAME : NEWLINE INDENT yield ::: 1064
) , [ NUMBER , NUMBER ::: 1064
INDENT while True : NEWLINE INDENT ::: 1064
True NEWLINE NAME = False NEWLINE ::: 1064
: { STRING : NUMBER } ::: 1063
NAME - NAME . NAME ( ::: 1063
DEDENT @ NAME NEWLINE class NAME ::: 1063
NAME NEWLINE DEDENT DEDENT elif NAME ::: 1063
) ) NEWLINE if NAME == ::: 1063
STRING ) NEWLINE for NAME , ::: 1063
return None NEWLINE DEDENT if NAME ::: 1063
NAME NEWLINE assert STRING in NAME ::: 1063
NUMBER ] [ STRING ] NEWLINE ::: 1063
STRING , NUMBER ) , NAME ::: 1063
= True ) NEWLINE if NAME ::: 1062
( NAME ) NEWLINE raise NAME ::: 1062
STRING + NAME [ STRING ] ::: 1062
[ : NUMBER ] NEWLINE NAME ::: 1062
raise NAME NEWLINE DEDENT NAME = ::: 1062
NEWLINE INDENT NAME ( NAME [ ::: 1062
: NUMBER ] ) NEWLINE NAME ::: 1061
NAME is True : NEWLINE INDENT ::: 1061
. NAME = NAME or NAME ::: 1061
= True NEWLINE NAME = False ::: 1061
= True ) NEWLINE DEDENT NAME ::: 1061
, STRING : NAME ( NUMBER ::: 1061
, NAME , NAME ) in ::: 1060
NUMBER ) for NAME in NAME ::: 1060
NAME . NAME ( ) or ::: 1060
= NAME ) , NAME = ::: 1060
STRING ] ) NEWLINE DEDENT except ::: 1060
NAME ( ) ) NEWLINE for ::: 1060
, STRING ) ] NEWLINE NAME ::: 1060
NAME [ NAME [ NAME ] ::: 1059
DEDENT return ( NAME , NAME ::: 1059
= NAME ( NAME , [ ::: 1059
False NEWLINE DEDENT return True NEWLINE ::: 1059
NAME [ : , : , ::: 1059
, ( NUMBER , NAME . ::: 1059
. NAME . NAME + STRING ::: 1058
( ) ) , ( STRING ::: 1058
( STRING , ) ) , ::: 1058
. NAME [ NAME ( NAME ::: 1058
DEDENT DEDENT DEDENT @ NAME NEWLINE ::: 1057
in ( NAME , NAME ) ::: 1057
: { STRING : [ STRING ::: 1056
return False NEWLINE DEDENT return True ::: 1056
NAME ] NEWLINE if NAME : ::: 1056
, None ) ) NEWLINE NAME ::: 1056
NAME ) NEWLINE DEDENT NAME , ::: 1056
STRING , ( NAME , NAME ::: 1055
False , NAME = NAME . ::: 1055
INDENT NAME = NUMBER NEWLINE def ::: 1055
[ STRING ] . NAME , ::: 1055
NAME >= NAME : NEWLINE INDENT ::: 1054
NAME , STRING ) NEWLINE @ ::: 1054
% NAME ( NAME ) NEWLINE ::: 1054
) == NUMBER NEWLINE NAME = ::: 1054
NAME . NAME } NEWLINE DEDENT ::: 1054
NAME . NAME ( NAME in ::: 1054
[ STRING ] NEWLINE for NAME ::: 1054
( NAME - NAME ) / ::: 1054
= NUMBER NEWLINE DEDENT class NAME ::: 1054
NAME ] [ NAME ] NEWLINE ::: 1053
) ) for NAME , NAME ::: 1053
STRING , STRING , ] ) ::: 1053
NUMBER NEWLINE NAME . NAME [ ::: 1052
NEWLINE from . NAME import ( ::: 1051
( NAME . NAME * NAME ::: 1051
: return NAME . NAME ( ::: 1051
. NAME ( NAME , lambda ::: 1050
, True ) NEWLINE DEDENT def ::: 1049
NEWLINE INDENT pass NEWLINE DEDENT try ::: 1049
INDENT pass NEWLINE DEDENT try : ::: 1049
: STRING } ) } } ::: 1049
NUMBER NEWLINE NAME = ( NAME ::: 1049
NEWLINE NAME . NAME ( False ::: 1049
NAME as NAME NEWLINE from . ::: 1049
( NAME , [ STRING ] ::: 1049
. NAME } NEWLINE NAME = ::: 1048
) , [ STRING ] ) ::: 1048
NAME NEWLINE DEDENT NAME = { ::: 1047
NUMBER , NUMBER ] , NUMBER ::: 1047
( NAME , True ) NEWLINE ::: 1047
) NEWLINE DEDENT if NAME in ::: 1047
( NAME . NAME ) - ::: 1047
NAME > NAME . NAME : ::: 1047
[ NUMBER ] NEWLINE DEDENT if ::: 1046
) is NAME : NEWLINE INDENT ::: 1046
+ NAME . NAME + NAME ::: 1046
True NEWLINE DEDENT except NAME : ::: 1046
DEDENT return NAME . NAME [ ::: 1046
NAME * NAME * NAME + ::: 1045
= NAME . NAME if NAME ::: 1045
) NEWLINE DEDENT return True NEWLINE ::: 1045
STRING : NEWLINE INDENT continue NEWLINE ::: 1045
= [ NAME ( NAME , ::: 1045
STRING , STRING : [ { ::: 1045
* NAME * NAME + NAME ::: 1045
STRING } ) } } NEWLINE ::: 1044
DEDENT DEDENT if NAME is None ::: 1044
NAME ) NEWLINE @ NAME . ::: 1044
INDENT NAME += STRING + NAME ::: 1044
[ NUMBER ] == NAME . ::: 1044
return { STRING : NAME , ::: 1044
, { STRING : [ STRING ::: 1044
NAME , STRING , { STRING ::: 1044
INDENT return STRING NEWLINE DEDENT NAME ::: 1044
True NEWLINE DEDENT DEDENT def NAME ::: 1043
NAME == - NUMBER : NEWLINE ::: 1043
NAME = NAME + NAME ( ::: 1043
NEWLINE NAME NAME . NAME ( ::: 1043
( STRING , STRING % NAME ::: 1043
NAME STRING % NAME . NAME ::: 1042
NAME ( NUMBER , STRING , ::: 1042
NAME = NAME = NAME = ::: 1042
= NUMBER ) , NAME ( ::: 1041
STRING STRING % NAME . NAME ::: 1041
NAME ] ) for NAME in ::: 1041
NAME = NUMBER NEWLINE DEDENT class ::: 1041
( NAME ( STRING STRING ) ::: 1040
None NEWLINE NAME . NAME . ::: 1040
return NAME . NAME ( NUMBER ::: 1040
NAME , NAME ) NEWLINE class ::: 1040
. NAME ( STRING ) is ::: 1040
[ NAME for NAME , NAME ::: 1040
, NUMBER ] ) ) NEWLINE ::: 1039
STRING ] , NAME = False ::: 1039
NUMBER NEWLINE DEDENT if NAME . ::: 1039
( ) - NAME . NAME ::: 1039
. NAME += NAME . NAME ::: 1039
NEWLINE assert NAME ( NAME [ ::: 1039
NAME ( ) - NAME . ::: 1039
= NAME NEWLINE try : NEWLINE ::: 1038
) } NEWLINE NAME = NAME ::: 1037
, NUMBER ) NEWLINE for NAME ::: 1037
= NAME ( [ NAME ( ::: 1037
, NAME ) [ NUMBER ] ::: 1037
STRING NEWLINE DEDENT return NAME NEWLINE ::: 1037
NAME - NAME . NAME NEWLINE ::: 1037
STRING , ( NAME . NAME ::: 1037
NAME ( NAME ) , [ ::: 1037
NAME [ STRING ] == NUMBER ::: 1037
] ) NEWLINE return NAME . ::: 1036
None NEWLINE NAME = NAME ( ::: 1036
= NUMBER NEWLINE DEDENT elif NAME ::: 1036
NEWLINE NAME = ( NAME + ::: 1036
( NUMBER ) NEWLINE DEDENT else ::: 1036
NEWLINE @ NAME ( STRING , ::: 1035
def NAME ( NAME = NUMBER ::: 1035
None : NEWLINE INDENT for NAME ::: 1035
) ] NEWLINE DEDENT else : ::: 1035
NAME : NAME [ NUMBER ] ::: 1034
NAME . NAME += NAME . ::: 1034
+ NAME * NAME * NAME ::: 1033
NAME < NAME ( NAME ) ::: 1033
return NAME NEWLINE DEDENT except NAME ::: 1033
STRING ) ) NEWLINE DEDENT else ::: 1033
NAME [ STRING ] ] ) ::: 1033
NAME . NAME ) + NAME ::: 1033
if NAME . NAME : NAME ::: 1033
NAME } NEWLINE DEDENT def NAME ::: 1033
NAME ( NAME ) < NAME ::: 1033
) NEWLINE raise NAME NEWLINE DEDENT ::: 1033
INDENT global NAME NEWLINE NAME = ::: 1033
else : NEWLINE INDENT if not ::: 1033
. NAME ] . NAME ( ::: 1032
in NAME [ NUMBER : ] ::: 1032
: NAME , } ) NEWLINE ::: 1032
. NAME ( ) ) == ::: 1032
NEWLINE INDENT NAME = lambda NAME ::: 1031
NAME ) , STRING : ( ::: 1031
NAME [ - NUMBER ] , ::: 1031
NUMBER ] + NAME [ NUMBER ::: 1031
] NEWLINE NAME = None NEWLINE ::: 1030
. NAME . NAME , } ::: 1030
True : NEWLINE INDENT NAME . ::: 1030
} } ) NEWLINE NAME . ::: 1029
NUMBER ] , NAME , NAME ::: 1029
[ ( STRING , NUMBER ) ::: 1029
) , NAME = [ STRING ::: 1029
continue NEWLINE DEDENT if NAME == ::: 1029
NAME . NAME ( ) in ::: 1029
NEWLINE DEDENT elif NAME in ( ::: 1028
NUMBER ] [ NUMBER ] [ ::: 1028
NAME + NAME * NAME * ::: 1027
in NAME ] NEWLINE DEDENT def ::: 1027
NAME ( NAME ( ) . ::: 1027
) if NAME . NAME ( ::: 1027
NAME ) == NUMBER and NAME ::: 1027
. NAME , False ) NEWLINE ::: 1026
. NAME . NAME = { ::: 1025
. NAME ) NEWLINE with NAME ::: 1025
, [ NAME . NAME , ::: 1025
: None , STRING : STRING ::: 1025
. NAME NEWLINE NAME = NUMBER ::: 1025
NUMBER , NUMBER ) ] NEWLINE ::: 1025
NAME . NAME - NUMBER ) ::: 1025
[ NAME [ NAME ] ] ::: 1025
NUMBER ] NEWLINE for NAME in ::: 1024
. NAME ( ( NAME ( ::: 1024
INDENT if NAME ( NAME [ ::: 1024
, NAME ) = NAME ( ::: 1024
NAME NEWLINE with NAME . NAME ::: 1024
) , ( ( NUMBER , ::: 1023
) , ( NUMBER , NAME ::: 1023
STRING NEWLINE with NAME ( NAME ::: 1023
NAME . NAME ( ) > ::: 1023
NAME ) . NAME . NAME ::: 1023
( NUMBER , NAME ) : ::: 1022
[ STRING ] . NAME ) ::: 1022
elif NAME ( NAME . NAME ::: 1022
NAME . NAME ) : NAME ::: 1022
NAME ( NUMBER ) , NUMBER ::: 1022
STRING + NAME NEWLINE NAME = ::: 1022
return NAME . NAME ( [ ::: 1022
= [ ( NAME . NAME ::: 1022
DEDENT return NAME , NAME , ::: 1022
, NAME ) in NAME : ::: 1021
[ STRING ] ) NEWLINE def ::: 1021
= STRING , ** NAME ) ::: 1021
NEWLINE NAME = STRING NEWLINE from ::: 1021
, NAME ) and NAME . ::: 1021
[ STRING ] ) NEWLINE return ::: 1021
NEWLINE DEDENT DEDENT DEDENT DEDENT if ::: 1021
NAME import * NEWLINE import NAME ::: 1021
, NAME + NUMBER , NAME ::: 1020
assert NAME [ NUMBER ] == ::: 1020
NAME STRING % NAME NEWLINE NAME ::: 1020
= NAME [ NAME : NAME ::: 1020
= STRING NEWLINE NAME = None ::: 1020
( NAME . NAME , True ::: 1020
DEDENT DEDENT DEDENT DEDENT DEDENT def ::: 1020
) NEWLINE assert NAME ( NUMBER ::: 1019
, NAME [ - NUMBER ] ::: 1019
NAME : NAME + NUMBER ] ::: 1019
NUMBER ) , STRING : NAME ::: 1019
INDENT pass NEWLINE DEDENT @ NAME ::: 1018
) NEWLINE NAME = [ NUMBER ::: 1018
( STRING ) ) NEWLINE if ::: 1018
NEWLINE INDENT pass NEWLINE DEDENT @ ::: 1018
) ) NEWLINE NAME [ NAME ::: 1017
( STRING , [ NAME ] ::: 1017
STRING : NAME ( ) , ::: 1017
NAME + NUMBER NEWLINE NAME = ::: 1017
NEWLINE INDENT STRING NEWLINE return ( ::: 1016
[ NAME + NUMBER : ] ::: 1016
} , { STRING : { ::: 1016
NUMBER ) ] ) NEWLINE DEDENT ::: 1016
) for ( NAME , NAME ::: 1016
NAME . NAME ) == NAME ::: 1016
NUMBER + NAME . NAME ( ::: 1016
= NAME ) NEWLINE DEDENT elif ::: 1015
NAME import * NEWLINE NAME = ::: 1015
( NAME ) . NAME ) ::: 1015
raise NAME ( NAME , NAME ::: 1015
NAME ( NUMBER ) ] NEWLINE ::: 1015
( not NAME . NAME ( ::: 1015
[ NAME ] . NAME NEWLINE ::: 1015
NEWLINE NAME = False NEWLINE if ::: 1015
DEDENT DEDENT DEDENT DEDENT DEDENT DEDENT ::: 1014
NEWLINE NAME = { NAME . ::: 1014
DEDENT elif NAME ( NAME . ::: 1014
( STRING STRING ) ) NEWLINE ::: 1014
NAME ) ) NEWLINE return NEWLINE ::: 1014
( NAME ( NUMBER , NAME ::: 1014
STRING , ( ( STRING , ::: 1014
( [ NAME [ NUMBER ] ::: 1013
( ( NAME ( NAME ) ::: 1013
) NEWLINE DEDENT NAME = None ::: 1013
= ( STRING STRING STRING STRING ::: 1013
, ( ( STRING , NAME ::: 1013
) NEWLINE NAME NAME . NAME ::: 1012
INDENT with NAME ( NAME . ::: 1012
= NUMBER NEWLINE for NAME , ::: 1012
NAME , NAME = ( STRING ::: 1012
STRING ] = True NEWLINE DEDENT ::: 1012
STRING ] . NAME = NAME ::: 1011
( STRING , NAME = ( ::: 1011
STRING , NAME ] ) NEWLINE ::: 1011
NAME = ( NAME - NAME ::: 1011
NEWLINE INDENT continue NEWLINE DEDENT DEDENT ::: 1010
NAME , NAME ( NAME = ::: 1010
STRING in NAME . NAME ) ::: 1010
NAME and NAME [ STRING ] ::: 1010
if not NAME . NAME and ::: 1010
NUMBER NEWLINE class NAME ( NAME ::: 1010
: NEWLINE INDENT yield NAME ( ::: 1009
NAME . NAME ) NEWLINE with ::: 1009
or NAME : NEWLINE INDENT NAME ::: 1009
= NAME . NAME NEWLINE try ::: 1009
] } NEWLINE NAME = NAME ::: 1009
( ) [ NUMBER ] . ::: 1009
( NAME ) ) ) ) ::: 1008
= NAME . NAME - NAME ::: 1008
NEWLINE if NAME > NAME : ::: 1007
, ) ) NEWLINE DEDENT NAME ::: 1007
NEWLINE return NAME NEWLINE DEDENT if ::: 1007
NEWLINE return NAME NEWLINE DEDENT except ::: 1007
NUMBER ) NEWLINE DEDENT return NAME ::: 1007
NAME = [ ( NAME . ::: 1006
: ] : NEWLINE INDENT NAME ::: 1006
NAME + STRING NEWLINE NAME . ::: 1006
] , [ NUMBER ] , ::: 1006
, False ) NEWLINE DEDENT def ::: 1005
: NEWLINE INDENT return ( STRING ::: 1005
NUMBER ] ] NEWLINE NAME = ::: 1005
= ( NAME , ) NEWLINE ::: 1005
DEDENT DEDENT NAME = [ ] ::: 1005
NAME ] [ STRING ] NEWLINE ::: 1005
NUMBER ] NEWLINE DEDENT except NAME ::: 1004
NEWLINE DEDENT DEDENT return True NEWLINE ::: 1004
NAME = STRING ) NEWLINE return ::: 1004
= NAME ( ** NAME ) ::: 1003
, STRING , ] , NAME ::: 1003
NAME + STRING , NAME = ::: 1003
] NEWLINE DEDENT if NAME ( ::: 1003
NAME ( NAME , - NUMBER ::: 1003
NUMBER , NAME . NAME [ ::: 1002
NAME . NAME ( ) ; ::: 1002
NUMBER ] != STRING : NEWLINE ::: 1002
[ NUMBER : NUMBER ] NEWLINE ::: 1002
= lambda NAME , NAME : ::: 1002
INDENT return NAME NEWLINE DEDENT elif ::: 1002
STRING , STRING : False , ::: 1001
) , STRING % ( NAME ::: 1001
INDENT assert NAME ( NAME ) ::: 1001
STRING , STRING ) ) ) ::: 1001
, None , None , STRING ::: 1001
NAME = NUMBER NEWLINE DEDENT elif ::: 1001
] , NAME , NAME , ::: 1000
STRING NEWLINE if NAME in NAME ::: 1000
) , { STRING : NAME ::: 1000
NAME ) NEWLINE break NEWLINE DEDENT ::: 1000
, } , { STRING : ::: 1000
= NAME NEWLINE NAME = { ::: 1000
STRING : [ NAME . NAME ::: 1000
STRING ] NEWLINE if NAME . ::: 1000
) - NAME . NAME ( ::: 999
( NUMBER ) NEWLINE def NAME ::: 999
= NAME ( NAME = { ::: 998
( NAME - NAME . NAME ::: 998
STRING : STRING } } ) ::: 997
[ NAME : NAME + NAME ::: 997
NEWLINE return NAME NEWLINE DEDENT else ::: 997
( STRING ) ] ) NEWLINE ::: 997
, ( STRING , None , ::: 997
NAME . NAME [ NAME : ::: 997
NAME . NAME ( NAME / ::: 997
= True ) NEWLINE @ NAME ::: 996
( STRING , ( ( STRING ::: 996
= NAME [ NAME ( NAME ::: 996
) ( NAME = NUMBER ) ::: 996
( STRING ) . NAME NEWLINE ::: 996
: ( STRING , ) , ::: 996
( STRING ) NEWLINE raise NAME ::: 996
= NAME NEWLINE if NAME ( ::: 996
. NAME = STRING . NAME ::: 995
] , NAME , NAME = ::: 995
{ } ) . NAME ( ::: 995
NAME = True ) NEWLINE @ ::: 995
NAME ( NUMBER ) NEWLINE def ::: 995
= None NEWLINE NAME = STRING ::: 994
NAME ( NUMBER ) NEWLINE return ::: 994
= STRING NEWLINE return NAME NEWLINE ::: 994
) NEWLINE for NAME in ( ::: 994
| NAME . NAME | NAME ::: 994
as NAME : NEWLINE INDENT with ::: 994
[ NAME : NAME + NUMBER ::: 994
( NUMBER ) ) ) NEWLINE ::: 994
NAME : NAME ( NAME . ::: 993
[ STRING ] , NAME ( ::: 993
NAME | NAME . NAME | ::: 993
== STRING : NEWLINE INDENT from ::: 993
) NEWLINE DEDENT DEDENT DEDENT except ::: 992
if ( not NAME . NAME ::: 992
( NAME . NAME for NAME ::: 992
[ NAME . NAME , STRING ::: 992
NAME = True NEWLINE if NAME ::: 992
NAME ( NAME ) == STRING ::: 991
NEWLINE return False NEWLINE DEDENT DEDENT ::: 991
STRING , STRING : None , ::: 991
. NAME ( NAME , False ::: 991
( ) ] ) NEWLINE NAME ::: 991
] NEWLINE if STRING in NAME ::: 990
: { STRING : NAME , ::: 990
INDENT STRING NEWLINE NAME ( STRING ::: 990
( NAME , [ NUMBER , ::: 990
= STRING NEWLINE DEDENT return NAME ::: 989
NAME or not NAME . NAME ::: 989
] ) NEWLINE NAME , NAME ::: 989
) : pass NEWLINE class NAME ::: 989
NAME = [ ] NEWLINE while ::: 989
( ) NEWLINE DEDENT DEDENT @ ::: 989
{ NUMBER : STRING , NUMBER ::: 989
: STRING } ) , NAME ::: 989
/ NUMBER NEWLINE NAME = NAME ::: 988
NAME . NAME ( - NAME ::: 988
NAME : NEWLINE INDENT return NUMBER ::: 988
NAME , NAME , None , ::: 988
NAME ( { NAME . NAME ::: 988
NAME ( ) ) , STRING ::: 988
pass NEWLINE class NAME ( NAME ::: 988
( NAME = STRING ) : ::: 988
: pass NEWLINE class NAME ( ::: 987
, STRING : NAME [ NUMBER ::: 987
STRING , None ) ) NEWLINE ::: 987
STRING , NAME ) . NAME ::: 987
. NAME + STRING NEWLINE NAME ::: 987
) ] ) NEWLINE DEDENT DEDENT ::: 986
STRING % NAME . NAME [ ::: 986
NAME ) , ( NAME . ::: 986
NAME == NAME ) NEWLINE DEDENT ::: 986
NAME == NUMBER NEWLINE DEDENT def ::: 986
NAME ( [ NAME [ NUMBER ::: 986
) , STRING , STRING , ::: 985
NEWLINE INDENT return NAME [ STRING ::: 985
= NAME ( STRING , [ ::: 985
NEWLINE NAME STRING NEWLINE NAME = ::: 985
STRING % { STRING : NAME ::: 985
] } , { STRING : ::: 985
NEWLINE DEDENT assert NAME ( NAME ::: 985
. NAME ( NAME in NAME ::: 984
STRING , STRING ) NEWLINE assert ::: 984
STRING % NAME [ NUMBER ] ::: 984
== NAME : NEWLINE INDENT if ::: 984
) , NAME , NAME . ::: 984
] ) NEWLINE DEDENT DEDENT EOS ::: 984
NAME < NAME . NAME : ::: 984
NAME ) - NAME ( NAME ::: 984
NAME ) ) , NAME . ::: 984
- NUMBER ] [ NUMBER ] ::: 983
. NAME as NAME NEWLINE NAME ::: 983
) ) NEWLINE DEDENT except : ::: 983
NUMBER ] , STRING : NAME ::: 983
, NAME NEWLINE from . . ::: 983
% NAME ) NEWLINE DEDENT else ::: 982
NAME ) : pass NEWLINE class ::: 982
. NAME ( NUMBER ) : ::: 982
STRING , NAME = NAME [ ::: 982
NUMBER ] - NAME [ NUMBER ::: 982
NAME = False ) ) NEWLINE ::: 981
+ NAME + STRING NEWLINE NAME ::: 981
, STRING ] ) NEWLINE def ::: 981
( NAME . NAME , False ::: 981
] NEWLINE if not NAME . ::: 981
INDENT NAME . NAME += NAME ::: 981
- NUMBER ) ) NEWLINE NAME ::: 981
[ : NUMBER ] ) NEWLINE ::: 981
NAME ( NAME , STRING + ::: 981
DEDENT DEDENT if NAME is not ::: 981
( NAME , STRING + NAME ::: 980
. NAME = [ NAME , ::: 980
) , NUMBER , NUMBER ) ::: 980
] NEWLINE DEDENT elif NAME . ::: 980
NAME NEWLINE DEDENT DEDENT DEDENT NAME ::: 979
STRING ) , STRING : STRING ::: 979
, ( NAME . NAME . ::: 979
NAME = True ) NEWLINE return ::: 979
STRING } ) NEWLINE DEDENT def ::: 979
NAME [ NAME ] = STRING ::: 979
: NAME . NAME } , ::: 979
) ) as NAME : NEWLINE ::: 979
NAME . NAME = STRING . ::: 979
} NEWLINE try : NEWLINE INDENT ::: 979
) ; NEWLINE NAME . NAME ::: 979
] ) NEWLINE assert NAME ( ::: 978
NAME . NAME = NAME = ::: 978
, NUMBER ) ) . NAME ::: 978
( ) NEWLINE NAME [ NAME ::: 978
INDENT return True NEWLINE DEDENT else ::: 978
NAME , NUMBER , NAME , ::: 977
NUMBER ] NEWLINE DEDENT return NAME ::: 977
or NAME . NAME : NEWLINE ::: 977
INDENT return NAME [ STRING ] ::: 977
== NAME . NAME ) NEWLINE ::: 977
STRING ) NEWLINE DEDENT DEDENT return ::: 977
[ NUMBER ] NEWLINE assert NAME ::: 977
. NAME . NAME NEWLINE assert ::: 977
<= NUMBER : NEWLINE INDENT NAME ::: 976
. NAME , [ NAME . ::: 976
, ) , ] NEWLINE DEDENT ::: 976
not NAME . NAME and NAME ::: 976
) NEWLINE NAME = { NAME ::: 976
NAME import * NEWLINE from . ::: 976
( NAME ) - NUMBER ) ::: 975
NAME is False : NEWLINE INDENT ::: 975
is True : NEWLINE INDENT NAME ::: 975
NAME = NAME [ NAME + ::: 974
, NAME ] NEWLINE NAME . ::: 974
with NAME ( NAME ) : ::: 974
} , { STRING : NAME ::: 974
= False NEWLINE DEDENT else : ::: 973
DEDENT @ NAME ( ) NEWLINE ::: 973
NAME = NAME [ : NUMBER ::: 973
. NAME , ( NUMBER , ::: 973
( NAME , ) , NAME ::: 972
( { STRING : NUMBER , ::: 972
% NAME for NAME in NAME ::: 972
. NAME ( NAME ) if ::: 971
return NAME ( NAME ) . ::: 971
) NEWLINE DEDENT DEDENT finally : ::: 971
DEDENT elif NAME in ( STRING ::: 971
) , NAME , NAME ( ::: 971
= NAME , NAME = { ::: 971
) > NAME : NEWLINE INDENT ::: 970
** NAME ) ) NEWLINE DEDENT ::: 970
( STRING , NAME ( NUMBER ::: 970
DEDENT raise NAME ( STRING % ::: 970
] ) : NEWLINE INDENT if ::: 970
- NUMBER , - NUMBER ] ::: 970
NUMBER , NUMBER ) . NAME ::: 969
) NEWLINE NAME STRING , NAME ::: 969
NAME ( ** NAME . NAME ::: 969
, ** NAME ) NEWLINE return ::: 969
NAME NEWLINE break NEWLINE DEDENT DEDENT ::: 968
] . NAME , NAME . ::: 968
NEWLINE assert ( NAME ( NAME ::: 968
) NEWLINE if NAME != NUMBER ::: 968
return ( NAME . NAME ( ::: 968
NEWLINE NAME += NAME NEWLINE NAME ::: 968
INDENT del NAME [ NAME ] ::: 968
) , NAME ( { STRING ::: 967
) is None : NEWLINE INDENT ::: 967
( NAME ) == NUMBER and ::: 967
( - NUMBER , - NUMBER ::: 967
NUMBER ] NEWLINE DEDENT elif NAME ::: 966
{ STRING : True } ) ::: 966
( NAME , NAME ) == ::: 966
yield NAME . NAME ( ) ::: 966
( STRING ) NEWLINE DEDENT EOS ::: 966
BOS NEWLINE import NAME . NAME ::: 966
. NAME ( NAME [ - ::: 965
( STRING , [ NAME . ::: 965
} ) , NAME ( { ::: 965
+ NAME NEWLINE DEDENT def NAME ::: 965
STRING : NAME ( STRING , ::: 965
NAME ( NAME ) , ) ::: 965
INDENT STRING NEWLINE NAME = False ::: 964
STRING , STRING , NAME ] ::: 964
NUMBER : NEWLINE INDENT for NAME ::: 964
NAME NEWLINE NAME = NAME * ::: 964
NEWLINE NAME = ( ) NEWLINE ::: 963
, NAME = True ) . ::: 963
not None : NEWLINE INDENT raise ::: 962
= ( NAME [ NUMBER ] ::: 962
NAME ( ) ) ) ) ::: 962
[ NAME ] ) for NAME ::: 962
} NEWLINE class NAME ( NAME ::: 962
+= STRING NEWLINE NAME += STRING ::: 961
STRING : NEWLINE INDENT return STRING ::: 961
= NAME ( STRING % NAME ::: 961
NEWLINE for NAME in [ NAME ::: 961
= NAME ( NAME = False ::: 961
for NAME in NAME ) ) ::: 961
NUMBER NEWLINE DEDENT class NAME ( ::: 960
NEWLINE NAME = False NEWLINE for ::: 960
BOS NEWLINE class NAME ( NAME ::: 960
NEWLINE INDENT NAME = NAME or ::: 960
] NEWLINE DEDENT if STRING in ::: 960
( ) : NEWLINE INDENT from ::: 960
] ] NEWLINE NAME . NAME ::: 960
STRING ] ( NAME , NAME ::: 960
NAME = NUMBER NEWLINE class NAME ::: 960
NAME ) ) ) NEWLINE return ::: 960
NAME = NAME NEWLINE if not ::: 960
NAME = STRING NEWLINE DEDENT return ::: 960
NAME . NAME ( not NAME ::: 960
NUMBER : NEWLINE INDENT return STRING ::: 959
[ { STRING : NUMBER , ::: 959
DEDENT DEDENT DEDENT DEDENT return NAME ::: 959
return STRING NEWLINE DEDENT NAME = ::: 959
) , True ) NEWLINE NAME ::: 959
( None , NAME ) NEWLINE ::: 958
, NUMBER ) , NUMBER , ::: 958
: NEWLINE INDENT return STRING + ::: 957
( NAME = NAME ( ) ::: 957
STRING % NAME for NAME in ::: 957
[ NUMBER ] - NAME [ ::: 957
STRING % NAME ) NEWLINE if ::: 957
NAME . NAME , } , ::: 957
STRING ) : NEWLINE INDENT continue ::: 957
( NAME ) ) , STRING ::: 956
STRING ] , { STRING : ::: 956
] . NAME ( ) . ::: 956
NUMBER ) NEWLINE NAME [ STRING ::: 956
( NAME , STRING % ( ::: 956
NAME [ : NAME . NAME ::: 956
= NUMBER ) NEWLINE DEDENT NAME ::: 956
if NAME . NAME and not ::: 955
) : NEWLINE INDENT NAME NAME ::: 955
, STRING , NAME ) ) ::: 955
. NAME ) . NAME NEWLINE ::: 955
NAME ( NAME , ( NUMBER ::: 954
= STRING ) NEWLINE assert NAME ::: 954
NAME = True , ) , ::: 954
NEWLINE DEDENT DEDENT for NAME , ::: 954
. NAME ( NAME == NAME ::: 953
STRING STRING ) NEWLINE DEDENT if ::: 953
NAME = NAME or { } ::: 953
, STRING NEWLINE NAME = NAME ::: 953
if NAME is not None else ::: 953
* NAME ) NEWLINE DEDENT DEDENT ::: 953
assert NAME == NAME NEWLINE DEDENT ::: 953
NAME = STRING NEWLINE from NAME ::: 952
) NEWLINE DEDENT return STRING . ::: 952
NAME ( NAME , STRING . ::: 952
if not NAME [ STRING ] ::: 952
{ STRING : NAME , } ::: 951
( ) , NAME = False ::: 951
= STRING NEWLINE try : NEWLINE ::: 951
, NAME NEWLINE import NAME . ::: 951
NEWLINE NAME [ NAME ] [ ::: 950
NAME < ( NUMBER , NUMBER ::: 950
NAME += STRING NEWLINE DEDENT NAME ::: 950
, NAME ( NAME ( STRING ::: 950
None NEWLINE NAME = STRING NEWLINE ::: 950
( STRING ) ) NEWLINE return ::: 950
NAME , NAME + NAME ) ::: 950
( lambda NAME : NAME ( ::: 950
= NAME [ : NUMBER ] ::: 950
NEWLINE INDENT if NAME : NAME ::: 950
NAME = True NEWLINE DEDENT except ::: 949
NAME ( NAME ) : NAME ::: 948
( NAME ) == NAME : ::: 948
NEWLINE DEDENT return NAME ( STRING ::: 948
( ( NUMBER , ) , ::: 948
False , STRING : False , ::: 948
NAME ( NAME = [ NUMBER ::: 948
= NUMBER NEWLINE NAME = { ::: 948
NAME = STRING NEWLINE with NAME ::: 948
NEWLINE INDENT break NEWLINE DEDENT if ::: 947
NEWLINE INDENT NAME ( STRING + ::: 947
= [ STRING ] NEWLINE def ::: 947
( STRING , ) ) NEWLINE ::: 947
] ) , STRING : NAME ::: 947
INDENT NAME = NAME + NUMBER ::: 947
STRING : NEWLINE INDENT from NAME ::: 947
NAME == STRING ) : NEWLINE ::: 947
) NEWLINE DEDENT return NEWLINE DEDENT ::: 947
NEWLINE NAME = { NUMBER : ::: 947
, NAME . NAME , ( ::: 947
) NEWLINE for ( NAME , ::: 946
DEDENT STRING NEWLINE def NAME ( ::: 946
STRING : NEWLINE INDENT try : ::: 946
( NAME ) NEWLINE @ NAME ::: 946
NEWLINE STRING NEWLINE def NAME ( ::: 946
, NAME ) = NAME NEWLINE ::: 945
= lambda NAME : NAME [ ::: 945
: ( NAME . NAME , ::: 945
NEWLINE INDENT pass NEWLINE DEDENT EOS ::: 945
NUMBER ) ) NEWLINE DEDENT NAME ::: 944
DEDENT from NAME . NAME . ::: 944
[ : NUMBER ] == STRING ::: 944
. NAME . NAME , ) ::: 943
, STRING : NAME ( ) ::: 943
NUMBER ) . NAME ( NUMBER ::: 943
= NAME - NAME . NAME ::: 943
INDENT @ NAME . NAME ( ::: 943
] [ STRING ] : NEWLINE ::: 943
NAME ] NEWLINE NAME [ NAME ::: 943
NAME - NAME ) NEWLINE NAME ::: 942
True , STRING : STRING , ::: 942
( STRING ) , STRING , ::: 942
, NAME NEWLINE NAME = STRING ::: 942
[ NAME [ NAME ] for ::: 942
( NAME . NAME [ : ::: 941
NAME NEWLINE NAME ( NAME ) ::: 941
[ NAME . NAME ( NUMBER ::: 941
NAME is not None or NAME ::: 941
: NAME [ NUMBER ] , ::: 941
) , NAME . NAME : ::: 941
NAME ( ) , [ STRING ::: 941
, ( NAME . NAME ( ::: 941
, NAME ) NEWLINE return NEWLINE ::: 940
STRING ) , NAME , NAME ::: 940
. NAME ( ) ; NEWLINE ::: 940
DEDENT DEDENT DEDENT DEDENT NAME = ::: 940
. NAME , ( NAME . ::: 940
) ) ) NEWLINE return NAME ::: 940
NEWLINE INDENT NAME = [ NUMBER ::: 940
] [ NAME ] [ STRING ::: 939
( [ ( STRING , NAME ::: 939
NAME . NAME ) , ) ::: 939
NAME : NAME ( NAME ) ::: 939
NUMBER ) NEWLINE DEDENT DEDENT NAME ::: 938
. NAME ) ] ) NEWLINE ::: 938
) , { STRING : STRING ::: 938
INDENT break NEWLINE DEDENT NAME = ::: 938
NEWLINE NAME ( NUMBER , NAME ::: 937
( STRING , ) NEWLINE DEDENT ::: 937
NEWLINE DEDENT from NAME import NAME ::: 937
NAME . NAME , ( STRING ::: 937
= NAME + NUMBER NEWLINE NAME ::: 937
NAME ( NAME ) ] , ::: 937
( NAME + NAME . NAME ::: 937
} ) NEWLINE DEDENT @ NAME ::: 936
NUMBER ] [ NUMBER ] == ::: 936
STRING ] == STRING NEWLINE assert ::: 935
STRING NEWLINE NAME ( NAME ) ::: 935
NAME ) NEWLINE NAME STRING NEWLINE ::: 935
( NAME = NUMBER ) . ::: 935
not NAME : NEWLINE INDENT break ::: 935
= NAME or { } NEWLINE ::: 935
NAME ) ) NEWLINE def NAME ::: 935
NAME = [ STRING , NAME ::: 934
) ) : NAME . NAME ::: 934
= NAME * NAME . NAME ::: 934
NEWLINE return NEWLINE DEDENT def NAME ::: 934
NAME ( NAME ) ( NAME ::: 934
NUMBER ] NEWLINE NAME = STRING ::: 934
( NAME ( NAME ( STRING ::: 934
] [ STRING ] = STRING ::: 933
NAME : NEWLINE INDENT return ( ::: 933
[ STRING ] ) , NUMBER ::: 933
NAME ( NAME ) NEWLINE @ ::: 933
NAME ) is NAME : NEWLINE ::: 932
. NAME ) NEWLINE DEDENT for ::: 932
, NAME ) ) , NAME ::: 932
[ NUMBER ] , NAME , ::: 932
] NEWLINE DEDENT DEDENT else : ::: 931
INDENT NAME STRING , NAME NEWLINE ::: 931
NAME = STRING NEWLINE try : ::: 931
raise NAME . NAME ( ) ::: 930
return ( NAME , NAME , ::: 930
, [ NUMBER ] , [ ::: 930
NAME . NAME + NAME NEWLINE ::: 929
: NEWLINE INDENT return not NAME ::: 929
NAME ( ) == STRING NEWLINE ::: 929
] == NUMBER NEWLINE assert NAME ::: 929
( { STRING : NUMBER } ::: 928
NAME ) NEWLINE @ NAME ( ::: 928
NEWLINE NAME . NAME = lambda ::: 928
DEDENT DEDENT except NAME , NAME ::: 928
, - NUMBER ] , [ ::: 928
: NEWLINE INDENT yield NAME , ::: 928
NAME ) NEWLINE if NAME not ::: 928
NAME ( ) ) : NAME ::: 928
) [ STRING ] NEWLINE NAME ::: 928
. NAME ( { NAME . ::: 928
NAME ] ) NEWLINE NAME ( ::: 927
, STRING , ] ) NEWLINE ::: 927
. NAME ( ) NEWLINE class ::: 927
INDENT STRING NEWLINE if NAME in ::: 927
NAME ) . NAME , NAME ::: 926
STRING NEWLINE @ NAME . NAME ::: 926
. NAME . NAME ( False ::: 926
is NAME : NEWLINE INDENT return ::: 925
== NAME . NAME ( NAME ::: 925
[ NAME ] NEWLINE NAME [ ::: 925
, } ) NEWLINE NAME = ::: 925
, NAME = STRING , ** ::: 925
STRING , } , STRING : ::: 925
: STRING } } NEWLINE NAME ::: 925
[ NAME ] NEWLINE DEDENT return ::: 925
NEWLINE DEDENT DEDENT DEDENT DEDENT return ::: 924
return STRING % ( NAME ( ::: 924
. NAME NEWLINE assert NAME ( ::: 924
, - NUMBER , NUMBER ] ::: 924
) * NAME . NAME ( ::: 924
) NEWLINE NAME . NAME , ::: 924
% ( NAME . NAME [ ::: 924
NAME STRING , NAME NEWLINE NAME ::: 924
NEWLINE from . . import NAME ::: 924
STRING , None ) , NAME ::: 924
( NUMBER , ( NUMBER , ::: 924
. NAME , NAME = None ::: 923
NEWLINE NAME ( NAME ( STRING ::: 923
NAME : NAME . NAME ) ::: 923
[ NUMBER ] ] ) NEWLINE ::: 923
( NAME ) NEWLINE return NEWLINE ::: 923
== NUMBER and NAME . NAME ::: 923
NAME . NAME , - NUMBER ::: 922
) ) NEWLINE DEDENT DEDENT elif ::: 922
NUMBER ) : NEWLINE INDENT raise ::: 922
STRING or NAME == STRING : ::: 922
NAME ( ) NEWLINE NAME += ::: 922
NAME = NAME - NUMBER NEWLINE ::: 922
STRING : True } ) NEWLINE ::: 922
] , STRING : [ ( ::: 922
and STRING in NAME : NEWLINE ::: 922
. NAME < NAME . NAME ::: 922
NAME is not NAME : NEWLINE ::: 922
NAME += STRING % NAME NEWLINE ::: 922
NAME * NAME ( NAME ) ::: 922
NEWLINE NAME += NAME NEWLINE DEDENT ::: 921
) , ( NAME ( STRING ::: 921
lambda NAME : NAME [ NUMBER ::: 921
NEWLINE break NEWLINE DEDENT DEDENT if ::: 920
NEWLINE @ NAME ( NAME ) ::: 920
, NAME . NAME , ) ::: 920
( NAME [ NUMBER : NUMBER ::: 920
NAME = NAME - NAME . ::: 920
DEDENT except ( NAME . NAME ::: 920
[ NUMBER ] == NUMBER NEWLINE ::: 919
STRING : STRING } ) ) ::: 919
: { STRING : NAME } ::: 919
STRING ] = NAME [ NUMBER ::: 919
) ) : NEWLINE INDENT STRING ::: 919
} } , { STRING : ::: 919
( ) ) : NAME . ::: 919
) . NAME ( NUMBER , ::: 918
NAME . NAME ) if NAME ::: 918
= NAME NEWLINE break NEWLINE DEDENT ::: 917
[ NUMBER ] + NAME [ ::: 917
- NUMBER ] : NEWLINE INDENT ::: 917
, ( NAME , ) ) ::: 917
STRING ] NEWLINE DEDENT except NAME ::: 917
[ STRING ] = STRING % ::: 917
, NAME , NAME [ STRING ::: 916
[ STRING ] ] ) NEWLINE ::: 916
( ) : NEWLINE INDENT pass ::: 916
not in ( STRING , STRING ::: 916
NEWLINE if NAME . NAME > ::: 916
( ) NEWLINE DEDENT DEDENT except ::: 916
( [ NAME [ STRING ] ::: 916
if NAME . NAME or NAME ::: 915
DEDENT if NAME in NAME : ::: 915
* NAME ( NAME . NAME ::: 915
NAME . NAME -= NUMBER NEWLINE ::: 915
, STRING : [ ] } ::: 915
STRING . NAME ( ( NAME ::: 914
NEWLINE INDENT STRING NEWLINE global NAME ::: 914
: NEWLINE INDENT STRING NEWLINE global ::: 914
- NUMBER , NUMBER ) NEWLINE ::: 914
STRING STRING ) NEWLINE DEDENT def ::: 914
= NAME ( NAME = ( ::: 914
NEWLINE INDENT for NAME in ( ::: 914
% { STRING : NAME . ::: 914
NAME NEWLINE from . NAME . ::: 914
NAME ( NAME = lambda NAME ::: 913
) , ) NEWLINE def NAME ::: 913
: NAME ( NAME ( NAME ::: 913
, { } ) . NAME ::: 913
NAME ] NEWLINE DEDENT DEDENT NAME ::: 913
) , NAME . NAME [ ::: 913
NAME = { STRING : False ::: 913
NAME ( ** NAME ) : ::: 913
( NAME ) . NAME , ::: 913
NEWLINE INDENT pass NEWLINE DEDENT elif ::: 913
] : NEWLINE INDENT return NAME ::: 912
NAME . NAME == NUMBER ) ::: 912
{ } NEWLINE DEDENT NAME = ::: 912
= NAME = NAME . NAME ::: 912
, ( NAME , NAME . ::: 912
( STRING STRING STRING STRING ) ::: 911
STRING % ( NAME [ NUMBER ::: 911
NAME } , NAME = NAME ::: 911
, NUMBER , STRING ) , ::: 911
NEWLINE @ NAME NEWLINE @ NAME ::: 911
, NAME , True ) NEWLINE ::: 911
NAME [ STRING ] NEWLINE assert ::: 911
( ** NAME ) : NEWLINE ::: 911
break NEWLINE DEDENT DEDENT if NAME ::: 911
) ( NAME = NUMBER , ::: 911
; NEWLINE NAME . NAME ( ::: 910
] - NAME [ NUMBER ] ::: 910
STRING ) : NEWLINE INDENT for ::: 910
, ) NEWLINE DEDENT class NAME ::: 910
NAME ) ) NEWLINE try : ::: 910
] } NEWLINE NAME . NAME ::: 909
STRING ) == STRING : NEWLINE ::: 909
NUMBER : ] ) NEWLINE NAME ::: 909
import NAME NEWLINE NAME = ( ::: 909
NUMBER , ) , ( NUMBER ::: 909
] ) NEWLINE if not NAME ::: 909
= NAME NEWLINE DEDENT except NAME ::: 909
] + NAME [ NUMBER ] ::: 908
NUMBER ] ) , NAME . ::: 908
INDENT NAME = NAME ( ( ::: 908
] NEWLINE NAME = ( NAME ::: 908
) NEWLINE assert NAME == STRING ::: 908
DEDENT try : NEWLINE INDENT from ::: 908
, NAME , False ) NEWLINE ::: 907
( ) if NAME . NAME ::: 907
, NUMBER ] NEWLINE NAME . ::: 907
NAME . NAME , ( NUMBER ::: 907
NAME . NAME , None , ::: 907
[ NUMBER ] == STRING NEWLINE ::: 907
= STRING % ( NAME ( ::: 906
NUMBER NEWLINE DEDENT elif NAME == ::: 906
: ( NUMBER , STRING ) ::: 906
NAME in NAME ) : NEWLINE ::: 906
DEDENT DEDENT elif NAME == NUMBER ::: 906
DEDENT if NAME in NAME . ::: 906
, STRING , { } ) ::: 905
] NEWLINE NAME [ NUMBER ] ::: 905
DEDENT DEDENT DEDENT if NAME . ::: 905
return True NEWLINE DEDENT DEDENT return ::: 905
NAME ( NAME ( lambda NAME ::: 905
) NEWLINE DEDENT return ( NAME ::: 905
in NAME . NAME and NAME ::: 905
< ( NUMBER , NUMBER ) ::: 905
NAME ( NAME , [ ( ::: 904
NAME ( ) if NAME . ::: 904
] ) [ NUMBER ] NEWLINE ::: 904
NEWLINE if NAME and not NAME ::: 904
STRING , ** NAME ) NEWLINE ::: 903
NAME / NAME NEWLINE NAME = ::: 903
NAME = [ [ NUMBER , ::: 903
] ) NEWLINE NAME [ NAME ::: 903
INDENT with NAME . NAME : ::: 902
import NAME NEWLINE return NAME ( ::: 902
NAME ( [ NAME [ STRING ::: 902
INDENT raise NAME , STRING % ::: 901
( NAME [ NAME ] . ::: 901
, NAME , NAME [ NAME ::: 901
NAME + NUMBER ) ) NEWLINE ::: 901
) , ) NEWLINE NAME . ::: 901
None : NEWLINE INDENT NAME += ::: 901
( NAME = True ) : ::: 901
( ) ] ) NEWLINE DEDENT ::: 901
] NEWLINE NAME = True NEWLINE ::: 901
NAME , NAME ) ] ) ::: 901
INDENT raise NAME . NAME . ::: 901
STRING % ( NAME , STRING ::: 901
NEWLINE return NAME NEWLINE DEDENT class ::: 901
, STRING NEWLINE NAME . NAME ::: 901
INDENT with NAME . NAME . ::: 900
NEWLINE INDENT return [ NAME ( ::: 900
STRING NEWLINE NAME ( NAME . ::: 899
= NAME ( [ NAME ] ::: 899
. NAME ) ] NEWLINE DEDENT ::: 899
, NAME ( NUMBER ) , ::: 899
= NAME ( * NAME ) ::: 899
NAME ) : NEWLINE INDENT del ::: 899
[ - NUMBER ] == STRING ::: 899
NEWLINE INDENT NAME NAME NEWLINE DEDENT ::: 898
NAME , NAME ( ) , ::: 898
DEDENT DEDENT NAME = STRING NEWLINE ::: 898
@ NAME ( STRING , STRING ::: 898
return [ NAME for NAME in ::: 897
- NUMBER , NUMBER ) , ::: 897
% ( NAME [ NUMBER ] ::: 897
, NUMBER ] : NEWLINE INDENT ::: 896
NAME + NAME . NAME . ::: 896
= NAME . NAME [ - ::: 896
NAME , ( STRING , STRING ::: 896
. NAME : NEWLINE INDENT yield ::: 896
+ STRING + NAME ) NEWLINE ::: 896
NUMBER ) NEWLINE return NAME NEWLINE ::: 895
NAME = False NEWLINE DEDENT else ::: 895
. NAME ) , ( NAME ::: 895
NAME . NAME < NAME . ::: 895
( STRING , [ ( STRING ::: 895
False ) , NAME . NAME ::: 895
NUMBER , NUMBER ) ) . ::: 895
DEDENT except : NEWLINE INDENT raise ::: 895
NAME = [ STRING , ] ::: 894
None NEWLINE DEDENT @ NAME NEWLINE ::: 894
, STRING ) NEWLINE DEDENT return ::: 894
( ) NEWLINE DEDENT finally : ::: 894
, ) , NAME = NAME ::: 894
( NUMBER , NAME = NAME ::: 894
INDENT return NAME . NAME == ::: 893
NUMBER ) NEWLINE try : NEWLINE ::: 893
DEDENT return STRING % ( NAME ::: 893
NEWLINE if NAME . NAME < ::: 893
( NAME , NAME , [ ::: 893
, NAME = ( STRING STRING ::: 893
NAME + NUMBER , NAME ) ::: 893
( ) NEWLINE DEDENT DEDENT else ::: 893
False NEWLINE DEDENT if NAME . ::: 892
INDENT STRING NEWLINE import NAME NEWLINE ::: 892
NAME ( lambda NAME , NAME ::: 892
True , STRING : STRING } ::: 892
, STRING ] NEWLINE for NAME ::: 892
, [ NAME ] , NAME ::: 892
DEDENT DEDENT NAME ( NAME , ::: 892
) ) NEWLINE DEDENT try : ::: 892
NAME ) == NUMBER NEWLINE DEDENT ::: 891
+ NUMBER ) NEWLINE NAME . ::: 891
STRING NEWLINE DEDENT @ NAME NEWLINE ::: 891
STRING ] ) , NAME ( ::: 891
NEWLINE INDENT pass NEWLINE DEDENT if ::: 890
NAME [ NAME ] == NAME ::: 890
STRING : STRING } ] } ::: 890
DEDENT NAME = None NEWLINE if ::: 890
. NAME ( NAME = lambda ::: 890
( ) ] NEWLINE NAME = ::: 889
NAME = [ STRING % ( ::: 889
NEWLINE del NAME . NAME NEWLINE ::: 889
DEDENT return NAME ( NAME ( ::: 889
NAME ( ) NEWLINE DEDENT finally ::: 889
assert NAME [ NUMBER ] . ::: 889
import NAME as NAME NEWLINE def ::: 888
NAME ( NAME ) & NAME ::: 888
False , NAME = NAME ) ::: 888
) , STRING ) as NAME ::: 888
NAME ) ) NEWLINE DEDENT EOS ::: 888
NAME or NAME . NAME ) ::: 888
NAME = NAME * NAME . ::: 888
( NAME in NAME . NAME ::: 888
% NAME ) NEWLINE NAME ( ::: 887
NEWLINE DEDENT return ( NAME , ::: 887
NAME = [ NAME [ NAME ::: 887
NAME , STRING % NAME , ::: 887
( NAME = [ NUMBER , ::: 887
- NUMBER , NAME . NAME ::: 887
NUMBER ] [ STRING ] [ ::: 887
NAME . NAME == NAME ( ::: 887
NEWLINE assert NAME ( STRING ) ::: 886
STRING : NAME ( NUMBER ) ::: 886
] , NAME = NUMBER , ::: 886
DEDENT else : NEWLINE INDENT break ::: 886
: STRING , } , STRING ::: 886
< NAME ( NAME ) : ::: 886
) , NAME ( ) ) ::: 886
STRING % ( NAME ) NEWLINE ::: 886
NUMBER , STRING ) ) NEWLINE ::: 886
NEWLINE INDENT with NAME ( STRING ::: 885
) and NAME ( NAME ) ::: 885
. NAME : NEWLINE INDENT break ::: 885
NEWLINE INDENT NAME ( STRING STRING ::: 885
NAME NEWLINE DEDENT DEDENT except NAME ::: 884
( NAME ( STRING ) % ::: 884
STRING ) ) NEWLINE DEDENT return ::: 884
not NAME ( NAME , ( ::: 884
else : NEWLINE INDENT break NEWLINE ::: 884
NAME if NAME ( NAME , ::: 884
NAME = True ) NEWLINE assert ::: 884
BOS NEWLINE STRING NEWLINE from . ::: 884
return STRING NEWLINE DEDENT else : ::: 884
) = NAME . NAME . ::: 884
NAME ( NUMBER , - NUMBER ::: 883
if NAME is None else NAME ::: 883
NAME ( not NAME . NAME ::: 883
NAME [ NUMBER ] != STRING ::: 883
[ - NUMBER ] , NAME ::: 883
STRING , None ) : NEWLINE ::: 883
) ) , ) ) NEWLINE ::: 883
[ NAME . NAME [ NUMBER ::: 882
( ( NAME , NAME ( ::: 882
NAME ) & NAME . NAME ::: 882
] ) ) : NEWLINE INDENT ::: 882
NEWLINE @ NAME ( NAME = ::: 882
] [ NAME ] NEWLINE DEDENT ::: 882
+ STRING ) NEWLINE DEDENT NAME ::: 881
] = [ ] NEWLINE DEDENT ::: 881
) & NAME . NAME ( ::: 881
NAME . NAME , { } ::: 881
NAME ) ) NEWLINE NAME += ::: 881
NEWLINE DEDENT DEDENT return NAME , ::: 881
: NAME ( NUMBER ) , ::: 880
, NAME . NAME ] , ::: 880
] = ( NAME , NAME ::: 880
= True NEWLINE DEDENT NAME . ::: 880
( NAME ) == NAME NEWLINE ::: 880
, NAME [ NAME ] [ ::: 880
NAME += NUMBER NEWLINE DEDENT if ::: 880
STRING ] ) , NUMBER ) ::: 880
NAME ( ) NEWLINE while NAME ::: 879
& NAME . NAME ( NAME ::: 879
for NAME in NAME ] , ::: 879
. NAME = STRING % ( ::: 879
( NAME ) and NAME . ::: 879
[ NUMBER , - NUMBER , ::: 878
del NAME . NAME [ STRING ::: 878
[ NUMBER ] ) . NAME ::: 878
( NAME = True ) , ::: 878
) NEWLINE if NAME != STRING ::: 878
= NAME + NAME ( NAME ::: 878
( NAME [ : , NUMBER ::: 878
) != NAME : NEWLINE INDENT ::: 878
) NEWLINE DEDENT class NAME : ::: 878
. NAME . NAME = ( ::: 877
, NAME = NAME NEWLINE if ::: 877
NAME NEWLINE if not NAME ( ::: 877
) and NAME ( NAME . ::: 877
NAME ( NAME ) ) + ::: 877
NEWLINE NAME ( NAME , [ ::: 876
NAME . NAME = [ NUMBER ::: 876
NEWLINE NAME [ NAME ] . ::: 876
NAME . NAME = [ ( ::: 876
STRING , STRING ) as NAME ::: 876
[ NUMBER ] = NUMBER NEWLINE ::: 876
= [ STRING % ( NAME ::: 876
NAME ) ) , NAME ) ::: 876
INDENT return NAME ( [ NAME ::: 876
NAME , STRING : { STRING ::: 876
NAME ( ) , NAME [ ::: 876
= NUMBER NEWLINE class NAME ( ::: 875
: STRING } } ) NEWLINE ::: 875
INDENT NAME += NAME NEWLINE DEDENT ::: 875
> NUMBER : NEWLINE INDENT if ::: 874
NAME [ STRING ] ) . ::: 874
NAME ( NAME . NAME - ::: 874
DEDENT DEDENT if STRING in NAME ::: 874
] ) ) ) NEWLINE DEDENT ::: 873
NAME , STRING : NAME [ ::: 873
STRING ) NEWLINE DEDENT with NAME ::: 873
NAME ) : NAME += NUMBER ::: 873
( NAME ) & NAME . ::: 872
( NAME , [ NAME , ::: 872
STRING ) ( NAME = NAME ::: 872
( STRING ) NEWLINE DEDENT for ::: 872
NAME + STRING + NAME ) ::: 872
[ NAME , NAME . NAME ::: 872
NEWLINE INDENT NAME = NAME = ::: 872
!= NAME . NAME . NAME ::: 871
( NAME = False ) ) ::: 871
+= NAME . NAME NEWLINE DEDENT ::: 871
[ - NUMBER ] [ NUMBER ::: 871
STRING , NUMBER , STRING , ::: 871
, NAME + STRING ) NEWLINE ::: 871
assert ( NAME . NAME ( ::: 871
) } NEWLINE NAME . NAME ::: 871
STRING ] ) NEWLINE return NAME ::: 870
, NUMBER , NAME = STRING ::: 870
NAME ( STRING ) , [ ::: 870
( NAME ) != NAME ( ::: 870
NAME ) ( NAME ) NEWLINE ::: 870
. NAME ) : NAME += ::: 870
( NAME , NAME = lambda ::: 870
NAME ( NAME for NAME in ::: 870
} , NAME = STRING ) ::: 870
] = NAME NEWLINE DEDENT elif ::: 870
} NEWLINE return NAME . NAME ::: 870
: NAME ] NEWLINE NAME = ::: 870
NEWLINE try : NEWLINE INDENT for ::: 870
= STRING ) NEWLINE return NAME ::: 870
NAME , NAME , NAME + ::: 869
= NAME ( STRING , None ::: 869
NAME ) , STRING , STRING ::: 869
* NUMBER ) NEWLINE NAME = ::: 868
] NEWLINE NAME = NAME + ::: 868
INDENT return True NEWLINE DEDENT if ::: 868
NEWLINE NAME STRING % NAME NEWLINE ::: 868
assert not NAME . NAME . ::: 868
. NAME ( NUMBER ) == ::: 868
STRING ) : NEWLINE INDENT try ::: 867
( STRING ) NEWLINE DEDENT try ::: 867
INDENT STRING NEWLINE with NAME ( ::: 867
assert NAME . NAME [ STRING ::: 867
[ ( NUMBER , NUMBER , ::: 866
DEDENT finally : NEWLINE INDENT if ::: 866
) ) NEWLINE with NAME . ::: 866
NAME , NAME : NAME , ::: 866
) NEWLINE if NAME < NAME ::: 866
, NAME NEWLINE NAME = [ ::: 866
NAME ( NAME , False ) ::: 866
= NAME / NAME NEWLINE NAME ::: 866
NUMBER , NAME + NUMBER ) ::: 866
: NEWLINE INDENT NAME -= NUMBER ::: 865
) NEWLINE NAME STRING % ( ::: 865
NUMBER NEWLINE try : NEWLINE INDENT ::: 865
. NAME ] NEWLINE DEDENT DEDENT ::: 865
NAME ] : NEWLINE INDENT if ::: 865
) [ NUMBER ] , NAME ::: 865
) ] ) NEWLINE DEDENT NAME ::: 865
NAME and NAME . NAME is ::: 864
STRING + NAME NEWLINE NAME . ::: 864
STRING , STRING ] NEWLINE for ::: 864
] NEWLINE DEDENT elif NAME == ::: 864
( ) ) NEWLINE DEDENT @ ::: 864
INDENT NAME . NAME ( None ::: 864
NAME , ( NAME , ) ::: 864
DEDENT try : NEWLINE INDENT if ::: 863
] , [ NAME , NAME ::: 863
STRING ] == NAME . NAME ::: 863
True NEWLINE DEDENT DEDENT return False ::: 863
NAME ( NAME / NUMBER ) ::: 863
, NAME , { STRING : ::: 863
False ) NEWLINE NAME ( NAME ::: 862
[ STRING ] NEWLINE return NAME ::: 862
] ) ) NEWLINE NAME ( ::: 862
not in NAME . NAME . ::: 862
. NAME not in NAME . ::: 862
== NUMBER ) : NEWLINE INDENT ::: 862
STRING ] [ NAME ] [ ::: 862
None , None , STRING , ::: 861
NAME NEWLINE NAME += NUMBER NEWLINE ::: 861
assert not NAME . NAME NEWLINE ::: 861
) , NAME ) : NEWLINE ::: 861
. NAME ( NUMBER * NAME ::: 861
None NEWLINE if NAME : NEWLINE ::: 861
= [ [ NUMBER , NUMBER ::: 861
: NAME ( NAME ) } ::: 861
NAME ) / NAME ( NAME ::: 861
, NAME , ) NEWLINE from ::: 861
while NUMBER : NEWLINE INDENT NAME ::: 860
: NAME ( STRING ) } ::: 860
+ NAME ) NEWLINE DEDENT DEDENT ::: 860
NUMBER ] NEWLINE if NAME ( ::: 860
NAME , NAME , True ) ::: 860
NAME ( ) ) NEWLINE assert ::: 860
DEDENT elif not NAME . NAME ::: 860
NUMBER , NUMBER ] : NEWLINE ::: 860
while NAME . NAME ( ) ::: 860
not STRING in NAME : NEWLINE ::: 859
STRING ] = [ ] NEWLINE ::: 859
INDENT NAME ( STRING + NAME ::: 859
INDENT NAME = NAME - NAME ::: 859
NAME [ NAME ] ) for ::: 859
= NAME ( NAME ) - ::: 858
, NAME = None , ) ::: 858
NUMBER NEWLINE if NAME : NEWLINE ::: 858
DEDENT DEDENT @ NAME ( STRING ::: 858
NUMBER ] ) NEWLINE NAME [ ::: 858
if NAME != None : NEWLINE ::: 858
) , STRING , NAME = ::: 858
DEDENT NAME = NAME ( [ ::: 858
NEWLINE DEDENT return { STRING : ::: 858
NUMBER ) : NEWLINE INDENT for ::: 858
[ NUMBER ] NEWLINE return NAME ::: 858
- NUMBER , NUMBER ] , ::: 858
* NAME . NAME NEWLINE NAME ::: 857
NAME * NAME . NAME ) ::: 857
) NEWLINE DEDENT return None NEWLINE ::: 857
STRING ] , NAME ( NAME ::: 857
NUMBER NEWLINE assert NAME [ NUMBER ::: 857
NAME ) , STRING ) ) ::: 857
. NAME ) NEWLINE DEDENT EOS ::: 857
[ STRING ] = [ ] ::: 857
NUMBER NEWLINE NAME , NAME = ::: 857
= NAME ( ( NAME . ::: 856
DEDENT DEDENT NAME = { STRING ::: 856
NUMBER : ] . NAME ( ::: 856
NAME = STRING , ) , ::: 856
NAME [ NAME , : ] ::: 856
( NAME ( lambda NAME : ::: 856
, STRING , [ STRING , ::: 855
( NAME . NAME and NAME ::: 855
[ - NUMBER , NUMBER , ::: 855
( ) NEWLINE DEDENT DEDENT return ::: 855
INDENT NAME = None NEWLINE if ::: 854
DEDENT if NAME == NAME : ::: 854
NAME ( ) ) , ( ::: 854
NAME = NAME ( [ ] ::: 854
] NEWLINE DEDENT return NAME . ::: 853
NUMBER ] NEWLINE NAME [ STRING ::: 853
NEWLINE while NUMBER : NEWLINE INDENT ::: 853
NAME [ STRING ] , [ ::: 853
: NEWLINE INDENT return { } ::: 853
% ( NAME , ) NEWLINE ::: 853
) NEWLINE import NAME NEWLINE NAME ::: 853
in NAME ) NEWLINE DEDENT def ::: 852
, [ ] , [ ] ::: 852
( ) NEWLINE NAME = None ::: 852
return NAME . NAME [ NUMBER ::: 852
== STRING : NEWLINE INDENT continue ::: 852
NAME , STRING , None , ::: 851
] NEWLINE DEDENT DEDENT if NAME ::: 851
NAME ] . NAME . NAME ::: 851
True NEWLINE DEDENT DEDENT class NAME ::: 851
NAME = ( NAME [ NUMBER ::: 851
. NAME . NAME : STRING ::: 851
= { STRING : ( STRING ::: 851
NAME . NAME ) or NAME ::: 851
NAME ( NAME ) : ] ::: 851
] ) NEWLINE NAME ( STRING ::: 851
[ STRING ] == NAME . ::: 850
= STRING % NAME ( NAME ::: 850
[ STRING ] = [ NAME ::: 850
NUMBER NEWLINE DEDENT DEDENT NAME = ::: 850
, STRING : [ ( STRING ::: 850
[ ] , NAME = [ ::: 850
INDENT if NAME is NAME : ::: 850
NAME [ ( NAME , NAME ::: 850
STRING ) ] , NAME = ::: 849
if NAME ( NAME [ NUMBER ::: 849
STRING : NEWLINE INDENT for NAME ::: 849
NAME = [ NAME ( ) ::: 849
NAME . NAME : ( STRING ::: 849
None , NAME ) NEWLINE NAME ::: 849
NAME , NAME ( NUMBER , ::: 849
. NAME = ( NAME , ::: 849
= STRING NEWLINE if NAME : ::: 848
NAME ( NAME ) } NEWLINE ::: 848
INDENT NAME = ( ( STRING ::: 848
= NUMBER ) ) NEWLINE DEDENT ::: 848
NAME == NUMBER NEWLINE NAME = ::: 848
( ( NAME - NAME ) ::: 848
= NAME ( ) NEWLINE return ::: 848
NAME ] = [ ] NEWLINE ::: 848
NAME NEWLINE DEDENT DEDENT DEDENT return ::: 848
NEWLINE INDENT NAME = - NUMBER ::: 847
) ) NEWLINE DEDENT DEDENT except ::: 847
NAME . NAME = lambda NAME ::: 847
] , STRING : [ NAME ::: 847
NEWLINE NAME = ( ( NAME ::: 847
. NAME ) NEWLINE class NAME ::: 847
NAME , NAME : NAME ( ::: 847
NAME = False ) NEWLINE if ::: 847
NAME = NAME NEWLINE try : ::: 847
for ( NAME , NAME , ::: 846
( NAME ) NEWLINE if STRING ::: 846
( ) and NAME . NAME ::: 846
NUMBER , NUMBER ] ] NEWLINE ::: 846
NAME ( NAME . NAME for ::: 846
NEWLINE DEDENT return STRING NEWLINE DEDENT ::: 846
DEDENT DEDENT NAME [ STRING ] ::: 846
( STRING ) , NUMBER ) ::: 846
NAME [ NUMBER ] ] ) ::: 846
elif NAME in ( STRING , ::: 846
NAME , STRING ) NEWLINE for ::: 846
NEWLINE assert NAME . NAME NEWLINE ::: 846
NAME NEWLINE @ NAME ( NAME ::: 845
( ) NEWLINE DEDENT if not ::: 845
( ) . NAME ) NEWLINE ::: 845
, NAME ) ) . NAME ::: 845
, ( NUMBER , ( NUMBER ::: 845
( NAME [ : - NUMBER ::: 844
True , NAME = None ) ::: 844
. NAME = STRING % NAME ::: 844
( ) : NEWLINE INDENT global ::: 843
= False ) , NAME . ::: 843
NAME ( NAME - NUMBER ) ::: 843
NEWLINE NAME . NAME ( - ::: 843
NAME ( ) and NAME . ::: 843
NAME = - NUMBER NEWLINE DEDENT ::: 843
[ - NUMBER , NUMBER ] ::: 843
= STRING STRING ) NEWLINE NAME ::: 843
NEWLINE DEDENT return STRING % ( ::: 843
NAME ( STRING ) == NAME ::: 843
} , NAME = { STRING ::: 843
NAME = None ) NEWLINE DEDENT ::: 843
and NAME ( NAME , STRING ::: 843
NAME ) NEWLINE ( NAME , ::: 842
import NAME NEWLINE from ... NAME ::: 842
= NAME NEWLINE NAME , NAME ::: 842
STRING STRING STRING % ( NAME ::: 842
NEWLINE return [ NAME . NAME ::: 842
. NAME : ( STRING , ::: 842
NAME , STRING % NAME NEWLINE ::: 842
) NEWLINE from . NAME import ::: 841
return STRING . NAME ( [ ::: 841
: NEWLINE INDENT NAME = yield ::: 841
NAME . NAME ) NEWLINE class ::: 841
NAME , STRING , ( NAME ::: 841
] NEWLINE if NAME is not ::: 841
STRING , STRING , None ) ::: 841
] , { } ) } ::: 841
( ) NEWLINE @ NAME . ::: 841
+= NAME . NAME . NAME ::: 841
[ STRING ] ] NEWLINE NAME ::: 841
= NAME ) NEWLINE if not ::: 841
INDENT break NEWLINE DEDENT DEDENT DEDENT ::: 841
is None or NAME . NAME ::: 841
( STRING . NAME ( [ ::: 841
= STRING + NAME NEWLINE DEDENT ::: 840
INDENT return STRING NEWLINE DEDENT elif ::: 840
INDENT NAME = NAME NEWLINE if ::: 840
STRING ] [ NUMBER ] ) ::: 840
, None ) , ( STRING ::: 840
NAME ) NEWLINE import NAME NEWLINE ::: 840
, STRING , False ) NEWLINE ::: 840
INDENT break NEWLINE DEDENT if NAME ::: 840
: NAME ( ) , STRING ::: 840
NAME NEWLINE if NAME in NAME ::: 840
( NAME ) ] = NAME ::: 840
= True ) , NAME ( ::: 839
. NAME ( STRING + STRING ::: 839
NEWLINE INDENT NAME -= NUMBER NEWLINE ::: 839
, NAME , NAME NEWLINE def ::: 839
, NAME ) or NAME ( ::: 839
NEWLINE DEDENT STRING NEWLINE def NAME ::: 839
from NAME import NAME NEWLINE try ::: 838
NAME ( False ) NEWLINE DEDENT ::: 838
[ NUMBER ] , NAME ( ::: 838
} NEWLINE NAME = [ ] ::: 838
, NAME , NAME ) . ::: 838
NAME ( NAME , STRING STRING ::: 838
NAME in NAME ] ) ) ::: 838
STRING ) ] ) NEWLINE DEDENT ::: 838
NUMBER , STRING ) , NAME ::: 838
, [ STRING ] , NAME ::: 838
. NAME : NEWLINE INDENT del ::: 837
( NAME + NAME , NAME ::: 837
STRING , NAME = [ ] ::: 837
NEWLINE for NAME in ( STRING ::: 837
) NEWLINE DEDENT if STRING not ::: 837
, NAME : NAME , NAME ::: 837
[ NAME ] . NAME ) ::: 837
NEWLINE if ( NAME ( NAME ::: 837
NAME ( ) NEWLINE if STRING ::: 837
STRING : { STRING : False ::: 837
NEWLINE INDENT NAME NAME . NAME ::: 836
!= - NUMBER : NEWLINE INDENT ::: 836
STRING ) , STRING ) , ::: 836
: NEWLINE INDENT NAME NAME . ::: 836
elif NAME [ NUMBER ] == ::: 836
while NAME < NAME : NEWLINE ::: 836
NAME NEWLINE import NAME NEWLINE if ::: 836
[ NAME ] ) NEWLINE if ::: 836
] ) NEWLINE NAME = { ::: 836
NEWLINE INDENT NAME = { NAME ::: 835
( NAME , NAME ( NUMBER ::: 835
None NEWLINE DEDENT if NAME . ::: 835
return False NEWLINE DEDENT DEDENT return ::: 835
* NUMBER ) NEWLINE NAME . ::: 835
( NAME ) is NAME : ::: 834
- NAME ) NEWLINE NAME = ::: 834
} , NAME = NAME . ::: 834
NAME [ STRING ] NEWLINE return ::: 834
NAME . NAME , False , ::: 834
) for NAME in NAME if ::: 833
) NEWLINE if NAME > NAME ::: 833
NEWLINE INDENT return STRING + NAME ::: 833
. NAME in ( STRING , ::: 833
NAME ) NEWLINE DEDENT NAME += ::: 833
( STRING % STRING . NAME ::: 833
DEDENT elif NAME is not None ::: 833
NAME += NAME + ( STRING ::: 833
NAME . NAME = ( STRING ::: 832
} ) NEWLINE return NAME NEWLINE ::: 832
if not NAME and not NAME ::: 832
= True NEWLINE DEDENT except NAME ::: 832
NAME ( ) - NAME ) ::: 832
return True NEWLINE DEDENT if NAME ::: 832
import * NEWLINE from . NAME ::: 832
STRING STRING , NAME . NAME ::: 832
NAME = ( NAME + NAME ::: 832
import NAME NEWLINE @ NAME . ::: 831
or NAME . NAME NEWLINE NAME ::: 831
( NUMBER * NAME . NAME ::: 831
, ** NAME ) ) NEWLINE ::: 831
NAME : NAME + NAME ] ::: 831
= NAME . NAME ( - ::: 831
( NAME ) NEWLINE DEDENT try ::: 830
, NAME NEWLINE DEDENT NAME = ::: 830
* NAME ( NAME , NAME ::: 830
) , ** NAME ) NEWLINE ::: 830
INDENT pass NEWLINE DEDENT elif NAME ::: 830
NAME , NAME , False ) ::: 830
else : NEWLINE INDENT raise NEWLINE ::: 830
+= NAME + ( STRING % ::: 830
% { STRING : NAME , ::: 829
) % { STRING : NAME ::: 829
, } NEWLINE DEDENT def NAME ::: 829
== STRING : NEWLINE INDENT try ::: 829
NAME = - NUMBER ) NEWLINE ::: 829
STRING ] ) ) , ( ::: 829
) NEWLINE assert ( NAME ( ::: 829
STRING ] = False NEWLINE NAME ::: 829
, NUMBER ) NEWLINE DEDENT @ ::: 829
[ NAME ] NEWLINE for NAME ::: 829
NAME ] ) . NAME ( ::: 828
= [ ] ) : NEWLINE ::: 828
NAME NEWLINE DEDENT NAME , NAME ::: 828
] NEWLINE NAME = STRING . ::: 828
NAME . NAME , * NAME ::: 828
True ) NEWLINE DEDENT else : ::: 828
NAME ) NEWLINE DEDENT raise NAME ::: 828
) : NEWLINE INDENT while NAME ::: 828
, ) , ) , NAME ::: 828
!= STRING : NEWLINE INDENT return ::: 828
NAME = [ ] ) : ::: 828
[ NAME ( NAME = NAME ::: 828
] NEWLINE DEDENT elif NAME ( ::: 827
[ ] NEWLINE NAME = { ::: 827
. NAME ( ) > NUMBER ::: 827
NAME ( NAME = STRING % ::: 827
True , NAME = NAME ( ::: 827
in NAME : NEWLINE INDENT del ::: 827
>= NAME . NAME : NEWLINE ::: 827
NUMBER , NUMBER ) , [ ::: 826
STRING ] NEWLINE DEDENT NAME . ::: 826
def NAME ( ** NAME ) ::: 826
, NUMBER ) , NAME ) ::: 826
( NAME + NUMBER ) * ::: 826
STRING : STRING } ] , ::: 826
STRING NEWLINE import NAME as NAME ::: 825
DEDENT DEDENT DEDENT except NAME : ::: 825
] ) , NAME ) NEWLINE ::: 825
) NEWLINE DEDENT if NAME != ::: 825
, NUMBER ) NEWLINE DEDENT else ::: 825
STRING ) % { STRING : ::: 825
] , None ) NEWLINE NAME ::: 825
] [ STRING ] == STRING ::: 825
( NAME = lambda NAME : ::: 825
STRING NEWLINE NAME = NAME or ::: 824
+ NAME + NAME + NAME ::: 824
[ STRING ] ) , STRING ::: 824
= NAME [ NAME + NUMBER ::: 824
- NAME ( NAME ) ) ::: 824
NEWLINE INDENT return { } NEWLINE ::: 824
( ( NAME [ NUMBER ] ::: 824
in NAME [ STRING ] . ::: 824
NAME ] NEWLINE if not NAME ::: 824
, STRING , NAME = { ::: 823
NAME , STRING ) NEWLINE try ::: 823
DEDENT NAME . NAME ( [ ::: 823
INDENT return { } NEWLINE DEDENT ::: 823
NAME , NAME + NUMBER , ::: 823
] , STRING : { STRING ::: 823
( NAME , ( NUMBER , ::: 822
, NUMBER ) NEWLINE NAME , ::: 822
STRING } ) , NAME ( ::: 822
( not NAME . NAME ) ::: 822
STRING ] = NAME NEWLINE if ::: 821
NUMBER ] NEWLINE DEDENT NAME . ::: 821
= STRING ) , ) NEWLINE ::: 821
) NEWLINE raise NEWLINE DEDENT DEDENT ::: 821
} NEWLINE DEDENT class NAME ( ::: 821
NEWLINE NAME = True NEWLINE def ::: 821
, NAME = NUMBER , NUMBER ::: 821
STRING : STRING } ] NEWLINE ::: 821
NAME . NAME in ( STRING ::: 821
. NAME > NAME . NAME ::: 821
STRING NEWLINE import NAME , NAME ::: 821
STRING : NAME } NEWLINE if ::: 820
None ) ) NEWLINE NAME . ::: 820
NEWLINE NAME = NUMBER NEWLINE class ::: 820
NAME ] ) NEWLINE return NAME ::: 820
} , NAME = NAME ) ::: 820
INDENT break NEWLINE DEDENT NAME . ::: 820
NAME ) > NUMBER and NAME ::: 820
NEWLINE NAME ( STRING + NAME ::: 820
False NEWLINE NAME = True NEWLINE ::: 820
) . NAME ( NAME [ ::: 819
NUMBER : NEWLINE INDENT return NEWLINE ::: 819
STRING ] ) NEWLINE assert NAME ::: 819
INDENT STRING NEWLINE return [ NAME ::: 819
NAME ) NEWLINE assert ( NAME ::: 819
DEDENT if NAME > NUMBER : ::: 819
NUMBER ] NEWLINE if NAME == ::: 818
!= NAME ( NAME ) : ::: 818
in NAME [ STRING ] ] ::: 818
NUMBER : - NUMBER ] NEWLINE ::: 818
) * NAME ( NAME ) ::: 818
NAME NEWLINE DEDENT from NAME . ::: 818
) ) : NEWLINE INDENT for ::: 818
NAME ] = { } NEWLINE ::: 818
NUMBER ] NEWLINE NAME ( NAME ::: 818
NUMBER ] , NAME ) ) ::: 818
= [ NAME ( NAME . ::: 818
NEWLINE INDENT NAME = yield NAME ::: 818
NAME NEWLINE NAME ( NAME = ::: 817
STRING ) [ NUMBER ] ) ::: 817
DEDENT NAME = [ NAME ( ::: 817
DEDENT NAME = None NEWLINE NAME ::: 817
: ( NUMBER , NUMBER ) ::: 817
= True NEWLINE break NEWLINE DEDENT ::: 817
) NEWLINE DEDENT DEDENT try : ::: 817
True ) NEWLINE @ NAME . ::: 817
, ] NEWLINE def NAME ( ::: 817
NAME ) , None ) NEWLINE ::: 817
NAME = NAME NEWLINE break NEWLINE ::: 817
, STRING : NUMBER } } ::: 817
STRING NEWLINE DEDENT DEDENT NAME = ::: 817
NAME ( ( NAME , ) ::: 817
NEWLINE DEDENT DEDENT raise NAME ( ::: 816
if NAME <= NUMBER : NEWLINE ::: 816
NAME ] NEWLINE DEDENT for NAME ::: 816
( NAME ) NEWLINE if ( ::: 816
NEWLINE if NAME and NAME : ::: 816
) or NAME . NAME . ::: 816
def NAME ( NAME = NAME ::: 816
, NAME NEWLINE DEDENT DEDENT DEDENT ::: 816
: NUMBER ] == STRING : ::: 815
, { STRING : NAME ( ::: 815
) , ( - NUMBER , ::: 815
= False NEWLINE NAME = True ::: 815
NAME is None or NAME . ::: 815
) , STRING ) NEWLINE def ::: 815
+ NAME . NAME , NAME ::: 815
. NAME = None NEWLINE STRING ::: 815
. NAME = True NEWLINE return ::: 814
NAME , STRING ) NEWLINE assert ::: 814
( { NAME . NAME : ::: 814
) NEWLINE NAME STRING % NAME ::: 814
: [ ( STRING , NAME ::: 813
for NAME in NAME ( ) ::: 813
[ STRING ] . NAME NEWLINE ::: 813
, NUMBER ] ) , NAME ::: 813
NAME , ** NAME ) ) ::: 813
NAME ( STRING % ( STRING ::: 813
, NAME = NUMBER , ) ::: 813
( NAME , NAME + STRING ::: 813
= False ) NEWLINE DEDENT DEDENT ::: 813
NUMBER NEWLINE NAME = None NEWLINE ::: 813
. NAME ( NAME ) } ::: 813
: NAME , STRING : { ::: 813
NUMBER ) . NAME ( STRING ::: 813
] NEWLINE if NAME in NAME ::: 812
if NAME == STRING or NAME ::: 812
False ) ) , ( STRING ::: 812
= NAME NEWLINE DEDENT for NAME ::: 812
NUMBER ] ) , NAME = ::: 812
NAME = NAME or [ ] ::: 812
, NUMBER ] ) , ( ::: 812
} , { STRING : [ ::: 812
NAME ( NAME [ : NAME ::: 812
INDENT NAME = NAME NEWLINE def ::: 812
NAME , NAME = STRING % ::: 811
NEWLINE if NAME is None or ::: 811
DEDENT from NAME import NAME NEWLINE ::: 811
[ NUMBER ] NEWLINE for NAME ::: 811
True NEWLINE NAME = NAME ( ::: 811
NAME ) = NAME ( NAME ::: 811
NAME : NEWLINE INDENT NAME >> ::: 811
NAME * NAME ) NEWLINE NAME ::: 811
NAME = None , * NAME ::: 811
NAME , NAME in NAME [ ::: 810
STRING ) NEWLINE @ NAME NEWLINE ::: 810
* NEWLINE from NAME import * ::: 810
, NAME = STRING STRING STRING ::: 810
, None , NAME ) NEWLINE ::: 810
NAME . NAME ] ) , ::: 810
. NAME == NAME NEWLINE DEDENT ::: 810
) , ( STRING , { ::: 810
. NAME ) NEWLINE NAME += ::: 810
( ) ) , NAME = ::: 810
. NAME ( ) NEWLINE @ ::: 810
STRING , [ NAME ] ) ::: 810
True ) ) NEWLINE NAME . ::: 810
if not STRING in NAME : ::: 810
: STRING } ) ) NEWLINE ::: 809
NAME = False NEWLINE DEDENT if ::: 809
True : NEWLINE INDENT try : ::: 809
[ ( STRING , NAME ( ::: 809
[ STRING ] NEWLINE NAME ( ::: 809
( ) ) NEWLINE continue NEWLINE ::: 809
] , NAME [ NUMBER : ::: 809
NAME ( NAME = ( STRING ::: 809
NAME ( ) ) , NUMBER ::: 808
INDENT pass NEWLINE DEDENT return NAME ::: 808
] , NAME = [ ] ::: 808
, NAME ) as NAME : ::: 808
, ( NAME ( STRING ) ::: 808
NAME or NAME . NAME : ::: 808
NAME ( NAME [ : - ::: 808
NEWLINE if NAME >= NUMBER : ::: 808
elif NAME ( NAME , STRING ::: 808
) < NAME : NEWLINE INDENT ::: 808
NAME ( ) ) NEWLINE continue ::: 808
( NUMBER , STRING ) ) ::: 807
] } ) NEWLINE NAME . ::: 807
None ) , ( STRING , ::: 807
STRING , NUMBER ) NEWLINE if ::: 806
NUMBER : NEWLINE INDENT break NEWLINE ::: 806
( NAME ) NEWLINE continue NEWLINE ::: 806
NAME ] [ NAME ] [ ::: 806
) >= NUMBER : NEWLINE INDENT ::: 806
NAME . NAME [ NAME + ::: 806
NEWLINE NAME = ( NAME [ ::: 806
STRING ] [ NAME ] NEWLINE ::: 806
= False ) ) , ( ::: 806
NEWLINE NAME = ( NAME - ::: 805
) NEWLINE DEDENT DEDENT except : ::: 805
, [ NUMBER ] ) NEWLINE ::: 805
NUMBER , NUMBER ) ] , ::: 805
NEWLINE NAME = NAME ( * ::: 805
+= NAME . NAME ( ) ::: 805
NAME ( NAME . NAME * ::: 805
NAME import * NEWLINE class NAME ::: 805
, ( STRING , ( NUMBER ::: 805
( { STRING : NAME ( ::: 805
@ NAME NEWLINE @ NAME ( ::: 805
NAME ) + STRING NEWLINE DEDENT ::: 805
NAME [ NUMBER ] + NUMBER ::: 804
[ NAME ( NAME ( NAME ::: 804
( NAME . NAME , ** ::: 804
NAME - NUMBER ) NEWLINE NAME ::: 804
( NAME ( NAME , NUMBER ::: 804
) ] , NAME = NAME ::: 804
NAME = None NEWLINE DEDENT return ::: 804
NAME . NAME = NAME , ::: 804
NAME = [ NAME ] , ::: 804
. NAME ( ) or NAME ::: 803
else : NEWLINE INDENT assert NAME ::: 803
+= NUMBER NEWLINE DEDENT if NAME ::: 803
NUMBER ) NEWLINE if NAME ( ::: 803
( ) : NEWLINE INDENT yield ::: 803
NAME ( ( NUMBER , ) ::: 803
= NAME or [ ] NEWLINE ::: 802
% NAME ) NEWLINE if NAME ::: 802
if ( NAME . NAME == ::: 802
( NAME [ : NUMBER ] ::: 802
. NAME ( STRING ) != ::: 802
) + STRING + NAME . ::: 802
= STRING ) NEWLINE class NAME ::: 802
not None : NEWLINE INDENT for ::: 802
NAME = NAME NEWLINE NAME , ::: 802
NAME + ( STRING % NAME ::: 802
NAME = STRING ) NEWLINE class ::: 802
, NAME , None , NAME ::: 801
NAME , ) NEWLINE DEDENT def ::: 801
NUMBER ] , NAME ( NAME ::: 801
, lambda : NAME . NAME ::: 801
, None , STRING , STRING ::: 801
) , } NEWLINE NAME = ::: 801
NAME . NAME is None NEWLINE ::: 800
False , NAME = NUMBER , ::: 800
STRING ] NEWLINE class NAME ( ::: 800
} NEWLINE DEDENT DEDENT class NAME ::: 800
STRING ] NEWLINE DEDENT if STRING ::: 800
: [ NUMBER , NUMBER ] ::: 800
return STRING NEWLINE DEDENT DEDENT def ::: 800
NAME ( ) NEWLINE raise NAME ::: 800
[ STRING ] , STRING , ::: 800
except NAME : NEWLINE INDENT try ::: 799
INDENT with NAME ( NAME ) ::: 799
) NEWLINE NAME ( ) . ::: 799
NAME ] NEWLINE def NAME ( ::: 799
None or NAME . NAME is ::: 799
NAME ( NAME ) NEWLINE continue ::: 799
NAME import NAME NEWLINE from ... ::: 799
STRING ] NEWLINE NAME ( NAME ::: 799
] , [ ( STRING , ::: 799
NAME [ NUMBER ] = NUMBER ::: 799
NAME and NAME [ NUMBER ] ::: 798
, NAME = None , * ::: 798
NAME = True NEWLINE break NEWLINE ::: 798
DEDENT return NAME NEWLINE DEDENT if ::: 798
) , NAME ) NEWLINE if ::: 797
NAME ( STRING ) , } ::: 797
= NAME NEWLINE return NAME . ::: 797
NEWLINE DEDENT NAME . NAME += ::: 797
STRING NEWLINE raise NAME ( NAME ::: 797
elif NAME [ STRING ] == ::: 797
DEDENT try : NEWLINE INDENT import ::: 797
. NAME is NAME . NAME ::: 797
DEDENT elif NAME . NAME is ::: 796
STRING ] ) , ( STRING ::: 796
NAME . NAME > NAME . ::: 796
NEWLINE NAME STRING . NAME ( ::: 796
NAME + NAME + NAME + ::: 796
( * NAME . NAME ) ::: 796
True NEWLINE DEDENT if NAME . ::: 796
return STRING NEWLINE DEDENT elif NAME ::: 796
. NAME ( True , NAME ::: 796
. NAME , STRING % ( ::: 796
. NAME import * NEWLINE NAME ::: 795
, NAME ) NEWLINE from . ::: 795
NUMBER , - NUMBER ) ) ::: 794
NEWLINE return False NEWLINE DEDENT NAME ::: 794
( NAME ) == NAME . ::: 794
INDENT return STRING NEWLINE DEDENT else ::: 794
( NUMBER ) , STRING : ::: 794
. NAME NEWLINE from NAME import ::: 794
NAME ( ( NAME - NAME ::: 793
] : NEWLINE INDENT NAME += ::: 793
( NAME . NAME or NAME ::: 793
[ STRING ] NEWLINE DEDENT return ::: 793
NEWLINE INDENT yield NAME , NAME ::: 792
( STRING , [ [ ( ::: 792
, NUMBER ) NEWLINE NAME [ ::: 792
in NAME ( ) : NEWLINE ::: 792
* NAME . NAME ( ) ::: 792
NUMBER ] , NUMBER , NUMBER ::: 792
NAME += NAME . NAME . ::: 792
return NAME in NAME . NAME ::: 792
( STRING ) and NAME . ::: 792
STRING : ( STRING , ) ::: 791
: NEWLINE INDENT assert ( NAME ::: 791
if NAME in [ STRING , ::: 791
NEWLINE return NUMBER NEWLINE DEDENT def ::: 791
None NEWLINE DEDENT DEDENT class NAME ::: 791
NAME = STRING ) , ] ::: 791
) NEWLINE if STRING not in ::: 791
( NAME . NAME ) != ::: 791
= STRING % ( NAME [ ::: 791
NEWLINE DEDENT @ NAME ( ) ::: 791
: NUMBER , STRING : [ ::: 791
NAME ( NAME + NAME , ::: 791
- NAME . NAME ) NEWLINE ::: 790
] , NUMBER , NUMBER ) ::: 790
NUMBER , NUMBER , NAME , ::: 790
None , STRING , STRING , ::: 790
STRING , NAME ( NUMBER ) ::: 790
) NEWLINE NAME = [ { ::: 790
) NEWLINE if NAME : NAME ::: 790
NUMBER and NAME [ NUMBER ] ::: 790
NAME ) NEWLINE return NAME [ ::: 790
, [ - NUMBER , NUMBER ::: 790
STRING ) NEWLINE DEDENT if STRING ::: 789
+ NAME NEWLINE DEDENT else : ::: 788
= NAME NEWLINE DEDENT DEDENT EOS ::: 788
. NAME . NAME } ) ::: 787
] ) NEWLINE DEDENT DEDENT if ::: 787
] , ( NUMBER , NUMBER ::: 787
. NAME ( { NAME : ::: 787
INDENT STRING NEWLINE if STRING in ::: 787
STRING NEWLINE import NAME . NAME ::: 787
None NEWLINE DEDENT return NAME . ::: 787
if NAME == STRING and NAME ::: 787
. NAME < NUMBER : NEWLINE ::: 787
) . NAME , NAME . ::: 787
NAME ] ) NEWLINE NAME [ ::: 787
is not None and NAME ( ::: 786
NAME . NAME < NUMBER : ::: 786
NAME ) ) for NAME , ::: 786
, NAME : NAME ( NAME ::: 786
NAME ) , ( NUMBER , ::: 786
] NEWLINE DEDENT except : NEWLINE ::: 786
= NAME NEWLINE class NAME ( ::: 786
NAME . NAME ( ) * ::: 785
NEWLINE from ... NAME import NAME ::: 785
] == NAME . NAME : ::: 785
: NEWLINE INDENT assert NAME is ::: 785
. NAME [ NUMBER : NUMBER ::: 785
, [ [ ( STRING , ::: 785
( STRING , None , None ::: 785
NUMBER : NEWLINE INDENT continue NEWLINE ::: 785
None , STRING : STRING , ::: 784
INDENT from NAME import NAME , ::: 784
INDENT raise NEWLINE DEDENT DEDENT DEDENT ::: 784
NAME . NAME < ( NUMBER ::: 784
None NEWLINE DEDENT try : NEWLINE ::: 784
( STRING % NAME , STRING ::: 784
, STRING : True } , ::: 784
INDENT NAME STRING NEWLINE NAME . ::: 784
) ] , [ ( STRING ::: 784
NAME = STRING ) , STRING ::: 783
) NEWLINE STRING NEWLINE NAME = ::: 783
STRING ) NEWLINE from NAME . ::: 783
] . NAME . NAME , ::: 783
NAME . NAME + NUMBER NEWLINE ::: 783
NEWLINE INDENT STRING NEWLINE if ( ::: 783
, NAME ( NUMBER , NAME ::: 783
import NAME NEWLINE DEDENT from NAME ::: 783
NUMBER ] NEWLINE try : NEWLINE ::: 783
- NUMBER ] NEWLINE DEDENT NAME ::: 783
[ ( STRING , NUMBER , ::: 783
: NEWLINE INDENT return [ STRING ::: 783
- NAME ( NAME . NAME ::: 783
STRING % NAME , NAME ) ::: 783
return False NEWLINE DEDENT return NAME ::: 782
NAME ) NEWLINE NAME = False ::: 782
INDENT STRING NEWLINE global NAME NEWLINE ::: 782
[ NAME ] ) : NEWLINE ::: 782
) NEWLINE DEDENT elif STRING in ::: 782
] , [ STRING ] ) ::: 782
NAME ( ) ; NEWLINE DEDENT ::: 782
. NAME < ( NUMBER , ::: 782
return NUMBER NEWLINE DEDENT NAME = ::: 782
STRING , NUMBER , STRING ) ::: 782
- NUMBER , STRING : - ::: 782
= NAME . NAME ( lambda ::: 782
( NUMBER , NAME = STRING ::: 781
) NEWLINE DEDENT assert NAME . ::: 781
NAME = NUMBER ) NEWLINE if ::: 781
( [ ] ) NEWLINE NAME ::: 781
STRING , STRING : True } ::: 781
[ STRING ] = ( STRING ::: 781
and NAME . NAME [ NUMBER ::: 781
STRING : NAME , } , ::: 781
] , NAME ( NAME ) ::: 781
NAME <= NAME : NEWLINE INDENT ::: 781
NAME ) NEWLINE NAME += STRING ::: 781
: NAME } NEWLINE if NAME ::: 780
STRING ) ) , NAME . ::: 780
, NAME [ NAME . NAME ::: 780
* NEWLINE from . NAME import ::: 780
= NAME ( STRING STRING STRING ::: 780
) NEWLINE assert NAME == [ ::: 780
NUMBER ) NEWLINE NAME ( NUMBER ::: 780
NAME ( NUMBER ) ] ) ::: 779
NUMBER ) , NUMBER , NUMBER ::: 779
NUMBER : NUMBER ] ) NEWLINE ::: 779
STRING , None , STRING ) ::: 779
NAME NEWLINE NAME . NAME += ::: 779
) , ] , STRING : ::: 778
INDENT STRING NEWLINE return NAME NEWLINE ::: 778
INDENT STRING NEWLINE NAME = True ::: 778
, STRING : { } } ::: 778
import NAME NEWLINE import NAME , ::: 778
. NAME , NAME ( ) ::: 778
DEDENT for NAME in NAME [ ::: 778
} ) NEWLINE DEDENT NAME = ::: 778
and NAME . NAME == STRING ::: 778
NAME NEWLINE DEDENT except NAME as ::: 778
= True ) ) NEWLINE DEDENT ::: 777
= NAME + NAME NEWLINE DEDENT ::: 777
, NAME = ( ) , ::: 777
in NAME NEWLINE DEDENT def NAME ::: 777
( ) NEWLINE with NAME ( ::: 777
- NAME . NAME . NAME ::: 777
( NAME , STRING ) ] ::: 777
- NUMBER , NAME = NUMBER ::: 777
, NAME ] : NEWLINE INDENT ::: 776
. NAME [ NAME , NAME ::: 776
DEDENT DEDENT if not NAME . ::: 776
NAME : NAME [ STRING ] ::: 776
STRING + NAME ( NAME ( ::: 776
NUMBER , NUMBER ) : [ ::: 776
NAME ( STRING ) , { ::: 775
= NAME ) NEWLINE NAME [ ::: 775
NEWLINE if NAME < NAME : ::: 775
STRING ] } , STRING : ::: 775
NAME ( STRING STRING ) , ::: 775
= NAME , ) NEWLINE DEDENT ::: 775
STRING ] [ NAME ] = ::: 775
= NAME ( * NAME , ::: 775
[ ] NEWLINE NAME = STRING ::: 775
. NAME ) NEWLINE @ NAME ::: 775
[ NUMBER ] NEWLINE DEDENT return ::: 775
INDENT NAME = lambda NAME : ::: 775
STRING , lambda NAME : NAME ::: 774
DEDENT return { STRING : NAME ::: 774
NAME ( STRING , [ ( ::: 774
NEWLINE NAME . NAME ( not ::: 774
if NAME == - NUMBER : ::: 774
while True : NEWLINE INDENT try ::: 774
NAME ( STRING ) : NAME ::: 774
NAME ( ) NEWLINE while True ::: 774
if not ( NAME . NAME ::: 774
not None and NAME ( NAME ::: 773
and NAME ( NAME ) > ::: 773
STRING ] ) NEWLINE DEDENT return ::: 773
STRING ) ] , [ ( ::: 773
. NAME NEWLINE return NAME ( ::: 773
, STRING ) ] , [ ::: 773
STRING ] : NEWLINE INDENT raise ::: 772
[ STRING ] , { STRING ::: 772
. NAME [ STRING ] ] ::: 772
is False NEWLINE assert NAME ( ::: 772
NUMBER , NAME [ STRING ] ::: 772
. NAME ( NAME , - ::: 772
NAME } ) : NEWLINE INDENT ::: 772
( ) ) ) ) NEWLINE ::: 772
return [ NAME ] NEWLINE DEDENT ::: 772
, NAME = False , ) ::: 772
, NUMBER ] ] NEWLINE NAME ::: 772
, NUMBER ) , [ NUMBER ::: 772
NUMBER NEWLINE while NAME < NAME ::: 772
( NAME . NAME == NUMBER ::: 771
, NAME NEWLINE try : NEWLINE ::: 771
( ) NEWLINE while True : ::: 771
= NAME ( NAME , ( ::: 771
+ ( STRING % NAME . ::: 771
] . NAME [ STRING ] ::: 771
NAME . NAME ) NEWLINE @ ::: 771
] NEWLINE if NAME is None ::: 771
; NEWLINE DEDENT else : NEWLINE ::: 770
for NAME in ( NAME , ::: 770
STRING NEWLINE DEDENT NAME = STRING ::: 770
NAME , NAME = ( ) ::: 770
NAME . NAME ) , ] ::: 770
NUMBER ] = NAME NEWLINE DEDENT ::: 770
NEWLINE if NAME : NAME . ::: 769
NEWLINE for NAME , ( NAME ::: 769
( STRING , None , STRING ::: 769
. NAME ( STRING ) as ::: 769
False ) NEWLINE def NAME ( ::: 769
, - NUMBER , NUMBER ) ::: 769
+= NUMBER NEWLINE DEDENT else : ::: 769
( NUMBER ) , NUMBER ) ::: 769
NAME . NAME . NAME in ::: 769
, NUMBER ) NEWLINE return NAME ::: 769
STRING NEWLINE NAME = STRING + ::: 769
( ) . NAME ( NUMBER ::: 768
= NAME ( NAME , None ::: 768
+= NUMBER NEWLINE DEDENT NAME = ::: 768
( NAME = None ) NEWLINE ::: 768
NEWLINE DEDENT if NAME < NUMBER ::: 768
] NEWLINE DEDENT if NAME : ::: 768
and NAME ( NAME ) == ::: 768
. NAME ( ) [ : ::: 768
{ STRING : [ NUMBER , ::: 767
NUMBER ] ) NEWLINE DEDENT if ::: 767
+ STRING NEWLINE NAME = STRING ::: 767
NAME ) NEWLINE NAME STRING % ::: 767
NAME if NAME is not None ::: 767
( ) NEWLINE assert NAME == ::: 767
NAME ( STRING ) + STRING ::: 767
and NAME [ NUMBER ] == ::: 767
] is not None : NEWLINE ::: 767
STRING ) ) NEWLINE DEDENT @ ::: 767
NAME , lambda NAME : NAME ::: 766
NAME not in ( STRING , ::: 766
, STRING + NAME . NAME ::: 766
NAME in NAME [ NUMBER ] ::: 766
if ( NAME . NAME . ::: 766
NAME ) NEWLINE raise NAME . ::: 766
NAME = { STRING : None ::: 766
. NAME not in NAME : ::: 765
return True NEWLINE DEDENT NAME = ::: 765
= False ) , NAME ( ::: 765
} ) ) NEWLINE NAME = ::: 765
. NAME , } NEWLINE NAME ::: 765
NAME [ : : - NUMBER ::: 765
NAME , NAME + STRING ) ::: 765
NAME NEWLINE DEDENT NAME [ STRING ::: 765
STRING NEWLINE DEDENT @ NAME . ::: 765
STRING ) ; NEWLINE NAME . ::: 765
STRING : STRING } } } ::: 765
NAME in [ NAME , NAME ::: 765
} , NAME = NAME ( ::: 764
None ) NEWLINE if not NAME ::: 764
* NAME ( NAME ) NEWLINE ::: 764
NAME ] NEWLINE DEDENT @ NAME ::: 764
{ } NEWLINE if NAME . ::: 764
: NEWLINE INDENT while NAME . ::: 764
NEWLINE INDENT while NAME . NAME ::: 764
NAME [ NUMBER ] [ NAME ::: 764
, STRING , STRING ] } ::: 764
) is True NEWLINE assert NAME ::: 764
. NAME = NAME = NAME ::: 764
NAME NEWLINE from . . import ::: 764
NUMBER ) NEWLINE if NAME : ::: 763
STRING NEWLINE assert NAME [ NUMBER ::: 763
if NAME is None and NAME ::: 763
None , NAME . NAME ) ::: 763
if NAME [ NUMBER ] != ::: 763
INDENT break NEWLINE DEDENT DEDENT NAME ::: 762
NEWLINE DEDENT DEDENT except NAME , ::: 762
NAME == NAME NEWLINE assert NAME ::: 762
( lambda NAME , NAME : ::: 762
% NAME , NAME = NAME ::: 762
NAME . NAME ) - NUMBER ::: 761
NAME ( STRING ) ] , ::: 761
INDENT STRING NEWLINE NAME [ NUMBER ::: 761
[ ] NEWLINE DEDENT else : ::: 761
) ) , ( NUMBER , ::: 761
NAME = NAME NEWLINE class NAME ::: 761
= NUMBER * NAME . NAME ::: 761
STRING ) ( NAME = STRING ::: 761
INDENT assert NAME . NAME == ::: 761
( NAME , NAME ) ( ::: 761
NEWLINE for NAME in ( NAME ::: 761
NAME STRING % ( NAME . ::: 761
NEWLINE DEDENT except ( NAME . ::: 761
NEWLINE assert NAME == STRING NEWLINE ::: 761
finally : NEWLINE INDENT if NAME ::: 761
STRING ] = NAME ( STRING ::: 760
. NAME ( ) [ - ::: 760
( NAME , [ NAME . ::: 760
[ ] , [ ] , ::: 760
NAME == NAME ( NAME ) ::: 760
STRING ) . NAME NEWLINE NAME ::: 760
{ STRING : NUMBER } NEWLINE ::: 759
NAME ) NEWLINE DEDENT return STRING ::: 759
= NAME ( NAME ) + ::: 759
: ] . NAME ( ) ::: 759
NEWLINE INDENT if NAME > NUMBER ::: 759
) != NAME ( NAME ) ::: 759
NUMBER ] [ NUMBER ] . ::: 759
( NAME , STRING , ( ::: 759
NAME [ : NUMBER ] , ::: 759
. NAME ( ) ) [ ::: 759
- NUMBER , NAME = NAME ::: 759
NAME ] [ STRING ] ) ::: 759
NAME ( ) [ - NUMBER ::: 759
NAME ( STRING % STRING . ::: 758
. NAME , [ STRING ] ::: 758
NUMBER ] ) NEWLINE assert NAME ::: 758
not NAME and NAME . NAME ::: 758
with NAME ( STRING ) as ::: 758
NEWLINE INDENT yield NAME ( NAME ::: 758
STRING , STRING % ( NAME ::: 758
return NEWLINE DEDENT if not NAME ::: 758
else : NEWLINE INDENT def NAME ::: 757
) NEWLINE return ( NAME . ::: 757
NUMBER , STRING ) ; NEWLINE ::: 757
NAME NEWLINE NAME ( ) NEWLINE ::: 757
DEDENT else : NEWLINE INDENT def ::: 757
if STRING in NAME and NAME ::: 757
STRING STRING ) . NAME ( ::: 756
. NAME . NAME + NAME ::: 756
, NAME ) NEWLINE NAME STRING ::: 756
) == NAME . NAME : ::: 756
NAME ( ) - NAME NEWLINE ::: 756
( ) ) NEWLINE DEDENT EOS ::: 756
False NEWLINE assert NAME ( NAME ::: 756
NAME . NAME ( False , ::: 756
. NAME + STRING , NAME ::: 755
] ) ) NEWLINE DEDENT else ::: 755
NAME = True , ** NAME ::: 755
NAME NEWLINE NAME = NAME / ::: 755
, ( STRING , [ [ ::: 755
STRING , NAME ) ] NEWLINE ::: 755
NAME ( ) ) , [ ::: 755
NAME NEWLINE DEDENT class NAME : ::: 755
+ NAME * NAME + NAME ::: 755
, ] ) NEWLINE NAME = ::: 755
- NAME . NAME ( ) ::: 755
) NEWLINE return STRING % ( ::: 755
None : NEWLINE INDENT continue NEWLINE ::: 755
NUMBER ) ] ] ) , ::: 755
% ( STRING . NAME ( ::: 755
) , NUMBER : ( NUMBER ::: 755
) ; NEWLINE DEDENT else : ::: 755
NAME . NAME * NUMBER ) ::: 755
) ] NEWLINE DEDENT NAME = ::: 754
) + STRING NEWLINE NAME = ::: 754
) is False NEWLINE assert NAME ::: 754
return False NEWLINE DEDENT else : ::: 754
, NAME . NAME ( ( ::: 754
elif NAME . NAME == NUMBER ::: 754
[ ] ) . NAME ( ::: 754
NAME ) + STRING NEWLINE NAME ::: 754
except ( NAME . NAME , ::: 754
NAME . NAME : NAME += ::: 754
STRING ) NEWLINE NAME ( ) ::: 754
NAME ( NAME == NAME ) ::: 754
. NAME ( ** NAME . ::: 753
NAME , NAME in NAME ] ::: 753
] . NAME = NAME . ::: 753
STRING , [ [ ( STRING ::: 753
: NAME } ) : NEWLINE ::: 753
NAME . NAME [ : NAME ::: 753
INDENT for NAME , NAME , ::: 753
= None NEWLINE DEDENT return NAME ::: 753
NUMBER ) NEWLINE DEDENT DEDENT if ::: 753
, NAME , NAME ) for ::: 753
NEWLINE DEDENT return NUMBER NEWLINE DEDENT ::: 753
True ) , NAME ( STRING ::: 753
NUMBER ) NEWLINE DEDENT class NAME ::: 752
, STRING ) ; NEWLINE NAME ::: 752
) NEWLINE return STRING NEWLINE DEDENT ::: 752
== STRING : NEWLINE INDENT for ::: 752
NAME . NAME : NAME ( ::: 752
] [ NAME ] NEWLINE NAME ::: 752
, NUMBER ] , [ - ::: 751
) ) , NAME = STRING ::: 751
not NAME [ STRING ] : ::: 751
NAME in NAME ( NAME + ::: 751
} , NAME = ( NAME ::: 751
( NAME ( STRING ) . ::: 751
False NEWLINE if NAME . NAME ::: 751
STRING ) ] NEWLINE NAME . ::: 750
NAME , NUMBER ) , ( ::: 750
, NUMBER ] , NAME . ::: 750
return NEWLINE DEDENT try : NEWLINE ::: 750
( NUMBER , NAME ) ) ::: 750
: - NUMBER ] , NAME ::: 750
NAME = ( ) , NAME ::: 750
NEWLINE DEDENT NAME ( NAME = ::: 750
, NUMBER ) NEWLINE DEDENT except ::: 750
) / NAME ( NAME ) ::: 750
NAME [ STRING ] } ) ::: 750
NAME , NAME NEWLINE try : ::: 750
: NEWLINE INDENT assert not NAME ::: 750
[ NAME ( STRING ) ] ::: 749
+= NAME . NAME ( STRING ::: 749
NUMBER ] , NAME = NUMBER ::: 749
NUMBER ] [ STRING ] = ::: 749
, { } ) ) NEWLINE ::: 749
: True , STRING : NAME ::: 749
+ STRING + NAME NEWLINE DEDENT ::: 749
DEDENT DEDENT NAME = [ NAME ::: 749
) ) ) NEWLINE for NAME ::: 749
: STRING } ) , ( ::: 749
, NAME ( STRING ) ] ::: 749
] = [ ] NEWLINE NAME ::: 748
NAME ] ) NEWLINE DEDENT return ::: 748
STRING ) and NAME ( NAME ::: 748
NAME ] [ NUMBER ] ) ::: 748
DEDENT DEDENT @ NAME NEWLINE class ::: 748
( ) . NAME , NAME ::: 748
] ) NEWLINE if NAME ( ::: 748
return NAME . NAME , NAME ::: 748
, STRING ) ) , ( ::: 748
( NAME is not None ) ::: 747
NAME = NAME = NAME . ::: 747
) NEWLINE while NAME . NAME ::: 747
is True NEWLINE assert NAME ( ::: 747
+ NAME + STRING NEWLINE DEDENT ::: 747
NAME in NAME ] NEWLINE return ::: 747
. NAME . NAME NEWLINE return ::: 747
) != STRING : NEWLINE INDENT ::: 747
= ( ) , NAME = ::: 746
None , * NAME , ** ::: 746
NUMBER ) , ( - NUMBER ::: 746
, NUMBER : ( NUMBER , ::: 746
, NAME = [ NAME , ::: 746
NEWLINE NAME STRING NEWLINE NAME . ::: 745
) NEWLINE DEDENT DEDENT DEDENT elif ::: 745
>= NAME : NEWLINE INDENT NAME ::: 745
NAME ] = { STRING : ::: 745
, [ NUMBER , - NUMBER ::: 745
NAME = NUMBER ) NEWLINE assert ::: 745
. NAME = [ STRING ] ::: 745
NAME , } ) NEWLINE DEDENT ::: 745
NAME . NAME ( lambda : ::: 745
[ STRING ] NEWLINE del NAME ::: 745
, STRING , STRING , None ::: 745
NAME NEWLINE if STRING in NAME ::: 745
= NAME ( None , NAME ::: 745
= NUMBER NEWLINE while NAME < ::: 744
STRING , NAME ( ) , ::: 744
= ( ( STRING , NAME ::: 744
) , NAME ) NEWLINE return ::: 744
True NEWLINE assert NAME ( NAME ::: 744
STRING % NAME ( ) NEWLINE ::: 744
. NAME , NAME , NUMBER ::: 744
[ NAME ( NUMBER , NUMBER ::: 744
. NAME [ NUMBER ] ] ::: 744
NAME + STRING , STRING ) ::: 744
NUMBER } NEWLINE NAME = NAME ::: 744
( NAME ) - NAME ( ::: 744
, ) , NAME ( STRING ::: 744
: STRING , STRING : ( ::: 744
( ) ; NEWLINE DEDENT else ::: 744
( NAME , None , NAME ::: 744
in NAME ( NAME ) ) ::: 743
( * NAME . NAME ( ::: 743
NAME NEWLINE from ... NAME import ::: 743
NAME , [ ( STRING , ::: 743
: ] ) NEWLINE NAME = ::: 743
NAME + NUMBER ) * NAME ::: 743
NAME , ) NEWLINE DEDENT DEDENT ::: 743
, { } ) } , ::: 743
and STRING in NAME . NAME ::: 743
NAME = NAME ( { NUMBER ::: 742
INDENT NAME = [ NAME [ ::: 742
NAME ( NAME ) >= NUMBER ::: 742
. NAME = NAME , NAME ::: 742
. NAME is not None or ::: 742
( NAME = [ NAME ] ::: 742
{ } ) } , STRING ::: 742
NUMBER ] [ STRING ] == ::: 742
= NAME ( { NUMBER : ::: 742
NAME ( NAME ( STRING % ::: 742
= NAME . NAME or NAME ::: 742
) ) , ( NAME , ::: 741
NEWLINE NAME = NAME ( None ::: 741
NUMBER , NAME = - NUMBER ::: 741
, ) ) NEWLINE DEDENT def ::: 741
None , None , None ) ::: 741
NUMBER , ( NUMBER , NUMBER ::: 741
) NEWLINE assert NAME == NUMBER ::: 741
) , NAME = ( NAME ::: 741
NAME , NAME ] : NEWLINE ::: 741
NAME if NAME . NAME else ::: 740
= STRING + NAME NEWLINE NAME ::: 740
NAME = ( ) NEWLINE NAME ::: 740
INDENT return STRING NEWLINE DEDENT return ::: 740
, NAME , NAME ) ] ::: 740
( NAME , NAME , ) ::: 740
) , False ) NEWLINE NAME ::: 740
( NAME - NAME ) ) ::: 739
, NUMBER ) , STRING ) ::: 739
, None ) NEWLINE if not ::: 739
= NAME . NAME * NAME ::: 739
NAME = [ [ STRING , ::: 739
] ) , ( ( NUMBER ::: 739
% NAME . NAME ( STRING ::: 739
] ) NEWLINE DEDENT DEDENT return ::: 738
NAME in NAME if NAME ( ::: 738
- NAME . NAME NEWLINE NAME ::: 738
) ) NEWLINE NAME += NAME ::: 738
DEDENT NAME . NAME = False ::: 738
STRING , } ) NEWLINE NAME ::: 738
, NAME = ( ) ) ::: 738
DEDENT NAME = [ NAME for ::: 738
) == NAME . NAME . ::: 738
* NAME . NAME ( NUMBER ::: 738
[ NUMBER ] = NAME ( ::: 737
( STRING , lambda NAME : ::: 737
= False ) NEWLINE NAME ( ::: 737
% NAME NEWLINE DEDENT def NAME ::: 737
( STRING ) == STRING : ::: 737
] ] ) , ( STRING ::: 737
NUMBER ) NEWLINE if not NAME ::: 737
NAME ( STRING ) for NAME ::: 737
NEWLINE INDENT NAME [ NAME , ::: 737
INDENT STRING NEWLINE return ( NAME ::: 736
. NAME ) ) NEWLINE for ::: 736
NAME for NAME in NAME [ ::: 736
( NAME ) ) is False ::: 736
BOS NEWLINE from NAME import * ::: 736
NEWLINE DEDENT DEDENT if STRING in ::: 736
[ NAME ] . NAME = ::: 735
INDENT NAME = - NUMBER NEWLINE ::: 735
NEWLINE NAME = NAME = NAME ::: 735
) ) NEWLINE DEDENT NAME [ ::: 735
[ STRING ] } NEWLINE NAME ::: 735
+= NUMBER NEWLINE DEDENT NAME . ::: 735
in NAME [ STRING ] [ ::: 735
yield NAME NEWLINE DEDENT DEDENT def ::: 735
NAME , { STRING : NUMBER ::: 735
) ( NAME = NAME [ ::: 735
NEWLINE return NAME [ STRING ] ::: 735
+= STRING % NAME . NAME ::: 735
NAME == NAME [ STRING ] ::: 735
( NAME , NAME ) + ::: 735
NAME . NAME is NAME . ::: 735
= NAME [ NAME : ] ::: 735
. NAME } NEWLINE NAME . ::: 735
: NEWLINE INDENT from . NAME ::: 734
) NEWLINE NAME = NAME / ::: 734
else : NEWLINE INDENT return [ ::: 734
( ) ) , NUMBER ) ::: 734
DEDENT elif not NAME ( NAME ::: 734
NUMBER ] ] , NAME = ::: 734
STRING ] ) NEWLINE for NAME ::: 734
] NEWLINE def NAME ( ) ::: 734
) } ) NEWLINE NAME . ::: 734
DEDENT return NAME ( STRING , ::: 734
+ NAME NEWLINE DEDENT NAME = ::: 734
NUMBER NEWLINE if NAME ( NAME ::: 734
: ] NEWLINE DEDENT else : ::: 734
= None , * NAME , ::: 734
with NAME ( ) as NAME ::: 734
STRING : NAME } ) : ::: 734
NEWLINE DEDENT if NAME != NAME ::: 734
( ) NEWLINE if NAME != ::: 734
or NAME ( NAME . NAME ::: 733
NAME . NAME is None or ::: 733
INDENT NAME = NAME ( * ::: 733
( ) NEWLINE if NAME in ::: 733
= [ NAME ] , NAME ::: 733
) ] NEWLINE def NAME ( ::: 733
) ] , STRING : [ ::: 733
NAME NEWLINE NAME STRING NEWLINE NAME ::: 733
) ] ] ) , ( ::: 733
NAME ] NEWLINE return NAME NEWLINE ::: 733
= None NEWLINE if NAME : ::: 733
NAME = NUMBER * NAME . ::: 733
NUMBER ] = NAME NEWLINE NAME ::: 733
NUMBER ) NEWLINE return NAME . ::: 733
NAME * NAME . NAME NEWLINE ::: 733
NAME ) : return NAME ( ::: 733
( ) ] NEWLINE NAME . ::: 732
, STRING : True , } ::: 732
NEWLINE raise NAME ( STRING % ::: 732
[ [ STRING , STRING , ::: 732
NEWLINE DEDENT elif NAME is NAME ::: 732
INDENT NAME = NAME ( { ::: 732
in NAME if NAME ( NAME ::: 732
except NAME : NEWLINE INDENT continue ::: 732
STRING % ( STRING . NAME ::: 732
: NAME } NEWLINE return NAME ::: 732
( NAME * NAME . NAME ::: 732
NEWLINE if NAME . NAME not ::: 732
INDENT from NAME import NAME as ::: 732
NAME ) NEWLINE assert not NAME ::: 732
= yield NAME . NAME . ::: 732
NEWLINE INDENT if NAME < NUMBER ::: 731
assert NAME ( STRING ) == ::: 731
( STRING ) for NAME in ::: 731
= True , ** NAME ) ::: 731
NEWLINE INDENT def NAME ( * ::: 731
INDENT def NAME ( * NAME ::: 731
[ NAME ] = [ ] ::: 731
( NAME . NAME [ - ::: 731
NUMBER ] * NAME [ NUMBER ::: 731
= True ) NEWLINE return NAME ::: 731
% NAME [ STRING ] ) ::: 731
) ) is False NEWLINE assert ::: 731
( NAME . NAME ) < ::: 731
NEWLINE NAME = NAME [ - ::: 731
[ NAME ] ) , NAME ::: 731
return [ ] NEWLINE DEDENT NAME ::: 731
STRING , NUMBER , NAME = ::: 730
] , STRING : STRING } ::: 730
] NEWLINE DEDENT if not NAME ::: 730
if NAME . NAME else STRING ::: 730
] in NAME : NEWLINE INDENT ::: 730
= NAME ( STRING . NAME ::: 730
) NEWLINE if not NAME or ::: 730
True ) , ( STRING , ::: 730
from ... NAME import NAME NEWLINE ::: 730
NAME = NAME NEWLINE DEDENT except ::: 730
NAME . NAME ( NAME is ::: 730
[ { STRING : NAME . ::: 730
STRING , NAME = ( NAME ::: 730
= NAME ( ) NEWLINE with ::: 729
NUMBER NEWLINE DEDENT @ NAME NEWLINE ::: 729
, NAME = NAME ( [ ::: 729
INDENT NAME = STRING NEWLINE return ::: 729
NEWLINE INDENT @ NAME ( NAME ::: 729
[ NAME ] = { } ::: 729
NAME ] = ( NAME , ::: 729
NEWLINE INDENT return ( NAME , ::: 729
STRING STRING ) ) NEWLINE NAME ::: 729
NAME , STRING NEWLINE DEDENT NAME ::: 729
NEWLINE NAME STRING , NAME NEWLINE ::: 729
NAME , NAME ) as NAME ::: 728
NAME [ NUMBER ] - NUMBER ::: 728
NAME ) ) is False NEWLINE ::: 728
[ ] NEWLINE DEDENT if NAME ::: 728
INDENT return True NEWLINE DEDENT NAME ::: 728
] NEWLINE with NAME . NAME ::: 728
( NAME , ) NEWLINE NAME ::: 728
) and not NAME ( NAME ::: 728
DEDENT else : NEWLINE INDENT from ::: 728
- NUMBER ] , [ NUMBER ::: 727
if NAME ( NAME [ STRING ::: 727
. NAME ( NAME ) * ::: 727
NAME , NAME ) [ NUMBER ::: 727
NUMBER ] NEWLINE if not NAME ::: 727
NAME ( { } ) NEWLINE ::: 727
, NAME NEWLINE DEDENT DEDENT def ::: 727
INDENT return STRING NEWLINE DEDENT if ::: 727
NAME = True NEWLINE for NAME ::: 727
= NAME . NAME + NUMBER ::: 727
NAME in [ NUMBER , NUMBER ::: 727
NUMBER ) NEWLINE NAME = { ::: 727
NAME ) NEWLINE return [ NAME ::: 727
NAME = NAME [ NAME [ ::: 727
[ [ ( STRING , NUMBER ::: 726
DEDENT NAME = NAME + NAME ::: 726
( NAME ) or NAME . ::: 726
( NUMBER , STRING , NAME ::: 726
NUMBER , STRING : NAME . ::: 726
. NAME , ( STRING , ::: 726
( NAME = [ NAME . ::: 726
, NAME NEWLINE DEDENT else : ::: 726
NAME += STRING % NAME . ::: 726
NEWLINE DEDENT elif NAME is not ::: 726
[ NAME [ NUMBER ] , ::: 726
( ( NAME . NAME . ::: 726
( NAME + NUMBER ) ) ::: 725
NAME ) / NAME . NAME ::: 725
) NEWLINE DEDENT return NAME [ ::: 725
NEWLINE while NAME < NAME : ::: 725
, None , STRING ) , ::: 725
NEWLINE if NAME != NAME . ::: 725
NAME = NAME or NAME ( ::: 725
assert NAME . NAME is None ::: 725
is False : NEWLINE INDENT NAME ::: 725
= None ) NEWLINE NAME = ::: 724
, None ) ) NEWLINE DEDENT ::: 724
NAME = ( ( NUMBER , ::: 724
NAME == STRING NEWLINE NAME = ::: 724
in NAME for NAME in NAME ::: 724
NAME in NAME ) ) NEWLINE ::: 724
, NAME ) , ) NEWLINE ::: 724
( NUMBER ) NEWLINE NAME [ ::: 724
. NAME : NAME += NAME ::: 724
NEWLINE assert NAME == NUMBER NEWLINE ::: 723
= False NEWLINE if NAME . ::: 723
None , NAME . NAME . ::: 723
NAME in NAME if NAME [ ::: 723
STRING , STRING ) ) : ::: 723
NUMBER : NUMBER ] NEWLINE NAME ::: 723
STRING . NAME ( STRING . ::: 723
NUMBER , - NUMBER ) ] ::: 723
) , ( NAME , NUMBER ::: 723
] NEWLINE NAME = STRING % ::: 723
DEDENT elif NAME . NAME [ ::: 722
( NAME ( ( NUMBER , ::: 722
, NAME = True , ** ::: 722
. NAME ( { } ) ::: 722
) NEWLINE NAME = NUMBER * ::: 722
NAME , NUMBER , STRING ) ::: 722
. NAME . NAME NEWLINE class ::: 722
NAME [ NAME ] NEWLINE return ::: 722
NAME ] , [ NAME ] ::: 722
[ NAME ] NEWLINE DEDENT elif ::: 722
. NAME == STRING NEWLINE NAME ::: 722
not None or NAME . NAME ::: 722
* NEWLINE from NAME import NAME ::: 722
NEWLINE DEDENT DEDENT NAME [ STRING ::: 722
} ) NEWLINE DEDENT else : ::: 721
NEWLINE global NAME NEWLINE NAME = ::: 721
NEWLINE DEDENT NAME ( STRING , ::: 721
: NEWLINE INDENT NAME STRING + ::: 721
= NAME ( ) NEWLINE try ::: 721
- NUMBER , NUMBER ) ) ::: 721
STRING ] } NEWLINE NAME = ::: 721
= True , NAME = [ ::: 720
NAME NEWLINE DEDENT DEDENT DEDENT EOS ::: 720
NEWLINE DEDENT raise NAME ( NAME ::: 720
break NEWLINE DEDENT else : NEWLINE ::: 720
( NAME ) ) ] NEWLINE ::: 720
NAME ( * NAME ) ) ::: 720
+ STRING , NAME ) NEWLINE ::: 720
( NAME . NAME + NUMBER ::: 720
INDENT STRING NEWLINE assert NAME . ::: 720
) , NAME ( [ STRING ::: 720
, NAME ( [ STRING , ::: 720
( NAME , NAME ) else ::: 720
NUMBER ] ) , ( ( ::: 719
not NAME . NAME ) : ::: 719
{ } , NAME . NAME ::: 719
( STRING , NAME , NUMBER ::: 719
NAME ( ) NEWLINE if ( ::: 719
NAME , NAME ) : return ::: 719
. NAME , NAME ) . ::: 719
not NAME . NAME and not ::: 719
NAME NEWLINE NAME = STRING . ::: 719
] . NAME : NEWLINE INDENT ::: 719
[ STRING ] = ( NAME ::: 719
INDENT NAME = [ STRING % ::: 718
if ( NAME ( NAME , ::: 718
= None NEWLINE DEDENT DEDENT def ::: 718
NAME : NAME += NAME + ::: 718
+ NAME , NAME ) NEWLINE ::: 718
if NAME else NAME . NAME ::: 718
: NAME += NAME + ( ::: 718
NAME , NAME ) NEWLINE with ::: 718
. NAME ( STRING ) for ::: 718
None NEWLINE STRING NEWLINE NAME . ::: 718
INDENT try : NEWLINE INDENT import ::: 717
NEWLINE NAME = [ NUMBER ] ::: 717
STRING ] NEWLINE NAME , NAME ::: 717
. NAME ( STRING ) if ::: 717
NEWLINE NAME ( NUMBER , NUMBER ::: 717
) NEWLINE DEDENT DEDENT DEDENT for ::: 717
, ( STRING , ( STRING ::: 717
, ( STRING , { STRING ::: 717
, NAME , NAME [ NUMBER ::: 717
NAME ( STRING STRING STRING % ::: 717
NAME + NAME * NAME + ::: 716
INDENT if NAME . NAME not ::: 716
, ) ) , STRING : ::: 716
) NEWLINE DEDENT elif ( NAME ::: 716
NAME [ : ] = NAME ::: 716
. NAME NEWLINE DEDENT DEDENT @ ::: 716
. NAME . NAME or NAME ::: 716
except : NEWLINE INDENT return NAME ::: 716
STRING ) NEWLINE return False NEWLINE ::: 715
NUMBER , ( NUMBER , ( ::: 715
STRING : NAME } NEWLINE return ::: 715
STRING , NUMBER , NAME ) ::: 715
NAME NEWLINE def NAME ( * ::: 715
= ( STRING STRING STRING ) ::: 715
[ NAME ( NAME ) : ::: 715
NAME ( ) NEWLINE del NAME ::: 715
NAME [ STRING ] } NEWLINE ::: 715
( STRING , STRING . NAME ::: 715
NEWLINE STRING NEWLINE import NAME as ::: 714
or NAME . NAME is not ::: 714
, None , None , ) ::: 714
NUMBER ] ) NEWLINE DEDENT except ::: 714
NAME ( NAME [ : NUMBER ::: 714
NEWLINE return True NEWLINE DEDENT except ::: 714
STRING ) NEWLINE assert NAME == ::: 714
( STRING ) ] NEWLINE DEDENT ::: 714
assert NAME [ NUMBER ] [ ::: 714
: NEWLINE INDENT return NAME in ::: 713
NEWLINE NAME = STRING NEWLINE @ ::: 713
STRING ] ) NEWLINE DEDENT @ ::: 713
NUMBER : NAME , NUMBER : ::: 713
NEWLINE with NAME . NAME : ::: 713
STRING , { STRING : True ::: 713
= NAME NEWLINE DEDENT DEDENT else ::: 713
NEWLINE if NAME and NAME ( ::: 713
INDENT NAME = NAME * NAME ::: 713
if NAME [ STRING ] != ::: 713
, True ) , ( STRING ::: 712
NAME ] , NAME = STRING ::: 712
None , None , ) , ::: 712
= [ ] NEWLINE DEDENT if ::: 712
NAME , - NUMBER ) NEWLINE ::: 712
. NAME , ) , ) ::: 712
) - NAME ( NAME ) ::: 712
== NAME NEWLINE assert NAME . ::: 712
NAME . NAME = ( NUMBER ::: 712
: NEWLINE INDENT yield ( NAME ::: 712
NAME is None and NAME is ::: 712
STRING ) ) NEWLINE DEDENT except ::: 712
INDENT pass NEWLINE DEDENT if NAME ::: 711
NEWLINE if NAME == None : ::: 711
: NAME , NUMBER : NAME ::: 711
NAME = STRING NEWLINE raise NAME ::: 711
STRING + NAME + STRING , ::: 711
False NEWLINE DEDENT DEDENT return True ::: 711
NEWLINE DEDENT if NAME > NUMBER ::: 711
NAME = False ) . NAME ::: 711
NAME ) > NAME : NEWLINE ::: 711
STRING : ( NAME . NAME ::: 710
STRING , ) ) , STRING ::: 710
= NAME ( NAME + STRING ::: 710
STRING NEWLINE class NAME : NEWLINE ::: 710
STRING , NAME . NAME ] ::: 710
, [ ] ) . NAME ::: 710
STRING : STRING , } } ::: 710
NEWLINE try : NEWLINE INDENT with ::: 710
NAME += NUMBER NEWLINE DEDENT return ::: 710
NAME is not None : NAME ::: 710
NAME ( STRING STRING ) ) ::: 709
NAME ) ) ) : NEWLINE ::: 709
) ) NEWLINE class NAME ( ::: 709
( NAME . NAME ( { ::: 709
STRING , NAME ( NAME ( ::: 709
) ( NAME = STRING , ::: 709
NEWLINE NAME >> NAME . NAME ::: 709
NAME in NAME for NAME in ::: 709
, NAME ) NEWLINE raise NAME ::: 709
False ) : NEWLINE INDENT return ::: 709
. NAME ( STRING STRING . ::: 709
) NEWLINE DEDENT DEDENT NAME [ ::: 709
[ NAME ] = [ NAME ::: 709
NAME STRING % NAME NEWLINE DEDENT ::: 708
) ( NAME ) NEWLINE DEDENT ::: 708
) , STRING : STRING } ::: 708
( STRING , NAME ) . ::: 708
is not None or NAME . ::: 708
) , [ NAME . NAME ::: 708
( NAME . NAME - NUMBER ::: 708
{ STRING : [ ] , ::: 708
NAME . NAME , } ) ::: 708
NAME ( NAME = [ ] ::: 708
[ : ] NEWLINE NAME = ::: 708
None , NAME . NAME , ::: 708
, STRING ) ) NEWLINE if ::: 708
None NEWLINE if NAME ( NAME ::: 707
- NUMBER ] == STRING : ::: 707
] , [ ] , [ ::: 707
NUMBER ] , [ STRING , ::: 707
: True , STRING : False ::: 707
] , [ STRING ] , ::: 707
NAME ( NAME ( ( NUMBER ::: 707
} NEWLINE return NAME NEWLINE DEDENT ::: 707
NAME ) [ STRING ] NEWLINE ::: 707
STRING : NEWLINE INDENT NAME , ::: 707
) and ( NAME . NAME ::: 706
NAME . NAME + NAME ( ::: 706
NAME [ STRING % NAME ] ::: 706
return STRING NEWLINE DEDENT DEDENT class ::: 706
NAME [ NUMBER ] ) . ::: 706
: [ STRING ] } ) ::: 706
NAME ) ] , NAME = ::: 706
( NAME ) NEWLINE while NAME ::: 706
, NAME ) ) NEWLINE for ::: 706
( STRING , None , [ ::: 706
) + NAME ( NAME . ::: 706
) ) is True NEWLINE assert ::: 705
) NEWLINE assert NAME [ NUMBER ::: 705
assert STRING in NAME NEWLINE assert ::: 705
. NAME ( not NAME . ::: 705
( NAME = NAME ) : ::: 705
except : NEWLINE INDENT raise NAME ::: 705
. NAME ] , NAME . ::: 705
. NAME ) NEWLINE return NEWLINE ::: 705
NAME . NAME is not NAME ::: 705
NAME if NAME . NAME == ::: 705
if NAME . NAME in ( ::: 705
) == NUMBER ) NEWLINE NAME ::: 705
None NEWLINE assert NAME . NAME ::: 704
% NAME NEWLINE DEDENT else : ::: 704
STRING , None ) , ( ::: 704
] = NAME ( NAME = ::: 704
, NAME ) ) for NAME ::: 704
. NAME = NAME + STRING ::: 704
+ NUMBER , NAME . NAME ::: 704
. NAME ( ) in NAME ::: 704
with NAME . NAME ( NUMBER ::: 704
NAME ] = NAME NEWLINE if ::: 703
INDENT STRING NEWLINE assert NAME ( ::: 703
( ( NAME . NAME [ ::: 703
if NAME [ - NUMBER ] ::: 703
NEWLINE NAME [ NUMBER , NUMBER ::: 703
STRING ] [ STRING ] == ::: 703
NUMBER NEWLINE DEDENT DEDENT if NAME ::: 703
, NAME = NAME [ : ::: 703
, STRING , NAME = [ ::: 703
. NAME import NAME NEWLINE EOS ::: 702
( ) , NAME ) ) ::: 702
@ NAME . NAME ( { ::: 702
= [ NAME [ NAME ] ::: 702
( NAME ( NAME ( NUMBER ::: 702
. NAME is not None NEWLINE ::: 702
/ NAME . NAME ( NAME ::: 702
import NAME , NAME NEWLINE DEDENT ::: 701
. NAME == ( NUMBER , ::: 701
: { STRING : False , ::: 701
NEWLINE NAME STRING , NAME . ::: 701
NAME ) ] NEWLINE if NAME ::: 701
return NAME ( ) . NAME ::: 701
NAME = NAME ( STRING . ::: 701
NAME . NAME ( STRING * ::: 701
import * NEWLINE class NAME ( ::: 700
( NUMBER , NAME = NUMBER ::: 700
STRING NEWLINE from . NAME import ::: 700
STRING NEWLINE DEDENT try : NEWLINE ::: 700
NAME , NAME NEWLINE if NAME ::: 700
= True NEWLINE DEDENT DEDENT DEDENT ::: 700
INDENT NAME = [ ( NAME ::: 700
INDENT return NAME ( NAME [ ::: 700
: NEWLINE INDENT if NAME >= ::: 700
NAME ] ) NEWLINE DEDENT if ::: 700
NAME = [ NUMBER ] NEWLINE ::: 700
NEWLINE if NAME is NAME : ::: 699
STRING ] ] NEWLINE NAME = ::: 699
= NAME ( [ ( STRING ::: 699
NAME = STRING ) NEWLINE for ::: 699
: NAME . NAME ) NEWLINE ::: 699
assert NAME . NAME ( NUMBER ::: 699
. NAME ( ) ] = ::: 699
STRING , None , [ NAME ::: 699
if NAME and not NAME . ::: 699
NAME , ) , NAME = ::: 699
STRING : NUMBER , } , ::: 699
( NAME ) ) is True ::: 699
None , STRING ) , ( ::: 698
( NAME ) > NUMBER and ::: 698
( ) [ - NUMBER ] ::: 698
= [ { STRING : NAME ::: 698
( NAME , False ) NEWLINE ::: 698
DEDENT return NAME ( NAME = ::: 698
NEWLINE INDENT return NAME ( ( ::: 698
NAME . NAME or not NAME ::: 698
NAME and NAME . NAME [ ::: 697
, [ ] ) : NEWLINE ::: 697
[ STRING ] = { } ::: 697
in NAME : NEWLINE INDENT assert ::: 697
. NAME = [ NUMBER , ::: 697
( NUMBER ) NEWLINE for NAME ::: 697
} ) NEWLINE DEDENT return NAME ::: 697
NAME = [ ] ) NEWLINE ::: 697
( ) NEWLINE class NAME : ::: 697
. NAME is NAME ) NEWLINE ::: 696
( ) ) NEWLINE def NAME ::: 696
} ) NEWLINE assert NAME . ::: 696
( STRING ) , ) NEWLINE ::: 696
in NAME . NAME [ NUMBER ::: 696
NAME ( [ NAME ( STRING ::: 696
== NAME ( NAME ) : ::: 696
STRING ] = { } NEWLINE ::: 696
NAME , } NEWLINE NAME . ::: 696
NAME ( NUMBER ) NEWLINE for ::: 695
in NAME ( NAME + NUMBER ::: 695
NEWLINE DEDENT elif not NAME ( ::: 695
INDENT assert NAME . NAME . ::: 695
= True , ) , NAME ::: 695
( STRING ) . NAME ) ::: 695
( ** NAME . NAME ) ::: 695
, STRING , STRING % NAME ::: 695
) NEWLINE while NAME : NEWLINE ::: 695
) ) NEWLINE DEDENT DEDENT for ::: 695
NAME [ NAME ] == STRING ::: 695
, NAME . NAME + STRING ::: 695
is None : NEWLINE INDENT continue ::: 695
) : return NAME ( NAME ::: 694
, { STRING : True } ::: 694
== NAME ( STRING ) NEWLINE ::: 694
NEWLINE INDENT NAME ( NUMBER ) ::: 694
( STRING STRING ) , NAME ::: 694
NUMBER } NEWLINE NAME . NAME ::: 694
: STRING } } , STRING ::: 694
INDENT NAME += STRING % ( ::: 694
NAME [ NUMBER ] = STRING ::: 694
if NAME or NAME : NEWLINE ::: 694
NAME , NAME ) == NAME ::: 694
( NAME . NAME , - ::: 693
= ( NAME - NAME ) ::: 693
if NAME . NAME is NAME ::: 693
None , None ) NEWLINE NAME ::: 693
not in [ STRING , STRING ::: 693
= STRING NEWLINE with NAME . ::: 693
and NAME is None : NEWLINE ::: 693
NAME = STRING ) as NAME ::: 693
NUMBER ] = NAME ( NAME ::: 693
( STRING STRING % NAME . ::: 693
( NAME [ NUMBER ] - ::: 693
= NUMBER NEWLINE if NAME . ::: 693
] = STRING NEWLINE DEDENT NAME ::: 693
[ ] NEWLINE DEDENT NAME . ::: 693
NAME , [ NAME ] , ::: 693
NAME . NAME . NAME if ::: 692
NAME + STRING , NAME ) ::: 692
. NAME ( ) , ( ::: 692
NAME ( NAME ) } ) ::: 692
[ NUMBER ] , NUMBER , ::: 692
NAME % ( NAME , NAME ::: 692
= STRING ) NEWLINE DEDENT @ ::: 691
NEWLINE if NAME . NAME >= ::: 691
return [ ] NEWLINE DEDENT DEDENT ::: 691
= { STRING : False , ::: 691
DEDENT DEDENT except ( NAME , ::: 691
[ NAME ] NEWLINE return NAME ::: 691
STRING : STRING } , } ::: 691
[ NAME ] . NAME . ::: 691
INDENT return STRING % NAME NEWLINE ::: 691
NAME ( NAME ) is not ::: 691
NEWLINE if NAME ( NAME [ ::: 691
, None , ) , ( ::: 691
NAME ) ) is True NEWLINE ::: 690
{ STRING : STRING % NAME ::: 690
( ) NEWLINE DEDENT try : ::: 690
NAME ] NEWLINE NAME ( NAME ::: 690
= NUMBER NEWLINE DEDENT DEDENT def ::: 690
NAME ] NEWLINE NAME = STRING ::: 690
[ NUMBER ] NEWLINE DEDENT elif ::: 690
STRING ) NEWLINE DEDENT except : ::: 690
[ : NAME ] NEWLINE NAME ::: 690
= False NEWLINE DEDENT if NAME ::: 690
NUMBER , STRING ) , NUMBER ::: 690
] [ NAME . NAME ] ::: 690
( ) ) NEWLINE assert NAME ::: 690
( NAME = NUMBER ) : ::: 689
NAME , STRING ) ) : ::: 689
+ STRING NEWLINE DEDENT def NAME ::: 689
( STRING ) , { STRING ::: 689
, ( NAME , NUMBER , ::: 689
, None , False ) , ::: 689
= STRING ) NEWLINE for NAME ::: 689
) } ) NEWLINE def NAME ::: 689
NAME ) NEWLINE DEDENT assert NAME ::: 689
NEWLINE DEDENT elif not NAME . ::: 688
( NAME = ( NAME , ::: 688
NUMBER : NEWLINE INDENT try : ::: 688
, STRING : NUMBER } ] ::: 688
) ) NEWLINE NAME += NUMBER ::: 687
NAME [ NUMBER ] in NAME ::: 687
= None NEWLINE NAME = [ ::: 687
] = ( NAME . NAME ::: 687
NAME , NAME ( NAME [ ::: 687
from . . import NAME NEWLINE ::: 686
. NAME ( [ ( NAME ::: 686
) == NAME NEWLINE assert NAME ::: 686
, NAME . NAME + NAME ::: 686
( NAME ( STRING , NUMBER ::: 686
= STRING NEWLINE @ NAME NEWLINE ::: 686
NUMBER , - NUMBER ) NEWLINE ::: 686
NAME = NUMBER ) , [ ::: 685
NAME = ( STRING ) NEWLINE ::: 685
| NAME . NAME . NAME ::: 685
( NAME [ NAME : NAME ::: 685
NUMBER ] NEWLINE NAME , NAME ::: 685
} NEWLINE DEDENT @ NAME NEWLINE ::: 685
NAME , STRING , NUMBER , ::: 685
STRING ] NEWLINE DEDENT return NAME ::: 685
( ) ) , STRING : ::: 685
} NEWLINE NAME = NUMBER NEWLINE ::: 685
NUMBER ) ) NEWLINE if NAME ::: 685
None , ) : NEWLINE INDENT ::: 685
NEWLINE NAME ( STRING in NAME ::: 685
NAME ( NAME ) ) == ::: 685
( NAME . NAME is not ::: 684
NAME ) NEWLINE assert NAME [ ::: 684
) , ) ) NEWLINE DEDENT ::: 684
NUMBER ] == NUMBER : NEWLINE ::: 684
STRING , ) , STRING : ::: 684
( NAME = NAME , ** ::: 683
NEWLINE DEDENT DEDENT except ( NAME ::: 683
STRING + NAME [ NUMBER ] ::: 683
] NEWLINE NAME ( NAME . ::: 683
NEWLINE NAME = None NEWLINE try ::: 683
( NUMBER , ) , NAME ::: 683
NEWLINE INDENT NAME = [ { ::: 683
return NAME + NAME NEWLINE DEDENT ::: 683
STRING ] ) NEWLINE @ NAME ::: 683
) in NAME . NAME . ::: 683
, NAME . NAME , False ::: 683
INDENT NAME = yield NAME . ::: 683
STRING } ) , ( STRING ::: 683
, [ STRING ] ) , ::: 683
INDENT return [ NAME ( NAME ::: 683
NAME ) , STRING ) , ::: 683
NUMBER : ( NUMBER , STRING ::: 682
] [ STRING ] = NUMBER ::: 682
( ) ) NEWLINE if ( ::: 682
. NAME = ( NUMBER , ::: 682
NAME ( STRING ) if NAME ::: 682
[ STRING % NAME for NAME ::: 682
( NAME * NAME ) NEWLINE ::: 682
( NAME = NAME [ NUMBER ::: 682
INDENT NAME . NAME ( True ::: 682
, NAME = NUMBER ) . ::: 682
* ( NAME - NAME ) ::: 682
* NEWLINE class NAME ( NAME ::: 682
[ : , NUMBER ] , ::: 682
NUMBER ] . NAME NEWLINE DEDENT ::: 682
True ) NEWLINE DEDENT @ NAME ::: 681
% NAME [ STRING ] NEWLINE ::: 681
NAME += NAME NEWLINE DEDENT DEDENT ::: 681
STRING , STRING ) NEWLINE class ::: 681
NEWLINE DEDENT NAME = True NEWLINE ::: 681
) [ : NUMBER ] NEWLINE ::: 681
= None NEWLINE if NAME ( ::: 681
[ ( NAME . NAME ( ::: 681
STRING } } , STRING : ::: 681
DEDENT NAME ( NAME = STRING ::: 681
DEDENT NAME = STRING % NAME ::: 681
+= NUMBER + NAME . NAME ::: 681
STRING , { } ) . ::: 681
= False ) NEWLINE if NAME ::: 681
= NAME ) NEWLINE NAME , ::: 681
return False NEWLINE DEDENT NAME . ::: 680
[ NUMBER ] NEWLINE try : ::: 680
) , { } ) NEWLINE ::: 680
: NAME += NUMBER + NAME ::: 680
NEWLINE INDENT NAME STRING + NAME ::: 680
NAME ) , STRING . NAME ::: 680
pass NEWLINE DEDENT DEDENT NAME = ::: 680
elif NAME is not None : ::: 680
( STRING ) == STRING NEWLINE ::: 680
NEWLINE INDENT del NAME [ STRING ::: 680
= NAME NEWLINE if NAME == ::: 680
DEDENT if NAME == NAME . ::: 679
NAME in NAME ] NEWLINE if ::: 679
] NEWLINE DEDENT DEDENT NAME . ::: 679
INDENT import NAME NEWLINE import NAME ::: 679
* NAME NEWLINE NAME . NAME ::: 679
STRING , STRING ) NEWLINE for ::: 679
NAME , ) NEWLINE from NAME ::: 679
[ NUMBER : ] , NAME ::: 679
, STRING % NAME NEWLINE DEDENT ::: 679
NAME + NUMBER , NAME , ::: 679
STRING ] = NAME ( ) ::: 679
None , NAME . NAME ( ::: 679
NAME , STRING : NUMBER , ::: 678
, NAME ( NAME [ NAME ::: 678
STRING : NUMBER , } NEWLINE ::: 678
NEWLINE INDENT import NAME NEWLINE import ::: 678
STRING NEWLINE if NAME not in ::: 678
( STRING % NAME [ STRING ::: 678
[ STRING ] == NUMBER NEWLINE ::: 677
] for NAME in NAME [ ::: 677
NAME != NAME . NAME . ::: 677
( NAME ) * NAME ( ::: 677
in NAME ] NEWLINE if NAME ::: 677
False , NAME = NAME , ::: 677
. NAME ( NAME ) is ::: 677
NAME . NAME / NUMBER ) ::: 677
] NEWLINE NAME , NAME , ::: 677
return NAME ( STRING , { ::: 677
. NAME = NAME ( ( ::: 677
False NEWLINE try : NEWLINE INDENT ::: 677
NUMBER ) NEWLINE NAME [ NAME ::: 677
) NEWLINE if NAME is NAME ::: 677
NAME . NAME + NAME ) ::: 676
] . NAME . NAME . ::: 676
NAME [ NUMBER ] NEWLINE assert ::: 676
[ NAME ] = STRING NEWLINE ::: 676
NAME , ) , ) , ::: 676
: NEWLINE INDENT NAME |= NAME ::: 676
for NAME in [ NAME . ::: 676
NAME = NAME ( NAME * ::: 676
] NEWLINE NAME += NUMBER NEWLINE ::: 676
DEDENT if NAME < NUMBER : ::: 676
NAME = NAME = None NEWLINE ::: 675
. NAME NEWLINE DEDENT for NAME ::: 675
, STRING ] ) , NAME ::: 675
NAME [ NAME ( NAME . ::: 675
} NEWLINE if NAME is not ::: 675
yield NAME . NAME ( STRING ::: 675
return STRING NEWLINE DEDENT @ NAME ::: 675
+ NAME [ NUMBER : ] ::: 675
STRING ] = NUMBER NEWLINE DEDENT ::: 675
NAME = True ) , STRING ::: 675
] ) NEWLINE DEDENT for NAME ::: 674
] [ NUMBER ] , STRING ::: 674
NAME [ NAME ] ] NEWLINE ::: 674
NAME ) for ( NAME , ::: 674
DEDENT raise NAME ( STRING ) ::: 674
+ NUMBER , NUMBER + NUMBER ::: 674
: NAME , STRING : NUMBER ::: 674
) NEWLINE if not NAME and ::: 674
NAME and not NAME ( NAME ::: 674
* NAME ) ) NEWLINE DEDENT ::: 674
and NAME == STRING : NEWLINE ::: 674
NAME = NUMBER , NUMBER NEWLINE ::: 673
, STRING , STRING ] ] ::: 673
- NUMBER ] NEWLINE if NAME ::: 673
None NEWLINE DEDENT return NAME NEWLINE ::: 673
. NAME ( ) ] , ::: 673
( STRING , False ) : ::: 673
] . NAME ( ) == ::: 672
, ( STRING , [ STRING ::: 672
, ) NEWLINE DEDENT DEDENT class ::: 672
, None ) , STRING : ::: 672
== STRING or NAME . NAME ::: 672
, - NUMBER ) ] ] ::: 672
INDENT del NAME [ STRING ] ::: 672
NAME : NEWLINE INDENT ( NAME ::: 672
NAME += NUMBER + NAME . ::: 671
, STRING , True ) NEWLINE ::: 671
. NAME . NAME NEWLINE from ::: 671
) * NAME ( NAME , ::: 671
, STRING ) NEWLINE DEDENT elif ::: 671
] = { } NEWLINE DEDENT ::: 671
= NAME ) , NAME ( ::: 671
NAME = ( NUMBER , ) ::: 671
NEWLINE NAME = NAME if NAME ::: 671
STRING , STRING , ) , ::: 671
] = NUMBER NEWLINE DEDENT DEDENT ::: 671
NAME ( ) ) NEWLINE def ::: 671
+= NUMBER NEWLINE DEDENT return NAME ::: 671
NAME - NAME ) / NAME ::: 671
[ NUMBER ] != STRING : ::: 671
NAME ( STRING ) [ : ::: 671
) , NAME ) for NAME ::: 671
. NAME , NAME ) for ::: 671
INDENT NAME = ( NAME ( ::: 670
= NUMBER NEWLINE NAME = None ::: 670
STRING ) NEWLINE DEDENT DEDENT elif ::: 670
) : NAME += NUMBER + ::: 670
NAME ( ) > NUMBER : ::: 670
} ) NEWLINE DEDENT DEDENT class ::: 670
) , ( NUMBER , ) ::: 670
DEDENT with NAME ( NAME , ::: 670
) NEWLINE NAME ( STRING in ::: 670
NAME ( ) NEWLINE DEDENT try ::: 670
( STRING . NAME ( STRING ::: 669
] = NAME ( NAME ( ::: 669
STRING ] = None NEWLINE NAME ::: 669
) NEWLINE assert NAME ( STRING ::: 669
( ) NEWLINE if STRING in ::: 669
DEDENT NAME ( ) NEWLINE NAME ::: 669
STRING , False ) NEWLINE DEDENT ::: 669
, lambda NAME , NAME : ::: 669
} ) . NAME ( STRING ::: 669
NUMBER NEWLINE NAME = True NEWLINE ::: 669
, NUMBER ] ] , NAME ::: 669
] ) NEWLINE try : NEWLINE ::: 669
DEDENT DEDENT DEDENT @ NAME . ::: 668
NAME = [ STRING % NAME ::: 668
{ } NEWLINE if NAME : ::: 668
NAME = ( NAME ( STRING ::: 668
NAME - NUMBER ) NEWLINE DEDENT ::: 668
STRING ] } ) NEWLINE NAME ::: 668
. NAME ( ) ) ] ::: 668
return True NEWLINE DEDENT except NAME ::: 668
- NUMBER ) ] ] ) ::: 668
( ) > NUMBER : NEWLINE ::: 668
+ STRING , NAME . NAME ::: 667
( NAME , ( STRING , ::: 667
, STRING , None ) ) ::: 667
( not NAME . NAME . ::: 667
NAME += [ NAME . NAME ::: 667
= NAME NEWLINE return NAME ( ::: 667
NAME ) [ NUMBER ] ) ::: 667
NAME ) ) NEWLINE NAME , ::: 667
assert NAME is not None NEWLINE ::: 666
None , ) , ( NUMBER ::: 666
NEWLINE NAME ( NAME ) . ::: 666
NEWLINE while NAME . NAME ( ::: 666
NUMBER ] . NAME == STRING ::: 666
% NAME , NAME ) NEWLINE ::: 666
, - NUMBER , NAME = ::: 666
( NAME ( ) ) ) ::: 666
/ NAME ( NAME ) NEWLINE ::: 666
DEDENT if NAME . NAME in ::: 666
NEWLINE INDENT STRING NEWLINE return { ::: 665
[ NUMBER ] * NAME [ ::: 665
> NUMBER ) : NEWLINE INDENT ::: 665
: { STRING : True , ::: 665
== NAME ) . NAME ( ::: 665
NUMBER + NUMBER , NUMBER + ::: 665
NAME : NAME } ) NEWLINE ::: 665
NAME : ( STRING , STRING ::: 665
] = { } NEWLINE NAME ::: 665
if NAME ( NAME [ NAME ::: 664
NUMBER ] , NAME [ NAME ::: 664
. NAME NEWLINE for NAME , ::: 664
if NAME [ NUMBER ] . ::: 664
NEWLINE NAME = lambda NAME , ::: 664
INDENT NAME = [ { STRING ::: 664
NAME , STRING ) ) ) ::: 664
False , STRING : STRING , ::: 664
NEWLINE DEDENT NAME = ( STRING ::: 664
] * NAME ( NAME ) ::: 664
STRING , NAME ) , ) ::: 664
) ] , NAME . NAME ::: 664
in NAME . NAME NEWLINE assert ::: 663
NAME = NAME + NAME + ::: 663
NAME [ NAME ] + NAME ::: 663
== NUMBER ) NEWLINE NAME . ::: 663
, NAME ( ( NUMBER , ::: 663
- NAME [ NUMBER ] ) ::: 663
, ) NEWLINE from NAME . ::: 663
NAME == NAME ) NEWLINE NAME ::: 663
NAME [ NAME ] - NAME ::: 663
NAME [ STRING ] NEWLINE for ::: 663
: NEWLINE INDENT if not ( ::: 663
( NAME = [ NAME ( ::: 663
[ NUMBER ] ] NEWLINE NAME ::: 662
: NUMBER } NEWLINE NAME . ::: 662
, ) NEWLINE class NAME ( ::: 662
= STRING . NAME ( STRING ::: 662
NAME , NUMBER ) NEWLINE if ::: 662
for NAME in ( NAME . ::: 662
None : NEWLINE INDENT NAME , ::: 662
NAME / NUMBER ) NEWLINE NAME ::: 662
NAME [ STRING ] in NAME ::: 662
NAME = STRING % NAME ) ::: 662
NAME = { } ) NEWLINE ::: 662
STRING : { } } NEWLINE ::: 661
NAME ( NAME . NAME is ::: 661
( STRING ) ) NEWLINE def ::: 661
if not NAME or not NAME ::: 661
. NAME NEWLINE @ NAME . ::: 661
INDENT if NAME != NAME : ::: 661
NAME NEWLINE if NAME == NAME ::: 661
DEDENT DEDENT DEDENT if not NAME ::: 661
STRING , NAME ) , ] ::: 661
NAME ) , STRING : STRING ::: 661
NAME [ STRING ] NEWLINE del ::: 661
[ NAME : NAME ] NEWLINE ::: 661
NAME ( NUMBER * NAME ) ::: 661
NAME ) ] NEWLINE DEDENT DEDENT ::: 661
- NAME . NAME , NAME ::: 660
[ STRING , STRING ] ] ::: 660
NAME = NUMBER , ** NAME ::: 660
} , NAME = [ STRING ::: 660
) NEWLINE return NEWLINE DEDENT def ::: 660
] . NAME , NAME ) ::: 660
: NUMBER } ) NEWLINE DEDENT ::: 660
= [ ( NUMBER , NUMBER ::: 660
NAME [ NUMBER ] + STRING ::: 660
NAME ( NAME ) NEWLINE del ::: 660
NUMBER , NAME ) , NAME ::: 660
] NEWLINE NAME = [ [ ::: 660
[ NUMBER ] NEWLINE NAME ( ::: 660
+ STRING NEWLINE DEDENT else : ::: 660
INDENT if NAME > NUMBER : ::: 660
. NAME . NAME , ( ::: 660
NAME . NAME , NAME NEWLINE ::: 660
NEWLINE INDENT return NAME in NAME ::: 659
NEWLINE NAME = ( ( NUMBER ::: 659
NEWLINE INDENT STRING NEWLINE DEDENT DEDENT ::: 659
NAME = None , ) : ::: 659
NAME ] NEWLINE DEDENT DEDENT return ::: 659
NAME is not None and not ::: 659
STRING , ** NAME ) : ::: 659
STRING % NAME , STRING % ::: 659
= None , ) : NEWLINE ::: 659
( NAME . NAME ( - ::: 659
NAME == ( NUMBER , NUMBER ::: 659
= STRING ) as NAME : ::: 659
in NAME or STRING in NAME ::: 659
STRING NEWLINE DEDENT DEDENT else : ::: 659
= NAME + STRING NEWLINE DEDENT ::: 658
NEWLINE return NAME ( ) NEWLINE ::: 658
. NAME ( ) != NAME ::: 658
( NAME = ( STRING , ::: 658
( NAME ) ) NEWLINE assert ::: 658
= ( NAME . NAME [ ::: 658
: NEWLINE INDENT return - NUMBER ::: 658
True ) NEWLINE DEDENT NAME . ::: 658
NAME ( STRING not in NAME ::: 658
) , None ) NEWLINE DEDENT ::: 658
STRING ) . NAME ) NEWLINE ::: 657
, NAME [ NUMBER ] ] ::: 657
STRING ) NEWLINE DEDENT NAME , ::: 657
[ NAME ] , [ NAME ::: 657
NAME NEWLINE DEDENT DEDENT return None ::: 657
NAME NEWLINE DEDENT except NAME . ::: 657
NUMBER ] * NAME . NAME ::: 657
NAME and NAME not in NAME ::: 657
[ STRING ] NEWLINE DEDENT elif ::: 656
NAME . NAME + ( NAME ::: 656
is not None and not NAME ::: 656
NAME += NAME NEWLINE DEDENT NAME ::: 656
NAME , NAME ) + NAME ::: 656
] NEWLINE DEDENT DEDENT DEDENT DEDENT ::: 656
NAME . NAME ) NEWLINE raise ::: 656
NAME ) , ] NEWLINE NAME ::: 656
) ] : NEWLINE INDENT NAME ::: 656
STRING NEWLINE DEDENT if NAME == ::: 656
) , ) NEWLINE DEDENT class ::: 656
NAME ( [ STRING % ( ::: 656
STRING ] ) , STRING : ::: 656
, ( NAME , ) , ::: 656
and NAME [ - NUMBER ] ::: 655
STRING , NAME = - NUMBER ::: 655
( NAME ) NEWLINE DEDENT finally ::: 655
, None , NAME , NAME ::: 655
else : NEWLINE INDENT from NAME ::: 655
STRING : NEWLINE INDENT if not ::: 655
) is None NEWLINE assert NAME ::: 655
assert NAME . NAME == ( ::: 655
= STRING % NAME ( ) ::: 655
( NUMBER , NAME ( STRING ::: 654
% NAME ( ) ) NEWLINE ::: 654
. NAME = lambda NAME : ::: 654
STRING : NUMBER } , NAME ::: 654
+ NAME ) NEWLINE DEDENT NAME ::: 654
NAME ( ) [ NAME ] ::: 654
NAME , NAME NEWLINE DEDENT except ::: 654
** NAME ) . NAME ( ::: 654
NAME ] , [ NAME . ::: 654
NAME , - NUMBER , NAME ::: 654
= True NEWLINE DEDENT DEDENT if ::: 654
% NAME NEWLINE NAME = STRING ::: 654
NUMBER , [ NUMBER , NUMBER ::: 653
= NAME . NAME NEWLINE assert ::: 653
] NEWLINE DEDENT return NAME ( ::: 653
NAME ) , ) ) NEWLINE ::: 653
] * NAME [ NUMBER ] ::: 653
) ) NEWLINE raise NAME ( ::: 653
( NUMBER ) ] NEWLINE NAME ::: 653
return STRING NEWLINE DEDENT if NAME ::: 653
STRING NEWLINE DEDENT if NAME : ::: 653
continue NEWLINE DEDENT else : NEWLINE ::: 653
True , ) , NAME . ::: 653
= False NEWLINE try : NEWLINE ::: 653
) : NEWLINE INDENT from . ::: 653
, STRING , [ ] ) ::: 653
DEDENT DEDENT raise NAME ( STRING ::: 653
NUMBER ) ] NEWLINE NAME . ::: 653
STRING % NAME ) ) NEWLINE ::: 653
STRING ) , STRING , NAME ::: 653
NAME - NAME ( NAME ) ::: 652
NEWLINE DEDENT NAME += NAME NEWLINE ::: 652
. NAME NEWLINE DEDENT if not ::: 652
NAME = - NUMBER ) : ::: 652
] ) ) ) NEWLINE NAME ::: 652
STRING : STRING } ] ) ::: 652
) , ] ) NEWLINE NAME ::: 652
] : NEWLINE INDENT try : ::: 652
NAME ] , [ NAME , ::: 652
NEWLINE return NAME [ NUMBER ] ::: 652
NAME , NAME ) ) for ::: 652
NEWLINE INDENT return NAME + NAME ::: 652
STRING : NAME } , STRING ::: 651
STRING , ) NEWLINE def NAME ::: 651
( NUMBER , ) , ( ::: 651
NAME , NAME , NAME : ::: 651
NUMBER NEWLINE NAME = False NEWLINE ::: 651
NAME [ STRING ] ] = ::: 651
NAME ] = NUMBER NEWLINE NAME ::: 651
with NAME ( STRING ) : ::: 651
STRING % NAME ( ) ) ::: 651
[ ] , NAME . NAME ::: 651
NEWLINE return True NEWLINE DEDENT DEDENT ::: 651
NAME ) ) NEWLINE raise NAME ::: 651
NAME = STRING NEWLINE NAME += ::: 650
] , NAME ( NAME . ::: 650
{ NAME . NAME . NAME ::: 650
= NUMBER , ** NAME ) ::: 650
* NAME - NAME * NAME ::: 650
NAME [ STRING ] is not ::: 650
( NAME ) NEWLINE del NAME ::: 650
= None NEWLINE NAME = NUMBER ::: 649
NUMBER ) , ( NAME . ::: 649
( NAME . NAME ) for ::: 649
. NAME . NAME NEWLINE for ::: 649
{ STRING : NUMBER } } ::: 649
. NAME . NAME , None ::: 649
NUMBER ) NEWLINE if NAME == ::: 649
NAME [ NAME ] ) : ::: 649
( NAME . NAME * NUMBER ::: 649
/ NUMBER ) NEWLINE NAME = ::: 649
import ( NAME , NAME ) ::: 649
- NUMBER ] , NAME [ ::: 649
* ( NAME + NUMBER ) ::: 649
DEDENT NAME ( STRING , NAME ::: 648
+ NUMBER , NAME , NAME ::: 648
in NAME . NAME ) : ::: 648
NAME + NUMBER ] ) NEWLINE ::: 648
* NAME . NAME + NAME ::: 648
) : ( ) , ( ::: 648
NAME . NAME = STRING + ::: 648
= NUMBER ) NEWLINE assert NAME ::: 648
= - NUMBER ) : NEWLINE ::: 648
NAME . NAME NEWLINE DEDENT for ::: 648
STRING ] NEWLINE try : NEWLINE ::: 647
= [ ] NEWLINE DEDENT DEDENT ::: 647
STRING ] [ NUMBER ] . ::: 647
STRING ] = ( STRING , ::: 647
) ) NEWLINE DEDENT NAME , ::: 647
( ) NEWLINE if NAME [ ::: 647
NAME = NUMBER ) NEWLINE return ::: 647
[ NUMBER : ] . NAME ::: 647
, NUMBER ) NEWLINE def NAME ::: 647
= [ NAME . NAME [ ::: 647
, NAME NEWLINE DEDENT except NAME ::: 647
NAME ( NAME ( * NAME ::: 647
NAME ( ) NEWLINE from NAME ::: 647
[ STRING ] } , STRING ::: 647
= NAME ( ) NEWLINE assert ::: 647
NUMBER , STRING ) , STRING ::: 647
+ NUMBER NEWLINE NAME . NAME ::: 646
NEWLINE assert STRING not in NAME ::: 646
NAME . NAME NEWLINE with NAME ::: 646
NAME = False NEWLINE try : ::: 646
NAME . NAME [ ( NAME ::: 646
[ STRING ] ) , ( ::: 646
] is None : NEWLINE INDENT ::: 646
== NAME . NAME NEWLINE NAME ::: 646
NUMBER ] , NAME ) : ::: 646
, NAME = STRING % ( ::: 646
NAME . NAME , NAME + ::: 646
STRING STRING ) , NAME = ::: 646
NAME is None : NAME = ::: 646
, ] ) NEWLINE NAME . ::: 645
NAME . NAME , [ NUMBER ::: 645
: NUMBER , STRING : { ::: 645
. NAME [ NAME [ NUMBER ::: 645
NAME } , { STRING : ::: 645
NAME [ NUMBER ] ] = ::: 645
None NEWLINE assert NAME ( NAME ::: 645
None NEWLINE NAME = NUMBER NEWLINE ::: 645
} ) NEWLINE DEDENT DEDENT DEDENT ::: 645
{ } ) ) NEWLINE NAME ::: 645
NAME = NAME [ : ] ::: 645
( NAME , NAME , ( ::: 645
NAME ( ( NAME [ NUMBER ::: 645
STRING ) : ( ) , ::: 645
INDENT NAME = [ NUMBER , ::: 645
NAME NEWLINE NAME STRING , NAME ::: 645
= True ) NEWLINE assert NAME ::: 645
STRING + NAME NEWLINE DEDENT NAME ::: 644
, - NUMBER ) ) NEWLINE ::: 644
. NAME , } ) NEWLINE ::: 644
( STRING , NAME , [ ::: 644
[ ] NEWLINE if NAME : ::: 644
NUMBER } ) NEWLINE NAME = ::: 644
, ( NUMBER , STRING , ::: 644
NAME ) NEWLINE from NAME import ::: 644
INDENT NAME STRING NEWLINE DEDENT DEDENT ::: 644
: NEWLINE INDENT return ( NUMBER ::: 643
NAME >= NAME . NAME : ::: 643
DEDENT if NAME and NAME . ::: 643
not in NAME . NAME ( ::: 643
STRING ) , ) , NAME ::: 643
: NAME = NAME ( NAME ::: 643
STRING ) NEWLINE NAME = None ::: 643
if NAME [ STRING ] is ::: 643
, STRING : False } NEWLINE ::: 643
NAME = NAME or NAME NEWLINE ::: 643
[ STRING ] is not None ::: 643
NAME ( [ ( NUMBER , ::: 643
, ( NUMBER , ) , ::: 643
, NAME ) NEWLINE DEDENT finally ::: 642
= { } NEWLINE DEDENT if ::: 642
. NAME ( STRING ) } ::: 642
NAME == NAME ( STRING ) ::: 642
NAME , { } , NAME ::: 642
NAME ( ) + STRING ) ::: 642
NUMBER ] , ( NUMBER , ::: 642
= NAME [ : , NUMBER ::: 642
NEWLINE if not NAME and NAME ::: 642
+= NAME ( NAME . NAME ::: 642
] ) : NEWLINE INDENT return ::: 642
+= NAME NEWLINE NAME . NAME ::: 642
if NAME is None : NAME ::: 642
STRING , NAME . NAME NEWLINE ::: 642
) NEWLINE DEDENT assert NAME ( ::: 641
NAME NEWLINE DEDENT raise NAME ( ::: 641
NUMBER NEWLINE NAME = NAME + ::: 641
NUMBER ] NEWLINE DEDENT DEDENT def ::: 641
NAME in NAME ( ) : ::: 641
NEWLINE INDENT NAME += [ NAME ::: 641
STRING % NAME NEWLINE DEDENT else ::: 641
NAME , lambda : NAME . ::: 641
[ NAME . NAME [ STRING ::: 641
NAME ( STRING , lambda NAME ::: 640
NAME = True , ) NEWLINE ::: 640
= NUMBER ) NEWLINE if NAME ::: 640
NAME or [ ] NEWLINE NAME ::: 640
STRING + NAME ( NAME [ ::: 640
) NEWLINE NAME = [ [ ::: 640
( [ NAME ( NAME . ::: 640
NAME ) ) [ NUMBER ] ::: 640
NAME , ) : NEWLINE INDENT ::: 640
STRING : STRING % ( NAME ::: 640
False , NAME = NUMBER ) ::: 639
. NAME , { } ) ::: 639
, NAME ( NUMBER , STRING ::: 639
NUMBER ) ) NEWLINE NAME [ ::: 639
= NAME . NAME , ** ::: 639
NAME = NAME ( [ [ ::: 639
STRING ) . NAME . NAME ::: 639
( STRING ) , NAME , ::: 639
None , None ) NEWLINE DEDENT ::: 639
for NAME in [ NAME , ::: 639
. NAME , - NUMBER , ::: 639
return NEWLINE DEDENT for NAME in ::: 638
, NAME + NAME ) NEWLINE ::: 638
] [ NAME ] . NAME ::: 638
= NAME [ NUMBER ] ) ::: 638
del NAME . NAME NEWLINE DEDENT ::: 638
( NUMBER ) NEWLINE DEDENT except ::: 638
NUMBER ] ) NEWLINE DEDENT return ::: 638
( NAME ) . NAME . ::: 638
) ) == STRING NEWLINE assert ::: 638
in NAME . NAME NEWLINE NAME ::: 638
] . NAME . NAME ) ::: 638
NUMBER NEWLINE DEDENT if NAME == ::: 638
( NAME ) + NUMBER ) ::: 637
INDENT assert NAME ( NAME . ::: 637
NAME , NAME ) NEWLINE EOS ::: 637
[ ( NAME , NAME . ::: 637
( [ STRING % ( NAME ::: 637
NUMBER ) : STRING , ( ::: 637
( NAME ) if NAME else ::: 637
: NAME ( STRING , NAME ::: 637
NEWLINE INDENT from . NAME import ::: 637
NUMBER NEWLINE DEDENT elif NAME . ::: 637
, NAME ) ) , ( ::: 636
NAME = not NAME . NAME ::: 636
( ) , ( NAME , ::: 636
) , NAME ( ( NUMBER ::: 636
INDENT STRING NEWLINE return STRING % ::: 636
] . NAME ( { STRING ::: 636
= NAME [ NUMBER : NUMBER ::: 636
, NAME ) NEWLINE import NAME ::: 636
NAME ( NAME [ NAME + ::: 636
NAME , NAME , { } ::: 636
} , STRING : { } ::: 636
{ NUMBER : NUMBER , NUMBER ::: 636
. NAME = NAME or [ ::: 636
, True ) NEWLINE DEDENT DEDENT ::: 636
NEWLINE raise NAME NEWLINE DEDENT DEDENT ::: 635
STRING NEWLINE NAME = ( ( ::: 635
+= NUMBER NEWLINE DEDENT DEDENT NAME ::: 635
NAME = NUMBER NEWLINE return NAME ::: 635
if NAME ( NAME ( NAME ::: 635
NEWLINE if not NAME or NAME ::: 635
} ) NEWLINE DEDENT DEDENT def ::: 635
{ NAME . NAME : ( ::: 635
NUMBER ) , ( NAME , ::: 635
. NAME ( STRING , lambda ::: 635
, STRING ) : ( ) ::: 634
if NAME is NAME . NAME ::: 634
= NAME ) NEWLINE try : ::: 634
NAME = NAME ) NEWLINE try ::: 634
NEWLINE INDENT with NAME ( ) ::: 634
in NAME ] NEWLINE return NAME ::: 634
NAME ( NAME * NUMBER ) ::: 634
, STRING : STRING . NAME ::: 634
NAME ( ) } NEWLINE NAME ::: 634
STRING ] . NAME ) NEWLINE ::: 634
NEWLINE INDENT NAME = [ [ ::: 633
INDENT NAME ( NUMBER ) NEWLINE ::: 633
] . NAME = NAME NEWLINE ::: 633
NAME ( None , NAME , ::: 633
. NAME , [ NAME ] ::: 633
DEDENT DEDENT elif NAME == NAME ::: 633
] ) , NAME ( [ ::: 633
] . NAME NEWLINE NAME . ::: 633
in NAME and NAME [ STRING ::: 633
if NAME >= NAME : NEWLINE ::: 633
NAME ) , STRING % ( ::: 632
( ) : NEWLINE INDENT import ::: 632
STRING , NUMBER ) , STRING ::: 632
NUMBER , NUMBER + NUMBER , ::: 632
in NAME ] ) ) NEWLINE ::: 632
( NUMBER , NAME ) , ::: 632
NAME ( NAME + NAME . ::: 632
assert NAME ( NAME [ NUMBER ::: 632
DEDENT elif NAME in NAME : ::: 632
, [ NAME . NAME . ::: 632
lambda NAME , NAME , NAME ::: 632
NAME += NUMBER NEWLINE DEDENT else ::: 632
. NAME is None or NAME ::: 632
NAME ) NEWLINE from . NAME ::: 631
( NAME . NAME ) as ::: 631
is None NEWLINE assert NAME ( ::: 631
) ] ) NEWLINE NAME ( ::: 631
STRING ] ] ) NEWLINE NAME ::: 631
= False NEWLINE DEDENT NAME = ::: 631
NAME NEWLINE DEDENT import NAME NEWLINE ::: 631
assert NAME ( NAME , ( ::: 631
STRING ) ) NEWLINE for NAME ::: 631
. NAME ( ) NEWLINE del ::: 631
( NAME , NUMBER , STRING ::: 631
= ( ) NEWLINE NAME = ::: 631
NUMBER ] == NUMBER NEWLINE assert ::: 631
NAME * NAME - NAME * ::: 630
INDENT return True NEWLINE DEDENT def ::: 630
) NEWLINE DEDENT return STRING % ::: 630
, [ ] ) ) NEWLINE ::: 630
- NUMBER ) NEWLINE DEDENT def ::: 630
, STRING , None ) , ::: 630
or not NAME : NEWLINE INDENT ::: 630
: NEWLINE INDENT NAME ( [ ::: 630
. NAME ( [ NAME for ::: 630
STRING in NAME or STRING in ::: 630
INDENT pass NEWLINE DEDENT DEDENT return ::: 629
) , ] NEWLINE NAME . ::: 629
] = True NEWLINE NAME . ::: 629
] ] NEWLINE NAME = [ ::: 629
NAME , NAME ) * NAME ::: 629
) ] = NAME . NAME ::: 629
NEWLINE INDENT NAME = ( NUMBER ::: 629
: NAME ( NAME , STRING ::: 629
INDENT pass NEWLINE DEDENT DEDENT if ::: 629
( ) . NAME NEWLINE DEDENT ::: 629
NUMBER : NEWLINE INDENT return NUMBER ::: 629
NAME , STRING , STRING ] ::: 629
NAME . NAME is NAME : ::: 629
. NAME >= NAME . NAME ::: 628
for NAME in NAME ) : ::: 628
) , NAME ) , NAME ::: 628
NUMBER ) NEWLINE with NAME . ::: 628
NAME + NUMBER : ] NEWLINE ::: 628
raise NAME ( NAME ( NAME ::: 628
] NEWLINE DEDENT if NAME == ::: 628
== ( NUMBER , NUMBER ) ::: 628
NAME NEWLINE NAME += NAME NEWLINE ::: 628
) if NAME ( NAME , ::: 628
STRING STRING STRING . NAME ( ::: 628
, NAME = NUMBER , ** ::: 627
STRING ] == STRING NEWLINE DEDENT ::: 627
: ( ) , ( NAME ::: 627
import * NEWLINE import NAME NEWLINE ::: 627
) NEWLINE DEDENT NAME += NUMBER ::: 627
if NAME [ NAME ] == ::: 627
DEDENT NAME . NAME ( { ::: 627
NAME , NAME ( NUMBER ) ::: 627
] ) NEWLINE NAME = ( ::: 627
True NEWLINE break NEWLINE DEDENT DEDENT ::: 627
NAME , } ) NEWLINE NAME ::: 627
= True NEWLINE for NAME in ::: 627
INDENT NAME = STRING NEWLINE for ::: 627
) NEWLINE with NAME ( STRING ::: 627
. NAME ( NAME ( { ::: 627
) / NUMBER NEWLINE NAME = ::: 626
NAME ) ) ) NEWLINE if ::: 626
) ) NEWLINE assert ( NAME ::: 626
[ NAME ( STRING , STRING ::: 626
, NAME ( STRING , None ::: 626
( NAME , NAME ) [ ::: 626
NAME . NAME NEWLINE NAME += ::: 626
) ) is None NEWLINE assert ::: 626
NAME ( STRING , STRING . ::: 626
None , NAME ) NEWLINE DEDENT ::: 626
( ) ) NEWLINE NAME [ ::: 625
pass NEWLINE DEDENT DEDENT NAME . ::: 625
- NUMBER NEWLINE NAME = NUMBER ::: 625
NAME NEWLINE @ NAME ( STRING ::: 625
[ NAME ] += NUMBER NEWLINE ::: 625
, NUMBER ) : STRING , ::: 625
[ NUMBER ] == NUMBER : ::: 625
. NAME is NAME : NEWLINE ::: 625
NEWLINE assert NAME is not None ::: 625
elif NAME in NAME : NEWLINE ::: 625
NAME [ NAME ] , STRING ::: 625
: , NUMBER ] , NAME ::: 625
NAME ( { NAME : NAME ::: 624
( NAME ) NEWLINE return True ::: 624
if NAME [ : NUMBER ] ::: 624
= False ) NEWLINE def NAME ::: 624
NAME is NAME ) NEWLINE NAME ::: 624
= { STRING : True , ::: 624
) ) ) ) ) ) ::: 624
. NAME . NAME if NAME ::: 624
] , [ NUMBER , - ::: 623
( NAME [ NAME + NUMBER ::: 623
( [ NAME ( NAME , ::: 623
= ( STRING , NAME ) ::: 623
NAME [ STRING ] + NAME ::: 623
NAME = False ) NEWLINE def ::: 623
{ STRING : NAME } } ::: 623
[ STRING % NAME ] = ::: 623
INDENT STRING NEWLINE from NAME import ::: 623
} NEWLINE NAME . NAME [ ::: 623
NEWLINE INDENT return ( NAME ( ::: 623
, [ ( STRING , NAME ::: 623
] [ STRING ] ) ) ::: 623
[ NUMBER ] ] NEWLINE DEDENT ::: 622
NAME . NAME ) , None ::: 622
NAME [ : NAME ] ) ::: 622
= ( NAME ( NAME ) ::: 622
== [ STRING , STRING , ::: 622
NAME ) NEWLINE raise NEWLINE DEDENT ::: 622
NAME ] , NAME = True ::: 622
NUMBER ) ) , NAME = ::: 622
+ STRING ) NEWLINE DEDENT def ::: 622
( NAME == NAME . NAME ::: 622
NEWLINE DEDENT elif NAME is None ::: 622
NEWLINE assert NAME == NAME ( ::: 622
: NUMBER ] . NAME ( ::: 622
] , NAME ) NEWLINE if ::: 622
= NAME = NAME = NAME ::: 622
NEWLINE INDENT if NAME < NAME ::: 621
( NUMBER , NAME [ NUMBER ::: 621
= NUMBER NEWLINE NAME [ NUMBER ::: 621
NAME ( None , None , ::: 621
NEWLINE STRING NEWLINE class NAME ( ::: 621
return NEWLINE DEDENT else : NEWLINE ::: 621
[ NUMBER ] = STRING NEWLINE ::: 621
NUMBER ] NEWLINE assert NAME ( ::: 621
( NAME , ) = NAME ::: 620
NEWLINE NAME = [ [ NUMBER ::: 620
pass NEWLINE DEDENT @ NAME . ::: 620
. NAME . NAME is None ::: 620
False NEWLINE NAME = NAME ( ::: 620
NAME [ NAME . NAME : ::: 620
( NUMBER ) ] ) NEWLINE ::: 620
for NAME in NAME [ : ::: 620
) ) ] NEWLINE NAME = ::: 620
= NAME ( [ ] ) ::: 620
assert NAME . NAME == [ ::: 620
STRING ) ) NEWLINE assert NAME ::: 620
NEWLINE INDENT NAME += [ STRING ::: 619
return None NEWLINE DEDENT else : ::: 619
NAME ] [ STRING ] [ ::: 619
not NAME and not NAME : ::: 619
return False NEWLINE DEDENT DEDENT DEDENT ::: 619
, } , NAME = ( ::: 619
= NAME ( NUMBER , STRING ::: 619
try : NEWLINE INDENT try : ::: 619
NAME or { } NEWLINE NAME ::: 619
NAME NEWLINE NAME [ NUMBER ] ::: 618
NAME . NAME >= NUMBER : ::: 618
NAME , NAME = NAME + ::: 618
return NUMBER NEWLINE DEDENT if NAME ::: 618
= NAME . NAME NEWLINE class ::: 618
= NAME , NAME NEWLINE DEDENT ::: 618
, [ ] ] ) NEWLINE ::: 618
= STRING NEWLINE raise NAME ( ::: 618
< NAME ( NAME . NAME ::: 617
NUMBER ] ) for NAME in ::: 617
* NAME ) NEWLINE DEDENT NAME ::: 617
NAME , NAME , ( NAME ::: 617
INDENT NAME = STRING NEWLINE raise ::: 617
NAME = ( STRING , NAME ::: 617
NAME += NAME ( NAME . ::: 617
: NAME . NAME [ NAME ::: 617
NAME ( STRING + NAME , ::: 617
= NUMBER ) , [ ] ::: 617
, NUMBER ] , NUMBER , ::: 617
: NUMBER , STRING : - ::: 617
. NAME = NAME NEWLINE for ::: 617
NEWLINE return NAME ( * NAME ::: 617
( NAME , NAME , False ::: 617
global NAME NEWLINE global NAME NEWLINE ::: 617
) if NAME . NAME else ::: 616
: False , STRING : True ::: 616
NAME ) , { STRING : ::: 616
= NAME NEWLINE NAME = None ::: 616
INDENT try : NEWLINE INDENT from ::: 616
NAME ( NAME ) NEWLINE yield ::: 616
] , STRING : NUMBER , ::: 616
return NAME , NAME . NAME ::: 616