Initial commit

2017/.gitignore

@@ -0,0 +1,3 @@
+*\~
+*.hi
+*.o

2017/01/day1.hs

@@ -0,0 +1,18 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+sumMatchingOffset :: Int -> [Int] -> Int
+sumMatchingOffset k xs =
+  foldr (\x acc -> if fst x == snd x then acc + fst x else acc) 0 xs'
+  where n = length xs
+        xs' = zip xs (take n . drop k . cycle $ xs)
+
+toDigits :: String -> [Int]
+toDigits = map (read . (:""))
+
+main :: IO ()
+main = do
+  digitsStr <- getLine
+  let digits = toDigits digitsStr
+  putStrLn . show $ sumMatchingOffset 1 digits
+  putStrLn . show $ sumMatchingOffset (length digits `div` 2) digits

2017/01/day1.scm

@@ -0,0 +1,19 @@
+#!/usr/bin/csi -script
+
+(use extras)
+(use srfi-1)
+(use list-comprehensions)
+
+(define (sum-matching-offset k xs)
+  (let* ((n (length xs))
+	 (newxs (zip xs (take (drop (concatenate ((repeat 3) xs)) k) n)))
+	 (f (lambda (x acc) (if (= (first x) (second x)) (+ acc (first x)) acc))))
+    (foldr f 0 newxs)))
+
+(define (main)
+  (let* ((digits-str (read-line))
+	 (digits (map string->number (map string (string->list digits-str)))))
+    (print (sum-matching-offset 1  digits))
+    (print (sum-matching-offset (/ (length digits) 2) digits))))
+
+(main)

2017/01/digits.txt

@@ -0,0 +1 @@
+8231753674683997878179259195565332579493378483264978184143341284379682788518559178822225126625428318115396632681141871952894291898364781898929292614792884883249356728741993224889167928232261325123447569829932951268292953928766755779761837993812528527484487298117739869189415599461746944992651752768158611996715467871381527675219481185217357632445748912726487669881876129192932995282777848496561259839781188719233951619188388532698519298142112853776942545211859134185231768952888462471642851588368445761489225786919778983848113833773768236969923939838755997989537648222217996381757542964844337285428654375499359997792679256881378967852376848812795761118139288152799921176874256377615952758268844139579622754965461884862647423491918913628848748756595463191585555385849335742224855473769411212376446591654846168189278959857681336724221434846946124915271196433144335482787432683848594487648477532498952572515118864475621828118274911298396748213136426357769991314661642612786847135485969889237193822718111269561741563479116832364485724716242176288642371849569664594194674763319687735723517614962575592111286177553435651952853878775431234327919595595658641534765455489561934548474291254387229751472883423413196845162752716925199866591883313638846474321161569892518574346226751366315311145777448781862222126923449311838564685882695889397531413937666673233451216968414288135984394249684886554812761191289485457945866524228415191549168557957633386991931186773843869999284468773866221976873998168818944399661463963658784821796272987155278195355579386768156718813624559264574836134419725187881514665834441359644955768658663278765363789664721736533517774292478192143934318399418188298753351815388561359528533778996296279366394386455544446922653976725113889842749182361253582433319351193862788433113852782596161148992233558144692913791714859516653421917841295749163469751479835492713392861519993791967927773114713888458982796514977717987598165486967786989991998142488631168697963816156374216224386193941566358543266646516247854435356941566492841213424915682394928959116411457967897614457497279472661229548612777155998358618945222326558176486944695689777438164612198225816646583996426313832539918

2017/02/day2.hs

@@ -0,0 +1,20 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+range :: (Ord a, Num a) => [a] -> a
+range l = maximum l - minimum l
+
+divisors :: (Integral a) => [a] -> a
+divisors [] = 0
+divisors (x:xs) =
+  case filter (\y -> (x `mod` y == 0) || (y `mod` x == 0)) xs of
+    [] -> divisors xs
+    y:_ -> if y > x then y `div` x
+           else x `div` y
+
+main :: IO ()
+main = do
+  contents <- getContents
+  let numbers = map (map read . words) $ lines contents :: [[Int]]
+  putStrLn . show $ sum $ map range numbers
+  putStrLn . show $ sum $ map divisors numbers

2017/02/day2.scm

@@ -0,0 +1,27 @@
+#!/usr/bin/csi -script
+
+(use extras)
+
+(define (range xs)
+  (- (apply max xs) (apply min xs)))
+
+(define (find-divisors x xs)
+  (cond ((null? xs) 0)
+	((= 0 (remainder x (car xs))) (/ x (car xs)))
+	((= 0 (remainder (car xs) x)) (/ (car xs) x))
+	(else (find-divisors x (cdr xs)))))
+
+(define (divisors xs)
+  (if (null? xs) 0 
+      (let* ((y (car xs))
+	     (ys (cdr xs))
+	     (first-divisor (find-divisors y ys)))
+	(if (= 0 first-divisor) (divisors ys) first-divisor))))
+
+(define (main)
+  (let* ((contents (read-lines))
+	 (numbers (map (lambda (x) (map string->number x)) (map string-split contents))))
+    (print (apply + (map range numbers)))
+    (print (apply + (map divisors numbers)))))
+
+(main)

2017/02/input.txt

@@ -0,0 +1,16 @@
+790	99	345	1080	32	143	1085	984	553	98	123	97	197	886	125	947
+302	463	59	58	55	87	508	54	472	63	469	419	424	331	337	72
+899	962	77	1127	62	530	78	880	129	1014	93	148	239	288	357	424
+2417	2755	254	3886	5336	3655	5798	3273	5016	178	270	6511	223	5391	1342	2377
+68	3002	3307	166	275	1989	1611	364	157	144	3771	1267	3188	3149	156	3454
+1088	1261	21	1063	1173	278	1164	207	237	1230	1185	431	232	660	195	1246
+49	1100	136	1491	647	1486	112	1278	53	1564	1147	1068	809	1638	138	117
+158	3216	1972	2646	3181	785	2937	365	611	1977	1199	2972	201	2432	186	160
+244	86	61	38	58	71	243	52	245	264	209	265	308	80	126	129
+1317	792	74	111	1721	252	1082	1881	1349	94	891	1458	331	1691	89	1724
+3798	202	3140	3468	1486	2073	3872	3190	3481	3760	2876	182	2772	226	3753	188
+2272	6876	6759	218	272	4095	4712	6244	4889	2037	234	223	6858	3499	2358	439
+792	230	886	824	762	895	99	799	94	110	747	635	91	406	89	157
+2074	237	1668	1961	170	2292	2079	1371	1909	221	2039	1022	193	2195	1395	2123
+8447	203	1806	6777	278	2850	1232	6369	398	235	212	992	7520	7304	7852	520
+3928	107	3406	123	2111	2749	223	125	134	146	3875	1357	508	1534	4002	4417

2017/03/day3.hs

@@ -0,0 +1,49 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+import qualified Data.Map.Strict as Map
+import Data.Maybe
+
+right, up, left, down :: (Int,Int) -> (Int,Int)
+right (a,b) = (a+1,b  )
+up    (a,b) = (a  ,b+1)
+left  (a,b) = (a-1,b  )
+down  (a,b) = (a  ,b-1)
+
+spiral :: [(Int, Int)]
+spiral = scanl (flip ($)) (0,0) directions
+  where directions = concat $
+          zipWith replicate (concat (map (replicate 2) [1..])) $
+          cycle [right, up, left, down]
+
+shortestPathLength :: Int -> Int
+shortestPathLength n =
+  let (x,y) = spiral !! (n-1) in
+    (abs x) + (abs y)
+
+neighbours :: (Int,Int) -> [(Int,Int)]
+neighbours (a,b) =
+  [(a+k,b+l) | k <- [-1..1], l <- [-1..1]]
+
+
+insertCell :: (Int,Int) -> Map.Map (Int,Int) Int -> Map.Map (Int,Int) Int
+insertCell (a,b) m =
+  Map.insert (a,b) (fromJust sumNeighbours) m
+  where sumNeighbours = fmap sum $ sequence . (filter isJust) $ fmap (\k -> Map.lookup k m) (neighbours (a,b))
+
+spiralSum :: Int -> Map.Map (Int,Int) Int
+spiralSum n = foldl (flip insertCell) (Map.singleton (0,0) 1) (take n (tail spiral))
+
+spiralSumValues :: Int -> [Int]
+spiralSumValues n = fromJust . sequence $ fmap (\x -> Map.lookup x (spiralSum n)) (take n spiral)
+
+firstValueLarger :: Int -> Int
+firstValueLarger n = head $ filter (> n) (spiralSumValues (n `div` 1000))
+
+main :: IO ()
+main = do
+  input <- getLine
+  let n = read input :: Int
+  putStrLn . show $ shortestPathLength n
+  putStrLn . show $ firstValueLarger n
+

2017/04/day4.hs

@@ -0,0 +1,29 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+import Data.List
+
+testDuplicates :: [String] -> Bool
+testDuplicates xs = length (nub xs) /= (length xs)
+
+countLinesWithDuplicates :: [String] -> Int
+countLinesWithDuplicates = sum . map (fromEnum . testDuplicates . words)
+
+isAnagram :: String -> String -> Bool
+isAnagram s1 s2 = sort s1 == sort s2
+
+testAnagrams :: [String] -> Bool
+testAnagrams [] = True
+testAnagrams (x:xs) =
+  if or (map (isAnagram x) xs)
+  then False
+  else testAnagrams xs
+
+countValidLines :: [String] -> Int
+countValidLines = sum . map (fromEnum . testAnagrams . words)
+
+main :: IO ()
+main = do
+  contents <- getContents
+  putStrLn . show . (\xs -> length xs - countLinesWithDuplicates xs) . lines $ contents
+  putStrLn . show . countValidLines . lines $ contents

2017/04/input.txt

