Mysterious Out Of Memory Error In 6502 BASIC -

i trying create simple word search game put characters on board on xpet in vice emulator using 6502 basic. find used work fine before added status indicator, fails, running out of memory @ 45, more 3 words. strange, because status indicator uses same variables rest of program uses, meaning should not take more space. have idea causing error? there hidden bug?

1 uu = 0 : goto 600 : rem can type run. uu=0: (toggle indicator on) 2 rem simple wordsearch game generator 3 rem takes words , creates board , key it. 4 rem words can read/written top bottom or left right. 5 rem board square between 3x3 , 21x21.  more information @ 12000. 8 print "zero words, terminating game..." : rem small piece 9 end : rem of code here happens if put 0 number of words.  10 rem below default data (it's random).  enough. 11 data "rat","clam","ten","sip","lie","ugly","not","yet","thou","if" 12 data "dog","cat","no","yes","maybe","truck","car","trap","lamb" 13 data "three","long","short","two","one","zero","cow","cart","house" 14 data "hair","hall","heart","head","who","is","truth","false","cake" 15 data "five","six","seven","eight","nine","ten","good","bad","rad" 16 data "thy","art","short","long","potatoes","tomato","ramble" 17 data "crumble","shambles","lion","turtle","beach","breach" 18 data "data","read","bamboozle","words","list","assasin","off" 19 data "are","viking","knight","sword","random","treacherous","..." 21 rem if not enough data, game reach "..." ,  22 rem game cut short (have less words).  there 23 rem 70 100 words in default list.   24 rem not remove "...", or crash when ask 25 rem many words (more number provided).  40 rem substring le ri st$ goes 0 len-1 41 rem left inclusive , right not inclusive. 42 rem assumes st$ exists; returns sr$.  le , ri must exit. 43 rem encapsulates mid function ease of use. 45 le = le+1: rem: remember basic strings go 1 len 46 sr$ = mid$(st$,le,ri-le+1) 47 le = le-1: rem: try avoid outside effects 48 return   49 rem: subroutine returns random 50 rem: boolean (tosses coin). 51 rem: return  0 or 1 randomly; output in mr. 52 mn = 0: mx = 1 53 gosub 500 54 gosub 10000 : return   55 rem assumes strings named s0$ , s1$ exist. 56 rem (these strings search intersection) 57 s2$ = "": rem returns string of intersections in s2$. 58 = 0 len(s0$)-1 : rem: characters in s0$ 59 st$ = s0$: le = : ri = i+1 60 gosub 40 61 ch$ = sr$ : rem temp var 62 j = 0 len(s1$)-1 63 le = j: ri = j+1: st$ = s1$ 64 gosub 40 65 if ch$ = sr$ s2$ = s2$ + ch$ 66 next j 67 next 68 gosub 10000 : return   99 rem gets random float. 100 mr = rnd(0)*(mx-mn)+mn 101 gosub 10000 : return   300 rem scrambles order of ps$(). 301 = 0 ip-1 302 mx = ip-1 303 mn = 0 304 gosub 500 305 sp$ = ps$(mr) 307 ps$(mr) = ps$(i) 309 ps$(i) = sp$ 311 next 312 gosub 10000 : return   499 rem random integer subroutine. 500 mx = mx+1 : rem increment here top inclusive 501 gosub 100 : rem run exclusive floating point version 502 mr = int(mr) : rem turn integer via truncation 503 mx = mx - 1 : rem reset mx, avoid side effects 504 gosub 10000 : return   505 goto 535 530 rem subroutine returns gp$(), 2 531 rem dimensional array of words 532 rem each value of ps$() word 533 rem list in gp$() of value has words 534 rem match/intersect it. 535 dim gp$(ip-1,ip-1) 536 l = 0 ip-1 537 ix = 0 538 cc = 0 ip-1 539 s0$ = ps$(l) 540 s1$ = ps$(cc) 541 gosub 55 543 if s2$ = "" goto 545 544 if s1s$ = ps$(l) goto 545 :rem same word 545 gp$(l,ix) = ps$(cc) 549 ix = ix + 1 555 rem skip 557 next cc 559 next l 560 gosub 10000 : return   588 rem highly recommend running in warp mode 589 rem feel game, because slow. 590 rem can speed up, however, not having status indicator. 592 rem near end guides developers 593 rem , users.  our main subroutine. 594 rem provide user helpful prompts 595 rem , take input user regarding how many words, , 596 rem words use. 598 rem global variable "ma" tracked length of 599 rem longest word.  sz number of words play with. 600 restore : ma = 0 : print "how many words want?" 601 print "(not many, or long please)" 602 print "(we recommend put less 12 words" 603 print "of lengths of 7 characters or below)" 604 input "how many words"; in$ : print "" : print "" : print "" 605 print "note: spaces , periods removed ends of words." 606 print "this game children." 607 print "you can have 1 of each word." 608 print "words aren't confirmed real words." 609 print "so please enter real words play them." 610 print "however, have default words. let "; 611 print "the computer finish filling list, "; 612 print "just enter .... .  enter ... finish early." 613 ip = val(in$) : if ip <= 0 goto 8 : rem 0 words 614 dim pr$(ip-1) : sz = 0 615 = 0 ip-1 616 input "next word"; ii$ : rem buggy emulator shows "?" regardless 617 ln = len(ii$): if ln > ma ma = ln:rem update mx wrd lngth 619 if ii$ = "..." if = 0 goto 8 : rem 0 words 620 if ii$ = "..." sz = -1 : if ii$ = "..." goto 635 621 if ii$ = "...." if ip = 1 goto 900 622 if ii$ = "...." goto 628 : rem fill default 623 gosub 2000 624 if cn = 1 print "that word added" 625 if cn = 1 goto 616 : rem: word again 626 gosub 9000 : pr$(i) = ii$ : sz = 627 next 628 if >= ip-1 goto 635 629 j = ip-1 :rem: fill in data 630 read ii$ : if ii$ = "..." goto 1200 631 gosub 2000 632 if cn = 1 goto 629 633 pr$(j) = ii$ : sz = j 634 next j 635 gosub 890 : rj = 0 : pa = 0 : dim re$(ip-1) : dim pl$(ip-1) 639 print "" : print "" : print "" 640 print "would have status indicator? (y/n)" 645 print "note slows down considerably." 647 input ""; ii$ 649 if ii$ = "n" uu = 1 : if ii$ = "n" goto 670 650 if ii$ = "y" uu = 0 : if ii$ = "y" goto 670 660 rem else 665 print "you must enter y or n.  y yes , n no." 668 goto 647 670 rem  671 print "please wait.  game loading..." 672 print "in cases take few minutes..." : 693 print "" : print "" : if ip = 1 goto 910 694 gosub 4000 : gosub 301 : gosub 535 695 gosub 1500 696 gosub 6500 697 gosub 7000 698 gosub 1000 699 rem go 701 print "" : print "" : print "" 702 print "*********************" 703 print "***wordsearch game***" 704 print "*********************" 710 gosub 5000 :rem: print 711 gosub 6600 :rem: key array , answer list. 790 end  888 rem turn pr$() ps$() size number 889 rem of words (in case terminate "..."). 890 if sz = -1 gosub 1300 891 dim ps$(sz) 892 = 0 sz 893 ps$(i) = pr$(i) 894 next 896 ip = sz+1 897 rem make work "ip-1" elsewhere 898 return  900 dim ps$(0) 901 ps$(0) = "rat" 902 rj = 0 : pa = 0 : dim re$(ip-1) : dim pl$(ip-1) 903 goto 910  906 rem subroutine continues running of game 907 rem normally, except deals case 908 rem there 1 word.  normal code fails 909 rem in case (which why need 910). 910 gosub 4000 911 gosub 6500 912 dr$ = ps$(0) 913 gosub 949 914 gosub 1001 931 print "" : print "" : print "" 932 print "*********************" 933 print "***wordsearch game***" 934 print "*********************" 935 gosub 5000 : rem print actual game 936 gosub 6600 : rem key array 940 end  947 rem subroutine places 1 word randomly on board. 948 if ps$(0) = "" goto 8 : rem (the case 1 word) 949 if len(ps$(0)) > sh goto 981 950 gosub 49 : me = mr : dr$ = ps$(0) 951 if me = 0 goto 960 : rem vertical 952 rem here code horizontal 953 mn = 0 954 mx = a-len(dr$) 955 gosub 40 : x = mr 956 mn = 0 957 mx = a-1 958 gosub 40 : y = mr 959 goto 979 960 rem here our code vertical 962 mn = 0 963 mx = a-len(dr$) 964 gosub 40 : y = mr 965 mn = 0 967 mx = a-1 968 gosub 40 : x = mr 969 goto 979 979 gosub 6000 : pl$(0) = dr$ 980 gosub 10000 : return 981 re$(0) = ps$(0) 982 return  998 rem subroutine fills board random 999 rem characters, assuming words have been 1000 rem placed.  copies wo$() wr$(), replaces dots. 1001 = 0 a-1 1002 j = 0 a-1 1003 wr$(i,j) = wo$(i,j) 1007 next j 1008 next 1009 = 0 a-1 1010 j = 0 a-1 1012 if wr$(i,j) <> "." goto 1020 1014 mn = 65: mx = 90 1015 gosub 500 1016 wr$(i,j) = chr$(mr) 1020 next j 1021 next 1100 gosub 10000 : return   1197 rem helper will, in read data loop, 1198 rem use termination functionality avoid crashes. 1199 rem here avoid clutter ":" commands in main. 1200 sz = -1 1201 if pr$(0) = "..." goto 8 1202 goto 635  1299 rem finds our sz; fixes bug using "...". 1300 sz = 0 1301 po = 0 ip-1 1302 if pr$(po) <> "" sz = po 1303 next po 1304 return  1500 rem subroutines orders words array 1501 rem called fd$().  orders them in way such 1502 rem words next each other have 1503 rem intersection if possible.  otherwise,  1504 rem may not. 1505 rem makes use of our previous 2d array gp$() this. 1510 dim fd$(ip-1) : rem list of words in order place them 1511 fd$(0) = ps$(0) 1520 k = 1 ip-1 1521 st$ = fd$(k-1) 1522 gosub 3500 1523 f = 0 :rem number of words in subarray 1524 kc = 0 ip-1 1525 if gp$(ni,f) = "" goto 1528 1526 f = kc 1527 next kc 1528 rem find matching word new 1529 d = 0 f-1 1530 ii$ = gp$(ni,d) : rem dst word matching 1531 gosub 1700 :rem cn = whether contained 1532 if cn = 0 fd$(k) = ii$ 1533 if cn = 0 goto 1649 1534 next d :rem check next subarray item 1535 rem @ point need entirely new word 1536 d = 0 ip-1 1537 ii$ = ps$(d) 1560 gosub 1700 1570 if cn = 0 fd$(k) = ii$ 1580 if cn = 0 goto 1649 1590 rem else (haven't found yet) 1600 next d 1610 rem should work , deterministic 1611 rem 1649 next k 1650 gosub 10000 : return   1700 rem assumes fd$() , ii$ , ip exist.  returns cn. 1701 rem checks whether ii$ in fd$(), 0 no, , 1 yes. 1702 cn = 0 1703 l = 0 ip-1 1704 if cn = 1 gosub 10000 : return  1705 if fd$(l) = ii$ cn = 1 1706 next l 1707 gosub 10000 : return   2000 rem assumes pr$() , ii$ ip exist.  outputs cn. 2001 rem returns whether ii$ in pr$() (0 no, 1 yes). 2002 cn = 0 2003 l = 0 ip-1 2004 if cn = 1 gosub 10000 : return  2005 if pr$(l) = ii$ cn = 1 2006 next l 2007 return   3500 rem finds index, outputted ni, @ st$ in ps$ 3501 rem if not present, returns -1. 3505 l = 0 ip - 1 3510 ni = l 3515 if ps$(ni) = st$ gosub 10000 : return  3520 next l 3525 ni = -1 3530 gosub 10000 : return   3999 rem set board dimensions. 4000 sh = 21: if ma > sh ma = sh : rem sh = screen height 4001 = int(ma + ip/5+ ip/8 + ip/10 + ip/20): if < 3 = 3 4002 rem emperically determined subroutine. 4003 if < ma+1 = ma+1 4005 if > sh = sh 4006 dim wr$(a-1,a-1): dim wo$(a-1,a-1) : rem square grid 4007 gosub 10000 : return   4998 rem subroutine prints regular game 4999 rem board screen. 5000 rem  5001 = 0 a-1 5002 j = 0 a-1 : rem cant use b :p 5003 print wr$(i,j); 5004 next j 5005 print "" 5006 next 5007 return   6000 rem subroutine places word, dr$, on board & key  6002 rem @ wr$/wo$(y,x). me 1 horizontal, 0 vertical. 6003 rem assumes possible. 6004 l = 0 len(dr$)-1 6005 st$ = dr$ 6006 le = l 6007 ri = l+1 6008 gosub 40 6009 wr$(y,x) = sr$: wo$(y,x) = sr$ 6010 if me = 1 x = x + 1 6011 if me = 0 y = y + 1 6012 next l 6013 gosub 10000 : return   6497 rem little subroutine fills key board 6498 rem dots, on top of words later 6499 rem placed.  makes game more usable. 6500 po = 0 a-1 6520 pp = 0 a-1 6530 wo$(po,pp) = "." 6540 next pp 6550 next po 6560 gosub 10000 : return   6567 rem simple subroutine waits key 6578 rem pressed, , waits in meantime. 6569 print "press key continue..." : rem key 6570 tm$ : if tm$ = "" goto 6570 6571 return   6596 rem subroutine prints out words 6597 rem used , words rejected. 6598 rem prints key out last, in case user wants search 6599 rem word didn't realize there once see 6600 rem list. (some people that...) 6605 print "to check answers, " 6611 gosub 6569 6612 print "words:" 6613 = 0 ip - 1 6614 print pl$(i); : print " "; 6615 next 6616 print "": gosub 6569 6617 print "rejected words:" 6618 = 0 ip-1 6619 print re$(i); : print " "; 6620 next 6621 print "" : gosub 6569 : print "key:" : print "" 6640 kl = 0 a-1 6641 lk = 0 a-1 6642 print wo$(kl,lk); 6643 next lk 6644 print "" 6645 next kl 6646 gosub 6569 : print "*********************" 6647 return   6995 rem subroutine our smart placing subroutine. 6996 rem goal place words fd$() in way 6997 rem maximize intersections of words , create 6998 rem best possible game. 6999 rem assumes have fd$(), wo$() , wr$() ready 7000 id = 0 : rem initial word spot on array 7003 if ip = 3 goto 7500 : rem somehow fixes bug 7004 rem above due bad emulator bug, nonsensical 7005 if id > ip-1 return : rem have placed words 7006 if id = ip-1 goto 7900 : rem 1 word 7010 rem else 7011 goto 7300 7200 rem general smart placer 7300 se$ = fd$(id+1) : si$ = fd$(id) 7310 s0$ = si$ : s1$ = se$ : gosub 55 : fr = 0 : rf = 0 7311 if s2$ = "" goto 7450 7315 le = 0 : ri = 1 : st$ = s2$ : gosub 40 : tm$ = sr$ 7320 pi = 0 len(si$)-1 7325 le = pi : ri = pi+1 : st$ = si$ : gosub 40 7330 if sr$ = tm$ goto 7350 7335 fr = fr + 1 7340 next pi 7350 po = 0 len(se$)-1  7355 le = po : ri = po+1 : st$ = se$ : gosub 40 7360 if sr$ = tm$ goto 7375 7365 rf = rf + 1 7370 next po 7375 rem rf : si$ ;;;;; fr : se$ 7380 rem 7385 mf = 1 : mk = 0 : rem 1st word horizontal, second vertical 7395 xx = 0 a-len(si$) 7400 yy = rf a-len(se$)+rf 7401 x = xx : y = yy : dr$ = si$ 7402 if xx < 0 goto 7430 7403 if xx > a-1 7430 7404 if yy < 0 7428 7405 if yy > a-1 7428 7407 kd = mf 7408 gosub 8300 7410 if kk = 0 goto 7428 7412 x = xx + fr : y = yy - rf 7413 dr$ = se$ : kd = mk  7414 gosub 8300  7415 if kk = 0 goto 7428 7417 dr$ = si$ : x = xx : y = yy : me = mf : gosub 6000 7420 dr$ = se$ : x = xx + fr : y = yy - rf : me = mk : gosub 6000 7425 pl$(pa) = si$ : pa = pa + 1 : pl$(pa) = se$ : pa = pa + 1 7426 goto 7461  7428 next yy 7430 next xx 7450 dr$ = si$ : gosub 8000 7460 dr$ = se$ : gosub 8000 7461 id = id + 2 7470 goto 7005 7500 dr$ = fd$(0) : gosub 8000 7501 dr$ = fd$(1) : gosub 8000 7502 dr$ = fd$(2) : gosub 8000 7503 return 7900 rem places last word 7901 dr$ = fd$(ip-1) 7902 gosub 8000 7926 return  7990 rem subroutine tries place word called dr$ 7991 rem anywhere possible on board testing 7992 rem locations directions allowed in game. 8000 rem meant words not placed our smart placer. 8002 if len(dr$) > sh goto 8028 8003 pn = 0 a-1 8004 pk = 0 a-1 8006 kd = 1 8008 gosub 8300 8010 if kk = 1 gosub 8100 : rem place 8012 if kk = 1 gosub 10000 : return  8014 rem else (if kk = 0) 8016 kd = 0 8018 gosub 8300 8020 if kk = 1 gosub 8100 : rem place 8022 if kk = 1 gosub 10000 : return  8024 next pk 8026 next pn 8028 kk = 0 : re$(rj) = dr$ : rj = rj + 1 : rem add rejects 8030 gosub 10000 : return   8099 rem parameter converter 8000 6000. 8100 rem place dr$ @ pn, pk (format (y,x)). 8101 y = pn : x = pk: me = kd: gosub 6000 8102 pl$(pa) = dr$ : pa = pa + 1 8103 gosub 10000 : return   8260 rem subroutine check whether 8261 rem can place string called dr$ 8262 rem in direction kd (0 vertical, 1 horizontal) 8263 rem @ position 8264 rem pn, pk (coords (y,x)) 8300 rem returns kk whther can place 8301 rem (kk = 0 if can't, = 1 if can) 8303 lu = len(dr$) 8305 if kd = 1 goto 8350 : rem horizontal 8307 kk = 1 : rem vertical 8309 if pn+lu-1 > a-1 kk = 0 8310 pc = pn pn+lu-1 8312 le = pc-pn 8313 ri = le+1 : st$ = dr$ 8314 gosub 40 : lc$ = sr$ 8315 if wo$(pc,pk) <> "." kk = 0 8316 if wo$(pc,pk) = lc$ kk = 1 8317 if kk = 0 gosub 10000 : return  8318 next pc 8319 gosub 10000 : return  8350 kk = 1 8351 if pk+lu-1 > a-1 kk = 0 8352 if kk = 0 gosub 10000 : return  8353 pc = pk pk+lu-1 8362 le = pc-pk 8363 ri = le+1 : st$ = dr$ 8364 gosub 40 : lc$ = sr$ 8374 if wo$(pn,pc) <> "." kk = 0 8376 if wo$(pc,pk) = lc$ kk = 1 8384 if kk = 0 gosub 10000 : return  8388 next pc 8389 gosub 10000 : return   8999 rem subroutine takes in string ii$ , removes spaces 9000 rem end.  meant avoid disastrous user errors. 9008 goto 9010 9010 st$ = ii$ 9015 tm$ = "" 9020 ck = 0 len(ii$)-1 9030 le = ck 9033 ri = ck+1 9035 gosub 40 9050 if sr$ = "" goto 9200 9100 tm$ = tm$ + sr$ 9200 next ck 9300 ii$ = tm$ 9301 return   10000 if uu = 1 return : rem set uu 0 on line 1 not status indicate. 10001 rem our rudimentary status indicator 10002 rem function.  print "." indicator line , delete it. 10005 print "."; 10006 sz=0 50 : print ""; : next sz 10007 print chr$(20); : rem deletes 10008 rem function called when stuff happens; 10009 rem not mean called consistently, 10010 rem instead means function called 10011 rem long system not frozen/crashed.  10012 rem may take while dot appear, if do, wait. 10013 return  11001 rem note can use same spot because comment. 11002 rem welcome function/method guide! 11003 rem functions written this:  11004 rem <line number>(<arg 1>, <arg 2> , <...>): <quick description>=<output> 11005 rem longer descriptions can found @ functions themselves. 11006 rem also, functions called @ earlier or later 11007 rem line numbers due comments.  still same function. 11008 rem modules not functions, extensions of other functions 11009 rem readability.  these here , labeled not being 11010 rem independent functions purposes of clearness. 11011 rem 10 data 11012 rem 40 (le, ri, st$): substring function = sr$ 11013 rem 49 (none): toincoss function = mr 11014 rem 55 (s0$, s1$): intersection = s2$  11015 rem 100 (mn,mx): random float = mr 11016 rem 300 (ps$()): scrambles ps$() = none  11017 rem 500 (mn,mx): random int = mr 11018 rem 505 (ps$()): grouping finder = gp$()() 11019 rem 600 (none): main = none (the game) 11020 rem 890 (pr$()): creates ps$() = ps$()  11021 rem 900 continuation of 600 (single word case) 11022 rem 948 continuation of 900 (places 1 single word randomly)  11023 rem 1000 (wo$()(), wr$()()): fill board = none  11024 rem 1200 extension of 600 11025 rem 1300 (pr$()): helper counter pr$() > ps$() = sz 11026 rem 1500 (ps$(), gp$()()): fd$() generator = fd$()  11027 rem 1700 (ii$, fd$()): fd$() contains = cn 11028 rem 2000 (ii$, pr$()): pr$() contains = cn 11029 rem 3500 (ps$(), st$): 1500 helper finding index of value = ni 11030 rem 4000 (ma, ip): board dimensions = wo$()(), wr$()() 11031 rem 5000 (wr$()()): print game = none 11032 rem 6000 (dr$, me, wo$()(), wr$()()): places word = none  11033 rem 6500 (wo$()()): fill key dots = none  11034 rem 6569 (none): press , key = none  11035 rem 6596 (pl$(), re$(), wo$()()): prints out end game info = none 11036 rem 7000 (fd$(), wo$(), wr$()): smart placer = none 11037 rem 8000 (dr$, wo$(), wr$()): dumb placer = none 11038 rem 8100 continuation of 8000  11039 rem 8300 (dr$, y, x, wo$(), wr$()): check if can place = kk 11040 rem 9000 (ii$): removes end spaces (rstrip) = ii$ 11041 rem 10000 (none): status indicator = none  11101 rem ---below simple guide game's inner workings--- 11102 rem simple word search game ideal children ,  11103 rem other such individuals.  runs slowly, , scales 11104 rem badly both space , time (though, should scale worse 11105 rem time, space relative word size , number of 11106 rem words since has @ 2 dimensional arrays).  play 11107 rem game maximum enjoyment, recommend warp mode, 11108 rem normal mode if want time dash manzanita 11109 rem , grab cup of coffee in morning (or something). 11110 rem luckily has rough status indicator.  if fills 11111 rem entirety of screen not afraid, being called 11112 rem lot because called time @ 11113 rem happens, , lot happening. 11114 rem game works follows: find combinations of words 11115 rem can work, , group words order 11116 rem placed in, based on words best grouped 11117 rem each other (though, randomly chooses if 2 words both 11118 rem can grouped same word, leading  different outcomes 11119 rem game; note while code may purely   11120 rem deterministic, due fact entire array ps$() 11121 rem input array pr$() loaded, not since ps$() scrambled 11122 rem randomly, meaning order may found, , due inner 11123 rem workings of combination finder, order combinations 11124 rem in different ways; why every single possible combination of  11125 rem words technically possible in game).  after loading  11126 rem placement order list (fd$()), place in pairs form 11127 rem crosses.  make first word horizontal , second 11128 rem vertical, due initial scramble, every single possibility 11129 rem can technically occur (thought typically makes game less 11130 rem "random").  if pair can't form cross (since either has none  11131 rem of same letters, or can't fit in, try fit each 11132 rem word individually.  if fails, add word 11133 rem rejects list (placed words added placed words list). 11134 rem after each word placed or rejected, game printed, ,  11135 rem after player desires see solution shows first 11136 rem words, rejects, answer key.  key last, in 11137 rem case players see words want find, , don't want 11138 rem have key revealed yet. 11139 rem  11140 rem crash notes: 11141 rem crashes after: 11142 rem many, many big words (ie if put 30+ words of length 11143 rem 12+ take forever, , might run out of memory). 11144 rem have run 50 words of average length 4 , works 11145 rem fine, slowly; remember can speed uu = 1.   11146 rem tanks if add long words because  11147 rem main factor of grid size. 11148 rem 11149 rem note: "l" iterator letter, not number. 11150 rem (i know can confusing).  11154 rem 11155 rem side note users: if put in tens or 11156 rem hundreds of words numbers , terminate early, still 11157 rem allocate array of size; crash game.  also, 11158 rem if ever suspicious crashes (ie out of memory 5 words) 11159 rem try restarting or reloading.  emulator buggy too.  other 11160 rem successful options fix emulator bugs include printing items 11161 rem in random places , deleting print statements.  it's 11162 rem nonsensical, worked me. 11168 rem 11169 rem empty strings "words" can break game on occasion. 11170 rem not dealt because users entering empty strings 11171 rem words not planning on playing legitimate game 11172 rem not matter general populace. 11173 rem  11174 rem luck! 11175 rem thank playing! 

the problem not line 45, despite ?out of memory @ line 45 error. line in , of cannot trigger oom, since merely incrementing memory variable @ worst trigger ?overflow eventually.

the problem basic program sufficiently large pet cannot allocate enough memory runtime variables - why working until added last routine.

so: either optimise memory usage (by trimming/optimising code and/or refining variable use) or reconfigure xpet more ram @ startup.