@@ -0,0 +1,512 @@
+sayndz zfxlkl attjtww cti sokkmty brx fhh suelqbp
+xmuf znkhaes pggrlp zia znkhaes znkhaes
+nti rxr bogebb zdwrin
+sryookh unrudn zrkz jxhrdo gctlyz
+bssqn wbmdc rigc zketu ketichh enkixg bmdwc stnsdf jnz mqovwg ixgken
+flawt cpott xth ucwgg xce jcubx wvl qsysa nlg
+qovcqn zxcz vojsno nqoqvc hnf gqewlkd uevax vuna fxjkbll vfge
+qrzf phwuf ligf xgen vkig elptd njdm gvqiu epfzsvk urbltg dqg
+sfpku viwihi fje umdkwvi ejzhzj qrbl sfpku sad nawnow ksnku
+nzhj mfudick ueaa jnhz kpy pzk
+euiin xvl elaoelu wbdd xlv jtm nohtq gfdbgdg gdfggdb edtym
+xfmkn wyww woe hwysuh gjw dtk utryasc dela eluk vmmun
+nmag qfwe cwslmgd nlhf hpf
+ifs sszo iod isf jna
+pjptwg wreera leyb hmlbpf qcrbma ylgue
+rwlpo jhla rprxvgs quguh pyybwgl qqvcb
+rxtcpdy wmpci mpcwi vwvdzdn nfpnj rcsxinl itatg ycy hrctg ron wveju
+zmkfn wip pyiz pyiz tnyg dvftf elks ezhotbj wip
+sgmtfdd xdl sch sch yaxzh wphgksh knzrixp yaxzh etm czqbaa jldta
+gnbr rnpd upe eeb sbq sbq oxc rwvugoj
+cshk thcc emfxx emfxx pbtcf jpim vltkqar czy iudkac jhpcc nqs
+uzbvx fkiuyk izxdiu yutntvn dixuzi hkyfnud oyz ynutntv
+ewl mfns idy fphu yqccb pte unukirt unukirt fdx
+lzn tin fgena qbql qycbdw gbtn lctlysx adhjfq blu aiv
+ites ites pbxzunl vljzh lqgerta pbxzunl
+vmk wjfzvhn pqkidze qfwh
+tqprmc exypl caf kwikh mdyyljc pbo hhxxo skna
+sqxgejb ejc fvup hpesvs luz fcxqwhr ypxof fxlcp pxyk xiczjri
+vjg qcw fsyqaoj mxf jha feclqqr vzdqnk verw mvmvm pvdqtcd xsfu
+fwwn ktvdh aecfv acfve yjozxwo cnujw bcgde lphnk knlph bqwlqju
+uwwapm dlln uwwapm uwwapm
+huupab ewetcte huupab ewetcte
+wjs zipivpd klwafr ipcczg wbv uujstsw hykn
+mgojdyh hlm xruta lbmaxit pabqrnp vkyigd ptpzr glin gfau pbo
+tbwx baqxq vtz jwex tvz tzv
+efopwx wfknzb ogaxln tqzrh jne zugd zpxikma
+rdjsa arjds hqdldw fjrtl midt qjv jfrlt
+dggqohj bidaaty iah lgmug wwmlbc lggmu laonaoq erkqrb tqolnns iygv qnonlst
+msc glwn xjfnij itt pka irrafjd euazydj silo
+zsyut znsht ldky zsyut dzcdft znsht
+iit cyteu pib fgvrs iux ffctql pib zuzp zsbb ieoi
+xxtwlu kqfxjhq isj xqjhfkq dohrs haovzc cgfwfrt munqon vuyexz nouqnm
+eptpqgi uiflvd acj livzq ejtt bniud cjdh jkrcken lspfy tpxri zibj
+zxme dpo fumup gly bkdcwxn lsly eglhe
+uoshw ijoyiql rcskaa vjbqv roiinzi fppqdu
+xuw vdbxie oypcx khxq xebjt oypcx uitqep vdbxie hoz
+lrjv tdksk uebo wktebvx nlapmp udhhxh uliqbm cklyyf jlzw xrmdlvx
+fosspck fosspck fosspck qyidyur hxnxmb dkpj
+rmrvlms susvos idw hzy idw tjgxbc lhgqxr tjgxbc uuq
+etjmbdr hwqe lnfwzni lnfwzni good eisci etjmbdr
+yqde bmlcc yuel vpyplss vyvhho kslgiu lllhc jtkijdj uclz hfbqsf
+tlohlvv tlohlvv bdqahw tlohlvv qavcqrn penia saafy
+lvtzyt qffe eaikhv eaikhv wbnl mdkg mdkg utfrm
+luowwk magp luowwk oyao oyao hsb yms
+gnxply vsdqum nprf jik axdp ariqjpc hjqcc
+izbo nkqkb xpqg pgxq qpxg gpm jxbkvu resj
+hsgyxar hvsl ner zzmcn lcpdvqn ern
+rfjlhu xkyh hafs cvvk drg vjsk mymc iab ycmlubx kpwemiw
+wlci qhhpr vhpr oyrili cnynh sivdso ldjya wilc ioiyrl
+cdfwd mbtk sienxui jsmxzo yxbeyl bybtc covxaq yuxn ktbvztl ktbvztl rcekjhk
+ptenhqv tzdt phetqvn mfkdz
+hmezeak pqvqld amsih jxqacc uferfyh nfqjsz rtuqdzz pohcx qia cpxho hgpqs
+iygny dluc uxqz nlujm xkdtlm xbdgepg jwn ohl wpfll
+lnqf pcxy cpit enp zpj lqfn oowgw yoxdff ohvcfcf fuvz qkpmb
+oydu jlscilm pzxen nmtdngu tslcupx ntdgmun uztpx nlhh jqn llsv
+euyx epn gyvg cwtoe ruyap yaurp uryap obbl ovo
+pgo irm ksrxe qotuygd afwh qfhzfsr wafh dqjbwce dzfo hew skrxe
+dpvel dpvel ipljjxs vrrsob iakey uheuu swxu qmnmn mpjkb jqrwfmv jozj
+sempz plzxqe qvyg sempz fejux
+cqgqvg zhqir rqzih vyu fmb mfb
+uejl kjh ayz dzimg yzafvg dem vlogg
+htfkd htfkd hwykmm htfkd
+oxvgq wtai rkyyxya ldkecdv
+lvlrsu rsullv pptnrwi slvulr vxrk dpzti
+gde ixwoz nnsx nhc nzi
+dsadkj qtgya wco psyondq jayad crc lswwm purrad pof
+nocibgs hxqdejv nlqxdpu dvzd
+jfaws aiwnjm tqjpgs fuiobz gwnemv hjevs xkbbgiq sakgv zmwpkuq grjllw
+xrr jwhtchs boaqkg wjhdr xrr
+vyapct tgw juzgwkz odddvof juzgwkz
+unuu kubdd dxr drwg
+qpefzz iemo fwa vhdcxx
+hseqy copss gytzub lxi mrxtwc hxqqdfx ijt kcy tafjs jit
+uevse rrq zmwyjfe xljx lhgnyzt rngvwqd
+gfvpyhq xpdhind eocgpiz ebs pcmsgjy swni iwns thspnh yvbzxz fgb
+hxr ehw ekfd ncxcs gxjmd oqszdjp fgu gwuoafw zumenf qltbw whzuxov
+wfc pawqo pim jxgt dtiwzil hdptivc slkazm htafjih hzheez rkk amy
+mgoatiy pkec ddvwyni zuya aqrcjes ubkaeus nuhhad upe qfem bpcc
+rmyeg qfq bia lzk fusqfb ltvgry vggr xaxi avwdkbg zhlzt
+zkjoeee dyi sxdwfqa irqljmw gek dgdb mrakr ddaznn zlh ajzzacf juv
+kmqcy pohbej hujdgao rsxfkn vlu
+scnpa hvl cybql lvh lbcyq msw deqqb yjpsndq
+ndhjooo dpf ziey jtjlc eesag ldhgoif
+tysbae wkpst kjz stpkw sil yetsba
+ghvlfq flhvgq tgkjie gqlvfh
+oimn vlmsljl ocala vokhrs odyv msn dzly wcky
+cfjwmh rpsdor bttnkg jxenm mwdk mer jgsusdz cslf
+ialvxk bvc qjfikr caw puhmmfl xpmsx
+tyoey egcf dijg vywd enued uxkshz nav bdrn hjugffi iobqwiy
+eykhxck shpfjhk vlqg alkenz kuj okxs oeth mqbr nfvqvkv xfvyi mboo
+zbw curcajm mel jxqcw mpdscxq rhadty zrddeh wmedc wkcwt yvwm
+iee hzeofmh pqlkkb azlam fpj hzeofmh ripi
+sawaqek oyoiwtb npq pisadk nnd bzgo wiqme lxnvn
+obqx ffiegn obxq for xobq
+zwway wwazy aqxg gaxq
+ebssilw nuscati mofyc sogyacc yujmdwu ehxsx qcaf udvoo nlcfaz eov
+vnbe wtzzjn bczyxt crmvas zujy kukq zujy kukq
+gvltk kgltv kglvt zflikic
+hby pium gut fjqn sksoqyq kcliapa
+tbonrr prf vga jqgw ulze ukfig
+zafixw hia omgwoi noeiox fqbket iviidgp bebune kwcuotp slvy wcx
+fjq cyecn fhxvj byv kojvj iaqd aaxva rkogp
+vqbbt sjmr mxu mxu rlfj yqhtzv cuar yde yrs sjmr
+iyxiyp auepgw dtpbyvu thuoai fpsfkpn bemgbsk lni ozy jogp xldyvvx fpsfkpn
+jtha ibn ahbkh xzxkei tql mycvmyh ioyw
+mpsc pvdiuu wqixxlo cqwmlrw cttoz lad
+srl xxlnofu dqf snxd zjlp htxzd
+fkv berlbyh kyna wkme qjzgh thpw frup
+irhreaj udkpbza qmgp ormlipa lbyuc
+empizc apcb ossmtj awk ttsgi bfoymzd ftx jkicph qqjv tywp fwzfe
+zaqkd ysn zaluvs rljdk ast fjp amjqr uabrya ufswzjg vcldkxt hzsmrbl
+qvy tqgnwj akibr tfjevhv vav
+mhe sxg hacoa emh kasf hid jklfy ijk dih
+qvwbenk akdctm jztmsx aqvpodu vmknns nck letcrk poba
+lhve kkvff iiixid vtsun uvgte mmlxk pgd
+gktphd aaoqwz lrvsuw ofcyvmi suvwrl dpqiol wjgj uqigjx
+tbp xoc lmz dyzlvp bjleh pxj xjp xbil
+gpzgvj tctszm tctszm pnp upqtmm rribg tctszm sllsbr
+hpm qvjnd lyqg bybpwn etz pwfigbg uqgrvpg cvniubo
+tpowus bdncyxg gmm ebfg zwoue izgkwtx gmtfeg xvudp xgmjp atrvn aqgl
+wlrxvo wvonohi owxlvr owhnvoi
+knyo aiixyi sjtqb kukhgv qkj qiuefb syhfc aoana okmot tdsmnoj eyzqjn
+szhto szhto szhto fxpsavu dtcz hnwqdvk iza
+poykme rboczge tuyiw sxr
+lpgbp bpmf aiqy exzqt gxdoow yjp fxwdmt eoklc jnps zbnbiwr ppvl
+huecy jjhyz pwcea ffofmj tts
+ahbmkw brz xdenmw mwexnd ncdxgf gcxnfd
+yhfnra vqljz bkyxzt vhtsyde ysaxt qbw
+gqhiej rofhmp soeebdp rcuiblb rcuiblb rrnh nses
+pxrwe suil iihzf lhcgmfm mqasxh ttpp kqitdyf cuabaa
+cxl cwsp qyseogj dimvv igsoxu ncrexla ubrvpp oum usluv
+rkmo jqqcdjb mobqcta pbcmoi afjlh mork
+nmohoeq fezpxh fezpxh yec
+yxlncrt ivi dajo tjpim tjpim
+hzhy rcjs uhyvwz tdpxlqw itoiyf
+ded apfmhe stfk ugyujv drwks zagqnw mbbzmvc aoupemq
+iezre wivdwif xzytxe xwytd vpnol pljx aot phln ztncw
+ozblu asda tkxh xqe pvijnl qwwh uvp bdhtgjt uynwtav cdz uqmvp
+eukgtsy kdfb bdfk tnv dfkb ewdemb
+rsf cxnk cid qsa zwk oetnggn
+fpq oim zetbmlk fpq oim xgv cbaj cjrqm
+phgldt fhmkc efkztj qidri vsv bvjf lfwfgm wfuoln toamg wfuoln idrs
+iuc rrdnk rrdnk asqhnz qxkigmo eeoim mmdtgif akk
+rfvsyy kopfhmd tnv ibo demeqm gxrxw hwk ukorln bep
+ialo eogif sxlj xfegx nanch egoif eymwt
+kttrpjq gbnyiat kptg oarewx vkmt gbnyiat szyokf
+tjll xviodi tjll efc rliugl wfbbpq wsqvdli jur tjll bguqyu
+uecm yzjhn vqf labnc xyaksj
+hjtef zzq ellr wtrodcg drwqo ernt uzx sqiokam
+izmh ddutl bdzft jvfthh
+ecr xqrp qlxstu kgprd gqvtwni mkughf bulabe bvoxkx
+jwsna vjwq swkycg cpp dvmyal xotxviy qkiva ffa eakwp fww yirri
+ufnl lpuxw rjki nggh ajdkpvo oeuaemy bjisma vsjzc
+ctxu aavlw rap fzxtcp msufn fzxtcp sdlaom vgvdvpc
+rftw cyf twyxi orifavd
+ogiht ertz wcw jnqdup phvp lbw
+tplpyq jeh aobamqe bvaim qptac gssi mkjbaj
+nmklyg iitx iczojzr vjspqb uooky uooky hjk
+ggnekbb bnebggk sepzjd fvqfgr
+wnfwrn yaiogv mbusuy cpbcgs thjea
+atndjc dbjgdz guedeay rasa kfhame pusuu dbjgdz
+xivzyml xivzyml eqsykxo bshvz xivzyml
+nfe ayx gscy ylyp oqyl isatnpx poaelm zsrw dpd eyrdjpq yllk
+feqktz mlm jhi yxigeu xzqa qwv yquxw emken jgqsp rojfcu
+ruvfcud poubal xswer hfhpyp guf pzgzoq pzgzoq jwgxafi guf kqzzlu apg
+rxwcsdc rxwcsdc ywu rxwcsdc
+dmgsey xrtx wldwyxz avi
+yxnqv ewlx fvif ozfcbxb zqapa yudqksk wlxe mjpvgz
+ozoa ozoa hwkbp ozoa
+qcv drtqn uqv kcsavgn ybzs tkw
+njmloq wapa srm srm ifurca
+ezm ccj rub yuaww xhee liikjee kcabgic sbgqx vrpyo pzmesdp ksvv
+hycyne raaksm nylsc lcpgn akasrm vxwoaum
+zhugs pqquitv bae lyozb fhij pcdcc bae rygsgm pqquitv pizz
+oxx bzk grpis qiqljwh svkn
+qcq qqc fzgn sqg
+lclad motw ukz zghp
+glr okzfs zgv ygsvv sauuog glr amxr vvmwmu khy eyh
+ukpxpy rgnqyaw ncm coeblf
+qdbr ortzo spvnrnq uomtj vffbeva
+miwar bidfxp eibo qyee
+yldec ghwj mxlemvi imac klkvmg fekxhp kevlzfr fcgnoq fncgqo
+hlm vlol qdic rltij nlzxfys rzpoh
+krpwspb yrosr hioqla dbpgzgu dvkvvc vvdckv lcjzb qbsbr acbi rtnk
+iqtvk jcldzuv smly whmnte mdwlse mkxw mfnkv mkxw kes owkfh
+iwcjmkt rnb bjcdjl furhzuu exs
+kjwu iuaj ixkujoa jzeau whpn
+tvj zrdy fwsbagh zrdy czuzum lxotprx wbohaai
+crsyzod jouf osxntw iwzzie bodu scze gjxn vgxvqo gjxn mmthykb
+dabjfb vjqz cvr gsymwoe qzpusj twvwhw gyvlqd kdrdkzm bdljp cvr
+vmswdz lgjsvxz yjkgqkg tzmjkfp uzbmwxe kuqa dzomt hep jjlibs oxvpvq cix
+iqgd btwdjd ncdrovj ltxqc orwhdlo orwhdlo
+nxro uxj ovgha elvzl xmlzssr wonimvb urecfx dbfn kope
+tbes cgyh fypswue fgxjqtd dxdrfm pzhnaeu kugspa
+eouzw qrpokyb fyhpb bcvfvze brdwey gpaa fpqutw pbqkroy axtc egamku gxk
+xdrovpt peeww wkcin suir gvrbix
+hgsjks juvod jtii iijt
+yaw hzifa wpagkd tgvmc iru yyeuy mgcvt fhiza
+lsk lks kls edypaxo
+tjz qjs mgoyd gomyd ztjbex nprwk vvw rtjsq quvf vuziqtb oygdm
+kftodz xua lyxt zfadf fgdwt zfadf xua ehwykd wniahd mqoarg
+qgiapb xptk iscyf zfspn qvrpva egufqte zfspn hksw xwxrs dkdruku vegfs
+wqifs wfsevg iwnjjpi oajju tkvhpl lemuw
+rzbmhso pbvb lfgpq fzjwxxh pqlgf rbhsomz
+ufi aiyd gxozgx hygjp dtma uughdc ojumcf yuadt
+caami tqzkvor tqzkvor tqzkvor
+vhtnvyx myxdywi mwpwq hjxadd qkcj vvytxnh dmbea
+jvjtcjg mbiwyad cup xkrfk puz uxpmutf rjxyxyn mfchc
+ocrak zprfbgu pjjzl zoehfkm xqn qki uxq tcv emknqjp wvmkas
+nxg myr myr vnfzpoy
+gwu ezt kbmeouj sxue cxax gcquz ieegnal xecusia vxf
+xermi xermi qporwc mzemns ticltnz ddpsstr ddpsstr slgbn
+xnujwtw bvzv xjwntuw unxwtjw
+tipo akp fkmcls wglmjq fnrtsv
+fan dfbya qrp lcvxqqu ldpm gucmeky mrzy fixaph rygneb ocm pjh
+ovtrqs ujmbnal geihpe mijhy eewuic toaxbp ipy tvb evlmrtd lbujmna
+lsmbwwd hvurk ihbuek hvoyq erzomhn gue lpq dihon dgzvst
+fuoshq hfrzeu zfrhue ufqohs
+icgwnbi gmhogxu gmguohx toixb hfwj haxlav hbe jdpxeyi xtgfi
+vfakk ioil hddqu sdztx hduqd bmiuyr vmas
+mcvjjhf sfgt sfgt lambvp dnqc pfecquk
+xgr omy bmoadg afbna mar nicpazd iveku zdioyo
+rpipon dwg wgd pironp
+fkyx wjefuy mfesst ztlf gnnceb rsbvuk ckilt kliqnm iuifcvu
+lmgzx oknwr wmttry luipa vcttj nuqdmy
+iota efrxkk daqzm certtoi nnvqrwz qrqgza tllwp efrxkk
+alde wqmdjy erh txrtqm zuljg hspbnrd pvsnebh bkue pvsnebh txrtqm txtthn
+hgggm rswwfpj uctzrv bylqeen dpbnw ostsjwn jtjiyuh ofxu mmmqlg ayhza opbgdrv
+qmhkh orbeokv agosach lhujcju jzpp wmxtcy jcxglu iuwmzrv xwkgz sxlzld
+dzcdm lwal xpujjm xpujjm lpfojz lqqcon qmqrg
+gmwugq ceslt rxcogaq jwkraq
+joxr brdy yixlou brdy lnr lnr
+wbut pxlsclt igigapq zeacg jxiezn hvws wwz ujpbl fdjtfjw opod kea
+tsodswf pufo zqrt zvcpu
+nyy mrqmg zkt tslzsf zkt
+hxywv lbmogd hhv npyzgjy whfvv mlfqjr ggjz owijo zmesslo gtvizw
+xzz dvpzxbd wxwlp cye rcqpgrr gynzo nhy gzpk fpfmb
+nhaakbv iazpdc yadqbe kmqm dffq lidnh cegjosw kgd hwivd wijj
+cwmdyf huoy awihev qav cwmdyf rdwck hahj pesfyk uoju zrirjdu
+qabl vwcwbb phnd xnp huuzwxl rukbp kod sfu ngcvgrt buncnfw
+regyd gjzfwf hpuv zmm vphu gwffjz
+rdf emo crsoeo bksetj aqfzm pphny
+opbmboi iakvj ymjwm vxoq qvox yafk zkch adlusz
+qhm jul zasv xhu qnhjwzx
+mjmyvd mezfuls upbdpzw awc qxta bzrx tjpjmj dxfyewc zorm
+bko kfokm htcpoqc liuvj xhmpcu ccqphot dthvo pfj dtxpmu xoocm cmxoo
+kxv eenns qhpfsvo gqoyv jzjho aoscl fetug agxmfea aygpt
+javmegf jlmt epdwy egfs hwv uszcqvn foixpz iukh dbuhqgs zgb
+zrex zrex xtx ydan maomp hqdhh mfvan broh wvwhqbu
+phatsot joipm pmniq arqzmbe vurl bgy iwbwk oyhngcv vnzbzgm bgy
+xprufgn vhca nrs abuh zwsxmhk mqrj tyslsij ojkdzom wepxg koodzv ypvyy
+vop nnpz mcod mlli ntyhz laqztb kauqkla gmrfte pcuhaci
+vrenj lypors prknc djbdkzv amofdx
+lgig lojnrw obusoc fkwe ggnv pydcraq bvdivl vev mrojjs rxa
+qeg tap jocwlsm vqxa lmjscow
+gptlrgq vdasm erdc oparmw
+rgbsa nacqhvm pczf anupcp upudwgp
+jbnobi ifhzrd ihrkkf osw wos lrnwv
+aiuntpl fcxpmz fplacs fplacs tipm gfotkx
+fsbnd qoc ozmbi rqv fmbxh tuso kfoxvjn ocja zzs jwplx
+muaklvq ghozoxh nwxbh mgoou ufptl ouhh reyuf jougckd dgprag
+gwbnqwv dtrd mkzxinl erxl zmfa skuu crxmp wwao wwvdpk nxbn lglzy
+qeejk wvnypc yfzyfcr eeqkj
+nmcp fmkgfyi grfthau azw
+kkallxz rjke ukbt ixkhfb bktu jkre
+pxj mnwe djrjde gpsc enqz pdbydx cktfs jjeddr
+mgplj yyunujc vis odee ccesa yyg yjcnuyu doo utse
+flyy juvxomm vcdcyva lfyy ozxnuzw bmgns
+kmsypi zpbyiv rrycnb qos sslwyeo jgbyv njltzt fuwk nwfb ozcf xqnf
+sdcvgmy sdcvgmy hzv uyq sdcvgmy
+fyox vmgxahj ywaxbmm ugy ruwc mys yrjwr ozsxb vaq
+gjpyc sgdn kgm fbvq cziui nzy bwu ezjkkus jrag
+kxcr tgjxss xkcr bembjv rbbiw bwbri
+dcz rrhvdc zbonfzy ubjt
+rvq yjnzswt vatkopb xlj dwxig dqlt qts iva
+lylclc jptz rbidu lbt byxk
+lwre vwriwh afixsi vwriwh
+kmvbflr nfptw fbglxh pyas dxmn hemf segaz zrs
+dvbey zmj xfoi bma udtxhb
+yryng geiwgz bbrvjp ala
+olzicp olzicp qhhslry olzicp
+exf xdmwh xdwhm nhjsssn rmlkdb excguia fex
+xkwgeso htys sjdk jizciy gjjl phgqdjh wzdb izew zcrumu llxfp
+frkohf oifsm aisebkt ijsfkot ukk
+koqf xvoior tpe erfpnp npnx
+sneysk nsxki wpmhd mdor akrpvgz moicncj sbsj owfhj exw
+oqqbvk xztx gtxlms icmo
+lfy ltq dlzqlvi ovbrsa gzm nhcjq umbtgm nhcjq
+iuopdzq cqaeuu xuzngq kxlx laml slvvr frtml tvioiez vyoomw xickbqh
+ckahov mepeku gtaf gtaf
+tlto cnnz kzsbkjo kzsbkjo
+kqf comkf dvrkyl jdsqi rnwvb vxvd pok
+hncq xcx yuykfs egrruvw yqh smcou
+tywyq xeq cix yywqt jhzptci hybcoe
+zsw zsgot wnu sumd azmuos qawjaz rpf zkxgwdu iom igh
+vmxmelt gll ysbbt yboqoyz ykdglk cnypf otn owsz ipn epfeka bkmy
+wxjpce etzyavi whb sxzft bfu dgwnbgc nfw sxcteis qqpk
+kofv dgoyme vlza oxhbo lrqt uic tvfqiyy iaqm afnk
+nsmpg wkibdcz dxbw tlxzm zgwe nqwjji eacbhn blk
+shlgws eencr rtufah kjyvqw transt ecsq otbf
+obs xsjceex ffqj sob djpq jcda zlskve
+rfqtle klarp mtzrx rasr eisqovk rpt vymibt zwrif ilsnd
+ldu ffd ldu tizfexr fwpmyan
+flxso tzec pzn flxso kzdouon tkvkj
+tvd arh qywql uev btvnpm
+wtwx kzafvk ybyzmhv mdbrphy vamlvr gbxhod tyulba krcqj ikotmla qfhpa
+bnfin ebngj agfdfzu rhjtj aaqzh fsyp nilar uwurjnu hhmso hhmso
+uanmesj vshh syosjdt xkormf syosjdt ifvytwl qnw vshh jkg
+epyzcn pgdxgye lecnx nebg jzdhvge hfy imiyft
+zonbcnv vuvg sxtuty zdhmiow lmud cuegzg
+bxgft mxhzrh unqd pqpsnce khykn qlb oujdxpq pxrd jzxjuxr tij
+qss mqirowz ijjswjm jjer utwn kuedqxx bxshuok qkfag dmfwcr
+jgln zdohd xitfbge xbokj xxeuv wqhvhjo erg cua fhc mhwy
+euo ousht ipxt tpzq vnbmlo wvbjpb yjg bwpjbv nzvsea aerhsqv
+axhmi bcf zdx vplso xhmai qsk psolv
+ydnpmyo pfba zmo nat ykwxvm ydnpmyo rtd uuvqqr hcfccbd rtd
+ytp guw ydmyf rww oucmpf gemhpj labc
+edpbefn awgg qzpe aat cupig
+mmi ghdaoh ibx fbyj gge vmmssen nplt mmqcra omcvm uwa fxypxfc
+kjaw mtijne cfmsigd zwcjjd ajxjlqr tbp bnilc
+fse ele vcsyiv bfe udny vznrao mgrjfgw
+hadl nikvvpf gmdg bkmgt ugj
+xkis qmr cgz nresp gms zrii coxkke vfsqiil
+wmicbf bkk wcwklfg vpcbeg kfmjab vabc dax tnao tnao fvvzeyq fqm
+bct tvj tra soo stqao kqua ikupoy wulcu nauxkkb pvqxy bfu
+wpz txdduxq gaehfki kxo lvjzpxu iqon swr eyihl nbbec
+fuphnbj bdtz huwu zdtb ilgzpa uyaut vpy viff tuuya
+cvusbh bgy apsao qsupha
+jtzlbd ljfvh wkjrw xsah sef jygb pqym zbcwok zdmug qpym
+hbibuax iorqc dqjrs daeb iorqc qiw sagyt rkc sagyt khbr
+shz mgn pqrdbm jvace gfhnq ann zosq wdwzmuf kswsg dzt brlavyo
+qiw cdvwds dckpruy pybjra lfvgfn cwj bajtud pojehb rzrzvwe
+txfyk zkgeeu zkgeeu zkgeeu wskcv nccoz
+eettnxq gbgr uiqonyz wqtgs ozfjbn gbgr
+svd thmmr rbbtxn sxkq isxlnhf tamdlbe bqrgvu nmpvlkc spko
+qmn rspbjme ikjddkq kdb ugpegi egipgu
+ufffijo revqpep zfw kwd pnya blqo rnntzx anpy
+piaeyf vbeye uuqd vbeye
+hamd hap ekk lgla twto
+isniinr crz sjpmfxn uskwj
+lzeofk tavbq ijcglqy lvy jliqcyg lwlip
+uhyyyw itlrf tdc iabeocv jzwnjh vqxll nefze pyrxmx eispxnm hzlksce
+ucuh mlam bhyej rgzkew ctbo iswqnvg
+ytmb toppqgp ytmb gqgpr gqgpr vps ebv
+eavn atkqltv bjvojs kaskr vqltakt uiktr xglc eyb rkkas fhnf eaorqm
+jmfipc ujggeh hdxpfa xtab ydkibi ycxn ujggeh icheh vpznael oprbf
+xazqxg khlemu awh uwz vhnixk vdcty hkk
+gcl kayi hfozask grpseyn zviy tzoum qywnr wqkhq
+ctrrcpw wqfbylp wqfbylp wqfbylp
+gtk lqohf hqeaku mdj zrfkmxn bcqgf msing
+luhpel kexokpx vojap ldaexs bbbtz
+oimnqb esg zyjmbfh dfyhcf khpo zjtgm yelztbs ugj zjtgm mxro xyfxpk
+dgtsu vvk wwfugbx aai zlxab beyxcg bpx chc bnxui
+irrwbo orwibr lqt qtl tqknh
+ihjsg ihjsg powwy pycyqo ihjsg
+xdcu outh fnqrc eihkss bdylm sjunib eihkss
+jpnw ycimse rffu ismyce uhxl feai
+yyodnh dvwshkx vulh pvxj ydhyno hyodny
+vuuweg pfguvyu orhei orhei wrm amkr xecja lmnveth
+wriwe xgtnvj tdmxf gadtqh bezjvz lifu
+euft tchbm xmtlwji tchbm
+cfi zudn zludl pwiu axe psed
+dbtfwf ajxcudj uaxdjcj dxuajjc zouyy
+fmycmej bqhe jyfecmm kkrv kcdvjoy
+grtb uzs rkxzt hivhic brtg hwyc lsl iivhch qbcp
+ymn xfpka hqm sldz dblvsoe
+qrcapma hntgmy difrkpk difrkpk xlsph
+flvqh akcw boxrz ywhq boxrz esnxzv boxrz
+zrvh jskaw mfs fkj
+abveb qxfnlfq abveb kbwiyvd abveb
+pgarl nbfrenx rnxgx bdlkix liltdm dzcokeg fubupcg iwp xfayp obfaz nevfw
+nuhvaci blyv fcsp adlanka sjy syj ysxl
+avwakn dkoya yzuszuk lqrr oqfyd dmgbhd lqrr
+pxa mcvtoug nlweso yffqc dtuagcd ovvrkz ggfhw wnlseo bpqbn ohxzs rxzo
+djkcl kbgyfir ogquot uoqotg jtmyd ohudvle xrnbt yvsln wykqt hntc xlrhqrb
+ykt tkxfmd exas kty
+zebstke msbbndq itmli ubexmht vekvd xbmb iajbj wac sta
+ptdg oftwo goiulah tfmsrqs jffxvnv ozaluj qlhqjy wyffa
+xeq ezmlpw xgno xorvfo yzq vwif wsi
+hdove hqbzhu pjrxlj uafuh rizlb advmkca
+jzk ddoisdh tfjh yuvikps ixpkf hnu
+kixa djx uksr ogxty dxj clda ukrs
+xgiy diwbvn vphdbg qnelyz tqptqig lenyzq ecsswj
+alx awj fpasmmg zukuh qaanvb too nvskuk too gnria
+suo suo brw nazq suo dqv
+tan uxiz oqa xyezcd lsaicjr bosiak rmmh
+bidpomf dimcj qekero wbrc lewt kmgmlao
+bciacj eye lxfpef cbdshd dhdsbc qwnhil iuokc
+zduefht lrgfjn nclksm wpjpjr hkeqd oprsjcw
+chhdr bram swdfjr yikqra xkzsloc otptp agec hhdrc uofljf toppt wpbyrwo
+bwlpb nishr knnrysj bvr ftnb iedskch weo
+czo hsfp wblh cru kzalun intt
+jvob rppz rkwv hgyhrqg
+sgo hued jnygge izf ztan kjgpcn fagff jsi ijcxzoi tgqjjp tgqjjp
+ltjq zidjy rfmy yevuaa nlhfyg xytdtle wsqvzzx wfflboo nawhv golhf xhsti
+bmtzlml xcbsquq vnfsux voep lkss ioim
+ntfffh gcncwu mmymn wkwlswa gcncwu iaeyumz
+kcgdm rbaau cwsoya pznnnn xzz zbbdlhw zxuelq xzz pjeq
+xrmnuct kwvykx khxr ioua xnmtrcu xrnctum ujq imnt ecee
+xjsgx fby fby fby ggtpgdm jqvuj qshewki tkml ymsazcq
+sdbyhwg kewtrte novhdcp wbuaoh dtytgtx zez whygbds hpg
+tjvaqo yrycda yrycda ldbp yrycda
+kloi tmsocmx dza sqtxc wgevs zlevs vtm
+ftnx drvdm ryjfdgw nerynh cwfjpa mddvr
+wsqjyn svg ncw aesn hvuq vybajti aesn bql atxhp ipu
+eye romgxj gumuke jwi jrf dtt kcj wmg waw
+ptltud oymklv fgnmbc ete apanovb vpt vyospi
+clkguhu rbxs lxtnmy ferdx qbmrpg pvojnj zbcffbp
+itngp dvtlq fzxp cxrf gbxxqp aafls pfe bpxgxq
+nmikrui ddsq srfilr gnuvghu mwnacz nlbdm zcjm uylgev umzu mftz nmikrui
+bow jmnxyen bow hvz
+lksibxk lefzh lksibxk nkxsi nkxsi pldvhk
+osjlzns pihvr zpeu zxjgjb xplykfk xplykfk
+hajmfss cardd kaddjw uicfde taue
+rgwdjra sgifh ggt mpzx usghkos oob fvzx ghnyxr sblcif
+dtu gnihpry kjdpiny xvax itmluk fxvgaap bei xuq wzcy rhb hailtgo
+wwob ueldq ueldq glxc umimwv onu dxhmhis ebottoa lnysfiu
+zfbyi eyq etaj idpbkf
+qshcfjb ozzqigv raztm ymcv sgivwoc kightf dcaglk udah fdm
+jmxr jrcnck enffwfl jycc jmxr cylnigo enffwfl
+bkslhv tykqw tykqw mbeqrbt tykqw
+vogf nhqltpt nhqltpt vogf kpc
+ryayz ddktu rfhkmx xok xninjcm ijcrw fxu
+cmezfj zaamjrs whlcuoo mug lcaqhkb ymkdci qexa onhgk pgy
+hcrcok qri fki wbiog ptj pmgtdt
+xsl mpfxwbz bmzxpwf hrysu bmfxwzp xfja
+gybzho ktokndy rzkbr jcnp ahicq weccg pgrodkt che vaglyn omhmpo
+vdv bngjox srs faymg xrmf enseu aygfm gvsd
+nuzi xodkbag eevovl bfjuv nuzi xmejqn
+kcswegw bpa dgil insf insf
+stg tklrut poi knurfpf
+pcs dgirfie yep lvkfk ype hntt athvad clfybsq ofjhegj epy qwawns
+wjtpgd wjtpgd vxnapp mwyfsm vxnapp rvcswcs jksa
+ckzslrg wdzeimw cqhp nfgk zgukvd yyt tra erkx wdzeimw
+hsww avl vkmzej hsww
+mum oczj jfew rag zjoc wjfe yqynjqt cbkcsgo mri
+vjhfqdi vjhfqdi npfa pzdmy utlyw bwvbfm nqdv iiap ygpky bwvbfm eocya
+ewkqi ckb yviuro mqz vtrdam yzkqzv ppbj lhmj blkafo juxvwke lvewc
+ljrewgx sutnb hfsavbu jofr ltml mjzkzz nmjii sutnb eonegt
+cxzv nepyrb wmejdo vwqi aeqys
+sbx fmne obzdz rdnfb gmb sbx ykcae hbzom ncwju rhpiao obzdz
+lsgfun cbmfjwk fya ktzxbwt
+ica bpsk bwjwkp obloxdx uwoqdo bnnhjuc tlsx qtaacp bdooxxl jamy ade
+psus wmtkg ikvfx fkvesj upqlhfs ueje nyt abxvo
+adlbl hzskbrp ooht nps
+wtcgnvy nvqtvx tvgnycw ntvcygw kkxcp zyjmpbh
+xfxww xsddqe ewvmgw qxqwy wpabtz ppe zuiw zubcc onaqii
+kkaeec xhcakul wrrvi dtlqfy ahqdilw bnt gwimw espaivx nam yfv
+lxz jtc nkwgz nbgsao olsck emtltf xidwcvm lcjxq
+eav dzh hnbp hnbp yeg
+egaq yvat kavsige csar zsi sptai
+pofijc ibdnoe caoazp azlnjk dqp chik lowll iby gpvjv ohm
+ors lexk zcneaj rmesx jman uqkb kvkq zfufmn
+qgsyzxd hlm juerg ortfzw hxjzg
+fxwy lcoc fyxw pzhynp yfn zdzrz
+datmws ckwghgr gbtyf lqrpfgl mbgpd dyjilr fgybt hxpg
+mxw facxdnu wxm urltwtf qfo wtpwrj
+esa srypq jauwv dpm wdgqq hrke icvudq bdmubb ellhfjh ttpjjd gxmg
+gvwvqwj cbzzuvj eckube adqinpa djutlue wcpw vrt ucqwu ekruwsn
+fhj fst zmtb yhwk dxlbozs fcb vjvuxin dxlbozs rixdvu
+egfoep cvq icd prwj icyg
+aojaa ezmcuf udreyi bja cyrtpl wjl
+gjeka bsbufp tbqqq vbmnqg sfqtgac odhq xzsxt
+yse gujdr ugjdr sye
+tax hntqw phf eixjwfh qkylnu nkyuql ugsuj
+wyh egum zizhfc jrq htbyug lop dsu
+exh vfdoosj ajrna jbiaz lqsgvks xklqgjv abtmdud
+juqc ormfa sab tucsfln detqfo feg kifsion juqc ovhra
+hvcrh oddhme omzmu vmy she xulvfa fecmgi
+ayo gspge nkmy yblsj lrsre nkmy pwocjz gdexqqx ovovm
+acy sqcz ijl htt yjsi rly vea bck
+bniafe yore xnh rkcfd hxfuzw xlr nkzmmcs ekwggiu kgoboi wfuzxh hwfxuz
+weq crkeq cccphe dtozviy kzkkdr yku cephcc ctq zbau dewpi
+vfla rzpl bnmx uvggon foivrb fval
+ziaove lawkpdn ddwl sxj krroj rqmffxv babb
+bdw dsifr kuueet hugddwt piz dwb sjixveg kmsoknq
+czl feyxf soyvbj tnmpjn kklwi akx nqepntc
+nrmhc tkkn jrxgc jrxgc tkkn
+ufzn mrhiapi qrme kjlf qrme xpp qrme loyzizz xqm coli
+qvaoye mysv ydfxr iixrw
+dql tqarux fxqfn haoinu lyati xml
+kyve obatly dgfjt fjz sqrz xlbst lgwlt zovih aepy otrpl oifid
+ymawam afgye lcnpkmv feilfws vonseh rxrdco
+tqij kuawg dmova slds imdtb sjsafo ffkzzl pxxenva wuakg efbgx
+yrwoaos vpw ijjpua jnbxl sev yvgdxzr mpqa vpe lboh sev
+krwdtd uglxtcz mljcgdk lqj fgpfle nuui cqk exr nuu oyn
+dwd nwt idhclm vgkh rpubq wybhapp
+hskhgpy gzvz jztbr jwv vcx vdjmnjr jrsp
+ikml ceuhcng biu zoo gra bnnforx abzan hwsmd lmki tsl yvogo
+kqfc younaz azvgfz gesajr tmwxvyb vmcdu dclwh rfjwhic slfym
+pbrhjml rsacryg jga qvgks neh fcq qmi mwb juezk mjteeg alkb
+pcj ujstl fkrqm eeczrle hbkcvm upbo mrb qrspjt
+jbq rrk xjl rgokbnx hor ogg szxqu hysy vqj piorq wtrtrdk
+bnq ntvhcrf vrm puer kde xaxkja sfxgjf
+pgcicus hqeqkkx xqekqhk qqkxhke
+puquxi hmeaehh oxe tasipw qzyg hyvy wcmpwe
+hvs fxq wvfy zjepsl dvrfxnc xnvg
+xle crcuc qkhnv crcuc oedez bjw pmwq
+xzzpiy cjwss jwscs apb bpa
+ydjhhf yeltadb lwi cjdcb ovaox xrdm vkxub
+zax xza admbc lvpzfeh auxn rwasj
+kebx eild nrskdr meja jxczomh gcne

2017/05/day5.hs

@@ -0,0 +1,36 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+jump :: Int -> [Int] -> [Int] -> Maybe ([Int], [Int])
+jump n back front =
+  if n == 0 then
+    Just (back, front)
+  else if n > 0 then
+    case front of
+      [] -> Nothing
+      x:xs -> jump (n-1) (x:back) xs
+  else
+    case back of
+      [] -> Nothing
+      x:xs -> jump (n+1) xs (x:front)
+
+countJumps :: Int -> [Int] -> [Int] -> Int
+countJumps count back [] = count
+countJumps count back (x:xs) =
+  case jump x back ((x+1):xs) of
+    Nothing -> count + 1
+    Just (back', front') -> countJumps (count+1) back' front'
+
+countJumps2 :: Int -> [Int] -> [Int] -> Int
+countJumps2 count back [] = count
+countJumps2 count back (x:xs) =
+  case jump x back (newx:xs) of
+    Nothing -> count + 1
+    Just (back', front') -> countJumps2 (count+1) back' front'
+  where newx = if x >= 3 then x-1 else x+1
+
+
+main :: IO ()
+main = do
+  front <- map read <$> lines <$> getContents
+  putStrLn . show $ countJumps2 0 [] front

2017/06/day6.hs

@@ -0,0 +1,35 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+import Data.List
+
+distribute :: Int -> Int -> [Int]
+distribute _ 0 = []
+distribute n len =
+  map (+1) (take k baselist) ++ (drop k baselist)
+  where baselist = replicate len (n `div` len)
+        k = n `mod` len
+
+redistribute :: [Int] -> [Int]
+redistribute xs =
+  zipWith (+) d xs'
+  where n = maximum xs
+        (a,_:b) = span (< n) xs
+        xs' = a ++ (0:b)
+        d = let l = distribute n (length xs)
+                k = length xs - length a - 1
+            in (drop k l) ++ (take k l)
+
+findCycle :: [Int] -> (Int, Int)
+findCycle xs =
+  aux 0 [] xs
+  where aux k acc xs =
+          case elemIndex xs' acc of
+            Nothing -> aux (k+1) (xs':acc) xs'
+            Just i -> (k+1, i + 1)
+          where xs' = redistribute xs
+
+main :: IO ()
+main = do
+  xs <- map read . words <$> getLine
+  putStrLn . show $ findCycle xs

2017/06/input.txt

@@ -0,0 +1 @@
+5	1	10	0	1	7	13	14	3	12	8	10	7	12	0	6

2017/07/day7.hs

@@ -0,0 +1,60 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.14 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Attoparsec.Text
+import Data.Text (Text)
+import qualified Data.Text as T
+import Data.List
+import Data.Maybe
+
+data Program = Program
+  { programName :: Text
+  , programWeight :: Int
+  , programChildren :: [Text]
+  } deriving (Show, Eq)
+
+parseProgram :: Parser Program
+parseProgram = do
+  name <- many1 letter
+  skipSpace
+  char '('
+  weight <- decimal
+  char ')'
+  option "" $ count 4 anyChar
+  children <- many' (option "" (string ", ") *> many1 letter)
+  return $ Program (T.pack name) weight (map T.pack children)
+
+findRoots :: [Program] -> [Program]
+findRoots xs =
+  filter (\x -> programName x `notElem` l) xs
+  where l = concat $ map programChildren xs
+
+totalWeight :: [Program] -> Program -> Int
+totalWeight _ (Program _ w []) = w
+totalWeight xs (Program _ w cs) =
+  w + (sum $ totalWeight xs <$> (filter (\x -> programName x `elem` cs) xs))
+
+childrenWeights :: [Program] -> Program -> [Int]
+childrenWeights xs (Program _ _ children) =
+  totalWeight xs <$> (filter (\x -> programName x `elem` children) xs)
+
+isUnbalanced :: [Int] -> Bool
+isUnbalanced [] = False
+isUnbalanced weights =
+  not . and $ map (== head weights) (tail weights)
+
+main :: IO ()
+main = do
+  contents <- T.lines . T.pack <$> getContents
+  let programs = map (parseOnly parseProgram) contents
+  --mapM_ (mapM_ (putStrLn . show)) $ programs
+  putStrLn "Root: "
+  mapM_ (mapM_ (putStrLn . show)) $ findRoots <$> sequence programs
+  putStrLn "Unbalanced: "
+  let Right programs' = sequence programs
+  let weights = zip programs' $ childrenWeights programs' <$> programs'
+  let unbalanced = filter (isUnbalanced . snd) weights
+  mapM_ (putStrLn . show) unbalanced
+  

2017/07/test.txt

@@ -0,0 +1,13 @@
+pbga (66)
+xhth (57)
+ebii (61)
+havc (66)
+ktlj (57)
+fwft (72) -> ktlj, cntj, xhth
+qoyq (66)
+padx (45) -> pbga, havc, qoyq
+tknk (41) -> ugml, padx, fwft
+jptl (61)
+ugml (68) -> gyxo, ebii, jptl
+gyxo (61)
+cntj (57)

2017/08/day8.hs

@@ -0,0 +1,85 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.17 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Attoparsec.Text
+import Data.Text (Text)
+import qualified Data.Text as T
+import qualified Data.Map.Strict as Map
+import Control.Applicative
+import Data.List
+
+type Register = Text
+
+data Order = L | LEQ | EEQ | GEQ | G | NEQ
+  deriving (Show, Eq)
+
+data Operation = Inc | Dec
+  deriving (Show, Eq)
+
+data Instruction = Instruction
+  { register :: Register
+  , op :: Operation
+  , value :: Int
+  , condition :: (Register, Order, Int)
+  } deriving (Show, Eq)
+
+parseOperation :: Parser Operation
+parseOperation =
+  (string "inc" >> return Inc) <|> (string "dec" >> return Dec)
+
+parseOrder :: Parser Order
+parseOrder =
+  (string ">=" >> return GEQ)
+  <|> (string ">" >> return G)
+  <|> (string "<=" >> return LEQ)
+  <|> (string "<" >> return L)
+  <|> (string "==" >> return EEQ)
+  <|> (string "!=" >> return NEQ)
+
+parseInstruction :: Parser Instruction
+parseInstruction = do
+  reg <- many1 letter
+  skipSpace
+  op <- parseOperation
+  skipSpace
+  val <- signed decimal
+  skipSpace
+  string "if"
+  skipSpace
+  condReg <- many1 letter
+  skipSpace
+  condOrd <- parseOrder
+  skipSpace
+  condVal <- signed decimal
+  return $ Instruction (T.pack reg) op val ((T.pack condReg), condOrd, condVal)
+
+executeInstruction :: Map.Map Register Int -> Instruction -> Map.Map Register Int
+executeInstruction map i =
+  if cond then
+    case op i of
+      Inc -> Map.insertWith (+) (register i) (value i) map
+      Dec -> Map.insertWith (+) (register i) (-(value i)) map
+  else map
+  where (condReg, condOrd, condVal) = condition i
+        curCondVal = Map.findWithDefault 0 condReg map
+        cond = case condOrd of
+                 L -> curCondVal < condVal
+                 LEQ -> curCondVal <= condVal
+                 EEQ -> curCondVal == condVal
+                 GEQ -> curCondVal >= condVal
+                 G -> curCondVal > condVal
+                 NEQ -> curCondVal /= condVal
+
+executeInstructions :: [Instruction] -> [Map.Map Register Int]
+executeInstructions = scanl' executeInstruction Map.empty 
+
+main :: IO ()
+main = do
+  contents <- T.lines . T.pack <$> getContents
+  let Right instructions = sequence $ parseOnly parseInstruction <$> contents
+  --mapM_ (putStrLn . show) instructions
+  let maps = executeInstructions instructions
+  putStrLn . show . maximum . Map.elems . last $ maps
+  putStrLn . show . maximum . concat $ Map.elems <$> maps

2017/08/test.txt

@@ -0,0 +1,4 @@
+b inc 5 if a > 1
+a inc 1 if b < 5
+c dec -10 if a >= 1
+c inc -20 if c == 10

2017/09/day9.hs

@@ -0,0 +1,38 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.17 script
+
+import Data.List
+
+data Stream = Stream
+  { depth :: Int
+  , score :: Int
+  , ignoreNextChar :: Bool
+  , garbage :: Bool
+  , countGarbage :: Int
+  } deriving (Show, Eq)
+
+processChar :: Stream -> Char -> Stream
+processChar stream c =
+  if ignoreNextChar stream then
+    stream { ignoreNextChar = False }
+  else if garbage stream then
+    case c of
+      '!' -> stream { ignoreNextChar = True }
+      '>' -> stream { garbage = False }
+      _ -> stream { countGarbage = countGarbage stream + 1 }
+  else if c == '}' then
+    stream { depth = depth stream - 1, score = score stream + depth stream }
+  else if c == '{' then
+    stream { depth = depth stream + 1 }
+  else if c == '<' then
+    stream { garbage = True }
+  else stream
+
+processStream :: String -> Stream
+processStream = foldl' processChar (Stream 0 0 False False 0)
+
+main :: IO ()
+main = do
+  stream <- processStream <$> getContents
+  putStrLn . show $ score stream
+  putStrLn . show $ countGarbage stream

2017/10/day10.hs

@@ -0,0 +1,41 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.17 script
+
+import Data.List
+import Data.List.Split
+import Data.Char
+import Data.Bits
+import Text.Printf
+
+twist :: [Int] -> Int -> Int -> [Int]
+twist xs len skip =
+  end ++ start
+  where (knot, keep) = splitAt len xs
+        (start, end) = splitAt skip $ keep ++ reverse knot
+
+twists :: [Int] -> [Int] -> Int -> [Int]
+twists list [] k = list
+twists list (x:xs) k = twists (twist list x k) xs (k+1)
+
+hashRound :: Int -> [Int] -> [Int]
+hashRound n lens = (drop rot list) ++ (take rot list)
+  where list = foldl' (\acc (x,k) -> twist acc x k) [0..(n-1)] $ zip lens (cycle [0..(n-1)])
+        rot = n - (sum (zipWith (+) [0..] lens) `rem` n)
+
+sparseHash :: [Int] -> [Int]
+sparseHash lengths =
+  hashRound 256 . concat . replicate 64 $ lengths ++ [17, 31, 73, 47, 23]
+
+denseHash :: [Int] -> [Int]
+denseHash h = foldr xor 0 <$> chunksOf 16 h
+
+main :: IO ()
+main = do
+  line <- getLine
+  let lengths = map read . splitOn "," $ line
+  -- let a:b:_ = hashRound 5 [3,4,1,5]
+  -- putStrLn . show $ a*b
+  let a:b:_ = hashRound 256 lengths
+  putStrLn . show $ a*b
+  let h = denseHash . sparseHash . map ord $ line
+  putStrLn . concat . map (printf "%02x") $ h

2017/10/input.txt

@@ -0,0 +1 @@
+192,69,168,160,78,1,166,28,0,83,198,2,254,255,41,12

2017/11/day11.hs

@@ -0,0 +1,56 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.17 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Attoparsec.Text
+import Data.Text (Text)
+import qualified Data.Text as T
+import Control.Applicative
+import Data.List
+
+data Direction = N | NE | NW | S | SE | SW
+  deriving (Eq, Show)
+
+type Path = [Direction]
+
+type Coord = (Int, Int, Int)
+
+parseDirection :: Parser Direction
+parseDirection =
+  (string "ne" >> return NE)
+  <|> (string "nw" >> return NW)
+  <|> (string "se" >> return SE)
+  <|> (string "sw" >> return SW)
+  <|> (string "n" >> return N)
+  <|> (string "s" >> return S)
+
+parsePath :: Parser Path
+parsePath = do
+  path <- many' (option "" (string ",") *> parseDirection)
+  return path
+
+step :: Coord -> Direction -> Coord
+step (x,y,z) dir = case dir of
+  N -> (x, y+1, z-1)
+  NE -> (x+1, y, z-1)
+  NW -> (x-1, y+1, z)
+  S -> (x, y-1, z+1)
+  SE -> (x+1, y-1, z)
+  SW -> (x-1, y, z+1)
+
+finalCoord :: Path -> Coord
+finalCoord = foldl' step (0,0,0)
+
+allSteps :: Path -> [Coord]
+allSteps = scanl' step (0,0,0)
+
+distance :: Coord -> Int
+distance (x,y,z) = maximum $ map abs [x,y,z]
+
+main :: IO ()
+main = do
+  Right path <- parseOnly parsePath . T.pack <$> getLine
+  --putStrLn . show $ path
+  putStrLn . show . distance .finalCoord $ path
+  putStrLn . show . maximum . map distance . allSteps $ path

2017/12/day12.hs

@@ -0,0 +1,39 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Attoparsec.Text
+import Data.Text (Text)
+import qualified Data.Text as T
+import Control.Applicative
+import Data.List
+
+parseAdjacencyList :: Parser (Int, [Int])
+parseAdjacencyList = do
+  node <- decimal
+  skipSpace
+  string "<->"
+  skipSpace
+  neighbours <- many1 (option "" (string ", ") *> decimal)
+  return (node, neighbours)
+
+dfs :: [(Int, [Int])] -> [Int] -> Int -> [Int]
+dfs graph visited vertex =
+  case lookup vertex graph of
+    Nothing -> vertex : visited
+    Just neighbours -> concat $ map f neighbours
+      where f n = if n `elem` visited then visited
+                  else dfs graph (neighbours ++ visited) n
+
+main :: IO ()
+main  = do
+  contents <- T.lines . T.pack <$> getContents
+  let Right graph = sequence $ parseOnly parseAdjacencyList <$> contents
+  -- mapM_ (putStrLn . show) graph
+  let cc0 = nub $ dfs graph [] 0
+  -- putStrLn . show $ cc0
+  putStrLn . show . length $ cc0
+  let ccs = nub $ map (sort . nub . dfs graph []) (map fst graph)
+  -- putStrLn . show $ ccs
+  putStrLn . show . length $ ccs

2017/12/test.txt

@@ -0,0 +1,7 @@
+0 <-> 2
+1 <-> 1
+2 <-> 0, 3, 4
+3 <-> 2, 4
+4 <-> 2, 3, 6
+5 <-> 6
+6 <-> 4, 5

2017/13/day13.hs

@@ -0,0 +1,31 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script --package ghc --package text
+
+{-# LANGUAGE OverloadedStrings #-}
+import Data.Text (Text)
+import qualified Data.Text as T
+import Util (filterByList)
+import Data.List
+
+caught :: [Int] -> [Int] -> [Bool]
+caught = zipWith (\d k -> d `rem` (2*(k-1)) == 0)
+
+severity :: [Int] -> [Int] -> [Bool] -> Int
+severity depths ranges catches =
+  sum $ zipWith (*) depths' ranges'
+  where depths' = filterByList catches depths
+        ranges' = filterByList catches ranges
+
+findDelay :: Int -> [Int] -> [Int] -> Int
+findDelay dt depths ranges =
+  if not . or $ caught (map (+dt) depths) ranges then
+    dt
+  else findDelay (dt+1) depths ranges
+
+main :: IO ()
+main = do
+  contents <- T.lines . T.pack <$> getContents
+  let depths:ranges:_ = transpose $ map (read . T.unpack) . T.splitOn ": " <$> contents
+  putStrLn . show $ severity depths ranges (caught depths ranges)
+  putStrLn . show $ findDelay 0 depths ranges
+  

2017/13/input.txt

@@ -0,0 +1,43 @@
+0: 3
+1: 2
+2: 4
+4: 4
+6: 5
+8: 6
+10: 6
+12: 8
+14: 6
+16: 6
+18: 9
+20: 8
+22: 8
+24: 8
+26: 12
+28: 8
+30: 12
+32: 12
+34: 12
+36: 10
+38: 14
+40: 12
+42: 10
+44: 8
+46: 12
+48: 14
+50: 12
+52: 14
+54: 14
+56: 14
+58: 12
+62: 14
+64: 12
+66: 12
+68: 14
+70: 14
+72: 14
+74: 17
+76: 14
+78: 18
+84: 14
+90: 20
+92: 14

2017/14/day14.hs

@@ -0,0 +1,41 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script
+
+import Data.List
+import Data.List.Split
+import Data.Char
+import Data.Bits
+import Text.Printf
+
+twist :: [Int] -> Int -> Int -> [Int]
+twist xs len skip =
+  end ++ start
+  where (knot, keep) = splitAt len xs
+        (start, end) = splitAt skip $ keep ++ reverse knot
+
+twists :: [Int] -> [Int] -> Int -> [Int]
+twists list [] k = list
+twists list (x:xs) k = twists (twist list x k) xs (k+1)
+
+hashRound :: Int -> [Int] -> [Int]
+hashRound n lens = drop rot list ++ take rot list
+  where list = foldl' (\acc (x,k) -> twist acc x k) [0..(n-1)] $ zip lens (cycle [0..(n-1)])
+        rot = n - (sum (zipWith (+) [0..] lens) `rem` n)
+
+sparseHash :: [Int] -> [Int]
+sparseHash lengths =
+  hashRound 256 . concat . replicate 64 $ lengths ++ [17, 31, 73, 47, 23]
+
+denseHash :: [Int] -> [Int]
+denseHash h = foldr xor 0 <$> chunksOf 16 h
+
+grid :: String -> [[Int]]
+grid input =
+  map (denseHash . sparseHash . map ord . ((input++"-")++) . show) [0..127]
+
+main :: IO ()
+main = do
+  let input = "stpzcrnm"
+  let g = grid input
+  mapM_ (putStrLn . concatMap (printf "%08b")) g
+  print . length . filter (=='1') . concat $ map (concatMap (printf "%08b")) g

2017/15/day15.hs

@@ -0,0 +1,29 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script
+
+import Data.Bits
+import Data.List
+
+genA :: Integral a => a -> a
+genA n = (16807 * n) `rem` 2147483647
+
+genB :: Integral a => a -> a
+genB n = (48271 * n) `rem` 2147483647
+
+matchLowest16Bits :: (Bits a, Num a) => a -> a -> Bool
+matchLowest16Bits n1 n2 =
+  n1 .&. 0xFFFF == n2 .&. 0xFFFF
+
+main :: IO ()
+main = do
+  let (inputA, inputB) = (783, 325) :: (Int, Int)
+  let n = 40000000
+  let seqA = take n $ iterate genA inputA
+  let seqB = take n $ iterate genB inputB
+  print . foldl' (flip ((+) . fromEnum)) 0 $ zipWith matchLowest16Bits seqA seqB
+  let n' = 5000000
+  let seqA' = take n' . filter (\k -> k `rem` 4 == 0)
+              $ iterate genA inputA
+  let seqB' = take n' . filter (\k -> k `rem` 8 == 0)
+              $ iterate genB inputB
+  print . foldl' (flip ((+) . fromEnum)) 0 $ zipWith matchLowest16Bits seqA' seqB'

2017/16/day16.hs

@@ -0,0 +1,112 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Text (Text)
+import qualified Data.Text as T
+import Data.Attoparsec.Text
+import Control.Applicative
+import Data.List
+import Data.Maybe
+import Data.Monoid
+
+data Move = Spin Int | Exchange Int Int | Partner Char Char
+  deriving (Eq, Show)
+
+isPartner :: Move -> Bool
+isPartner (Partner _ _) = True
+isPartner _ = False
+
+parseSpin :: Parser Move
+parseSpin = string "s" *> decimal >>= return . Spin
+
+parseExchange :: Parser Move
+parseExchange = do
+  string "x"
+  a <- decimal
+  string "/"
+  b <- decimal
+  return $ Exchange a b
+
+parsePartner :: Parser Move
+parsePartner = do
+  string "p"
+  a <- letter
+  string "/"
+  b <- letter
+  return $ Partner a b
+
+parseMove :: Parser Move
+parseMove = parseSpin <|> parseExchange <|> parsePartner
+
+parseMoves :: Parser [Move]
+parseMoves = parseMove `sepBy` (skipSpace *> string "," *> skipSpace)
+
+spin :: Int -> [a] -> [a]
+spin n xs = end ++ start
+  where (start, end) = splitAt (length xs - n) xs
+
+exchange :: Int -> Int -> [a] -> [a]
+exchange m n xs
+  | m == n = xs
+  | m > n = exchange n m xs
+  | otherwise = start ++ b:as ++ a:bs
+  where (start, end) = splitAt m xs
+        (a:as, b:bs) = splitAt (n-m) end
+
+partner :: Eq t => t -> t -> [t] -> [t]
+partner a b xs = exchange m n xs
+  where Just m = elemIndex a xs
+        Just n = elemIndex b xs
+
+move :: [Char] -> Move -> [Char]
+move xs (Spin n) = spin n xs
+move xs (Exchange m n) = exchange m n xs
+move xs (Partner a b) = partner a b xs
+
+findRepetition :: Eq a => [a] -> Maybe Int
+findRepetition [] = Nothing
+findRepetition (x:xs) = case elemIndices x xs of
+  [] -> Nothing
+  inds -> Just $ last inds
+
+moveMany 0 _ xs _ = xs
+moveMany n seen xs (m:ms) =
+  if xs `elem` seen
+  then concat $ intersperse "\n" seen-- !! (length seen - n `rem` length seen)
+  else let xs' = move xs m in
+         moveMany (n-1) (xs:seen) xs' ms
+
+newtype Perm16 = Perm16 [Int]
+  deriving (Show, Eq)
+
+toPermutation :: Move -> Perm16
+toPermutation (Spin n) = Perm16 $ spin n [0..15]
+toPermutation (Exchange m n) = Perm16 $ exchange m n [0..15]
+toPermutation (Partner _ _) = Perm16 [0..15]
+
+instance Monoid Perm16 where
+  mempty = Perm16 [0..15]
+  mappend (Perm16 p1) (Perm16 p2) = Perm16 $ map (p1 !!) p2
+
+applyPerm :: [b] -> Perm16 -> [b]
+applyPerm xs (Perm16 p) = map (xs !!) p
+
+main :: IO ()
+main = do
+  contents <- T.pack <$> getContents
+  let Right moves = parseOnly parseMoves contents
+  let start = ['a'..'p']
+  let partnerMoves = filter isPartner moves
+  -- print (length moves)
+  let positions = scanl' move start . concat $ replicate 1 moves
+  putStrLn $ last positions
+  let dance = mconcat . map toPermutation $  moves
+  putStrLn $ foldl' move (applyPerm start dance) partnerMoves
+  let thousanddance = iterate (<> dance) dance !! 1000
+  let milliondance = iterate (<> thousanddance) thousanddance !! 1000
+  let billiondance = iterate (<> milliondance) milliondance !! 1000
+  print billiondance
+  let billionPartnerMoves = concat $ replicate 1000000000 partnerMoves
+  putStrLn $ foldl' move (applyPerm start billiondance) billionPartnerMoves

2017/17/day17.hs

@@ -0,0 +1,26 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.18 script
+
+{-# LANGUAGE BangPatterns #-}
+
+import Data.List
+
+rotate :: Int -> [a] -> [a]
+rotate n xs = take (length xs) (drop n (cycle xs))
+
+spinlock :: (Num a, Enum a) => a -> Int -> [a] -> [a]
+spinlock n steps buf = foldl' f buf [1..n]
+  where f !curbuf !i = let !newbuf = rotate (steps+1) curbuf in i:newbuf
+
+valueAfter :: Eq t => t -> [t] -> t
+valueAfter n buf = buf !! ((i + 1) `rem` length buf)
+  where Just i = elemIndex n buf
+
+main :: IO ()
+main = do
+  let input = 312
+      n = 2017
+      start = [0]
+  print $ valueAfter n $ spinlock n input start
+  -- let n = 50000000
+  -- print $ valueAfter 0 $ spinlock n input start

2017/17/day17.scm

@@ -0,0 +1,25 @@
+;; $ csc day17.scm -o day17 -O5
+;; $ ./day17 -:hm8g
+
+(use srfi-1)
+(declare (fixnum))
+
+(define (prepend! x list)
+  (set-cdr! list (cons (car list) (cdr list)))
+  (set-car! list x))
+
+(define (spin steps n after)
+  (let ((buffer (circular-list 0)))
+    (do ((i 1 (+ i 1)))
+	((> i n) (cadr (member after buffer)))
+      (let ((new (drop buffer (+ steps 1))))
+	(prepend! i new)
+	(set! buffer new)))))
+
+(write (spin 3 2017 2017))
+(newline)
+(write (spin 312 2017 2017))
+(newline)
+(write (spin 312 50000000 0))
+(newline)
+

2017/20/day20.hs

@@ -0,0 +1,70 @@
+#!/usr/bin/env stack
+-- stack --resolver lts-9.20 script
+
+{-# LANGUAGE OverloadedStrings #-}
+
+import Data.Attoparsec.Text hiding (take)
+import Data.Text (Text)
+import qualified Data.Text as T
+import Data.List (minimumBy, (\\))
+import Data.Function (on)
+
+data Point a =
+  Point { position :: (a,a,a)
+        , velocity :: (a,a,a)
+        , acceleration :: (a,a,a)
+        }
+  deriving (Show, Eq)
+
+parseVector :: Text -> Parser (Int,Int,Int)
+parseVector id = do
+  string id
+  string "=<"
+  x <- signed decimal
+  string ","
+  y <- signed decimal
+  string ","
+  z <- signed decimal
+  string ">"
+  return (x,y,z)
+
+parsePoint :: Parser (Point Int)
+parsePoint = do
+  pos <- parseVector "p"
+  string ","
+  skipSpace
+  vel <- parseVector "v"
+  string ","
+  skipSpace
+  acc <- parseVector "a"
+  return $ Point pos vel acc
+
+update :: Num a => Point a -> Point a
+update (Point (posx,posy,posz) (velx,vely,velz) (accx,accy,accz)) =
+  Point (posx',posy',posz') (velx',vely',velz') (accx,accy,accz)
+  where velx' = velx + accx
+        vely' = vely + accy
+        velz' = velz + accz
+        posx' = posx + velx'
+        posy' = posy + vely'
+        posz' = posz + velz'
+
+removeCollisions :: Eq a => [Point a] -> [Point a]
+removeCollisions [] = []
+removeCollisions (p:ps) = case filter (\x -> position x == position p) ps of
+  [] -> p : removeCollisions ps
+  xs -> removeCollisions $ ps \\ xs
+
+distance :: Num a => Point a -> a
+distance (Point (x,y,z) _ _) = abs x + abs y + abs z
+
+closestZero :: [Point Int] -> Integer
+closestZero = fst . minimumBy (compare `on` (distance . snd)) . zip [0..]
+
+main :: IO ()
+main = do
+  contents <- T.lines . T.pack <$> getContents
+  let Right points = mapM (parseOnly parsePoint) contents
+  -- mapM_ print points
+  print . take 1000 . map closestZero $ iterate (map update) points
+  print . take 200 . map length $ iterate (removeCollisions . map update) points

2017/README.org

@@ -0,0 +1,3 @@
+* Advent of Code 2017
+
+My answers for [[http://adventofcode.com/2017][Advent of Code 2017]].