Showing preview only (4,615K chars total). Download the full file or copy to clipboard to get everything.
Repository: skanev/playground
Branch: master
Commit: 07b88d789391
Files: 1993
Total size: 4.1 MB
Directory structure:
gitextract_j8jnmwhq/
├── .git-hooks/
│ ├── install-hooks
│ └── prepare-commit-msg
├── .gitignore
├── README
├── Rakefile
├── advent-of-code/
│ ├── 2020/
│ │ ├── 01.1.pl
│ │ ├── 01.2.pl
│ │ ├── 02.1.pl
│ │ ├── 02.2.pl
│ │ ├── 03.1.pl
│ │ ├── 03.2.pl
│ │ ├── 04.1.pl
│ │ ├── 04.2.pl
│ │ ├── 05.1.pl
│ │ ├── 05.2.pl
│ │ ├── 06.1.pl
│ │ ├── 06.2.pl
│ │ ├── 07.1.pl
│ │ ├── 07.2.pl
│ │ ├── 08.1.pl
│ │ ├── 08.2.pl
│ │ ├── 09.1.pl
│ │ ├── 09.2.pl
│ │ ├── 10.1.pl
│ │ ├── 10.2.pl
│ │ ├── 11.1.pl
│ │ ├── 11.2.pl
│ │ ├── 12.1.pl
│ │ ├── 12.2.pl
│ │ ├── 13.1.pl
│ │ ├── 13.2.pl
│ │ ├── 14.1.pl
│ │ ├── 14.2.pl
│ │ ├── 15.1.pl
│ │ ├── 15.2.pl
│ │ ├── 16.1.pl
│ │ ├── 16.2.pl
│ │ ├── 17.1.pl
│ │ ├── 17.2.pl
│ │ ├── 18.1.pl
│ │ ├── 18.2.pl
│ │ ├── 19.1.pl
│ │ ├── 19.2.pl
│ │ ├── 20.1.pl
│ │ ├── 20.2.pl
│ │ ├── 21.1.pl
│ │ ├── 21.2.pl
│ │ ├── 22.1.pl
│ │ ├── 22.2.pl
│ │ ├── 23.1.pl
│ │ ├── 23.2.pl
│ │ ├── 24.1.pl
│ │ ├── 24.2.pl
│ │ ├── 25.1.pl
│ │ ├── 25.2.pl
│ │ └── inputs/
│ │ ├── 1.1
│ │ ├── 10
│ │ ├── 11
│ │ ├── 12
│ │ ├── 13
│ │ ├── 14
│ │ ├── 16
│ │ ├── 17
│ │ ├── 18
│ │ ├── 19
│ │ ├── 2
│ │ ├── 20
│ │ ├── 21
│ │ ├── 22
│ │ ├── 24
│ │ ├── 3
│ │ ├── 3.sample
│ │ ├── 4
│ │ ├── 4.sample
│ │ ├── 5
│ │ ├── 6
│ │ ├── 7
│ │ ├── 8
│ │ └── 9
│ ├── 2021/
│ │ ├── .gitignore
│ │ ├── day01/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day02/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day03/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day04/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day05/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day06/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day07/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day08/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day09/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day10/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day11/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day12/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day13/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day14/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day15/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day16/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day17/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day18/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day19/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day20/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day21/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day22/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day23/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day24/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day25/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── inputs/
│ │ ├── 01
│ │ ├── 02
│ │ ├── 03
│ │ ├── 04
│ │ ├── 05
│ │ ├── 06
│ │ ├── 07
│ │ ├── 08
│ │ ├── 09
│ │ ├── 10
│ │ ├── 11
│ │ ├── 12
│ │ ├── 13
│ │ ├── 14
│ │ ├── 15
│ │ ├── 16
│ │ ├── 17
│ │ ├── 18
│ │ ├── 19
│ │ ├── 20
│ │ ├── 21
│ │ ├── 22
│ │ ├── 23
│ │ ├── 24
│ │ └── 25
│ └── 2022/
│ ├── .gitignore
│ ├── day01/
│ │ ├── day01.nimble
│ │ └── src/
│ │ └── day01.nim
│ ├── day02/
│ │ ├── day02.nimble
│ │ └── src/
│ │ └── day02.nim
│ ├── day03/
│ │ ├── day03.nimble
│ │ └── src/
│ │ └── day03.nim
│ ├── day04/
│ │ ├── day04.nimble
│ │ └── src/
│ │ └── day04.nim
│ ├── day05/
│ │ ├── day05.nimble
│ │ └── src/
│ │ └── day05.nim
│ ├── day06/
│ │ ├── day06.nimble
│ │ └── src/
│ │ └── day06.nim
│ ├── day07/
│ │ ├── day07.nimble
│ │ └── src/
│ │ └── day07.nim
│ ├── day08/
│ │ ├── day08.nimble
│ │ └── src/
│ │ └── day08.nim
│ ├── day09/
│ │ ├── day09.nimble
│ │ └── src/
│ │ └── day09.nim
│ ├── day10/
│ │ ├── day10.nimble
│ │ └── src/
│ │ └── day10.nim
│ ├── day11/
│ │ ├── day11.nimble
│ │ └── src/
│ │ └── day11.nim
│ ├── day12/
│ │ ├── day12.nimble
│ │ └── src/
│ │ └── day12.nim
│ ├── day13/
│ │ ├── day13.nimble
│ │ └── src/
│ │ └── day13.nim
│ ├── day14/
│ │ ├── day14.nimble
│ │ └── src/
│ │ └── day14.nim
│ ├── day15/
│ │ ├── day15.nimble
│ │ └── src/
│ │ └── day15.nim
│ ├── day16/
│ │ ├── day16.nimble
│ │ └── src/
│ │ └── day16.nim
│ ├── day17/
│ │ ├── day17.nimble
│ │ └── src/
│ │ └── day17.nim
│ ├── day18/
│ │ ├── day18.nimble
│ │ └── src/
│ │ └── day18.nim
│ ├── day19/
│ │ ├── day19.nimble
│ │ └── src/
│ │ └── day19.nim
│ ├── day20/
│ │ ├── day20.nimble
│ │ └── src/
│ │ └── day20.nim
│ └── inputs/
│ ├── 01
│ ├── 02
│ ├── 03
│ ├── 04
│ ├── 05
│ ├── 06
│ ├── 07
│ ├── 08
│ ├── 09
│ ├── 10
│ ├── 11
│ ├── 12
│ ├── 13
│ ├── 14
│ ├── 15
│ ├── 16
│ ├── 17
│ ├── 18
│ ├── 19
│ └── 20
├── git-hooks/
│ └── prepare-commit-msg
├── go/
│ └── gopl/
│ ├── .ruby-version
│ ├── 01/
│ │ ├── 01/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 02/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 03/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 04/
│ │ │ ├── dup.go
│ │ │ ├── dup_test.go
│ │ │ └── fixtures/
│ │ │ ├── first
│ │ │ ├── second
│ │ │ └── third
│ │ ├── 05/
│ │ │ └── lissajous.go
│ │ ├── 06/
│ │ │ └── lissajous.go
│ │ ├── 07/
│ │ │ └── fetch.go
│ │ ├── 08/
│ │ │ └── fetch.go
│ │ └── 09/
│ │ └── fetch.go
│ ├── Gemfile
│ ├── README.markdown
│ └── Thorfile
├── haskell/
│ ├── aryth/
│ │ ├── Ast.hs
│ │ ├── Interpreter.hs
│ │ ├── Parser.hs
│ │ └── World.hs
│ ├── programming_haskell/
│ │ ├── Chapter01.hs
│ │ ├── Chapter04.hs
│ │ ├── Chapter05.hs
│ │ ├── Chapter06.hs
│ │ ├── Chapter07.hs
│ │ ├── Chapter09.hs
│ │ ├── Nim.hs
│ │ └── README
│ └── real_world_haskell/
│ ├── Find.hs
│ ├── Glob.hs
│ ├── PgmParser.hs
│ ├── PgmSimple.hs
│ ├── Traverse.hs
│ ├── json/
│ │ ├── Main.hs
│ │ ├── Prettify.hs
│ │ ├── PrettyJSON.hs
│ │ ├── PrettyStub.hs
│ │ ├── PutJSON.hs
│ │ ├── README
│ │ └── SimpleJSON.hs
│ └── sample/
│ └── foo.pgm
├── java/
│ └── tdd_by_example/
│ ├── Money.java
│ ├── MoneyTest.java
│ └── README
├── other/
│ ├── 7languages/
│ │ ├── erlang/
│ │ │ ├── day1/
│ │ │ │ ├── count_to_ten.erl
│ │ │ │ ├── result_of.erl
│ │ │ │ └── word_count.erl
│ │ │ └── day2/
│ │ │ ├── pseudo_dict.erl
│ │ │ ├── tictactoe.erl
│ │ │ └── total_price.erl
│ │ ├── io/
│ │ │ ├── day2/
│ │ │ │ ├── 1/
│ │ │ │ │ ├── loop.io
│ │ │ │ │ └── recursive.io
│ │ │ │ ├── 2.io
│ │ │ │ ├── 3.io
│ │ │ │ ├── 4.io
│ │ │ │ ├── 5.io
│ │ │ │ ├── 6.io
│ │ │ │ ├── 7.io
│ │ │ │ ├── 8.io
│ │ │ │ └── reflection.io
│ │ │ └── day3/
│ │ │ ├── 1.io
│ │ │ ├── 2.io
│ │ │ ├── 3.io
│ │ │ ├── 3.xml.io
│ │ │ ├── actors.io
│ │ │ ├── builder.io
│ │ │ ├── coroutine.io
│ │ │ ├── futures.io
│ │ │ └── phonebook.io
│ │ ├── prolog/
│ │ │ ├── day1/
│ │ │ │ ├── food.prolog
│ │ │ │ ├── friends.prolog
│ │ │ │ └── map.prolog
│ │ │ ├── day2/
│ │ │ │ ├── 2.1.prolog
│ │ │ │ ├── 2.2.2.prolog
│ │ │ │ ├── 2.2.prolog
│ │ │ │ ├── 2.3.prolog
│ │ │ │ ├── concatenate.prolog
│ │ │ │ ├── fibonacci.prolog
│ │ │ │ └── list_math.prolog
│ │ │ ├── day3/
│ │ │ │ ├── queens.prolog
│ │ │ │ └── sudoku.prolog
│ │ │ └── other/
│ │ │ └── einstein.prolog
│ │ └── scala/
│ │ ├── day1/
│ │ │ ├── 1.scala
│ │ │ └── 2.scala
│ │ ├── day2/
│ │ │ ├── 1.scala
│ │ │ ├── 2.scala
│ │ │ ├── 3.scala
│ │ │ └── censored_words.txt
│ │ └── day3/
│ │ └── sizer.scala
│ └── clrs/
│ ├── .gitignore
│ ├── .powrc
│ ├── .ruby-version
│ ├── .rvmrc
│ ├── 01/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ └── problems/
│ │ └── 01.markdown
│ ├── 02/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ ├── 01.c
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.c
│ │ ├── 01.run.py
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ └── 04.test.c
│ ├── 03/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ └── 08.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ └── 08.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.markdown
│ │ ├── 05.markdown
│ │ └── 06.markdown
│ ├── 04/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.run.c
│ │ │ ├── 03.test.c
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ └── 05.test.c
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.dot
│ │ │ ├── 02.markdown
│ │ │ ├── 03.dot
│ │ │ ├── 03.markdown
│ │ │ ├── 04.dot
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.dot
│ │ │ ├── 07.markdown
│ │ │ ├── 08.dot
│ │ │ ├── 08.markdown
│ │ │ ├── 09.dot
│ │ │ └── 09.markdown
│ │ ├── 05/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 06/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.markdown
│ │ ├── 05.markdown
│ │ ├── 05.py
│ │ ├── 05.test.py
│ │ ├── 06.c
│ │ ├── 06.markdown
│ │ └── 06.test.c
│ ├── 05/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ └── 02.markdown
│ ├── 06/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.dot
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 05/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.dot
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.c
│ │ │ ├── 06.markdown
│ │ │ ├── 06.test.c
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.py
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.c
│ │ ├── 03.markdown
│ │ └── 03.test.c
│ ├── 07/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ └── 02.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.run.c
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ └── problems/
│ │ ├── 01.c
│ │ ├── 01.dot
│ │ ├── 01.markdown
│ │ ├── 01.test.c
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.markdown
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ ├── 04.test.c
│ │ ├── 05.markdown
│ │ ├── 06.c
│ │ ├── 06.markdown
│ │ └── 06.test.c
│ ├── 08/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.c
│ │ ├── 03.markdown
│ │ ├── 03.test.c
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ ├── 04.test.c
│ │ ├── 05.c
│ │ ├── 05.markdown
│ │ ├── 05.test.c
│ │ ├── 06.markdown
│ │ ├── 07.c
│ │ ├── 07.markdown
│ │ ├── 07.run.c
│ │ └── 07.test.c
│ ├── 09/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ └── 02.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 08.py
│ │ │ ├── 08.test.py
│ │ │ └── 09.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 10/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ ├── 07.c
│ │ │ ├── 07.markdown
│ │ │ ├── 07.test.c
│ │ │ ├── 08.c
│ │ │ ├── 08.markdown
│ │ │ └── 08.test.c
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ └── 05.test.c
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ └── 03.markdown
│ ├── 11/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.run.py
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ └── 05.run.py
│ │ ├── 05/
│ │ │ └── 01.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 12/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ └── 05.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.dot
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 03/
│ │ │ ├── 01.c
│ │ │ ├── 01.markdown
│ │ │ ├── 01.test.c
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.debug.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 13/
│ │ ├── 01/
│ │ │ ├── 01.draw.py
│ │ │ ├── 01.markdown
│ │ │ ├── 02.draw.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.draw.py
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.draw.py
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.draw.py
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.draw.py
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.draw.py
│ │ │ └── 07.markdown
│ │ ├── misc/
│ │ │ ├── red_black_tree.py
│ │ │ └── red_black_tree_test.py
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.test.py
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 03.py
│ │ ├── 03.test.py
│ │ ├── 04.markdown
│ │ ├── 04.py
│ │ └── 04.test.py
│ ├── 14/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 07.py
│ │ │ ├── 07.test.py
│ │ │ ├── 08.markdown
│ │ │ ├── 08.py
│ │ │ └── 08.test.py
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.test.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.test.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 07.py
│ │ │ └── 07.test.py
│ │ ├── misc/
│ │ │ ├── augmentable_tree.py
│ │ │ ├── augmentable_tree_test.py
│ │ │ ├── interval_tree.py
│ │ │ ├── interval_tree_test.py
│ │ │ └── order_statistic_tree.py
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.test.py
│ │ ├── 02.markdown
│ │ ├── 02.py
│ │ └── 02.test.py
│ ├── 15/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.dot
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ └── 05.test.py
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.run.py
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ └── 06.test.py
│ │ └── 05/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.py
│ │ ├── 02.markdown
│ │ ├── 02.py
│ │ ├── 02.run.py
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── C/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ ├── 10.markdown
│ │ │ ├── 11.markdown
│ │ │ ├── 12.markdown
│ │ │ ├── 13.markdown
│ │ │ ├── 14.markdown
│ │ │ └── 15.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ └── 10.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ └── 10.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 05/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ └── 01.markdown
│ ├── Gemfile
│ ├── Rakefile
│ ├── build/
│ │ ├── app.rb
│ │ ├── build.rb
│ │ ├── ext/
│ │ │ ├── debug_helpers.h
│ │ │ ├── drawing.py
│ │ │ └── test.h
│ │ ├── lib/
│ │ │ ├── catalog.rb
│ │ │ ├── chapter_number.rb
│ │ │ ├── exercise.rb
│ │ │ ├── generator.rb
│ │ │ ├── graph.rb
│ │ │ ├── problem.rb
│ │ │ ├── renderer.rb
│ │ │ ├── runtimes/
│ │ │ │ ├── c.rb
│ │ │ │ └── python.rb
│ │ │ ├── runtimes.rb
│ │ │ └── solution.rb
│ │ ├── public/
│ │ │ └── css/
│ │ │ └── clrs.scss
│ │ └── views/
│ │ ├── catalog.erb
│ │ ├── exercise.erb
│ │ ├── layout.erb
│ │ └── problem.erb
│ ├── config.ru
│ ├── notes/
│ │ ├── week-01.markdown
│ │ ├── week-02.markdown
│ │ ├── week-03.markdown
│ │ ├── week-04.markdown
│ │ ├── week-05.markdown
│ │ ├── week-06.markdown
│ │ ├── week-07.markdown
│ │ └── week-08.markdown
│ └── target/
│ └── .gitignore
├── ruby/
│ └── understanding-computation/
│ ├── .gitignore
│ ├── 03/
│ │ ├── 03.rb
│ │ ├── example.rb
│ │ ├── lib/
│ │ │ ├── dfa.rb
│ │ │ ├── dfa_design.rb
│ │ │ ├── dfa_rulebook.rb
│ │ │ ├── dot.rb
│ │ │ ├── fa_rule.rb
│ │ │ ├── grammar.treetop
│ │ │ ├── index.html
│ │ │ ├── nfa.rb
│ │ │ ├── nfa_design.rb
│ │ │ ├── nfa_rulebook.rb
│ │ │ ├── nfa_simulation.rb
│ │ │ └── pattern.rb
│ │ └── rulebooks.rb
│ ├── 04/
│ │ ├── 04.rb
│ │ ├── lib/
│ │ │ ├── dpda.rb
│ │ │ ├── dpda_design.rb
│ │ │ ├── dpda_rulebook.rb
│ │ │ ├── lexical_analyzer.rb
│ │ │ ├── npda.rb
│ │ │ ├── npda_design.rb
│ │ │ ├── npda_rulebook.rb
│ │ │ ├── pda_configuration.rb
│ │ │ ├── pda_rule.rb
│ │ │ ├── simple_parser.rb
│ │ │ └── stack.rb
│ │ └── rulebooks.rb
│ └── Rakefile
├── scala/
│ ├── expr/
│ │ ├── .gitignore
│ │ ├── README.markdown
│ │ ├── project/
│ │ │ ├── build/
│ │ │ │ └── Expressions.scala
│ │ │ └── build.properties
│ │ └── src/
│ │ ├── main/
│ │ │ └── scala/
│ │ │ └── expr/
│ │ │ ├── ActorEvaluation.scala
│ │ │ ├── BadInputException.scala
│ │ │ ├── Callable.scala
│ │ │ ├── Env.scala
│ │ │ ├── Evaluation.scala
│ │ │ ├── Expr.scala
│ │ │ ├── ExprException.scala
│ │ │ ├── Lambda.scala
│ │ │ ├── Parser.scala
│ │ │ ├── Printer.scala
│ │ │ ├── ScalaCode.scala
│ │ │ └── repl/
│ │ │ ├── Command.scala
│ │ │ ├── ConsoleShell.scala
│ │ │ ├── InteractiveInterpreter.scala
│ │ │ ├── JLineShell.scala
│ │ │ ├── REPL.scala
│ │ │ └── Shell.scala
│ │ └── test/
│ │ └── scala/
│ │ └── expr/
│ │ ├── EnvSpec.scala
│ │ ├── EvaluationSpec.scala
│ │ ├── ExprGen.scala
│ │ ├── ExpressionSpec.scala
│ │ ├── LambdaSpec.scala
│ │ ├── ParsingSpec.scala
│ │ ├── PrintingExpressionsSpec.scala
│ │ ├── PropertiesSpec.scala
│ │ ├── ScalaCodeSpec.scala
│ │ └── repl/
│ │ ├── CommandSpec.scala
│ │ ├── REPLSpec.scala
│ │ └── RecordingShell.scala
│ └── programming_in_scala/
│ ├── .gitignore
│ ├── README
│ ├── project/
│ │ ├── build/
│ │ │ └── ProgrammingInScala.scala
│ │ └── build.properties
│ └── src/
│ ├── main/
│ │ └── scala/
│ │ ├── actorsimulation/
│ │ │ ├── Adders.scala
│ │ │ ├── Circuit.scala
│ │ │ ├── Clock.scala
│ │ │ ├── Demo.scala
│ │ │ └── Simulant.scala
│ │ ├── arithmetic/
│ │ │ └── Expr.scala
│ │ ├── layout/
│ │ │ ├── Element.scala
│ │ │ └── Spiral.scala
│ │ └── simulation/
│ │ ├── BasicCircuitSimulation.scala
│ │ ├── CircuitSimulation.scala
│ │ ├── Simulation.scala
│ │ └── StairwayBookSimulation.scala
│ └── test/
│ └── scala/
│ ├── arithmetic/
│ │ ├── ExprFormatterSpec.scala
│ │ └── SimplificationSpec.scala
│ └── layout/
│ ├── CompositionSpec.scala
│ ├── FactoryMethodsSpec.scala
│ └── SpiralSpec.scala
├── scheme/
│ ├── eopl/
│ │ ├── .gitignore
│ │ ├── .ruby-version
│ │ ├── .rvmrc
│ │ ├── 01/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ ├── 32.scm
│ │ │ ├── 33.scm
│ │ │ ├── 34.scm
│ │ │ ├── 35.scm
│ │ │ ├── 36.scm
│ │ │ └── tests/
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 27-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 30-tests.scm
│ │ │ ├── 31-tests.scm
│ │ │ ├── 32-tests.scm
│ │ │ ├── 33-tests.scm
│ │ │ ├── 34-tests.scm
│ │ │ ├── 35-tests.scm
│ │ │ └── 36-tests.scm
│ │ ├── 02/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ └── tests/
│ │ │ ├── 01-tests.scm
│ │ │ ├── 03-tests.scm
│ │ │ ├── 05-tests.scm
│ │ │ ├── 06-tests.scm
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 10-tests.scm
│ │ │ ├── 11-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 14-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 30-tests.scm
│ │ │ └── 31-tests.scm
│ │ ├── 03/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ ├── 32.scm
│ │ │ ├── 33.scm
│ │ │ ├── 34.scm
│ │ │ ├── 35.scm
│ │ │ ├── 36.scm
│ │ │ ├── 37.scm
│ │ │ ├── 38.scm
│ │ │ ├── 39.scm
│ │ │ ├── 40.scm
│ │ │ ├── 41.scm
│ │ │ ├── 42.scm
│ │ │ ├── 43.scm
│ │ │ ├── 44.scm
│ │ │ ├── cases/
│ │ │ │ ├── let/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ ├── letrec/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ ├── nameless/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ └── proc/
│ │ │ │ ├── all.scm
│ │ │ │ ├── env.scm
│ │ │ │ ├── eval.scm
│ │ │ │ ├── parser.scm
│ │ │ │ ├── test-helpers.scm
│ │ │ │ └── tests.scm
│ │ │ └── tests/
│ │ │ ├── 06-tests.scm
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 10-tests.scm
│ │ │ ├── 11-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 14-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 27-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 31-tests.scm
│ │ │ ├── 32-tests.scm
│ │ │ ├── 33-tests.scm
│ │ │ ├── 34-tests.scm
│ │ │ ├── 35-tests.scm
│ │ │ ├── 36-tests.scm
│ │ │ ├── 37-tests.scm
│ │ │ ├── 38-tests.scm
│ │ │ ├── 39-tests.scm
│ │ │ ├── 40-tests.scm
│ │ │ ├── 41-tests.scm
│ │ │ ├── 42-tests.scm
│ │ │ ├── 43-tests.scm
│ │ │ ├── 44-tests.scm
│ │ │ └── helpers/
│ │ │ ├── let.scm
│ │ │ ├── letrec.scm
│ │ │ ├── nameless.scm
│ │ │ └── proc.scm
│ │ ├── 04/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ └── cases/
│ │ │ └── explicit-refs/
│ │ │ ├── all.scm
│ │ │ ├── env.scm
│ │ │ ├── eval.scm
│ │ │ ├── parser.scm
│ │ │ ├── test-helpers.scm
│ │ │ └── tests.scm
│ │ ├── B/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ └── tests/
│ │ │ ├── 01-tests.scm
│ │ │ ├── 03-tests.scm
│ │ │ ├── 04-tests.scm
│ │ │ └── 05-tests.scm
│ │ ├── Gemfile
│ │ ├── Guardfile
│ │ ├── Thorfile
│ │ ├── build/
│ │ │ ├── exercise.rb
│ │ │ └── templates/
│ │ │ ├── exercise.scm
│ │ │ └── test.scm
│ │ ├── notes/
│ │ │ ├── week-01.markdown
│ │ │ ├── week-02.markdown
│ │ │ └── week-03.markdown
│ │ └── support/
│ │ └── eopl.scm
│ └── sicp/
│ ├── .gitignore
│ ├── 01/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ └── tests/
│ │ ├── 03-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 27-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ └── 46-tests.scm
│ ├── 02/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── 80.scm
│ │ ├── 81.scm
│ │ ├── 82.scm
│ │ ├── 83.scm
│ │ ├── 84.scm
│ │ ├── 85.scm
│ │ ├── 86.scm
│ │ ├── 87.scm
│ │ ├── 88.scm
│ │ ├── 89.scm
│ │ ├── 90.scm
│ │ ├── 91.scm
│ │ ├── 92.scm
│ │ ├── 93.scm
│ │ ├── 94.scm
│ │ ├── 95.scm
│ │ ├── 96.scm
│ │ ├── 97.scm
│ │ ├── showcase/
│ │ │ └── picturelang/
│ │ │ └── main.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 20-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 27-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 34-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ ├── 46-tests.scm
│ │ ├── 47-tests.scm
│ │ ├── 48-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 57-tests.scm
│ │ ├── 58-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 65-tests.scm
│ │ ├── 66-tests.scm
│ │ ├── 67-tests.scm
│ │ ├── 68-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 73-tests.scm
│ │ ├── 74-tests.scm
│ │ ├── 75-tests.scm
│ │ ├── 78-tests.scm
│ │ ├── 79-tests.scm
│ │ ├── 80-tests.scm
│ │ ├── 82-tests.scm
│ │ ├── 83-tests.scm
│ │ ├── 84-tests.scm
│ │ ├── 85-tests.scm
│ │ ├── 86-tests.scm
│ │ ├── 87-tests.scm
│ │ ├── 88-tests.scm
│ │ ├── 89-tests.scm
│ │ ├── 90-tests.scm
│ │ ├── 91-tests.scm
│ │ ├── 92-tests.scm
│ │ ├── 93-tests.scm
│ │ ├── 94-tests.scm
│ │ ├── 96-tests.scm
│ │ └── 97-tests.scm
│ ├── 03/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── 80.scm
│ │ ├── 81.scm
│ │ ├── 82.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 23-tests.scm
│ │ ├── 24-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 50-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 55-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 64-tests.scm
│ │ ├── 66-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 70-tests.scm
│ │ ├── 71-tests.scm
│ │ ├── 72-tests.scm
│ │ ├── 73-tests.scm
│ │ ├── 74-tests.scm
│ │ ├── 76-tests.scm
│ │ ├── 80-tests.scm
│ │ ├── 81-tests.scm
│ │ └── 82-tests.scm
│ ├── 04/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── showcase/
│ │ │ ├── amb/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── analyzing/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── evaluator/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── lazy/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ └── query/
│ │ │ ├── database.scm
│ │ │ ├── evaluator.scm
│ │ │ ├── main.scm
│ │ │ ├── test-helpers.scm
│ │ │ └── tests.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 09-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 13-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 20-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 34-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ ├── 48-tests.scm
│ │ ├── 49-tests.scm
│ │ ├── 51-tests.scm
│ │ ├── 52-tests.scm
│ │ ├── 53-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 55-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 57-tests.scm
│ │ ├── 58-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 63-tests.scm
│ │ ├── 67-tests.scm
│ │ ├── 68-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 75-tests.scm
│ │ ├── 76-tests.scm
│ │ ├── 77-tests.scm
│ │ ├── 78-tests.scm
│ │ ├── 79-tests.scm
│ │ └── helpers/
│ │ └── query.scm
│ ├── 05/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── showcase/
│ │ │ ├── compiler/
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── explicit-evaluator-text.scm
│ │ │ │ ├── helpers.scm
│ │ │ │ ├── main.scm
│ │ │ │ ├── operations.scm
│ │ │ │ ├── syntax.scm
│ │ │ │ └── tests.scm
│ │ │ ├── explicit/
│ │ │ │ ├── controller-text.scm
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ ├── operations.scm
│ │ │ │ └── tests.scm
│ │ │ └── simulator/
│ │ │ ├── sample-machines.scm
│ │ │ ├── simulator.scm
│ │ │ └── tests.scm
│ │ ├── support/
│ │ │ ├── 51/
│ │ │ │ ├── evaluator.c
│ │ │ │ └── tests.scm
│ │ │ ├── 52/
│ │ │ │ ├── build.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── metacircular-evaluator.scm
│ │ │ │ ├── runtime.c
│ │ │ │ ├── syntax.scm
│ │ │ │ └── tests.scm
│ │ │ └── bin/
│ │ │ └── .gitignore
│ │ └── tests/
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 09-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 13-tests.scm
│ │ ├── 15-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 23-tests.scm
│ │ ├── 24-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 47-tests.scm
│ │ ├── 50-tests.scm
│ │ ├── 51-tests.scm
│ │ ├── 52-tests.scm
│ │ └── helpers/
│ │ ├── compiler.scm
│ │ ├── evaluator.scm
│ │ ├── memory.scm
│ │ ├── monitored-stack.scm
│ │ ├── sample-machines.scm
│ │ └── simulator.scm
│ ├── README.markdown
│ ├── Rakefile
│ ├── notes/
│ │ ├── week-01.markdown
│ │ ├── week-02.markdown
│ │ ├── week-03.markdown
│ │ ├── week-04.markdown
│ │ ├── week-05.markdown
│ │ ├── week-06.markdown
│ │ ├── week-07.markdown
│ │ ├── week-08.markdown
│ │ ├── week-09.markdown
│ │ ├── week-10.markdown
│ │ ├── week-11.markdown
│ │ ├── week-12.markdown
│ │ ├── week-13.markdown
│ │ ├── week-14.markdown
│ │ ├── week-15.markdown
│ │ ├── week-16.markdown
│ │ ├── week-17.markdown
│ │ ├── week-18.markdown
│ │ └── week-19.markdown
│ └── tests.watchr
└── textmate/
└── PLT Scheme.tmbundle/
├── README
├── Syntaxes/
│ └── Scheme.tmLanguage
└── info.plist
================================================
FILE CONTENTS
================================================
================================================
FILE: .git-hooks/install-hooks
================================================
#!/usr/bin/env zsh
emulate -R zsh
cd ${0%/*}
hooks_dir="$(git rev-parse --git-dir)/hooks"
for hook in *; do
if [[ $hook = ${0:t} ]]; then
continue
fi
target="$hooks_dir/$hook"
if [[ ! -f $target ]]; then
print "Linking $hook..."
ln -fs ${hook:a} $target
elif [[ -h $target ]]; then
print "$hook already linked."
else
print "[ERROR] $hook already exists!"
return 1
fi
done
================================================
FILE: .git-hooks/prepare-commit-msg
================================================
#!/usr/bin/env zsh
emulate -LR zsh
setopt extendedglob
files=("${(@f)$(git diff --cached --name-only)}")
case $files[1] in
(#b)other/clrs/([0-9][0-9])/([0-9][0-9]|problems)/([0-9][0-9]).*)
prefix=${files[1]%%.*}
# The filenames are sorted. If the first and the last have the same prefix,
# then every element in the file has this prefix.
if [[ $files[-1] != $prefix.* ]]; then
return 0
fi
# Don't do anything if a commit message is already present
if [[ -n $(head -n 1 $1) ]]; then
return 0
fi
chapter=${match[1]#0}
section=${match[2]#0}
exercise=${match[3]#0}
if [[ $section = 'problems' ]]; then
title=$(head -n 1 $prefix.markdown)
message="clrs; problem $chapter.$exercise - ${(L)title##\#\# }"
else
message="clrs; exercise $chapter.$section.$exercise - "
fi
sed -i -e "1i\\
$message\\
" $1
;;
(#b)scheme/eopl/([0-9][0-9])/([0-9][0-9]).scm)
chapter=${match[1]}
exercise=${match[2]}
# Abort if files are not for the same exercise
for file in $files; do
[[ $file != scheme/eopl/$chapter(/$exercise|/tests/${exercise}-tests).scm ]] && return 0
done
# Abort if commit message already enetered
[[ -n $(head -n 1 $1) ]] && return 0
sed -i -e "1i\\
eopl; exercise ${chapter#0}.$exercise - \\
" $1
;;
*)
;;
esac
================================================
FILE: .gitignore
================================================
java/**/bin/**
java/*/.classpath
java/*/.project
java/*/.settings/
================================================
FILE: README
================================================
You should probably not care about this project. It contains various code I decided to keep for various reason, none of them actually worth sharing.
================================================
FILE: Rakefile
================================================
desc 'Install git hooks'
task :hooks do
Dir['git-hooks/*'].each do |file|
name = file.split('/').last
sh "ln -s ../../#{file} .git/hooks/#{name}"
end
end
================================================
FILE: advent-of-code/2020/01.1.pl
================================================
use strict;
use v5.32;
open INPUT, '<', 'inputs/1.1';
my @numbers;
while (<INPUT>) {
chomp $_;
push @numbers, $_;
}
for my $a (@numbers) {
for my $b (@numbers) {
if ($a + $b == 2020) {
say "$a + $b = 2020; a * b = @{[$a * $b]}";
}
}
}
================================================
FILE: advent-of-code/2020/01.2.pl
================================================
use strict;
use v5.32;
open INPUT, '<', 'inputs/1.1';
my @numbers;
while (<INPUT>) {
chomp $_;
push @numbers, $_;
}
for my $a (@numbers) {
for my $b (@numbers) {
for my $c (@numbers) {
if ($a + $b + $c == 2020) {
say "$a + $b + $c = 2020; a * b = @{[$a * $b * $c]}";
}
}
}
}
================================================
FILE: advent-of-code/2020/02.1.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/2' or die;
my $valid = 0;
while (<INPUT>) {
/^(\d+)-(\d+) (\w): (.*)$/ or die("Unmatched input: $_");
my ($low, $high, $char, $password) = ($1, $2, $3, $4);
my $count = () = ($password =~ /$char/g);
$valid++ if ($low <= $count && $count <= $high);
}
say $valid;
================================================
FILE: advent-of-code/2020/02.2.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/2' or die;
my $valid = 0;
my $count = 0;
while (<INPUT>) {
$count++;
/^(\d+)-(\d+) (\w): (.*)$/ or die("Unmatched input: $_");
my ($first, $second, $char, $password) = ($1, $2, $3, $4);
$valid++ if substr($password, $first - 1, 1) eq $char xor substr($password, $second - 1, 1) eq $char;
}
say $valid;
================================================
FILE: advent-of-code/2020/03.1.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/3' or die;
my $input = [map { chomp; $_ } <INPUT>];
my $width = length($input->[0]);
my $height = @$input;
my @directions = (3, 1);
my ($x, $y) = (0, 0);
my $trees = 0;
while ($y < $height) {
$trees++ if substr($input->[$y], $x, 1) eq '#';
$y += $directions[1];
$x += $directions[0];
$x %= $width;
}
say $trees;
================================================
FILE: advent-of-code/2020/03.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( reduce );
open INPUT, '<', 'inputs/3' or die;
sub collisions {
my ( $input, $directions ) = @_;
my $width = length($input->[0]);
my $height = @$input;
my ($x, $y) = (0, 0);
my $trees = 0;
while ( $y < $height ) {
$trees++ if substr( $input->[$y], $x, 1 ) eq '#';
$y += $directions->[1];
$x += $directions->[0];
$x %= $width;
}
$trees;
}
my $input = [map { chomp; $_ } <INPUT>];
my $directions = [
[1, 1],
[3, 1],
[5, 1],
[7, 1],
[1, 2],
];
my @numbers;
for my $direction (@$directions) {
my $trees = collisions( $input, $direction );
say "right $direction->[0], left $direction->[1] = $trees";
push @numbers, $trees;
}
say "product = " . reduce { $a * $b } @numbers;
================================================
FILE: advent-of-code/2020/04.1.pl
================================================
use v5.32;
use warnings;
use Set::Scalar;
open INPUT, '<', 'inputs/4';
my $required = Set::Scalar->new(qw(byr iyr eyr hgt hcl ecl pid));
my $count;
local $/ = "\n\n";
while (<INPUT>) {
chomp;
my $record = $_;
my %fields;
$fields{$1} = $2 while $record =~ /(\S+):(\S+)/g;
my $keys = Set::Scalar->new(keys(%fields));
$count++ if $required->difference($keys)->is_empty;
}
say $count;
================================================
FILE: advent-of-code/2020/04.2.pl
================================================
use v5.32;
use warnings;
use Set::Scalar;
use Data::Dump qw(dump);
open INPUT, '<', 'inputs/4';
my $required = Set::Scalar->new(qw(byr iyr eyr hgt hcl ecl pid));
my $count;
local $/ = "\n\n";
while ( <INPUT> ) {
chomp;
my $record = $_;
my %fields;
$fields{$1} = $2 while $record =~ /(\S+):(\S+)/g;
my $keys = Set::Scalar->new( keys( %fields ) );
next unless $required->difference( $keys )->is_empty;
my ( $height, $unit ) = ( $fields{hgt} =~ /(\d+)(cm|in)/ );
next unless 1920 <= $fields{byr} and $fields{byr} <= 2002;
next unless 2010 <= $fields{iyr} and $fields{iyr} <= 2020;
next unless 2020 <= $fields{eyr} and $fields{eyr} <= 2030;
next unless defined $unit;
next unless ( $unit eq 'cm' and 150 <= $height and $height <= 193 ) or
( $unit eq 'in' and 59 <= $height and $height <= 76);
next unless $fields{hcl} =~ /^#[0-9a-f]{6}$/;
next unless $fields{ecl} =~ /^(amb|blu|brn|gry|grn|hzl|oth)$/;
next unless $fields{pid} =~ /^\d{9}$/;
$count++;
}
say $count;
================================================
FILE: advent-of-code/2020/05.1.pl
================================================
use v5.32;
use warnings;
use List::Util qw(max);
my $line = 'BFFFBBFRRR';
open INPUT, '<', 'inputs/5';
sub seat {
$_ = shift;
s/[BR]/1/g;
s/[FL]/0/g;
my ( $row, $column ) = (m/(\d{7})(\d{3})/);
$row = oct( "0b$row" );
$column = oct( "0b$column" );
[ $row, $column ];
}
sub seat_id {
my ($row, $column) = seat($_[0])->@*;
return $row * 8 + $column;
}
my @ids;
push @ids, seat_id($_) while <INPUT>;
say max(@ids);
================================================
FILE: advent-of-code/2020/05.2.pl
================================================
use v5.32;
use warnings;
use Array::Utils qw(array_minus);
use List::Util qw(min max);
my $line = 'BFFFBBFRRR';
open INPUT, '<', 'inputs/5';
sub seat {
$_ = shift;
s/[BR]/1/g;
s/[FL]/0/g;
my ( $row, $column ) = (m/(\d{7})(\d{3})/);
$row = oct( "0b$row" );
$column = oct( "0b$column" );
[ $row, $column ];
}
sub seat_id {
my ( $row, $column ) = seat( $_[0] )->@*;
return $row * 8 + $column;
}
my @ids;
push @ids, seat_id($_) while <INPUT>;
my @range = ( min(@ids) .. max(@ids) );
say array_minus(@range, @ids);
================================================
FILE: advent-of-code/2020/06.1.pl
================================================
use v5.32;
use warnings;
use Data::Dump qw( dump );
use List::Util qw( reduce );
use List::MoreUtils qw( uniq );
open INPUT, '<', 'inputs/6' or die;
$_ = do { local $/; <INPUT> };
my @chunks = split /\n\n/;
chomp @chunks;
s/\n//g for @chunks;
dump reduce { $a + $b }
map { scalar uniq split '' }
@chunks;
================================================
FILE: advent-of-code/2020/06.2.pl
================================================
use v5.32;
use warnings;
use Data::Dump qw( dump );
use List::Util qw( reduce );
use List::MoreUtils qw( uniq );
use Set::Scalar;
open INPUT, '<', 'inputs/6' or die;
$_ = do { local $/; <INPUT> };
my @chunks = split /\n\n/;
chomp @chunks;
dump reduce { $a + $b }
map { scalar $_->elements }
map { reduce { $a->intersection($b) } map { Set::Scalar->new(split '') } split "\n" }
@chunks;
================================================
FILE: advent-of-code/2020/07.1.pl
================================================
use v5.32;
use warnings;
use Data::Dump qw(dump);
my %bags;
open INPUT, '<', 'inputs/7' or die;
while (<INPUT>) {
/^(.*)? bags contain (.*)\.$/ or die;
my $color = $1;
if ( $2 eq 'no other bags' ) {
$bags{ $color } = [];
next;
}
my @options = split ', ', $2;
for ( @options ) {
/^(\d+) (.*?) bags?$/ or die;
my ( $count, $inner_color ) = ( $1, $2 );
push @{ $bags{$color} }, $inner_color;
}
}
sub can_contain {
my ( $outer, $inner ) = @_;
my @stack = ( $outer );
while ( @stack ) {
my $key = shift @stack;
return 1 if ( $key eq $inner );
push @stack, $bags{$key}->@*;
}
0;
}
my $count;
for ( keys %bags ) {
next if $_ eq 'shiny gold';
$count++ if can_contain( $_, 'shiny gold' );
}
say $count;
================================================
FILE: advent-of-code/2020/07.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( reduce );
use Data::Dump qw(dump);
my %bags;
open INPUT, '<', 'inputs/7' or die;
while (<INPUT>) {
/^(.*)? bags contain (.*)\.$/ or die;
my $color = $1;
if ( $2 eq 'no other bags' ) {
$bags{ $color } = [];
next;
}
my @options = split ', ', $2;
for ( @options ) {
/^(\d+) (.*?) bags?$/ or die;
my ( $count, $inner_color ) = ( $1, $2 );
push @{ $bags{$color} }, { count => $count, color => $inner_color };
}
}
sub number_of_bags {
my ( $color ) = @_;
return 0 unless $bags{ $color }->@*;
reduce { $a + $b }
map { $_->{count} + $_->{count} * number_of_bags($_->{color}) }
$bags{ $color }->@*;
}
say number_of_bags( 'shiny gold' );
================================================
FILE: advent-of-code/2020/08.1.pl
================================================
use v5.32;
use warnings;
use experimental qw( switch );
my @instructions;
open INPUT, '<', 'inputs/8';
while ( <INPUT> ) {
my ( $op, $arg ) = split ' ';
push @instructions, { op => $op, arg => $arg };
}
my @executed;
my $ip = 0;
my $reg = 0;
while (1) {
my ( $op, $arg ) = $instructions[$ip]->@{'op', 'arg'};
last if $executed[$ip];
$executed[$ip] = 1;
$ip++;
given ( $op ) {
when('nop') { }
when('jmp') { $ip += $arg - 1 }
when('acc') { $reg += $arg }
}
}
say $reg;
================================================
FILE: advent-of-code/2020/08.2.pl
================================================
use v5.32;
use warnings;
use experimental qw( switch );
use Storable qw( dclone );
my @instructions;
open INPUT, '<', 'inputs/8';
while ( <INPUT> ) {
my ( $op, $arg ) = split ' ';
push @instructions, { op => $op, arg => $arg };
}
use Data::Dump qw(dump);
sub evaluate {
my ( $instructions ) = @_;
my @executed;
my $infinite = 0;
my $ip = 0;
my $reg = 0;
while ( $ip <= $#instructions ) {
my ( $op, $arg ) = $instructions->[$ip]->@{'op', 'arg'};
if ( $executed[$ip] ) {
$infinite = 1;
last;
}
$executed[$ip] = 1;
$ip++;
given ( $op ) {
when('nop') { }
when('jmp') { $ip += $arg - 1 }
when('acc') { $reg += $arg }
}
}
return { reg => $reg, infinite => $infinite };
}
use Data::Dump qw(dump);
for my $i (0..$#instructions) {
my $modified = dclone( \@instructions );
if ( $modified->[$i]{op} eq 'nop' ) {
$modified->[$i]{op} = 'jmp';
} elsif ( $modified->[$i]{op} eq 'jmp' ) {
$modified->[$i]{op} = 'nop';
} else {
next
}
my $result = evaluate( $modified );
if ( ! $result->{infinite} ) {
say $result->{reg};
}
}
__DATA__
nop +0
acc +1
jmp +4
acc +3
jmp -3
acc -99
acc +1
jmp -4
acc +6
================================================
FILE: advent-of-code/2020/09.1.pl
================================================
use v5.32;
use warnings;
use Data::Dump qw(dump);
open INPUT, '<', 'inputs/9';
my $preamble = 25;
my $consume = $preamble;
my @window;
my %counts;
sub is_sum_of_two {
my ( $number, $counts ) = @_;
for my $key ( %$counts ) {
next unless $counts->{$key};
my $difference = $number - $key;
return 1 if $counts->{$difference} and ($difference != $key or $counts->{$difference} >= 2);
}
0
}
while (<INPUT>) {
chomp;
if ( $consume ) {
push @window, $_;
$counts{$_}++;
$consume--;
next;
}
unless (is_sum_of_two( $_, \%counts )) {
say "invalid: $_";
last;
}
my $removed = shift @window;
$counts{$removed}--;
push @window, $_;
$counts{$_}++;
}
================================================
FILE: advent-of-code/2020/09.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( min max );
use Data::Dump qw(dump);
open INPUT, '<', 'inputs/9';
my $preamble = 25;
sub is_sum_of_two {
my ( $number, $counts ) = @_;
for my $key ( %$counts ) {
next unless $counts->{$key};
my $difference = $number - $key;
return 1 if $counts->{$difference} and ($difference != $key or $counts->{$difference} >= 2);
}
0
}
sub weakness {
my ( $number, $numbers ) = @_;
for my $i ( 0 .. $#$numbers ) {
my $sum = 0;
my $j;
for ( $j = $i; $j <= $#$numbers; $j++ ) {
$sum += $numbers->[$j];
last if $sum >= $number;
}
next unless $sum == $number;
my @subrange = @{$numbers}[ $i .. $j ];
my $min = min @subrange;
my $max = max @subrange;
my $weakness = $min + $max;
return $weakness;
}
}
my $consume = $preamble;
my @numbers;
my @window;
my %counts;
while (<INPUT>) {
chomp;
push @numbers, $_;
if ( $consume ) {
push @window, $_;
$counts{$_}++;
$consume--;
next;
}
unless ( is_sum_of_two( $_, \%counts ) ) {
pop @numbers;
my $weakness = weakness( $_, \@numbers );
say "invalid: $_";
say "weakness: $weakness";
last;
}
my $removed = shift @window;
$counts{$removed}--;
push @window, $_;
$counts{$_}++;
}
================================================
FILE: advent-of-code/2020/10.1.pl
================================================
use v5.32;
use warnings;
use List::Util qw( max );
open INPUT, '<', 'inputs/10';
my @numbers = ( 0 );
while (<INPUT>) {
chomp;
push @numbers, $_;
}
@numbers = sort { $a <=> $b } @numbers;
push @numbers, max( @numbers ) + 3;
my %diffs;
for my $i ( 0 .. $#numbers - 1 ) {
my $diff = $numbers[$i + 1] - $numbers[$i];
$diffs{$diff}++
}
say $diffs{1} * $diffs{3}
================================================
FILE: advent-of-code/2020/10.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( max reduce );
open INPUT, '<', 'inputs/10';
my @numbers;
while (<INPUT>) {
chomp;
push @numbers, $_;
}
@numbers = sort { $a <=> $b } @numbers;
push @numbers, max( @numbers ) + 3;
my %diffs;
for my $i ( 0 .. $#numbers - 1 ) {
my $diff = $numbers[$i + 1] - $numbers[$i];
$diffs{$diff}++
}
my @count = (1);
for my $i ( @numbers ) {
my $possible = reduce { ($a // 0) + ($b // 0) } @count[max($i - 3, 0) .. $i - 1];
$count[$i] = $possible;
}
say $count[max(@numbers)];
================================================
FILE: advent-of-code/2020/11.1.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/11';
my $plan;
while ( <INPUT> ) {
chomp;
push @$plan, [ split '' ];
}
sub neighbours {
my ( $x, $y, $h, $w ) = @_;
my @result;
for my $a ( $x - 1 .. $x + 1 ) {
for my $b ( $y - 1 .. $y + 1 ) {
push @result, [ $a, $b ] if ( 0 <= $a and $a < $h and 0 <= $b and $b < $w and ( $a != $x or $b != $y ) );
}
}
@result;
}
sub iterate {
my $plan = shift;
my $height = @$plan;
my $width = @{$plan->[0]};
my $result = [];
for my $i ( 0 .. $height - 1 ) {
for my $j ( 0 .. $width - 1 ) {
my @neighbours = neighbours( $i, $j, $height, $width );
my $seat = $plan->[ $i ][ $j ];
my $taken = 0;
for ( @neighbours ) {
$taken++ if $plan->[ $_->[0] ][ $_->[1] ] eq '#';
}
if ( $seat eq 'L' and $taken == 0 ) {
$seat = '#';
} elsif ( $seat eq '#' and $taken >= 4 ) {
$seat = 'L';
}
$result->[ $i ][ $j ] = $seat;
}
}
$result;
}
for ( 0 .. 100000 ) {
my $before = join "\n", map { join '', @$_ } @$plan;
$plan = iterate( $plan );
my $after = join "\n", map { join '', @$_ } @$plan;
if ( $before eq $after ) {
my $count = () = $after =~ /#/g;
say $count;
last;
}
}
================================================
FILE: advent-of-code/2020/11.2.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/11';
my $plan;
while ( <INPUT> ) {
chomp;
push @$plan, [ split '' ];
}
sub neighbours {
my ( $x, $y, $h, $w ) = @_;
my @result;
for my $a ( $x - 1 .. $x + 1 ) {
for my $b ( $y - 1 .. $y + 1 ) {
push @result, [ $a, $b ] if ( 0 <= $a and $a < $h and 0 <= $b and $b < $w and ( $a != $x or $b != $y ) );
}
}
@result;
}
sub iterate {
my $plan = shift;
my $height = @$plan;
my $width = @{$plan->[0]};
my $result = [];
for my $i ( 0 .. $height - 1 ) {
for my $j ( 0 .. $width - 1 ) {
my $seat = $plan->[ $i ][ $j ];
my $taken = visible_occupied( $plan, $i, $j );
if ( $seat eq 'L' and $taken == 0 ) {
$seat = '#';
} elsif ( $seat eq '#' and $taken >= 5 ) {
$seat = 'L';
}
$result->[ $i ][ $j ] = $seat;
}
}
$result;
}
sub first_in_direction {
my ( $plan, $x, $y, $direction ) = @_;
my $height = @$plan;
my $width = @{$plan->[0]};
$x += $direction->[0];
$y += $direction->[1];
while ( 0 <= $x and $x < $height and 0 <= $y and $y < $width ) {
my $seat = $plan->[ $x ][ $y ];
if ( $seat ne '.' ) {
return $seat;
}
$x += $direction->[0];
$y += $direction->[1];
}
return '.';
}
sub visible_occupied {
my ( $plan, $x, $y ) = @_;
my @directions = ( [0, 1], [0, -1], [1, 0], [-1, 0], [1, 1], [-1, 1], [1, -1], [-1, -1] );
my @seen = map { first_in_direction( $plan, $x, $y, $_ ) } @directions;
my $count = 0;
for ( @seen ) {
$count++ if $_ eq '#';
}
$count;
}
for ( 0 .. 100000 ) {
my $before = join "\n", map { join '', @$_ } @$plan;
$plan = iterate( $plan );
my $after = join "\n", map { join '', @$_ } @$plan;
if ( $before eq $after ) {
my $count = () = $after =~ /#/g;
say $count;
last;
}
}
================================================
FILE: advent-of-code/2020/12.1.pl
================================================
use v5.32;
use warnings;
use experimental qw(smartmatch switch);
open INPUT, '<', 'inputs/12';
my @pos = ( 0, 0 );
my @dir = ( 0, 1 );
sub rotate {
my ( $deg, $a, $b ) = @_;
my @dir = $deg > 0 ? ( 1, -1 ) : ( -1, 1 );
my $steps = abs($deg) / 90;
for ( 1..$steps ) {
( $a, $b ) = ( $b * $dir[0], $a * $dir[1] );
}
( $a, $b );
}
while (<INPUT>) {
/^([NSEWLRF])(\d+)$/;
my ( $cmd, $d ) = ( $1, $2 );
my ( $x, $y, $a, $b ) = ( @pos, @dir );
given ( $cmd ) {
when('F') { @pos = ( $x + $a * $d, $y + $b * $d ) }
when('L') { @dir = rotate(-$d, $a, $b) }
when('R') { @dir = rotate($d, $a, $b) }
when('N') { @pos = ( $x - $d, $y ) }
when('S') { @pos = ( $x + $d, $y ) }
when('W') { @pos = ( $x, $y - $d ) }
when('E') { @pos = ( $x, $y + $d ) }
}
}
say abs($pos[0]) + abs($pos[1]);
__END__
F10
N3
F7
R90
F11
================================================
FILE: advent-of-code/2020/12.2.pl
================================================
use v5.32;
use warnings;
use experimental qw(smartmatch switch);
open INPUT, '<', 'inputs/12';
my @pos = ( 0, 0 );
my @wp = ( -1, 10 );
sub rotate {
my ( $deg, $a, $b ) = @_;
my @dir = $deg > 0 ? ( 1, -1 ) : ( -1, 1 );
my $steps = abs($deg) / 90;
for ( 1..$steps ) {
( $a, $b ) = ( $b * $dir[0], $a * $dir[1] );
}
( $a, $b );
}
while (<INPUT>) {
chomp;
/^([NSEWLRF])(\d+)$/;
my ( $cmd, $d ) = ( $1, $2 );
my ( $x, $y, $a, $b ) = ( @pos, @wp );
say "$_: [$x, $y] // [$a, $b]";
given ( $cmd ) {
when('F') { @pos = ( $x + $a * $d, $y + $b * $d ) }
when('L') { @wp = rotate(-$d, $a, $b) }
when('R') { @wp = rotate($d, $a, $b) }
when('N') { @wp = ( $a - $d, $b ) }
when('S') { @wp = ( $a + $d, $b ) }
when('W') { @wp = ( $a, $b - $d ) }
when('E') { @wp = ( $a, $b + $d ) }
}
}
say abs($pos[0]) + abs($pos[1]);
================================================
FILE: advent-of-code/2020/13.1.pl
================================================
use v5.32;
use warnings;
open INPUT, '<', 'inputs/13';
my $contents = do { local $/; <INPUT> };
my ( $time, $schedule ) = split "\n", $contents;
my @ids = grep { $_ ne 'x' } split ',', $schedule;
my $min = 10_000_000_000;
my $answer = 0;
for my $id ( @ids ) {
my $wait = ($id - $time % $id);
if ( $wait < $min ) {
$min = $wait;
$answer = $wait * $id;
}
}
say $answer;
__END__
939
7,13,x,x,59,x,31,19
================================================
FILE: advent-of-code/2020/13.2.pl
================================================
use v5.32;
use warnings;
use Math::Utils qw( gcd );
open INPUT, '<', 'inputs/13';
my $contents = do { local $/; <INPUT> };
my ( $time, $schedule ) = split "\n", $contents;
my @ids = split ',', $schedule;
my $start = shift @ids;
my $offset = 0;
my $step = $start;
for my $id ( @ids ) {
$offset += 1;
next if $id eq 'x';
$start += $step until ( $start + $offset ) % $id == 0 and $start >= $id ;
$step = ($step * $id) / gcd( $step, $id );
}
say $start;
================================================
FILE: advent-of-code/2020/14.1.pl
================================================
use v5.32;
use warnings;
use experimental "switch";
use bigint;
use List::Util qw( sum );
open INPUT, '<', 'inputs/14';
sub bin { oct "0b$_[0]" }
sub mask {
my ( $mask, $num ) = @_;
( $num & bin( $mask =~ s/X/1/rg ) ) | bin( $mask =~ s/X/0/rg );
}
my $mask;
my %mem;
while (<INPUT>) {
given ($_) {
when(/^mask = ([X01]+)$/) {
$mask = $1;
}
when(/^mem\[(\d+)\] = (\d+)$/) {
$mem{$1} = mask( $mask, $2 );
}
default { say "OH NON NON ON ON O" }
}
}
say sum values(%mem);
================================================
FILE: advent-of-code/2020/14.2.pl
================================================
use v5.32;
use warnings;
use experimental "switch";
use bigint;
use List::Util qw( sum );
use List::MoreUtils qw( uniq zip6 );
open INPUT, '<', 'inputs/14';
sub bin { oct "0b$_[0]" }
sub mask {
my ( $mask, $addr ) = @_;
my @mask = split '', $mask;
my @addr = split '', sprintf( "%036b", $addr );
variants( join "", map { $_->[0] == 1 ? '1' : $_->[0] eq 'X' ? 'X' : $_->[1] } zip6( @mask, @addr ) );
}
sub variants {
my ( $mask ) = @_;
my @result;
return ( $mask ) unless $mask =~ m/^([01]*)(?:(X)(.*))$/;
my ( $prefix, $suffix ) = ( $1, $3 );
map { ( "${prefix}0$_", "${prefix}1$_" ) } variants( $suffix );
}
my $mask;
my %mem;
while (<INPUT>) {
given ($_) {
when(/^mask = ([X01]+)$/) {
$mask = $1;
}
when(/^mem\[(\d+)\] = (\d+)$/) {
my ( $x, $y ) = ( $1, $2 );
my @addrs = mask( $mask, $1 );
$mem{$_} = $y for ( @addrs );
}
default { say "OH NON NON ON ON O" }
}
}
say sum values(%mem);
================================================
FILE: advent-of-code/2020/15.1.pl
================================================
use v5.32;
use warnings;
my @numbers = ( 15, 12, 0, 14, 3, 1 );
my %spoken;
my $next = shift @numbers;
my $turn = 1;
for my $number ( @numbers ) {
$spoken{$next} = $turn++;
$next = $number;
}
while ( $turn < 2020 ) {
my $said;
if ( $spoken{$next} ) {
$said = $turn - $spoken{$next};
} else {
$said = 0;
}
$spoken{$next} = $turn;
$turn++;
$next = $said;
}
say $next;
================================================
FILE: advent-of-code/2020/15.2.pl
================================================
use v5.32;
use warnings;
my @numbers = ( 15, 12, 0, 14, 3, 1 );
my %spoken;
my $next = shift @numbers;
my $turn = 1;
for my $number ( @numbers ) {
$spoken{$next} = $turn++;
$next = $number;
}
while ( $turn < 30000000 ) {
my $said;
if ( $spoken{$next} ) {
$said = $turn - $spoken{$next};
} else {
$said = 0;
}
$spoken{$next} = $turn;
$turn++;
$next = $said;
}
say $next;
================================================
FILE: advent-of-code/2020/16.1.pl
================================================
use v5.32;
use warnings;
use List::Util qw( none );
open INPUT, '<', 'inputs/16';
my $contents = do { local $/; <INPUT> };
my @parts = split "\n\n", $contents;
my %rules;
my @ticket;
my @nearby;
for ( split "\n", $parts[0] ) {
/^([^:]+): (\d+)-(\d+) or (\d+)-(\d+)$/ or die $_;
my ( $name, $a, $b, $c, $d ) = ( $1, $2, $3, $4, $5 );
$rules{$name} = sub { my $x = $_[0]; $a <= $x and $x <= $b or $c <= $x and $x <= $d };
}
@ticket = ( split ",", ( split("\n", $parts[1]) )[1] );
$parts[2] =~ s/^nearby tickets:\n//sg;
for ( split "\n", $parts[2] ) {
push @nearby, [ split "," ];
}
my $sum;
for my $ticket ( @nearby ) {
for my $number ( @$ticket ) {
$sum += $number if none { $_->($number) } (values %rules);
}
}
say $sum;
================================================
FILE: advent-of-code/2020/16.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( none );
use Set::Scalar;
open INPUT, '<', 'inputs/16';
my $contents = do { local $/; <INPUT> };
my @parts = split "\n\n", $contents;
my %rules;
my @ticket;
my @nearby;
for ( split "\n", $parts[0] ) {
/^([^:]+): (\d+)-(\d+) or (\d+)-(\d+)$/ or die $_;
my ( $name, $a, $b, $c, $d ) = ( $1, $2, $3, $4, $5 );
$rules{$name} = sub { my $x = $_[0]; $a <= $x and $x <= $b or $c <= $x and $x <= $d };
}
@ticket = ( split ",", ( split("\n", $parts[1]) )[1] );
$parts[2] =~ s/^nearby tickets:\n//sg;
for ( split "\n", $parts[2] ) {
push @nearby, [ split "," ];
}
sub is_valid {
my $ticket = shift;
for my $number ( @$ticket ) {
return 0 if none { $_->($number) } (values %rules);
}
1;
}
my @valid = grep { is_valid($_) } @nearby;
my @possible = map { Set::Scalar->new( keys(%rules) ) } ( 1 .. %rules );
for my $ticket ( @valid ) {
my @numbers = @$ticket;
for my $i ( 0 .. $#numbers ) {
while ( my ( $name, $fn ) = each %rules ) {
if ( ! $fn->( $numbers[$i] ) ) {
$possible[$i]->delete( $name );
}
}
}
}
for ( 0 .. $#possible ) {
my $remove = Set::Scalar->new( map { $_->elements } grep { $_->size == 1 } @possible );
for my $set ( @possible ) {
$set -= $remove if ( $set->size > 1 );
}
}
my %positions;
for ( 0 .. $#possible ) {
my $set = $possible[$_];
die "collision" if $set->size != 1;
$positions{ ($set->members)[0] } = $_;
}
my $result = 1;
while ( my ( $name, $pos ) = each %positions ) {
next unless $name =~ /^departure /;
$result *= $ticket[$pos];
}
say $result;
================================================
FILE: advent-of-code/2020/17.1.pl
================================================
use v5.32;
use warnings;
use Hash::MultiKey;
use List::Util qw( sum uniq );
my %game;
tie %game, 'Hash::MultiKey';
my $x = 0;
open INPUT, '<', 'inputs/17';
while (<INPUT>) {
my @chars = split '';
for my $y ( 0 .. $#chars ) {
if ( $chars[$y] eq '#' ) {
$game{ [ $x, $y, 0] } = 1;
}
}
$x++;
}
sub neighbours {
my ( $x, $y, $z ) = $_[0]->@*;
my @result;
for my $dx ( -1 .. 1 ) {
for my $dy ( -1 .. 1 ) {
for my $dz ( -1 .. 1 ) {
next unless $dx || $dy || $dz;
push @result, [ $x + $dx, $y + $dy, $z + $dz ];
}
}
}
@result;
}
for ( 1 .. 6 ) {
my %next;
tie %next, 'Hash::MultiKey';
my @space;
while ( my ( $cube, $alive ) = each %game ) {
next unless $alive;
for my $neighbour ( neighbours( $cube ) ) {
push @space, join(',', @$neighbour);
}
}
@space = map { [ split ',' ] } uniq @space;
for my $cube ( @space ) {
my $count = sum( grep { defined $_ } @game{ neighbours( $cube ) } );
my $alive = $game{ $cube } // 0;
$next{ $cube } = 1 if $count == 3 || ( $alive && $count == 2 ) ;
}
%game = %next;
}
say sum values( %game );
================================================
FILE: advent-of-code/2020/17.2.pl
================================================
use v5.32;
use warnings;
use Hash::MultiKey;
use List::Util qw( sum uniq );
my %game;
tie %game, 'Hash::MultiKey';
my $x = 0;
open INPUT, '<', 'inputs/17';
while (<INPUT>) {
my @chars = split '';
for my $y ( 0 .. $#chars ) {
if ( $chars[$y] eq '#' ) {
$game{ [ $x, $y, 0, 0 ] } = 1;
}
}
$x++;
}
sub neighbours {
my ( $x, $y, $z, $w ) = $_[0]->@*;
my @result;
for my $dx ( -1 .. 1 ) {
for my $dy ( -1 .. 1 ) {
for my $dz ( -1 .. 1 ) {
for my $dw ( -1 .. 1 ) {
next unless $dx || $dy || $dz || $dw;
push @result, [ $x + $dx, $y + $dy, $z + $dz, $w + $dw ];
}
}
}
}
@result;
}
for ( 1 .. 6 ) {
my %next;
tie %next, 'Hash::MultiKey';
my @space;
while ( my ( $cube, $alive ) = each %game ) {
next unless $alive;
for my $neighbour ( neighbours( $cube ) ) {
push @space, join(',', @$neighbour);
}
}
@space = map { [ split ',' ] } uniq @space;
for my $cube ( @space ) {
my $count = sum( grep { defined $_ } @game{ neighbours( $cube ) } ) // 0;
my $alive = $game{ $cube } // 0;
$next{ $cube } = 1 if $count == 3 || ( $alive && $count == 2 ) ;
}
%game = %next;
}
say sum values( %game );
================================================
FILE: advent-of-code/2020/18.1.pl
================================================
use v5.32;
use warnings;
use experimental 'switch';
open INPUT, '<', 'inputs/18';
sub evaluate {
my $tokens = shift;
my $op = sub { $_[1] };
my $result = 0;
while (my $next = shift( @$tokens )) {
given ( $next ) {
when( /(\d)/ ) { $result = $op->( $result, $1 ) }
when( '+' ) { $op = sub { $_[0] + $_[1] } }
when( '*' ) { $op = sub { $_[0] * $_[1] } }
when( '(' ) { $result = $op->( $result, evaluate( $tokens ) ) }
when( ')' ) { return $result }
default { die "unexpected token: $next"; }
}
}
$result;
}
sub parse {
$_ = shift;
s/ //g;
chomp;
my @tokens = split '';
evaluate( \@tokens );
}
my $result = 0;
while (<INPUT>) {
$result += parse( $_ );
}
say $result;
__DATA__
1 + (2 * 3) + (4 * (5 + 6))
2 * 3 + (4 * 5)
5 + (8 * 3 + 9 + 3 * 4 * 3)
5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))
((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2
================================================
FILE: advent-of-code/2020/18.2.pl
================================================
use v5.32;
use warnings;
my $parse = qr{
(?&MULT) (?{ $_ = $^R->[1] })
(?(DEFINE)
(?<NUMBER> ( \d ) (?{ [$^R, eval $^N] }) )
(?<ATOM> ( (?&NUMBER) | \( (?&MULT) \) ) )
(?<MULT>
(?&ADD) (?{ [ $^R->[0], $^R->[1] ] })
(?: \* (?&ADD) (?{ [ $^R->[0][0], $^R->[0][1] * $^R->[1] ] }) )*
)
(?<ADD>
(?&ATOM) (?{ [ $^R->[0], $^R->[1] ] })
(?: \+ (?&ATOM) (?{ [ $^R->[0][0], $^R->[0][1] + $^R->[1] ] }) )*
)
)
}xms;
sub parse {
local $_ = shift;
local $^R;
s/ //g;
eval { m{\A$parse\z} } and return $_;
die $@;
}
open INPUT, '<', 'inputs/18';
my $result;
$result += parse($_) while (<INPUT>);
say $result;
================================================
FILE: advent-of-code/2020/19.1.pl
================================================
use v5.32;
use warnings;
use experimental 'switch';
open INPUT, '<', 'inputs/19';
my $contents = do { local $/; <INPUT> };
my @parts = split "\n\n", $contents;
my %definitions;
for ( split "\n", $parts[0] ) {
m/^(\d+): (.*)$/;
$definitions{ $1 } = $2;
}
my %compiled;
sub compile {
my $n = shift;
return $compiled{ $n } if exists $compiled{ $n };
my $compiled;
given ( $definitions{ $n } ) {
when(/^ " (\w) " $/x) {
$compiled = $1
}
when(/^ (\d+) ( \s+ ( \d+ | \| ) )* $/x) {
$compiled = '(' . ( join '|', map { s/(\d+)\s*/compile( $1 )/eg; $_ } split /\s*\|\s*/ ) . ')';
}
default {
die "can't compile: $_",
}
}
$compiled{ $n } = $compiled;
}
my $pattern = compile( 0 );
my $regex = qr/^$pattern$/;
my $count = 0;
for ( split "\n", $parts[1] ) {
$count++ if $_ =~ $regex;
}
say $count;
================================================
FILE: advent-of-code/2020/19.2.pl
================================================
use v5.32;
use warnings;
open STDIN, '<', 'inputs/19';
$/ x= 2;
$_ = <>;
s/^8: .*$/8: 42 | 42 8/m;
s/^11: .*$/11: 42 31 | 42 11 31/m;
s/^(\d+): (.*)$/"(?<g$1> (" . ( $2 =~ s#(\d+)#(?&g$1)#gr ) . ") )"/gem;
s/\("(\w)"\)/$1/g;
my $pattern = qr/^(?&g0) (?(DEFINE) $_)$/x;
say scalar grep { m/$pattern/ } split "\n", <>;
================================================
FILE: advent-of-code/2020/20.1.pl
================================================
use v5.32;
use warnings;
use List::Util qw( first min max reduce );
open STDIN, '<', 'inputs/20';
my @tiles;
sub bin {
$_ = shift;
s/\./0/g;
s/#/1/g;
oct "0b$_";
}
sub rotate {
my ( $t, $r, $b, $l ) = @_;
return ( scalar reverse( $l ), $t, scalar reverse( $r ), $b );
}
sub hpose {
my ( $t, $r, $b, $l ) = @_;
return ( $b, scalar reverse( $r ), $t, scalar reverse( $l ) );
}
$/ x= 2;
while (<>) {
m/Tile (\d+):/ or die $_;
my $id = $1;
my ( $first , @lines ) = split "\n";
my ( $top, $bottom ) = ( $lines[0], $lines[-1] );
my $left = join '', map { substr $_, 0, 1 } @lines;
my $right = join '', map { substr $_, -1, 1 } @lines;
my @row = ( $top, $right, $bottom, $left );
my @variants;
push @variants, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @variants, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @variants, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @variants, [ @row ], [ hpose( @row ) ];
push @tiles, {
id => $id,
lines => [ @lines ],
left => $left,
right => $right,
top => $top,
bottom => $bottom,
variants => [ map { [ map { bin( $_ ) } @$_ ] } @variants ]
};
}
$tiles[0]{pos} = [0, 0];
$tiles[0]{rotation} = $tiles[0]{variants}[0];
my @unchecked = ( $tiles[0] );
while ( @unchecked ) {
my $tile = shift @unchecked;
my ( $top, $right, $bottom, $left ) = $tile->{rotation}->@*;
my ( $x, $y ) = $tile->{pos}->@*;
for my $other ( @tiles ) {
next if exists $other->{pos};
for my $variant ( $other->{variants}->@* ) {
if ( $top == $variant->[2] ) {
$other->{pos} = [ $x - 1, $y ];
$other->{rotation} = $variant;
push @unchecked, $other;
} elsif ( $right == $variant->[3] ) {
$other->{pos} = [ $x, $y + 1 ];
$other->{rotation} = $variant;
push @unchecked, $other;
} elsif ( $bottom == $variant->[0] ) {
$other->{pos} = [ $x + 1, $y ];
$other->{rotation} = $variant;
push @unchecked, $other;
} elsif ( $left == $variant->[1] ) {
$other->{pos} = [ $x, $y - 1 ];
$other->{rotation} = $variant;
push @unchecked, $other;
}
}
}
}
my $top = min map { $_->{pos}[0] } @tiles;
my $bottom = max map { $_->{pos}[0] } @tiles;
my $left = min map { $_->{pos}[1] } @tiles;
my $right = max map { $_->{pos}[1] } @tiles;
my @corners = (
(first { $_->{pos}[0] == $top && $_->{pos}[1] == $left } @tiles)->{id},
(first { $_->{pos}[0] == $top && $_->{pos}[1] == $right } @tiles)->{id},
(first { $_->{pos}[0] == $bottom && $_->{pos}[1] == $left } @tiles)->{id},
(first { $_->{pos}[0] == $bottom && $_->{pos}[1] == $right } @tiles)->{id},
);
say reduce { $a * $b } @corners;
================================================
FILE: advent-of-code/2020/20.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( first min max reduce );
use List::MoreUtils qw( all );
use Hash::MultiKey;
use experimental 'switch';
open STDIN, '>&', DATA;
open STDIN, '<', 'inputs/20';
my @tiles;
sub bin {
$_ = shift;
s/\./0/g;
s/#/1/g;
oct "0b$_";
}
sub rotate {
my ( $t, $r, $b, $l ) = @_;
return ( scalar reverse( $l ), $t, scalar reverse( $r ), $b );
}
sub hpose {
my ( $t, $r, $b, $l ) = @_;
return ( $b, scalar reverse( $r ), $t, scalar reverse( $l ) );
}
$/ x= 2;
while (<>) {
m/Tile (\d+):/ or die $_;
my $id = $1;
my ( $first , @lines ) = split "\n";
my ( $top, $bottom ) = ( $lines[0], $lines[-1] );
my $left = join '', map { substr $_, 0, 1 } @lines;
my $right = join '', map { substr $_, -1, 1 } @lines;
my @row = ( $top, $right, $bottom, $left );
my @images;
push @images, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @images, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @images, [ @row ], [ hpose( @row ) ];
@row = rotate( @row );
push @images, [ @row ], [ hpose( @row ) ];
push @tiles, {
id => $id,
image => [ map { [split ''] } @lines ],
left => $left,
right => $right,
top => $top,
bottom => $bottom,
variants => [ map { [ map { bin( $_ ) } @$_ ] } @images ]
};
}
$tiles[0]{pos} = [0, 0];
$tiles[0]{rotation} = $tiles[0]{variants}[0];
$tiles[0]{orientation} = 0;
my @unchecked = ( $tiles[0] );
sub orient {
my ( $image, $index ) = @_;
my $s = $#{$image->[0]};
my $pick;
given ($index) {
when(0) { $pick = sub { my ( $a, $b ) = @_; $image->[$a][$b] } }
when(1) { $pick = sub { my ( $a, $b ) = @_; $image->[$s - $a][$b] } }
when(2) { $pick = sub { my ( $a, $b ) = @_; $image->[$s - $b][$a] } }
when(3) { $pick = sub { my ( $a, $b ) = @_; $image->[$s - $b][$s - $a] } }
when(4) { $pick = sub { my ( $a, $b ) = @_; $image->[$s - $a][$s - $b] } }
when(5) { $pick = sub { my ( $a, $b ) = @_; $image->[$a][$s - $b] } }
when(6) { $pick = sub { my ( $a, $b ) = @_; $image->[$b][$s - $a] } }
when(7) { $pick = sub { my ( $a, $b ) = @_; $image->[$b][$a] } }
}
my @result;
for my $x ( 0 .. $s ) {
my @line;
for my $y ( 0 .. $s ) {
push @line, $pick->( $x, $y );
}
push @result, [ @line ];
}
\@result;
}
while ( @unchecked ) {
my $tile = shift @unchecked;
my ( $top, $right, $bottom, $left ) = $tile->{rotation}->@*;
my ( $x, $y ) = $tile->{pos}->@*;
for my $other ( @tiles ) {
next if exists $other->{pos};
for my $i ( 0..$#{$other->{variants}} ) {
my $variant = $other->{variants}[$i];
use Data::Dump qw(dump);
if ( $top == $variant->[2] ) {
$other->{pos} = [ $x - 1, $y ];
$other->{rotation} = $variant;
$other->{orientation} = $i;
push @unchecked, $other;
} elsif ( $right == $variant->[3] ) {
$other->{pos} = [ $x, $y + 1 ];
$other->{rotation} = $variant;
$other->{orientation} = $i;
push @unchecked, $other;
} elsif ( $bottom == $variant->[0] ) {
$other->{pos} = [ $x + 1, $y ];
$other->{rotation} = $variant;
$other->{orientation} = $i;
push @unchecked, $other;
} elsif ( $left == $variant->[1] ) {
$other->{pos} = [ $x, $y - 1 ];
$other->{rotation} = $variant;
$other->{orientation} = $i;
push @unchecked, $other;
}
}
}
}
my $top = min map { $_->{pos}[0] } @tiles;
my $bottom = max map { $_->{pos}[0] } @tiles;
my $left = min map { $_->{pos}[1] } @tiles;
my $right = max map { $_->{pos}[1] } @tiles;
my %positions;
tie %positions, 'Hash::MultiKey';
for my $tile ( @tiles ) {
$positions{ $tile->{pos} } = $tile;
}
my @complete;
for my $x ( $top .. $bottom ) {
my @images;
for my $y ( $left .. $right ) {
my $tile = $positions{ [$x, $y] };
my $image = orient( $tile->{image}, $tile->{orientation} );
push @images, $image;
}
for my $i ( 1 .. 8 ) {
my @line;
for my $image ( @images ) {
push @line, @{$image->[$i]}[1..8];
}
push @complete, [ @line ];
}
}
my $pattern = <<END;
#
# ## ## ###
# # # # # #
END
sub patternize {
my @dots;
my $pattern = shift;
my @lines = split "\n", $pattern;
for my $x ( 0..$#lines ) {
my $line = $lines[$x];
my @chars = split "", $line;
for my $y ( 0..$#chars ) {
my $char = $chars[$y];
if ( $char eq '#' ) {
push @dots, [$x, $y];
}
}
}
return @dots;
}
my @dots = patternize( $pattern );
my $size = $#complete;
for my $orientation ( 0 .. 7 ) {
my $h = max map { $_->[0] } @dots;
my $w = max map { $_->[1] } @dots;
my $image = orient( \@complete, $orientation );
my $found = 0;
for my $x ( 0 .. $size - $h ) {
for my $y ( 0 .. $size - $w ) {
if ( all { $image->[$x + $_->[0]][$y + $_->[1]] eq '#' } @dots ) {
$found = 1;
for ( @dots ) {
$image->[$x + $_->[0]][$y + $_->[1]] = '.';
}
}
}
}
if ( $found ) {
say scalar grep { $_ eq '#' } map { @$_ } @$image;
last;
}
}
================================================
FILE: advent-of-code/2020/21.1.pl
================================================
use v5.32;
use warnings;
use Set::Scalar;
use List::Util qw( uniq );
use Array::Utils qw( array_diff );
open STDIN, '<', 'inputs/21';
my %possible;
my @foods;
while (<>) {
m/^(.*) \(contains (.*)\)$/;
my @ingredients = split ' ', $1;
my @allergens = split ', ', $2;
my $set = Set::Scalar->new( @ingredients );
push @foods, { ingredients => [ @ingredients ], allergens => [ @allergens ] };
for ( @allergens ) {
$possible{ $_ } ||= $set;
$possible{ $_ } = $possible{ $_ }->intersection( $set );
}
}
for ( 0 .. scalar keys %possible ) {
my @sets = values %possible;
my $remove = Set::Scalar->new( map { $_->elements } grep { $_->size == 1 } @sets );
for ( keys %possible ) {
$possible{ $_ } -= $remove if ( $possible{ $_ }->size > 1 );
}
}
my @all = uniq map { $_->{ingredients}->@* } @foods;
my @allergens = uniq map { $_->elements } values %possible;
my $safe = Set::Scalar->new( array_diff @all, @allergens );
my $count = 0;
for ( @foods ) {
for ( $_->{ingredients}->@* ) {
$count++ if ( $safe->has( $_ ) );
}
}
say $count;
================================================
FILE: advent-of-code/2020/21.2.pl
================================================
use v5.32;
use warnings;
use Set::Scalar;
use List::Util qw( uniq );
use Array::Utils qw( array_diff );
open STDIN, '<', 'inputs/21';
my %possible;
my @foods;
while (<>) {
m/^(.*) \(contains (.*)\)$/;
my @ingredients = split ' ', $1;
my @allergens = split ', ', $2;
my $set = Set::Scalar->new( @ingredients );
push @foods, { ingredients => [ @ingredients ], allergens => [ @allergens ] };
for ( @allergens ) {
$possible{ $_ } ||= $set;
$possible{ $_ } = $possible{ $_ }->intersection( $set );
}
}
for ( 0 .. scalar keys %possible ) {
my @sets = values %possible;
my $remove = Set::Scalar->new( map { $_->elements } grep { $_->size == 1 } @sets );
for ( keys %possible ) {
$possible{ $_ } -= $remove if ( $possible{ $_ }->size > 1 );
}
}
my %allergens;
for ( keys %possible ) {
my $name = ( $possible{ $_ }->elements )[0];
$allergens{ $name } = $_;
}
my @all = uniq map { $_->{ingredients}->@* } @foods;
my @allergens = uniq map { $_->elements } values %possible;
my $safe = Set::Scalar->new( array_diff @all, @allergens );
my $count = 0;
for ( @foods ) {
for ( $_->{ingredients}->@* ) {
$count++ if ( $safe->has( $_ ) );
}
}
say join ',', sort { $allergens{ $a } cmp $allergens{ $b } } @allergens;
================================================
FILE: advent-of-code/2020/22.1.pl
================================================
use v5.32;
use warnings;
use List::MoreUtils qw( zip );
open STDIN, '<', 'inputs/22';
$_ = do { local $/; <> };
m/^Player 1:\n(.*)\n\nPlayer 2:\n(.*)\n$/sm;
my @a = split "\n", $1;
my @b = split "\n", $2;
while ( @a and @b ) {
my ( $a, $b ) = ( shift @a, shift @b );
if ( $a > $b ) {
push @a, $a, $b;
} else {
push @b, $b, $a;
}
}
my $i = @a + @b;
my $sum = 0;
$sum += $_ * $i-- for ( @a, @b );
say $sum;
================================================
FILE: advent-of-code/2020/22.2.pl
================================================
use v5.32;
use warnings;
use List::MoreUtils qw( zip );
open STDIN, '<', 'inputs/22';
$_ = do { local $/; <> };
m/^Player 1:\n(.*)\n\nPlayer 2:\n(.*)\n$/sm;
my @a = split "\n", $1;
my @b = split "\n", $2;
sub round {
my @a = $_[0]->@*;
my @b = $_[1]->@*;
my %seen;
while ( @a and @b ) {
my $signature = join( ' ', @a ) . ' | ' . join( ' ', @b );
return { winner => 1, a => \@a, b => \@b } if $seen{ $signature };
$seen{ $signature } = 1;
my ( $a, $b ) = ( shift @a, shift @b );
my $a_wins;
if ( $a <= @a and $b <= @b ) {
my $result = round( [ @a[ 0 .. $a - 1] ], [ @b[ 0 .. $b - 1 ] ] );
$a_wins = ($result->{winner} == 1);
} elsif ( $a > $b ) {
$a_wins = 1;
} else {
$a_wins = 0;
}
if ( $a_wins ) {
push @a, $a, $b;
} else {
push @b, $b, $a;
}
}
return {
winner => ( @a ) ? 1 : 2,
a => [ @a ],
b => [ @b ],
}
}
my $result = round( [ @a ], [ @b ] );
my $i = $result->{a}->@* + $result->{b}->@*;
my $sum = 0;
$sum += $_ * $i-- for ( $result->{a}->@*,$result->{b}->@* );
say $sum;
================================================
FILE: advent-of-code/2020/23.1.pl
================================================
use v5.32;
use warnings;
use List::Util qw( any );
use constant INPUT => '784235916';
package Ring {
use List::MoreUtils qw( firstidx );
sub new {
my ( $package, $pointer, @elements ) = @_;
bless { pointer => $pointer, elements => [ @elements ] }, $package;
}
sub show {
my $self = shift;
use Data::Dump qw(dump);
warn dump $self->{elements};
}
sub pick_three {
my $self = shift;
my $ring = $self->normalize;
my @three = splice $ring->{elements}->@*, 1, 3;
( $ring, @three );
}
sub normalize {
my $self = shift;
my @elements = $self->{elements}->@*;
my @prefix = splice @elements, 0, $self->{pointer};
Ring->new( 0, @elements, @prefix );
}
sub current {
my $self = shift;
$self->{elements}[ $self->{pointer} ];
}
sub insert_after {
my ( $self, $destination, @items ) = @_;
my @elements = ( $self->{elements}->@* );
my $i = firstidx { $_ == $destination } @{$self->{elements}};
splice @elements, $i + 1, 0, @items;
Ring->new( $self->{pointer}, @elements );
}
sub select_next {
my $self = shift;
my ( $pointer, @elements ) = ( $self->{pointer}, $self->{elements}->@* );
$pointer = $pointer + 1 % scalar( @elements );
Ring->new( $pointer, @elements );
}
sub cannonical {
my $self = shift;
my $i = firstidx { $_ == 1 } $self->{elements}->@*;
my $ring = Ring->new( $i, $self->{elements}->@* )->normalize;
join '', $ring->{elements}->@[1..8];
}
}
sub destination {
my @numbers = @_;
my $n = $numbers[0];
while ( any { $_ == $n } @numbers ) {
$n--;
$n = 9 if $n == 0;
}
$n;
}
my $ring = Ring->new( 0, split( '', INPUT ) );
for ( 1 .. 100 ) {
say "-- move $_ --";
say "cups: " . join( ' ', $ring->{elements}->@* );
( $ring, my @pick ) = $ring->pick_three;
say "pick up: " . join( ' ', @pick );
my $destination = destination $ring->current, @pick;
say "destination: " . $destination;
$ring = $ring->insert_after( $destination, @pick );
$ring = $ring->select_next;
say "";
}
say $ring->cannonical;
================================================
FILE: advent-of-code/2020/23.2.pl
================================================
use v5.32;
use warnings;
use List::Util qw( any );
use constant INPUT => '784235918';
use constant LIMIT => 1_000_000;
use constant MOVES => 10_000_000;
my ( $n, @numbers ) = split '', INPUT;
my @index;
my $first = { number => $n, next => undef };
@index[ $n ] = $first;
my $current = $first;
for ( @numbers ) {
my $next = { number => $_, next => undef };
@index[$_] = $next;
$current->{next} = $next;
$current = $next;
}
for ( my $i = 10; $i <= LIMIT; $i++ ) {
my $next = { number => $i, next => undef };
push @index, $next;
$current->{next} = $next;
$current = $next;
}
$current->{next} = $first;
$current = $first;
sub take {
my $n = shift;
my $first = $current->{next};
my $last = $first;
my @result;
while ( $n-- ) {
push @result, $last;
$last = $last->{next};
}
$current->{next} = $last;
$result[-1]->{next} = undef;
@result;
}
sub destination {
my @numbers = @_;
my $n = $numbers[0];
while ( any { $_ == $n } @numbers ) {
$n--;
$n = LIMIT if $n == 0;
}
$n;
}
sub insert {
my ( $destination, @elements ) = @_;
my $after = $destination->{next};
$destination->{next} = $elements[0];
$elements[-1]->{next} = $after;
}
for ( my $c = 1; $c <= MOVES; $c++ ) {
my @pick = take 3;
my $destination = destination $current->{number}, map { $_->{number} } @pick;
insert $index[ $destination ], @pick;
$current = $current->{next};
}
say $index[1]->{next}{number} * $index[1]->{next}{next}{number};
================================================
FILE: advent-of-code/2020/24.1.pl
================================================
use v5.32;
use warnings;
use experimental 'switch';
use Hash::MultiKey;
open STDIN, '<', 'inputs/24';
sub coordinates {
my ( $x, $y ) = 0, 0;
while ( $_[0] =~ /([ns])?([we])/g ) {
given ( ($1 // '') . $2 ) {
when('e') { $y += 1 }
when('w') { $y -= 1 }
when('ne') { $x -= 1; $y += ( $x + 1 ) % 2 }
when('nw') { $x -= 1; $y -= $x % 2 }
when('se') { $x += 1; $y += ( $x + 1 ) % 2 }
when('sw') { $x += 1; $y -= $x % 2 }
default { die "unknown $_" }
}
}
( $x, $y )
}
my %grid;
tie %grid, 'Hash::MultiKey';
while (<>) {
chomp;
my $c = [ coordinates( $_ ) ];
$grid{ $c } = ! ( $grid{ $c } // 0 );
}
say scalar grep { $_ } values( %grid );
================================================
FILE: advent-of-code/2020/24.2.pl
================================================
use v5.32;
use warnings;
use experimental 'switch';
use List::Util qw( uniq );
use Hash::MultiKey;
open STDIN, '<', 'inputs/24';
sub coordinates {
my ( $x, $y ) = 0, 0;
while ( $_[0] =~ /([ns])?([we])/g ) {
given ( ($1 // '') . $2 ) {
when('e') { $y += 1 }
when('w') { $y -= 1 }
when('ne') { $x -= 1; $y += ( $x + 1 ) % 2 }
when('nw') { $x -= 1; $y -= $x % 2 }
when('se') { $x += 1; $y += ( $x + 1 ) % 2 }
when('sw') { $x += 1; $y -= $x % 2 }
default { die "unknown $_" }
}
}
( $x, $y )
}
sub neighbours {
my ( $x, $y ) = $_[0]->@*;
my $offset = $x % 2 || -1;
(
[ $x - 1, $y ], [ $x - 1, $y + $offset ],
[ $x, $y - 1 ], [ $x, $y + 1 ],
[ $x + 1, $y ], [ $x + 1, $y + $offset ],
)
}
my %grid;
tie %grid, 'Hash::MultiKey';
while (<>) {
chomp;
my $c = [ coordinates( $_ ) ];
$grid{ $c } = ! ( $grid{ $c } // 0 );
}
for ( 1 .. 100 ) {
my %new;
tie %new, 'Hash::MultiKey';
my @check =
map { [ split ',' ] }
uniq
map { join ',', @$_ }
map { ( $_, neighbours( $_ ) ) }
grep { $grid{ $_ } }
keys %grid;
for ( @check ) {
my $black = $grid{ $_ };
my $count = scalar grep { $grid{ $_ } } neighbours $_;
$new{ $_ } = 1 if $count == 2 or $black and $count == 1;
}
%grid = %new;
}
say scalar grep { $_ } values( %grid );
================================================
FILE: advent-of-code/2020/25.1.pl
================================================
use v5.32;
use warnings;
use constant MOD => 20201227;
sub transform {
my ( $loop, $subject ) = @_;
my $result = 1;
for ( 1 .. $loop ) {
$result *= $subject;
$result %= MOD;
}
$result;
}
sub find_loop_size {
my ( $key, $subject ) = @_;
my $n = 1;
my $i = 0;
while (1) {
$i++;
$n *= $subject;
$n %= MOD;
return $i if $n == $key;
}
return undef;
}
sub hack {
transform( find_loop_size( $_[0], 7 ), $_[1] ) ;
}
#say hack 5764801, 17807724;
say hack 2069194, 16426071;
================================================
FILE: advent-of-code/2020/25.2.pl
================================================
================================================
FILE: advent-of-code/2020/inputs/1.1
================================================
1028
1987
1938
1136
1503
1456
1107
1535
1946
1986
855
1587
1632
1548
1384
1894
1092
1876
1914
1974
1662
1608
2004
1464
1557
1485
1267
1582
1307
1903
1102
1578
1421
1184
1290
1786
1295
1930
1131
1802
1685
1735
1498
1052
1688
990
1805
1768
1922
1781
1897
1545
1591
1393
1186
149
1619
1813
1708
1119
1214
1705
1942
1684
1460
1123
1439
1672
1980
1337
1731
1203
1481
2009
1110
1116
1443
1957
1891
1595
1951
1883
1733
1697
1321
1689
1103
1300
1262
1190
1667
1843
1544
1877
1718
1866
1929
1169
1693
1518
1375
1477
1222
1791
1612
1373
1253
1087
1959
1970
1112
1778
1412
1127
1767
1091
1653
1609
1810
1912
1917
935
1499
1878
1452
1935
1937
968
1905
1077
1701
1789
1506
1451
1125
1686
1117
1991
1215
1776
1976
846
1923
1945
1888
1193
1146
1583
1315
1372
1963
1491
1777
1799
1363
1579
1367
1863
1983
1679
1944
1654
1953
1297
530
1502
1738
1934
1185
1998
1764
1856
1207
1181
1494
1676
1900
1057
339
1994
2006
1536
2007
644
1173
1692
1493
1756
1916
1890
1908
1887
1241
1447
1997
1967
1098
1287
1392
1932
================================================
FILE: advent-of-code/2020/inputs/10
================================================
84
60
10
23
126
2
128
63
59
69
127
73
140
55
154
133
36
139
4
70
110
97
153
105
41
106
79
145
35
134
146
148
13
77
49
107
46
138
88
152
83
120
52
114
159
158
53
76
16
28
89
25
42
66
119
3
17
67
94
99
7
56
85
122
18
20
43
160
54
113
29
130
19
135
30
80
116
91
161
115
141
102
37
157
129
34
147
142
151
68
78
24
90
121
123
33
98
1
40
================================================
FILE: advent-of-code/2020/inputs/11
================================================
LLLLLLL.LLLLLLLLLLLL.LL.L.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
LLLLLLL.LLLLLLLLLLLL.LLL..LLLLLLLLLLLLLLLLLLLLLLL..LLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLL
LLLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLLLLL.LLLL.LLLLLLLLLLL.LLLLLLLLLLLLLLLL.LLLLL.LLLLLLLL.LLLL
LLLLLLL.LLLLLL.LLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLL.L.LLLLLLLL.L.LLLLLL.LLLLLL.LL.LLLLL.LLLLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
.L.....L...L.....LL..L...LLL.L.LL..LLL..LL.LLL...LLLL..L......L..........L...L..LL..LLL.L...L
LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLL.LLLLL.L.LLLLLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLLLLL.LL.LLLLLLLLLLLLL
LLLL.LL.LLLLLL.LLLL.LLLLL.LLLLL.LLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LL.LLLLL.LLLLLLLLL.LLLL.
LLLLLLL.LLLLLL.LLLLL..LLL.LLLLLL.L.LLLLLLLLL.LLLL..LLLLLLL.L.L.LLLLL.LLLLLLLLLL.LLLLLLLLLLLLL
LLL.LLL.LLLLLLLLLL.L.LLLL..LLLLLLLLLL.LL.LL.LLLLLL.LLLLL.LLLLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLL.L.LLLLL.LLLLLLL.LL.LLLLLLLLLLL.LLLLL.LLLLLLLLLLLL.
LLLLLLL.LLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLL
L...L..LLL.....L.LL..L.LLLL....LLLL.....L.L.LLL..L.L...LL.LL....L..LLLL..L..L.LL...L.L.....L.
LLLLLLL.LLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLLLL.LLL.L.LLLLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLLLLLLLL.LLL.LLLLLLL.LLLLLLLLLL.LLLLL
LLLLLLL.LLLLLLLLLLLL.LLLL.LLLL.LLL.LLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL.L.LL.LLLLL.LLLLLLLLLLLLL
LLLLLLL..LLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLL
.........LL..LL..LL..LL.....L..L..LL.............L...L....LLLL...LL...LLL..L...LLL.....L....L
LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLL..LLLLLL.L.LLL
LLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL
LLLLLLL.LL.LLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL.LLLLLLLLL.LLL.LLLLLLLLLL
LLLLLLL.LLLLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLL.LL.LL..LLLLLLLLLLLL
LLLLLLL.LLLLLLLLLLLL.LLLL.LLLLLLLLLL.LLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLLLLLL.L.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL
...L.L..L.L.L....L....L.LLL.L.L.L..L..L...L....L......L.......L..L.L.L..L..LL...L....L....LL.
LLLLLLL.LLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.L.LL.LL.LL.LLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLL.L.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL..LLL..LLLL.LLLL.LL.LLLLL
LLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLL.LLLLLLLLL.LLLLL.L.LLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLLLLLLLLL..LLLL
LLLLLLL.LLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LL.LLLLLLLLLL.LLLLLLLLL.LLLLLLLLLL.LLLLLLL.LLLLL
..LLLLL...LL...L..L.....L.LL.L....L.L..LL.L......L.L.L..L...L.L..L..L..L.LL..L.L.L..L.....L..
LLLLLLL.LLLLLL.LLL.L.LLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLL.LL.LLLLL.LLLL.LLLLLLLL.LLLLLL.LL.LLLL..LLLLLL.LLLLLLLLLL.LLLL..LLLL.LLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLLLLLLLL.LLLLLLL.LLLLL
.LLLLLL.LLLLLL.LLLLL.LLLLLLLLL.LLL.LLLLLLL.L.LLLLLLLLLLLLLLLL.LLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL.LLLLLLLL.LLLLLLLLL.LLLL.LLLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
LLLLLLL.LLL.LL.LLLLLLLLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLL.LL.LL.LLLLLLLLLLLLLL.LL.LLLL.LL.LLLL.
LLLLLLL.LLLLLL.LLLLLLLLLL.L..LLLLLLLLLLLLLLL.LLLLLLLLLLLL.LLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLL
LL......LLL...L.LL...LL..LLLL.L..L.........L..L.....L..L......L..L...LLL.....LL.......LL.....
LLLLLLL.LLLLLL.LLLLL.L.LL.LLLLLLLL.LLLL.LLLLL.L.LLLLLLLLLL.LLLLLLLLL.LLLLLLLLL..LLLLLLLLLLLLL
LLLLLLL.L.LLLL.LLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLL.LLLL.LL.LL.LLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL..LLLLLLLLLLLLLLLLLLLLLLL.L.LLLLL.LLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL
LLLLLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.L.LLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLL.LLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLLL.LLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL.LLL.LLLLLLLLLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLL.L.LLLL.LLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
L....L.L..L.L....L..L.L...L.....L..LL...L.L.L.L.LL..L....LL..LL....L.L.......LLL..LLL...LL..L
LLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLL.LLLLLLL.LLLLLLLLLLLLLL..LLLLLLLLL.LLLL..LLLL.LLLLLLLLLLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLLL.LLLLLLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLL..LLLLL.LLLLLLLLLLLLL.LLLLLL.LL..LLLLLLLLLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLLLL.LLL
L.L.LLLLLLLLLL.LLLLL.LLLL.LLLLL.LL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLL.LLL.LLLL.LLLLLLLLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLL.LLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.L.LLLLLLLLLL.LLLLL.LLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLL.LLLL.LLLL.LLLLLLLLLLLLLLLLLL.
LL.L.LLLLLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLLLLLLLLL.LLLLL
...L..L..L..L....LLL..L.LL....L........L.......L.L.LL.L........L...LLLL....LL.......L.LL..L.L
LLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLL
LLLLLLL.LLLLLL.LL.LL.LLLLLLLLLL.LL.LLLLLLLLL.LLLLL.LLL..LLLLLLLLLLLL.LLLL..LL.L.LLLLLLL.LLLLL
LLLLLLL.LLLLLLLLLLLL.LLLL.LLLLLLLL.LLLLLLL.L.LL.LL.LLLLLLL.LLLLLLLLLL.LLL.LLLLL.LLLLLLL.LLLLL
LLLLLLLLLLL.LL.L.LLL.LLLL.LLLLLLL..LLLLLLLLL.LLLLLL.LLLLLLLLLLLLLLLL.LLLL..LLLLLLLLLLLL.LLLLL
LLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLLLLLLLLLLLLL.LLLLL.L.LLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL.LLLLLLLL.L.LLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLL.LLLL.L.LLL.LLLLLLL..LLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL.L.LL.L.LLL.LLLLLLL.LLLL.
....LLLL.L..L....LL..L.....LL..........LL.....L.L..LL.LL......L.L.L.L....L.LL.L.L..L......L..
LLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLL.LLLLLLL
LLLLLLLLLLL.LLLLLLLL.LLLL.LLLLLLLL.LLL.LLLLL.LLLL..LLLLLLLLLLLLLLLLL.LLLL.LLLLL..LLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLLLLLLLLL.LL.LLLLL.LLLLLLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LL.LL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLL.LLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLLL.LLLLLLLLLL.
LLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLL..LLLLLL.LLLLLLL.LL.LLLLLLLLLLLLLLLLLLLLLLLLL.L.LLLLL..LLLL
LLL.LLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLL.LL.LLLLLLL.LLLLLLL.L.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLLLLLLLLL.LLLLL.LLLL.LLLLLLLL.LLLL.LLLL.LLLLL.LLLL.LLLLLLLLLLLL.LLLLLLLLLL.LLLLLLL.LLLLL
LLLLLL..LLLLLLLLLL.L.LLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLL.LLLLLLLLL.LLLLLLLLLL.LLLLLLL.L.LLL
LLLLLLLLLL.LLLLLLLLL.LL.L.LLLLLLLL.LLLLLLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLL.LLL.LLLLL
L.L...L....LL.L....LL..L...L...LL.L.............LLLLL..LL........LLL.L....L.L...L.L...LLL.LL.
LLLLLLL.LLLLLL.LLLLLLLLLL.LLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLLL.LLLLLL.LLLLL
LL.LLLL.LLLLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLL.L.LLL.LLLLLLLLLLLLLLLLLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLL.LLLLLLLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLLLLLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL.LLLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLL.LLLL.LLL.LLLLLLLLLLL.LLL
.LLL..LL.L.LL.L...L.L..L...L....L.L................L....L.......L..L.....L...LLL....L....LL..
LLLLL.LLLLLLLL.LLLLL.L.LL.LLLLLLLL.LLLLLLLLL..LLLLLLLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLL.LLLLL
LLLLLLL.LLLLLL.LLLLLLLLLL.LL.L.LLL.LLLLLL.LL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLL.LLLLLLLLL.LLLLL
LLLLLLL.LLLLLL.LLLLL.LLLL.LLLLLLLLLL.L.LLLLL.LLLLLLLLLLLLLLLLLLLLLLL.LLLLLLLLLLLLLLLLLL.LLLLL
LLLLLL..LLLLLLLLLLLLLLLLL.LLLLLLLL.L.LLL.LLL.LLLLL.LLLLLLLLLLLLLLLLL.LLLLLLLLLL.LLLLLLLLLLLLL
LLLLLLL.LLLL.L.LLL.LLLLLLLLLLLLLLL.LLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLL.LLLLLLLL
LLLLLLL.LLLLLLLLLLLL..LLL.LLLLLLLL..LLLLLLLLLLLLLL.LLLLLLLLLLL.LLLLLLL.LLLLLLLL.LLLLLLL.LLLLL
================================================
FILE: advent-of-code/2020/inputs/12
================================================
F29
E5
L90
W1
R90
E1
R90
W5
F32
E2
S3
R270
F61
R180
R180
E2
F13
R180
F18
L180
F15
N2
S2
R270
N2
F81
W4
N2
E1
N5
F5
N3
R90
W5
S1
F20
L90
S2
R90
F81
S2
E1
F59
N1
L180
W3
R90
E5
F2
R90
F28
R90
F70
L180
S4
L90
F97
W2
R180
S5
F12
N4
L90
F47
R90
F20
W3
S2
E2
F29
S2
L90
S1
L180
F92
L90
S4
W3
L90
W5
F56
N3
L90
S4
F83
S2
F82
W4
F34
R90
N5
F85
R90
F17
R90
F15
W1
L90
F55
S3
F38
W1
F38
S3
W1
N1
F77
R180
S5
F89
L90
F62
N4
R90
E3
L180
E2
F44
S4
R90
W2
L180
S4
R90
N5
F30
S5
R90
F88
R90
F10
L90
N5
F45
E5
F51
W5
N3
E3
F93
E5
F85
N5
L90
F6
W4
N3
F25
L90
E2
S4
W1
R180
E4
S3
E2
F26
N3
E3
F32
N3
L90
F25
L180
E3
F46
F12
N3
W4
L90
S2
L90
F31
W4
F75
L180
E3
F79
R90
N5
L270
W5
L180
S5
F19
N2
F90
L180
W3
S4
E2
F85
N1
F62
W4
F77
L180
W1
N2
L90
F86
R90
W5
F34
E1
F72
R90
E3
F5
N2
R90
S2
R270
W4
F58
F19
R180
R90
W4
F60
N1
E1
R90
F27
W4
L90
F35
E1
F11
E4
R90
W5
F68
L90
S2
W3
F2
L90
F24
W4
N4
R90
F32
L90
L90
F22
F91
R90
W1
F23
W2
S1
W3
S2
F97
W4
L90
W1
F16
S4
L180
W4
F48
E5
F21
N3
F2
E2
F75
N5
E2
L90
E3
F76
L90
N1
L90
N5
E1
L90
E2
R90
F40
L90
S5
E1
F8
S1
L90
E4
N3
F10
L180
F68
R90
F89
R90
W1
L180
E2
F48
S2
L90
F61
N3
L90
L180
W2
N2
F32
R90
E2
F74
W4
N5
F78
N2
F62
S1
R180
S2
E1
L90
N4
F85
R90
W4
R90
E1
R180
W3
S5
E1
R270
N4
F89
N4
R90
N1
E2
N3
F89
N5
E1
F17
R270
F58
E1
L90
F38
W4
S1
E2
R90
E2
W2
L90
W5
L90
E2
F1
E1
F34
S4
F16
W5
L180
F31
L90
E2
F46
L180
N5
F64
R90
F58
L90
F15
L90
S4
E3
F74
F26
S2
W2
S4
F81
S4
L180
E1
F21
F53
E5
F55
L270
W2
S2
E1
S2
E3
N2
F24
L180
N1
E5
F60
S1
F54
N1
F9
N3
L90
E3
L90
E3
L90
N1
F28
N4
R180
N5
F44
N2
E3
R90
W4
R180
F69
W3
S2
R180
E3
R270
S4
W2
R90
F69
E3
F44
L90
F87
E4
F21
E1
S2
R90
E5
L90
W5
R90
E1
F66
W4
F51
S3
S4
W3
L90
E1
R90
W1
R180
W1
N1
L180
N3
L180
E2
F14
N2
E5
F95
L270
N4
R90
N1
R90
N1
E4
F90
N3
F35
N5
F74
R90
N3
F64
N1
F28
N2
W2
F7
W4
N2
F37
E3
F100
R90
F36
L90
F41
E1
L90
L90
W1
N3
W2
W3
L90
W5
F100
R90
N2
L180
F7
W2
E2
F77
L180
N2
R180
F60
L90
N5
L90
F72
L270
W1
L180
N5
R90
F54
S3
F70
N1
F72
E4
N5
R90
S1
W1
N3
R90
F45
E4
F32
W5
F78
W3
R90
W4
F58
R90
E5
L90
F3
R90
N1
R90
W1
N4
E1
W3
N5
R90
W5
S3
F25
W4
N3
F55
W2
R90
N1
F98
L90
W3
L270
E1
N3
N2
R90
S1
F39
L90
W2
L90
N3
E3
F80
W1
N1
W4
F25
R90
E3
L180
F21
S4
F75
L90
F76
W5
N4
E2
R90
F44
E3
N1
W3
F49
N2
L180
S4
L90
F55
S4
R90
F14
R90
W5
L90
F85
N2
L90
L90
E3
R90
N3
E4
S5
F75
L90
F60
N2
R180
E2
L90
E2
L180
F27
E4
N4
L90
N2
L180
F91
N4
F47
W2
N2
F63
F63
W4
F28
L90
N1
F57
S1
E2
L90
E5
L180
N3
E4
F70
R90
W5
L90
W1
E3
F18
E3
F15
N1
E4
L90
W1
F49
E3
R90
F61
N3
E2
F69
E1
F7
L90
S1
F73
R90
S5
E2
L90
N1
S4
R180
F8
S1
E5
F44
N1
F39
L90
S1
F83
L90
E4
F59
N4
W2
S3
W2
R90
L270
E4
R90
N5
E4
F22
E1
S3
R90
W5
R270
N1
S4
F39
N4
F78
N4
W3
F34
E5
F31
L90
N3
R180
F75
S2
E1
R180
F89
E5
R180
S1
W3
F97
R180
F54
W2
F6
W5
N3
F58
R90
N2
L180
F2
W3
E3
N3
R180
W1
E3
S3
E2
F87
W5
E3
R90
F63
F30
R90
S3
F69
E2
F87
N1
F95
S4
L90
F52
================================================
FILE: advent-of-code/2020/inputs/13
================================================
1006726
23,x,x,x,x,x,x,x,x,x,x,x,x,41,x,x,x,x,x,x,x,x,x,647,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,13,19,x,x,x,x,x,x,x,x,x,29,x,557,x,x,x,x,x,37,x,x,x,x,x,x,x,x,x,x,17
================================================
FILE: advent-of-code/2020/inputs/14
================================================
mask = 11110100010101111011001X0100XX00100X
mem[17610] = 1035852
mem[55284] = 229776690
mem[16166] = 12685380
mem[8340] = 16011
mask = 0X1X0X010101011X10X101000X0001110100
mem[968] = 15992
mem[32758] = 7076
mem[30704] = 1701
mem[33719] = 58012
mem[20818] = 25927237
mem[16718] = 46485
mask = 111001111X0X0X101X111X1X001XX0011010
mem[2115] = 14848
mem[42753] = 617
mem[56076] = 9933868
mem[19106] = 43503
mem[10073] = 32909
mem[40830] = 1959686
mask = X11X00000XX1011X10000X01110000X0001X
mem[41605] = 13245557
mem[6571] = 7973763
mem[46231] = 28527162
mem[44901] = 163334644
mask = 0101XXX1X10XX1101011110000000010010X
mem[53492] = 357272
mem[32816] = 35015
mem[6965] = 11280352
mem[27745] = 160101
mem[26728] = 1260
mask = 1XXX0100XX1X0X10101100011101101X0111
mem[22010] = 28123044
mem[42154] = 82539
mem[54914] = 22078
mem[7185] = 436
mem[58583] = 25334197
mask = 11110010X001011010X1XX010XX0110001XX
mem[62397] = 9570559
mem[49595] = 15491062
mem[21644] = 9478776
mem[19853] = 31023
mask = 001110000101011X1111100XX1111000X111
mem[62345] = 1200300
mem[34309] = 115943357
mem[23144] = 873
mem[36010] = 954
mem[6857] = 645222
mask = 0011X101110X10101111000X010X00100000
mem[12284] = 570
mem[44849] = 48293
mem[48549] = 489763617
mem[51371] = 1151
mask = 01X0X10101000XXX10111010011010XX0X10
mem[17699] = 14190020
mem[32796] = 84255743
mem[62003] = 1426
mem[18906] = 353
mem[38218] = 615297
mask = 0X0101010111XXX01011010111XX01100010
mem[26389] = 62531634
mem[12404] = 1034263
mem[49398] = 1006
mem[22929] = 313056
mem[16164] = 1694664
mem[19077] = 53452
mask = 0X1XXX0X010101101X1110XX101010X01010
mem[38381] = 18385
mem[2319] = 552
mem[60857] = 1931
mem[41219] = 19301038
mem[9073] = 85077
mask = 00010000010XX1X01000110101100X000111
mem[10385] = 227941
mem[31042] = 151514106
mem[22360] = 168649336
mask = 0110010X0100XX10001X11X1X11100XX0X11
mem[40411] = 8140928
mem[3859] = 2742
mem[45449] = 4317450
mem[17740] = 1337381
mem[19338] = 6605990
mem[22407] = 53051
mem[42292] = 550664
mask = X1110XX00X0101101011XX0X101110001111
mem[59509] = 304929
mem[43817] = 14977
mem[39410] = 439
mem[38730] = 34567670
mem[31862] = 8027039
mem[60857] = 5209
mask = X11X0000X1X101X010110XX011111011X011
mem[28472] = 14882
mem[50099] = 1135
mem[58921] = 980796
mem[50737] = 36974
mem[54167] = 22140347
mem[2139] = 22934
mem[13202] = 136157
mask = X1X001X1010001X0X0111100101110X0X101
mem[911] = 8925
mem[652] = 183714641
mem[58633] = 5186611
mem[41763] = 29030
mask = 011X01010010001110110X0X1100000000X1
mem[47324] = 8124
mem[31660] = 355290
mem[19624] = 1760
mem[32635] = 27873924
mem[45190] = 439446159
mem[1090] = 428
mask = XX10000X00011X1X1011010X0001110X0101
mem[40622] = 1839170
mem[45103] = 108379641
mem[29222] = 187252
mem[42753] = 2592089
mem[46615] = 4466791
mem[22416] = 6619543
mask = X0X101X10X000010XXX10110111011011101
mem[42154] = 3271203
mem[10355] = 89584861
mem[14447] = 383415
mask = 1X000X001X100X10X0X1X01X1101X0110101
mem[40691] = 1490354
mem[6162] = 601597339
mem[62819] = 15727
mem[48596] = 8589566
mem[46732] = 56337
mem[35437] = 1568988
mask = 00X0X10X01010110X0111X0XX01100001111
mem[43285] = 75734
mem[41605] = 46442
mem[7672] = 667983
mem[29222] = 9835
mem[34949] = 3945167
mask = 01X00101X101001010X1100X0X11X110X101
mem[8617] = 182201
mem[33667] = 11585659
mem[57414] = 235257
mask = 0111010001010XX01X11XX1011XX101X1011
mem[19633] = 3970
mem[10580] = 6454804
mem[22445] = 12328278
mem[22131] = 70709
mem[31438] = 870851666
mem[46279] = 638924631
mem[20402] = 311245
mask = 0110000101X1X11010111X001111X1000111
mem[2405] = 733626
mem[27649] = 150996
mem[45000] = 13156617
mask = 01X10X0X01X10110101101X1X1X00100011X
mem[44304] = 5130
mem[25804] = 264101480
mem[896] = 1445
mem[20949] = 386031115
mem[24951] = 9889
mem[51040] = 3708234
mask = 00100X01010101101111100010XX0100X1XX
mem[31907] = 15551
mem[1218] = 1034
mem[17073] = 359232
mask = 010100010101X1101X11011X010001XXXXX0
mem[11137] = 1499158
mem[59509] = 262392
mem[6988] = 14863
mem[28213] = 554
mem[7044] = 68
mask = 01100101X1XX0X10X01110X1001X00X00X11
mem[22674] = 3230
mem[35891] = 3585
mem[3551] = 15928515
mem[36206] = 104461320
mem[22167] = 1161073
mask = 01X1X00X01010X1010111X010XX00011X101
mem[17360] = 494
mem[34415] = 3766044
mem[8898] = 846638
mem[48368] = 500781
mask = 011001010X0X001X0X101X010X100101100X
mem[60679] = 10414
mem[34463] = 11
mask = 01100100010XX11X1X0X0000001111010011
mem[40952] = 1659
mem[27502] = 2916485
mem[7436] = 211741
mem[58641] = 944726
mem[58633] = 46218913
mask = 010110000101011X101101X0111110X00X11
mem[3042] = 13844
mem[49701] = 56163826
mask = 011001X00101011010X1100010X11X011X11
mem[38067] = 7299191
mem[31130] = 116061
mem[2139] = 63458254
mem[4521] = 1237
mask = 0111X000X1010110101X011100100100011X
mem[21329] = 642
mem[41123] = 28058
mem[29555] = 4111
mem[15009] = 3801745
mem[49595] = 317
mem[56642] = 126724425
mem[29388] = 19214321
mask = 1101X1X0X11X101011X01X11X0111X001X01
mem[20118] = 21164480
mem[39432] = 508
mem[39859] = 958
mem[36851] = 196470
mem[26907] = 97849565
mask = XX10000011110X001011XX0010X110100001
mem[34234] = 17652327
mem[16028] = 80890944
mem[54559] = 64040
mem[25194] = 41593756
mask = 001110000101X1101XX1000X10110000110X
mem[33667] = 916652067
mem[2405] = 1244
mem[63718] = 292918
mem[29526] = 711465
mem[24951] = 1884
mem[22360] = 167190303
mask = 1100000000111X11101X0110X00010X00100
mem[6620] = 2734891
mem[64584] = 215747822
mask = 01X00X000100101000X11000X01110100X01
mem[56211] = 3278176
mem[40364] = 340370
mem[23555] = 27655
mem[42471] = 227213
mask = 1X10X1111101X110X011X000X0X0X10011X0
mem[6829] = 110833304
mem[15624] = 23686
mem[59705] = 5391933
mem[10724] = 32064
mem[14827] = 6939
mask = X1X1100001010X111011101X00110X000010
mem[50595] = 719945
mem[1480] = 39227195
mem[52615] = 124668762
mask = 01100XX1110X011XX01100001011X1X10X10
mem[58924] = 3492
mem[16850] = 584
mem[61283] = 289490093
mem[20396] = 55247
mem[12216] = 9844180
mem[12216] = 14974951
mask = 00X00101010101X010111000101XX0100001
mem[4778] = 4486654
mem[24826] = 1334889
mem[30412] = 685
mem[424] = 40892660
mem[19019] = 87071
mem[58641] = 13743890
mask = 011100XXX10101101X0X00010001011100X0
mem[10355] = 392450
mem[20082] = 23264
mem[25220] = 1800190
mem[59108] = 141835
mem[58233] = 543
mem[48973] = 863
mem[54167] = 28960
mask = 1110X0000001X11010110000X1011XXX1010
mem[52783] = 2071776
mem[60857] = 108259027
mem[37356] = 2641268
mem[21950] = 47481758
mem[52557] = 7700825
mask = 0X11010XX10X001011110010111000101001
mem[58111] = 244589936
mem[41399] = 42658
mem[27306] = 237040
mem[4122] = 1592
mask = X1X00X0111110110101XX1001001X0010X10
mem[6801] = 34789897
mem[59447] = 10675177
mem[28987] = 666686
mask = X110000X000110X11011111000X11100010X
mem[424] = 2927
mem[30920] = 894899
mem[1670] = 305032596
mask = 0111X01000X1X1101011001X111000011010
mem[29811] = 632621
mem[40046] = 51323
mem[55593] = 6182
mask = 01100011100XX11X00X110X011110XX10101
mem[58803] = 484311
mem[49237] = 12281
mem[46823] = 1332
mem[24356] = 1277234
mem[42561] = 1938
mem[14991] = 8909
mask = 0111X00000X101101X11101010111X001111
mem[8482] = 2735
mem[36657] = 64651206
mem[3842] = 157
mem[60137] = 483271
mem[5610] = 709
mask = XX1X00X00X01X11010111X001101110X1111
mem[22416] = 27971815
mem[19192] = 7861
mem[51678] = 25016
mask = 011XX1111101XX101111001X001110010000
mem[64535] = 155
mem[38057] = 669
mem[8482] = 29767095
mask = 00100X000X010X10X111100X11100110X101
mem[38067] = 10211
mem[37762] = 11637
mem[34706] = 44902
mask = 0X11001100110XXX1011011X10X10X01100X
mem[26809] = 2100865
mem[60446] = 25094
mem[43745] = 461971
mem[24321] = 28927
mem[7984] = 355769146
mem[9488] = 1910
mask = 0X1001X1X10X0X1010111X10X011X01X1111
mem[51678] = 2889
mem[46700] = 214866595
mem[40992] = 4945733
mem[25409] = 172376952
mask = 0110011111X100101X11000XX110X0001X0X
mem[11587] = 9651
mem[41265] = 61660
mem[1822] = 6155
mem[29303] = 250909900
mem[59145] = 51920318
mask = 01X1X0X0X1010110101100101111100X0001
mem[33719] = 2071728
mem[24951] = 108
mem[12284] = 369552742
mem[55012] = 53272268
mem[31862] = 3576
mem[5950] = 460151
mem[55978] = 53697916
mask = XX1100000X01011010X1100011X01000X110
mem[61606] = 1036
mem[6477] = 81209
mem[2187] = 6526467
mask = 111000X011110100X011X0XXX11X10110X01
mem[25194] = 7338343
mem[16563] = 225968
mem[51983] = 30985431
mask = 0X000100010101101X11100X00011X111011
mem[34309] = 434429
mem[16850] = 476433401
mem[63015] = 181118
mask = X110001011X1010X1011010X1011X01100X0
mem[19081] = 237103716
mem[24300] = 10640
mem[23963] = 430607
mask = 0111XXXX001101101011000011XX00X01XX1
mem[26941] = 27590
mem[31862] = 20472
mem[4020] = 3134353
mem[55543] = 1761762
mem[45048] = 1024489921
mask = 11100111X10X111XX0X1000010111110101X
mem[48596] = 3587524
mem[2018] = 451398
mem[54298] = 121634159
mem[26371] = 5517119
mem[57585] = 1825
mask = 0111X00X0011X11010X10X100100X1100000
mem[44281] = 1515553
mem[36633] = 1289
mem[30077] = 12046281
mem[55362] = 226809
mem[48993] = 794317
mem[58968] = 241
mask = X110010101100X10101110100011000XX001
mem[22929] = 2072990
mem[22931] = 336
mem[31880] = 119168961
mem[3859] = 49656496
mem[45103] = 296484159
mask = XX11000001011110100101100X0X01100101
mem[41219] = 826
mem[38539] = 22527609
mem[40238] = 29540
mem[34813] = 4305171
mem[51640] = 4302332
mem[44070] = 1373134
mask = 011X0000X101011010011111X01X10101011
mem[40884] = 256867181
mem[56234] = 2181222
mem[5950] = 68826
mem[1760] = 88028804
mem[50704] = 5302105
mem[24366] = 442
mem[10147] = 127227597
mask = 0110X1100101X1101011X111100X0X0XX010
mem[21956] = 121736133
mem[25007] = 3174
mem[42616] = 925004
mem[1670] = 3018
mem[46932] = 2981988
mask = X1110011001XXXX01011011X1X1100011X01
mem[61283] = 521975
mem[27640] = 322
mem[62514] = 153670214
mem[23951] = 14226595
mem[9549] = 2336533
mem[11888] = 827772
mask = 1101X100XXX1X010111000XX0001000X10X1
mem[16797] = 22808
mem[48021] = 2258240
mem[12370] = 185157105
mask = 01110X0X00XX0X1X10110100X10X01000010
mem[4594] = 93
mem[57388] = 665641765
mem[1345] = 361710791
mem[37543] = 1730
mem[57136] = 388716965
mem[42524] = 553
mem[13403] = 637623155
mask = 0110X1X0X101011X10110110100101011110
mem[16512] = 3631
mem[11337] = 203803846
mem[2504] = 336583240
mem[12269] = 4069068
mask = 01XX001111001110101100001X01000100X0
mem[33661] = 6490
mem[30704] = 128919282
mem[41797] = 22490
mem[8134] = 38294563
mem[63208] = 12103
mask = 11X00X0000X1XX1X101100010000010011XX
mem[24951] = 3275742
mem[23998] = 1551
mem[19972] = 5727596
mem[17337] = 205937438
mem[41952] = 53261
mem[64651] = 26734
mask = X11001111101XX101X110X001011100X0X1X
mem[57388] = 441426
mem[11337] = 336
mem[8515] = 381065399
mem[49625] = 1066556272
mem[54274] = 7650
mem[8575] = 15426
mem[18302] = 216253866
mask = 1X0X00X000X11X1110110100110111X1X101
mem[6256] = 17076091
mem[7973] = 5554062
mem[39859] = 1429203
mask = 0X110001011101101X1111101001XX000110
mem[38807] = 351
mem[28213] = 22387
mem[26591] = 76518875
mem[15712] = 12048675
mask = 01X1XX00010101101011X111XX1010XX1011
mem[9073] = 789
mem[39859] = 919291385
mem[18302] = 347
mem[41224] = 4579691
mem[41167] = 19132842
mem[424] = 158741911
mask = X110010X0100X010X0100X00XX111001X011
mem[28822] = 66019
mem[46209] = 2719
mem[35264] = 1826
mem[60137] = 389000
mask = 01010001X101X11010110X111111X1000001
mem[16591] = 62860121
mem[10737] = 1180
mem[31130] = 16000
mem[34880] = 584
mem[6800] = 39
mask = 0111X000X1XX11101001010X00110010011X
mem[5501] = 31780835
mem[31862] = 6009
mem[49129] = 91037
mem[7935] = 15099
mem[44839] = 31518815
mask = 0101000101011110X1110111000001XXX000
mem[14827] = 1206371
mem[62398] = 1062
mem[50952] = 1253562
mem[32584] = 22533969
mem[9662] = 2590
mask = 01100X111X0X1110XX111X000X1101000001
mem[40142] = 107915
mem[10580] = 4884244
mem[2187] = 1020
mask = 11X100XX1001X1X0101X01X1001X11111100
mem[19551] = 54829
mem[18208] = 627039
mem[18032] = 3423
mem[24162] = 301557348
mem[35891] = 1206
mask = 01100111110100X0XX1X1011XXX100101000
mem[9695] = 368318059
mem[9916] = 30083984
mem[9903] = 866066456
mem[3360] = 434642
mem[3609] = 2437
mask = 0XX1X000010XX1X0100X1010X10100X00111
mem[64662] = 5845
mem[20000] = 2302117
mem[21056] = 11248
mem[641] = 200833516
mem[46678] = 3506929
mask = 0X100111111100101111110X01110X00010X
mem[59199] = 1984963
mem[43784] = 7811709
mem[49701] = 3967
mem[11888] = 790487
mask = 111X00000101111010010X10001101XX11X0
mem[51082] = 222096294
mem[50595] = 121297
mem[27424] = 268132
mem[9473] = 200971
mem[42941] = 1604
mask = 0X11010X1X00X01011110010111XX010X00X
mem[44304] = 31572
mem[14907] = 1066531
mem[34745] = 91393
mem[1617] = 124090
mem[25898] = 49692
mask = X11X01000X010X111X1X10100000010X10X0
mem[12953] = 62465686
mem[24718] = 15597133
mem[20124] = 4930329
mask = 0X11010000X10X1010110111XX00X1XX101X
mem[12426] = 694
mem[2226] = 70693
mem[6332] = 3693756
mask = 0111100000110XX010X11000X1X111011010
mem[42447] = 86599788
mem[62694] = 50365
mem[59239] = 4355782
mem[12523] = 14292673
mem[52756] = 2685769
mem[54978] = 207845
mem[17699] = 366567692
mask = 011001011111X0XX101100000X10X0X01011
mem[8186] = 1183
mem[6181] = 8087
mem[61605] = 3505
mem[46678] = 85544
mem[40046] = 5212041
mem[28835] = 3272650
mask = 011100000101X11010X1011X10X1XX00X011
mem[55012] = 105058
mem[52202] = 26295
mem[59657] = 2809
mask = X1X10100X101XXX0X110001110001XX01001
mem[45682] = 323588
mem[49237] = 58065
mem[41032] = 27927
mem[35647] = 280
mem[47892] = 252817
mem[29350] = 15075
mask = X11100X0010X01X010111101001100000010
mem[34234] = 10472
mem[14531] = 102821
mem[49081] = 3626197
mem[62940] = 630043
mem[4115] = 453716952
mask = 0111010001XX0110111X0101100X1X10101X
mem[911] = 198069
mem[5550] = 42378
mem[27566] = 13692
mem[13890] = 46764242
mem[11669] = 66225421
mem[54529] = 652599152
mask = X11X01X00X01011X10110110X00X100X10X0
mem[7236] = 3301
mem[10580] = 971
mem[51284] = 232016
mem[13784] = 33278200
================================================
FILE: advent-of-code/2020/inputs/16
================================================
departure location: 26-724 or 743-964
departure station: 33-845 or 864-954
departure platform: 26-472 or 482-967
departure track: 27-140 or 158-956
departure date: 25-884 or 894-952
departure time: 37-924 or 941-949
arrival location: 48-311 or 335-972
arrival station: 39-703 or 724-950
arrival platform: 40-108 or 114-950
arrival track: 30-101 or 108-967
class: 33-386 or 399-949
duration: 44-444 or 452-956
price: 27-220 or 234-974
route: 42-774 or 790-959
row: 48-900 or 918-956
seat: 42-165 or 178-949
train: 45-831 or 842-965
type: 49-522 or 548-974
wagon: 32-565 or 588-964
zone: 27-608 or 617-953
your ticket:
101,71,193,97,131,179,73,53,79,67,181,89,191,137,163,83,139,127,59,61
nearby tickets:
818,269,901,814,631,821,607,127,247,636,755,762,559,670,189,249,499,273,565,463
470,472,597,259,345,370,827,520,595,92,204,52,104,248,688,500,99,694,659,803
432,251,666,518,217,469,791,304,139,724,516,522,702,496,804,142,408,518,82,823
333,471,429,58,129,754,304,879,459,288,268,386,217,138,284,554,762,370,769,161
242,255,344,634,710,124,813,241,697,342,600,637,202,421,75,195,496,470,806,554
464,948,755,334,662,493,251,948,286,472,562,400,774,790,385,263,100,689,681,83
511,796,756,593,637,647,377,277,178,642,588,695,591,495,678,682,346,318,417,84
762,238,803,343,290,80,558,216,806,157,821,359,654,661,870,552,503,604,200,754
613,290,370,761,595,899,743,868,289,162,303,653,810,311,95,468,588,456,772,342
352,332,559,813,443,243,881,75,522,245,190,61,488,755,341,489,219,671,642,875
884,60,949,97,626,597,472,371,273,464,942,254,497,443,50,555,692,286,557,445
159,512,555,651,88,237,71,259,76,639,727,356,519,93,696,644,872,117,160,655
897,767,193,255,485,702,370,160,597,651,918,444,831,160,67,107,768,140,163,282
523,415,900,125,409,75,335,512,807,507,769,73,108,427,269,826,817,434,946,80
114,60,239,55,73,122,619,799,754,795,497,792,835,311,594,767,821,267,812,597
795,291,757,746,626,752,220,649,269,918,75,895,895,369,310,794,638,900,712,619
740,295,117,790,364,344,900,921,884,896,809,382,189,944,165,92,878,791,827,212
256,293,876,370,159,678,669,512,755,185,430,489,515,457,467,312,384,219,380,830
186,130,560,633,920,457,59,766,305,835,642,813,68,453,656,429,427,256,364,296
281,488,117,820,159,444,923,325,805,801,91,698,631,343,131,287,560,831,495,661
132,875,622,812,308,880,160,830,668,238,445,454,410,685,64,413,428,799,55,656
261,772,752,829,367,947,71,194,66,254,102,812,280,455,90,744,823,460,205,406
656,347,472,489,419,355,693,250,221,75,302,492,83,617,691,556,687,99,773,520
208,365,163,0,181,820,403,844,343,347,557,124,945,599,699,439,75,800,745,115
278,228,294,803,372,759,239,384,80,243,99,456,378,367,668,703,762,288,758,689
89,198,186,409,123,279,100,367,275,399,470,163,752,215,659,342,69,916,467,875
624,551,663,437,441,753,807,638,373,881,108,377,229,367,769,691,79,254,409,456
661,553,822,674,435,55,800,139,749,800,158,368,402,521,321,842,285,439,673,417
218,363,786,191,694,117,130,95,701,284,159,308,802,400,826,284,158,462,405,234
887,763,452,724,336,882,818,377,400,681,674,814,511,470,260,433,97,653,62,744
690,606,756,361,283,670,501,621,519,325,764,239,137,501,62,454,241,237,368,507
61,283,521,131,751,521,696,181,214,766,762,503,190,336,311,345,74,600,617,789
297,375,215,56,675,695,825,125,277,84,656,181,563,790,828,694,343,710,744,298
412,359,842,243,520,876,696,555,620,190,668,487,274,238,599,54,633,297,727,637
690,556,264,384,369,18,190,808,344,603,767,90,695,219,63,896,484,255,483,799
122,877,512,905,254,495,692,751,369,675,625,640,355,879,604,627,457,70,878,78
942,121,807,564,919,431,768,675,65,619,461,336,247,623,527,493,133,283,237,404
84,384,876,444,880,403,675,114,632,255,21,205,339,253,62,372,404,683,292,88
185,348,472,400,63,444,80,883,373,336,426,563,675,561,305,516,449,456,514,872
648,82,604,650,697,825,462,813,306,94,814,597,879,795,461,294,213,511,331,487
488,761,215,264,421,492,695,191,205,753,918,639,162,317,769,212,123,202,591,795
842,127,163,78,765,180,236,87,235,462,60,800,871,364,217,614,924,597,247,409
807,423,611,589,759,629,192,471,456,118,77,760,94,82,882,429,60,462,499,898
772,503,822,287,342,458,918,633,624,216,280,75,328,125,352,685,520,769,508,655
212,386,347,829,752,482,690,521,136,687,991,899,244,798,562,424,354,554,654,61
558,252,63,674,882,420,693,273,604,269,812,621,266,338,697,479,58,295,659,204
351,426,373,683,869,621,815,263,685,244,804,435,446,461,353,764,762,815,403,760
590,469,920,421,125,382,650,844,694,602,493,746,372,874,243,990,198,486,745,100
249,668,621,369,630,216,242,752,588,10,125,216,675,162,162,352,462,242,296,771
161,81,595,194,61,359,300,379,339,696,58,485,282,696,11,265,302,621,678,439
256,944,238,602,599,184,410,229,244,899,509,289,119,488,159,75,79,269,607,809
992,802,308,271,58,520,201,64,164,748,551,123,371,122,602,403,361,205,820,443
662,601,606,596,57,757,160,687,139,215,783,72,444,440,365,298,511,654,56,237
460,302,355,632,824,664,760,210,924,673,692,688,763,358,488,419,709,275,663,206
595,420,202,434,454,550,274,745,453,195,314,374,682,372,695,249,65,245,57,680
247,877,682,187,743,288,884,509,281,341,355,499,296,178,310,289,651,659,231,250
601,421,558,658,641,884,104,483,865,647,255,945,439,286,821,697,693,820,700,115
608,944,870,617,414,271,440,404,378,426,714,295,791,89,792,280,654,243,193,273
639,183,837,439,161,696,494,653,86,215,58,550,67,758,355,435,507,214,251,403
757,216,644,124,775,382,159,84,599,381,202,946,672,744,443,426,219,490,246,360
406,214,643,589,107,521,819,124,425,774,339,74,608,654,399,444,624,623,943,250
696,291,829,514,696,472,235,751,602,823,259,416,160,24,250,439,743,164,949,762
807,652,337,772,876,685,899,190,459,358,429,831,125,206,834,655,53,422,453,208
837,881,335,774,884,690,588,441,302,864,53,607,81,140,897,470,258,693,355,507
450,471,55,235,307,383,623,488,662,208,302,844,344,622,137,492,604,633,685,745
244,140,457,495,381,558,264,509,69,703,337,756,774,593,824,361,627,513,899,110
588,675,747,751,348,687,310,212,88,711,433,665,947,247,493,941,182,564,242,803
131,809,52,243,229,244,265,212,282,248,441,246,210,701,506,348,812,52,354,791
195,800,417,404,746,683,488,558,53,625,520,774,201,377,143,73,417,457,556,820
879,365,346,239,821,924,843,844,662,648,828,251,374,78,17,768,453,108,245,265
217,286,600,281,408,676,265,5,311,433,236,134,67,463,380,684,123,292,420,690
753,453,500,898,487,556,185,839,361,521,282,674,617,399,946,100,647,941,874,297
509,403,121,483,371,672,768,181,894,109,486,765,308,55,94,196,400,947,551,665
284,628,619,764,673,117,140,649,275,279,347,696,949,668,479,234,186,125,807,658
159,179,808,697,270,948,744,702,588,878,178,600,466,502,189,513,313,219,844,813
794,89,798,897,762,943,632,181,753,637,113,358,236,882,280,680,67,466,299,873
687,211,824,97,459,945,159,521,517,201,252,355,359,303,635,429,643,135,824,738
366,522,355,949,490,500,425,119,517,212,75,301,636,658,188,635,660,115,838,308
67,693,297,257,461,604,287,92,75,601,773,240,193,292,881,916,694,128,603,594
684,486,773,235,386,773,896,401,894,766,551,632,87,196,462,763,103,417,299,867
601,369,703,467,497,74,420,516,235,450,197,198,820,806,370,942,161,813,943,303
565,669,213,604,349,499,203,553,549,690,590,379,89,649,513,517,420,345,366,317
250,514,752,810,520,254,276,692,90,865,458,657,694,4,117,89,519,158,643,248
809,868,194,665,315,99,504,826,211,335,410,512,701,131,879,797,593,204,509,419
89,666,249,808,190,195,991,186,812,353,188,774,65,700,700,457,498,273,745,879
192,299,357,829,601,455,263,123,245,807,594,139,130,98,103,453,645,400,163,919
757,291,511,756,659,640,878,749,408,452,621,598,128,262,365,805,726,252,159,639
998,361,517,654,745,73,799,64,261,243,618,265,806,416,945,84,686,430,452,702
193,686,757,225,206,358,509,552,522,606,592,748,372,375,507,871,501,99,693,373
800,433,423,244,75,399,822,357,866,613,489,598,405,218,772,100,421,374,812,428
232,658,918,309,335,250,271,237,756,115,514,74,254,220,242,130,120,260,691,429
516,135,63,608,68,366,260,827,599,687,433,381,192,464,75,640,890,132,590,592
293,790,666,369,497,824,195,882,100,63,894,386,872,703,511,679,684,639,82,477
112,54,444,68,946,797,370,343,685,588,759,791,499,249,241,941,374,434,239,443
347,666,104,948,623,826,680,277,341,57,411,624,443,455,51,548,290,668,693,502
465,270,252,463,253,434,128,595,774,256,598,64,67,307,348,213,478,348,809,262
278,381,798,768,516,825,831,426,114,181,74,274,772,187,750,799,374,161,3,60
489,340,296,553,96,805,239,648,791,309,484,88,484,797,363,829,128,120,868,977
275,902,677,688,488,867,751,98,874,443,236,379,203,486,200,895,431,241,251,617
187,511,602,442,301,631,876,793,510,623,75,56,101,407,805,164,772,302,608,910
341,194,268,818,450,467,82,262,260,874,185,92,943,436,164,287,644,672,190,949
521,644,922,869,471,467,134,209,878,249,805,259,640,140,820,868,680,867,797,888
696,92,208,819,197,486,240,70,114,697,768,922,52,182,227,414,659,216,745,921
360,764,235,823,822,195,498,290,677,989,811,666,876,872,666,418,484,310,268,206
806,773,119,191,642,746,417,125,946,770,68,386,639,484,847,819,91,452,264,67
894,420,617,399,594,921,811,679,869,642,403,350,816,671,703,279,612,745,271,766
452,724,361,759,428,754,626,410,190,210,217,306,879,51,829,936,603,165,80,279
135,93,678,283,624,488,326,755,240,384,56,641,502,50,790,99,756,816,57,899
468,89,447,490,129,650,796,802,617,403,75,598,827,470,136,826,924,599,510,69
11,519,284,210,795,452,503,701,666,878,300,865,689,632,132,456,269,341,640,289
274,299,214,499,693,677,430,499,427,280,415,554,304,126,509,740,724,823,287,498
702,401,94,647,999,340,100,682,210,412,348,762,625,864,64,661,403,97,697,384
697,695,226,292,556,658,771,802,515,309,797,588,652,509,379,508,115,365,285,452
184,672,373,894,697,699,489,630,269,455,749,352,208,412,512,648,231,295,517,648
116,341,746,199,120,372,89,782,656,620,417,199,379,820,94,668,873,385,818,482
71,437,428,588,87,129,797,604,308,942,148,127,455,252,180,335,343,373,121,774
743,193,820,873,595,357,819,305,409,747,228,763,872,506,84,562,180,809,670,661
943,442,899,309,767,137,199,407,679,944,304,357,792,979,190,198,278,419,214,798
460,413,257,872,134,666,943,446,644,160,549,359,129,684,344,341,633,335,517,662
122,277,89,487,684,358,550,722,97,643,72,361,495,370,919,124,651,651,900,697
817,802,682,797,412,649,506,495,644,897,51,821,471,683,696,384,160,52,112,828
899,483,853,804,384,607,82,91,656,815,624,687,554,820,125,188,78,289,183,656
713,408,672,270,350,123,159,879,746,654,53,506,249,804,259,132,374,128,384,84
51,746,949,761,697,518,884,649,426,99,124,924,631,255,293,633,701,798,21,376
483,294,192,212,455,359,337,814,949,495,164,766,281,799,729,211,515,96,257,754
820,368,756,16,657,651,797,422,601,674,187,234,443,765,883,52,644,262,399,277
374,182,140,695,504,620,617,675,363,52,615,380,878,268,441,756,672,72,352,195
302,201,406,506,483,499,198,120,689,560,411,57,506,622,931,698,188,865,282,597
149,813,402,366,896,264,499,99,68,502,804,923,798,866,882,161,646,193,666,688
773,827,126,773,948,553,808,482,336,990,165,384,821,831,870,62,750,118,814,55
402,669,320,258,631,271,876,201,129,311,373,98,486,666,596,806,949,114,638,252
511,878,125,191,340,868,349,813,100,444,517,303,746,288,670,623,59,664,86,835
58,652,898,548,501,122,644,561,591,379,660,513,751,367,893,750,826,560,867,826
760,799,874,623,304,759,880,946,211,947,180,617,671,215,654,343,161,383,267,148
554,649,296,248,807,69,335,703,371,943,139,456,944,763,772,845,465,549,638,106
382,339,199,347,351,96,864,165,125,65,464,650,820,87,827,199,110,287,922,307
854,408,123,371,134,798,756,278,923,283,492,864,385,563,565,190,252,486,482,630
383,592,2,484,65,922,644,345,793,386,423,679,348,817,471,281,880,415,179,623
306,452,549,877,132,81,454,553,179,343,94,502,72,204,139,678,289,9,413,804
629,424,490,307,695,433,64,95,949,693,378,191,296,72,198,434,485,445,256,89
755,809,606,499,74,259,94,649,315,667,297,88,254,425,241,52,255,352,685,657
768,828,654,691,254,461,241,108,63,661,817,617,17,602,771,753,180,307,635,441
490,699,275,651,456,681,432,335,552,377,279,124,594,869,53,872,788,98,63,769
297,625,382,211,694,408,897,510,196,195,455,339,351,807,760,802,910,71,649,828
483,555,88,691,442,868,289,643,74,403,260,633,561,437,665,460,419,277,154,549
520,411,599,807,278,486,555,165,900,218,500,752,828,250,68,791,200,103,124,188
506,841,843,244,375,303,158,487,134,759,235,763,558,597,805,257,469,274,877,50
628,192,375,975,517,138,180,677,305,60,276,134,817,691,551,214,284,794,51,67
352,642,494,845,634,746,71,619,402,227,808,360,819,920,617,753,643,491,812,492
381,296,293,139,455,643,140,294,245,505,921,201,378,443,800,369,976,879,92,267
918,268,63,181,372,78,264,63,638,236,837,266,644,399,702,257,946,824,869,138
509,206,617,373,55,321,662,376,664,692,458,218,211,560,399,459,163,421,289,483
104,724,435,627,120,348,123,272,304,199,423,190,865,749,234,204,942,894,770,493
180,764,752,135,212,630,554,427,607,621,811,212,362,347,239,777,634,900,455,877
644,946,151,844,220,288,608,385,159,278,370,491,362,949,680,281,871,179,75,386
878,820,458,92,289,195,66,814,362,137,461,127,770,412,916,453,98,797,668,370
385,770,241,744,555,809,268,443,119,132,470,377,74,184,253,122,141,746,197,201
384,667,617,103,869,871,799,257,792,488,127,384,269,680,551,505,280,431,269,254
482,702,159,489,830,123,215,204,872,56,514,260,456,108,368,229,242,191,53,799
602,558,864,268,802,434,160,644,102,592,945,411,607,360,493,796,468,384,386,404
164,371,220,434,628,418,82,588,190,560,608,131,916,694,884,198,765,703,358,82
491,490,263,825,565,509,53,670,416,703,877,126,161,944,76,486,747,784,288,266
679,419,626,341,588,364,758,594,671,51,913,795,261,827,651,633,386,115,626,648
264,621,203,521,366,96,881,431,818,557,356,590,236,383,344,941,655,628,382,227
901,499,378,762,488,671,350,255,876,239,406,556,683,521,158,421,829,373,158,72
624,900,869,467,444,820,247,280,291,234,896,747,899,654,184,471,622,13,871,471
799,683,279,131,663,678,225,676,430,65,345,98,138,193,188,267,505,257,689,588
766,305,865,416,60,516,771,462,165,105,483,555,883,761,498,665,660,696,617,506
469,431,658,439,267,163,505,194,698,681,494,258,408,107,669,294,809,136,549,288
417,440,178,259,816,193,502,90,945,991,307,465,343,564,488,118,139,798,441,824
946,683,592,182,813,74,864,872,408,640,460,948,77,263,692,467,402,202,11,108
607,214,949,219,466,431,486,280,635,342,254,405,793,374,256,94,692,552,615,261
497,681,195,924,877,92,198,186,308,403,250,372,484,301,111,187,56,201,401,193
549,608,490,811,549,284,335,648,2,684,920,165,277,866,749,400,604,278,461,202
122,826,658,844,270,817,896,340,656,784,876,340,306,383,589,647,797,296,220,605
671,804,653,297,61,340,239,772,373,688,291,755,92,240,371,65,21,604,607,642
994,381,193,868,76,495,943,403,415,84,423,626,99,675,214,344,805,588,115,410
646,276,478,845,116,947,564,462,407,689,91,284,257,59,64,596,287,292,214,286
250,668,109,239,701,646,347,278,440,210,108,185,670,238,556,884,180,415,405,310
56,159,267,821,744,435,762,658,657,262,827,196,870,352,713,873,682,73,71,724
677,494,594,700,597,551,767,138,749,430,124,560,339,386,278,200,896,94,139,712
938,73,489,383,346,635,638,747,821,345,408,758,800,431,765,183,842,263,186,745
5,125,769,508,404,250,747,818,458,757,54,875,651,803,896,250,797,589,293,636
642,342,361,132,598,83,629,443,336,213,77,829,208,295,811,379,269,192,449,235
303,794,376,117,198,874,88,284,241,565,632,425,240,57,768,398,606,685,516,212
291,819,947,878,829,423,410,880,7,101,379,761,595,867,384,559,64,896,92,664
263,654,441,635,564,661,914,640,668,268,290,344,286,757,490,588,818,765,421,305
655,622,797,562,414,85,179,375,867,801,418,460,69,276,158,109,140,302,212,381
466,217,763,790,486,202,57,124,878,122,239,520,774,628,502,749,357,604,862,92
479,549,68,134,238,687,796,368,817,209,252,301,495,918,682,161,409,247,897,81
254,451,894,681,618,437,509,791,592,454,349,258,456,282,793,254,793,56,820,158
800,185,138,434,291,19,134,140,759,765,288,178,268,621,218,439,291,502,496,52
373,810,255,509,189,84,756,746,498,364,216,824,774,656,392,765,370,199,771,304
650,443,845,605,900,340,189,124,259,820,608,810,761,370,242,555,834,800,752,507
441,757,425,831,636,139,448,746,98,249,895,184,454,442,756,685,432,553,120,634
115,563,74,562,841,823,501,945,671,354,680,279,604,772,279,194,286,257,258,272
414,455,515,162,53,505,165,554,441,422,369,367,297,220,755,516,849,554,191,132
620,139,813,95,354,241,493,880,652,901,408,98,431,866,695,66,119,664,80,202
589,373,596,461,340,335,286,695,766,423,695,626,470,550,882,367,897,838,382,943
374,339,518,555,212,409,511,109,687,592,338,77,831,588,897,164,163,508,603,416
634,767,376,844,749,803,383,53,752,274,96,116,628,549,126,450,465,179,865,554
115,821,821,383,605,275,619,654,564,819,799,644,651,431,430,114,804,165,907,482
649,452,253,493,680,366,761,677,794,501,207,806,822,92,683,811,618,229,881,435
421,489,178,459,402,436,216,103,272,498,675,341,811,369,875,758,418,702,246,344
429,805,100,604,420,436,465,304,342,818,126,517,65,552,899,858,67,270,634,483
186,98,22,429,795,453,774,58,924,431,753,266,827,65,627,667,797,140,805,116
645,692,67,515,189,455,820,195,872,54,750,63,442,806,614,71,818,134,697,265
644,209,487,486,751,68,243,494,744,810,351,431,72,621,61,584,266,411,470,99
824,790,625,384,96,629,195,749,440,557,633,83,211,983,354,655,178,195,646,73
309,342,684,275,288,621,430,347,135,84,549,203,631,428,755,472,588,386,786,472
805,455,309,139,845,992,702,353,621,307,123,68,694,404,516,755,699,122,620,192
814,880,192,466,68,645,119,509,337,671,238,813,134,894,896,298,469,263,254,858
197,634,618,115,559,180,632,831,772,497,234,342,92,517,130,562,935,499,347,899
253,104,423,752,278,341,339,108,459,193,829,671,670,603,752,374,751,497,430,793
273,80,79,101,69,442,381,472,117,118,747,76,633,108,446,634,554,291,306,400
86,245,132,135,101,420,262,664,442,765,551,703,820,293,703,890,460,899,434,264
789,748,257,799,680,696,350,604,92,362,679,260,336,842,468,924,490,262,191,131
208,941,258,823,87,11,746,419,364,492,440,66,405,245,211,182,376,257,287,829
842,807,739,773,633,411,471,595,659,50,464,276,867,266,122,767,290,866,494,406
519,696,438,924,430,287,444,265,245,608,415,120,77,642,878,99,60,309,104,125
81,62,295,220,284,286,590,414,651,16,240,873,279,629,270,78,698,560,754,796
501,378,589,256,724,206,698,873,383,404,443,628,633,245,652,838,829,628,651,192
101,943,695,519,359,865,132,246,206,767,871,922,85,288,645,533,629,462,133,601
755,632,54,459,801,69,24,63,367,81,770,680,235,688,414,210,747,409,761,632
18,434,493,136,114,368,452,503,379,687,671,80,640,422,256,641,299,560,666,135
129,347,747,259,435,436,64,100,403,416,453,415,92,468,194,120,486,111,218,628
374,381,708,99,404,372,502,99,648,945,624,919,461,792,81,469,116,744,60,690
208,131,218,115,658,695,756,184,599,159,820,138,472,667,779,137,276,680,196,506
594,761,703,487,67,218,84,67,790,470,130,750,383,687,380,900,199,610,242,594
364,501,597,753,130,619,220,69,520,404,945,415,556,439,552,716,811,756,62,459
595,179,510,773,606,647,518,55,998,256,830,617,413,433,688,127,139,805,186,845
243,472,648,340,911,201,415,460,432,516,793,416,884,799,800,83,949,62,758,50
118,89,942,439,340,278,137,908,135,699,453,383,287,194,403,501,829,242,54,879
462,461,655,114,504,463,256,362,340,414,463,416,769,808,864,127,565,373,662,615
266,706,116,219,246,69,620,75,600,50,553,831,440,342,919,99,271,76,680,215
899,344,676,979,372,270,274,201,84,161,409,593,250,194,514,206,380,309,352,399
================================================
FILE: advent-of-code/2020/inputs/17
================================================
#####..#
#..###.#
###.....
.#.#.#..
##.#..#.
######..
.##..###
###.####
================================================
FILE: advent-of-code/2020/inputs/18
================================================
2 * 9 + 5 + ((8 + 6 + 5) * (2 + 3 * 9 + 3) + 5) * (7 + 9 + 7 + 3 * 7) * 5
7 + (2 + 8 * 8 * 2 + (4 * 3 * 9 + 4 * 4)) + 4 * 3
6 + 9 * 2 * 2 + (2 + (7 * 6 * 6) + 4 * (7 * 8 * 2 + 4) * 7) + 7
2 + ((3 * 6 * 5 * 4 + 7 * 7) + 5 * 4 * 5 * (8 * 7 + 9) + 8) * (4 + 6 * 5)
(7 * 6 * 3 + 4 * 3 * 9) + (6 * 6 * (4 + 6 + 4) + 7 + 2 + (9 * 8 * 9 + 9 * 7 * 4)) + (3 * 4 + 3 + 2) * 8
(3 + (7 * 7 + 9 * 9 * 6)) * 3 * 5 + 4 * 8
8 + 9 * (2 + 2 * 5 + 9 * 2) * 2 + ((6 + 4) * 4 + (4 * 7 + 3 * 3 + 7) * (4 * 5 + 8 + 8 + 7 * 6) + (6 + 2) + 5)
(2 + 2 * 9 * 7) * ((9 + 8) * 3 * 6 + 6 + (5 * 4 * 4 * 3)) + 9 + (3 + 2)
2 + 7 * 3 + ((7 + 7 * 3) * 6 + 8)
2 + 7 + 6 + (4 + 7 * 7) + 9 * 2
(9 * 2 * 4 * 4) + 4
8 + (8 + 8 + 7) * (5 * 4 + 4 + 5 * 5) * 9 + 8
(6 * (4 * 2 + 4 + 7 + 4) + 4 * 7 + (7 + 5 + 3 + 3 * 7) * 6) * 6 + 3 + 6 + 5
5 + ((7 * 3 * 2) + 9 * (9 + 2) * 6)
(3 * (2 * 2 * 3 * 7 * 2) * 8) * 8
((3 + 2) + 5 + 7 + 3 * (8 + 4 + 5 * 8 * 9)) + 7 * 3 * 6
7 * 6 + 8 * 4 + ((7 + 5 + 2 + 4 * 9 + 9) * 7 + 5)
6 * (6 * (4 + 8 + 6) * 6)
4 + 3 + (6 * (2 * 8))
(2 * 8 * (3 + 8 + 3 + 2) * (8 * 4 + 2 + 8) * 9 + 7) * 8
4 * (3 + 9) + 9 + 4 + 8 + 4
((6 + 3 + 5 + 6 + 6) * 9 * (2 + 7 * 4 * 9 + 3 * 7) + 6) * (3 * 9 + 2 + 7 * 3) * 6
8 * (5 + 4 * 3) + 3 * 7 + 6 * 4
4 + 6 + 6 + (4 + 9 + 3 + 3 + 3) + (2 + 6 * 2 + 3 + 4) * (2 * 4 + 9 + 3)
7 + (3 + 2 * 4 + 4 * 9 + 2) * 2 * ((8 * 6 + 6 * 2 + 7 + 7) + (2 + 8 * 7 + 6 * 9) + 7 * 6) * 7 + 8
3 * (8 * 7 * (5 + 2 + 8 * 9))
6 * 9 + 2 + 8 + (4 * 3 * 4 + 6)
(2 * 6) + 7 * 9 + (3 * 9 + 8 * 4 * 3 * 5) * (9 * 7)
5 * 2 + (3 + 5 * (5 + 7 + 7 + 4) * 2)
9 + 4 * (8 + 3 * 2 + 9 * 6 * 4) * 9 * 6
6 + (6 * (2 * 5 * 4 * 7 * 3) * 9 + 4 + 6 * 3) + 4 * 8
(6 + (4 * 7) + 6 * 5) + 4 + 7 + 2
3 + 4 * 9 + 9 * 8 + (3 * 4 + (9 * 6 * 9 * 2) * 5 + 8)
8 + (3 + (9 * 3) + (6 * 4) + 8 * 6 + 8) + 5
(7 + 6 * 3) * 2 + 5
6 + 6 + ((6 + 7) * 9 + 5) * 2
(3 * 3 * 2 * 5) + 9 * 9 + 3
(8 * (6 + 2) + 4) * 9
(4 * 6 * 6 * 3) * 9 * 4 + 4 * 4 * 9
5 * 5 + ((8 * 9 * 2 + 5) + (3 + 7 * 5 + 2) + 2 + 8 + 5)
9 + 8 * (6 + 2 * 2) + 7 + 4 * 9
7 * 8 + (9 + (9 + 4 + 6 * 6 * 9 * 6)) * 8 * 5
9 * 7 + 8 + 7 * (4 * 2 + (6 + 3 * 4 + 6 * 6 + 6) * 2) + 9
8 + 2 + (4 * 3) + (2 + 8) * 5 * 7
2 * 7 * 7 * 8 + (3 * 4 * (7 * 4) + 5 * 8)
2 * ((6 + 7 + 6 + 2) * 4 + (9 + 4 * 5) + 8 + 6 * 7)
(6 + 4 * 4 + 9 * (4 + 9 * 5 + 9 + 9 * 9) + 7) * 2
8 + 9 * (4 + (6 + 4 * 3 * 6 * 6) + 7 + (6 * 2 * 8) + (9 + 5 * 3 + 3 * 3) * 9) * 9 * 4
(8 + 8 * 9 + 9 + (7 + 8 * 3)) * (6 + 4 * 7)
2 + (6 * 3 * 5 * 5) + 4 + 9 + (4 + 9 + 9) + 4
8 + 3 + 8 + (4 + 6 * 6 * 2 * 5) + 5 * 5
2 * 4 + (7 + 6 + 9 + 5 + 9 + 2)
(5 * 5 + (5 + 7 + 4 + 3 + 7) * 4) + ((6 * 4) + 2 * (8 + 8 + 4 * 4) * (7 * 7 * 2 + 3) + (8 + 6 + 8 * 2 * 8 + 8)) * 7
3 * 4 * (7 + 6 * 4 + 6 * 3) * 4 + 4 + ((8 * 6 + 2 + 5 + 7 + 6) + 6)
9 + (9 * 7 + 2 * 9) + 8 + 6
4 + 6 + 7 + 6 * 3
5 * ((4 + 4) + 4 + 7 * 9) * 6
9 * 6 + 6 + (4 + (5 + 9 + 2 + 9 * 5 + 8) * 4 * 8 * (3 * 4 + 7 * 6 * 3) + 7) * (4 + 4 * (6 + 7 * 6 * 7 * 9)) * 5
6 + (2 + 4 + 6 + 6 + (8 * 7 * 2 + 6)) + 5 + 9 + 2 + (8 * 7 * (9 + 8 * 6 * 6 * 7 * 3))
6 + 9 + 7 + 8 + (8 * 6 * (5 + 5 * 7 + 3) * 8 * (4 + 8 * 2 + 9))
(9 + 3 + 8 + 4 + 8 + 4) * 6 * 3 * 6
5 * ((5 + 7 + 2 * 3 + 4 + 3) + 3) + 6 + 4
2 * (8 * 4 + (9 * 3) * (7 + 2 + 3 * 4) * 7) * (6 + 9 + 7) + 5 + 4 + 7
9 * (9 * (8 * 9 + 5 * 3 * 2) + (9 + 7 + 8 * 8) * (9 * 7 + 6)) * 3 * 3 + 8 * 6
5 * ((2 + 5) * (8 + 2 * 6 + 6 + 3) + 9 + 3 + 9) * (7 * 4) + (3 * 7 + 8 + 5 + 2 + (7 * 7 + 6)) + 4 * 7
(2 + 8 + 6 + 6 + 8 + 3) + 5 + (5 + 7 * 8 * 5 + 5 * (2 * 4 * 2 + 2 + 6))
5 + 6 + (9 * 7 * (6 * 8 * 4 + 7 * 2 * 4) + 3 * 5) + 4 + (2 * 4 * 6 * (9 + 6 + 7))
5 + 6 * (7 + 5 * (4 * 3 * 9))
6 * 8 + 4 + (2 + 8 * 6 * 2 + (5 + 9) * 3) + 6
(7 + 5) * 7 + 5 * (6 + 4 * 9 + 6 * 2)
9 * (9 + (5 + 9 * 7 + 7 * 2 + 2) * 9 + 8 + 5 * 6) + (5 + 5 * (2 + 4 + 7 + 9 + 6) + 2) * 9 * (3 + 5 + (8 + 2 * 2 + 7 * 7 * 6))
7 * (7 + 3 * 8 * 9 * 9 + (5 * 2)) + 5
9 * 9 * (8 + 3 + (2 + 9 + 6 + 6)) * 4 + 2 + (2 + 9 + 6)
((9 * 4 * 9 * 3 + 2 * 5) + (7 + 2 * 4 * 3 * 6 * 8) * 7) * 3 * 9
(3 + (8 + 6 * 6 * 5) + (3 * 5 + 8 * 5) + 7 * (2 + 3 * 7)) + (8 * (6 * 8 * 5 + 8 * 2)) + 8
4 * 4 + 5 * 8 * (2 * 2 + 8) * 8
7 * 8 + (5 * 4) * 7 + 2 + 9
((4 * 9) * 4 * 8 * (4 * 6 * 5 * 2) * 5 + 9) + 7 * 2 + 8
((4 * 3 * 9 + 7 * 7) * (7 + 3 + 7) + 9 + 6 + 8 + (3 + 2 * 6 * 2 * 9)) * 2 + (7 + (9 * 9) + 6) * 3 + 6
8 + (9 * 8 + (2 + 3 * 3) + 4 + 4 + 4) + 4 * (5 * 4 + 4 * 6) * 7 + 8
9 + 8 * ((2 * 5 + 7 * 2) + 3 * 4 * 3 * 8 * (2 * 6 + 6 + 3 * 5 + 6)) + (8 + 9 * 8 * 2 * 3 * 9)
8 + (9 * (8 * 5))
(5 * 4 * 9 * 3) + 7 + (3 + 7)
3 * (2 * 8 + 2 * (8 * 3 * 8 + 8)) * 7 + (6 + 7)
3 + 4
2 * 8 + ((8 + 9 + 6 * 7 * 4 + 5) + 2 + (5 * 2 + 8)) * 4 + 2
2 + 5 * 7 * 4 * (3 + 9 * (4 + 5 * 7) + 4) + 5
5 + 7 * (6 * 9 + 9 + 5 * 3) + 8
4 + (8 + 6 + 5 + 5 * (2 + 6) * 5)
5 * 4 + 3 + ((4 * 5 * 7 * 6) + (7 * 7 + 6 + 8 * 9 + 4) + 5 + 2 * 7 * 5)
9 * (8 + (4 + 9 * 8 + 7 * 3) + 3 * 9) + (7 * 7 + 5 * (5 + 7 + 3 * 9))
4 * 6 + (2 + 6)
6 + 2 * 2 + 4
4 + 9 * 7 * (2 + 5 * 4) * 9
(2 + 4 * (2 * 9 * 4 * 8 + 5 + 4)) + 4 + (8 * 7) + 7 + (3 + 5 * 7)
9 * 8 * 8 * (6 + 6 * 2 + 5 * 7 + 3) + 6 + 8
(3 + 9 + (7 * 2 + 2 + 3 + 2)) + (4 * 6)
((6 + 3) + 3 * 8 + 7 * 7 + 8) + (9 + (8 * 6 + 7) + 2 + 5 * 4) + 5 + 3
8 * ((5 + 2 * 9 + 2 + 7) * 7 * 7 + 7) * 4 + 8 + (4 * (3 * 9 + 3) + (2 * 9 * 4 * 9 * 7 + 6) + 6) * (8 + (2 + 5 * 3 + 8) + 4 + 8)
5 + 4 + 7 * (4 + (5 * 5 + 3 * 3 + 8 + 7) + 3 + 8 * 6)
((9 + 5 * 5 * 6 + 4) + (2 + 2) * 2) * (9 * 9 + 7 * 7 * 6) + 9 + 6 + 2 + (9 * (5 * 9) + 3 * 5 * (5 * 2 * 4 * 7))
2 * (9 * (5 + 9 * 2 * 9) * 9 + 6) * (2 * 6) * 5 + (3 + 9 + 4 + 6 + (4 * 5 * 7 + 6) + (6 + 7)) * 7
3 * 8 * 8 * 9 * 2 + 3
6 * 8 * 6 + (2 + 7) + 5
(6 * (3 * 4 + 6 + 9) * (2 + 8 + 3 * 8 + 3 * 2)) * 7 * 9 * 7
8 + (4 + 9 + 2 + 9 * 2 + 9)
5 + 7 + 6 + ((2 * 2 + 7 + 3 + 9) + 2 + 8) * 7
(3 * 2) * 2 * 7 * 5
9 + ((4 * 3 + 3 * 6 * 2 * 9) * 5 * 7 * 3) * 4 * 7 * 2
(2 * 2 + 9 + 7) + (6 + 4 * 9 * 5) + 6 * 8 * 3 + 8
8 * 8 + (7 * 9 + 6 * 7 * (2 * 2) * (4 + 2 + 8 * 2 * 3)) + 4
(3 * (7 * 9 * 6) + 2 + (2 * 6)) * (4 * 3 * 7)
2 + (2 * (6 + 9 + 9 * 6)) * (7 + 7 * 3 + 8) + 7 + 3
9 + (5 * 2 + (8 * 4) * 7 * 5) + 9 + 4
2 + 4 * 4 + 8 * 3 + 5
8 * 2 * (8 * (7 * 3 * 5 + 7) * 5 + 6 * 4 + 9) * 8 * 2 * 8
((7 + 4) + 7 * 3 + 6 * (3 + 6 + 8) * (5 + 4)) * 2 * (7 + (2 + 3 * 5) * 5 + 3 + 6) * ((6 + 3 + 4 + 2 + 3) + 4 * (3 * 7 + 2))
(2 + (3 * 8 * 2)) + 2 * ((3 + 6 + 3 + 7) * 5 * (9 * 2 + 6 + 7 + 3))
(6 + (7 * 2 + 4 * 9 + 5 * 2) + 4 + 8 * (4 * 8 * 5 + 7) + 9) * 7 + 2 * 9
2 + (6 + 4 * 2 + (7 * 2)) * (8 * 6 + 6 * 4 + 5 * (5 * 4 + 9))
(6 * 3 + (5 * 8 * 4 + 7)) + 7 * 7 + 9 + 9 + 7
(2 * 9 * 7 * 5 * 7 + 5) * 8 + (8 * (9 + 9 * 8) * 7) * 4 + 5
6 + (3 + 8 + 4 + 9 * 7)
4 * 8 + 2
((8 * 8 + 4 + 9) + 9 * 7 + 8) * 8 * (5 + 7 * 5) * 2 + ((3 * 2 + 6 + 6 * 3) * 8 + 9 * 9 * (9 * 6)) + (4 * 8 * (5 + 8 * 5 * 8) * 6 * 9 + 8)
(3 * 6 * 7) * (4 + 8) + 9
6 * ((9 * 3 * 4 + 9 * 2) + 7 + 2 * 6)
6 + (7 + 8 + 2 * 5 * 2) * 7 + (5 + 3) * 7
7 + ((6 * 8 * 6 * 3) * 9 * 3) + 9 + ((3 + 4 * 2 * 6) * 4 * 3) + 5 + 3
(4 + 3 * (5 * 2 * 2)) + 5
4 * 3 * (6 * (4 + 3 + 9 * 3)) + (4 * 2 * 5 + (9 * 2) * (6 + 8 + 9 + 6 * 8 + 8) + 2) + 6 + 8
7 * 5 * 9 + 7 + (5 * (9 + 8 + 3 * 6 * 3)) * ((3 + 5) * (7 + 9 + 3 + 6 * 2) * 3 + 9)
((3 + 3 * 9 + 4 * 8 * 2) + 6) + 2 * (5 * (2 * 5 * 7 + 8 + 6) * 2 + 8 + 3 + 6) + (4 + 6 + 4)
(2 * 8 + 8 + 4 + 3 + 5) + 7
6 + (6 * 5 * 9 * 6)
8 + 2 + 6 + 3 + (9 + 6 + (7 * 3) + 5 + 4 + 8)
6 + 7 * (3 * 7 * 5 + (9 + 6 + 6) * 7) * (3 + 4 + 7 * 4 + 6) * 4 * 4
9 * 9 * (4 * 4 * (3 * 2 * 2 + 4 + 7 * 3) * 7 * 5 + (7 * 4)) + 5
9 * ((6 + 3 * 6 + 2) + 4 * (9 * 8 + 8)) + 5 * 6 * 4 + 4
(8 * 9 + (8 + 5 + 8 + 5 + 3)) + 3 + 6 * 4 * 2 * 4
8 + (3 * 6 * 7) * 4 * 4 * 3
(6 * 8 + (2 * 2 + 3 * 8) + 6 * (4 * 9)) * 6 * (2 * 8 + 7 * (8 + 9 + 6 * 9 + 3 + 3))
3 + 8 * 2 + (8 * 3)
4 + 3 * 2 * (5 + 3 + 5 + (6 * 5 * 3 * 6 * 6)) + 9 + 7
(3 + 5 + (3 + 9 + 9 + 7) * 7 * 6) + 7 * 5 * (5 + 3)
2 + ((7 + 2 + 9 + 2 + 6) * 3 * 2 * 5 * 5 + 2) + 2
6 * 8 * (2 + 4 * 9 * 5) + 9 + 3
4 * (6 + 9)
5 * 2 + 3 * 2 * (5 * 3 * 9 * 7 + (6 + 4 * 5 + 6) * (6 * 2 * 2)) * (9 + 6 + 9 + (8 + 9 + 9))
5 + (4 * 4 * 5 * (4 * 2 * 4 * 2) * 7) * 2
3 * 2 + ((4 * 6 * 8) + 9 * (3 * 9 * 8 * 2))
(3 * 5 + 6 * 8) + 5 + ((2 + 9) + (3 + 4 * 2 * 5 * 3) + 4 + (3 * 7)) * 6
6 + 3 + 2 + 4 + (6 * 2 + 6 + 4) * 2
(5 + (5 + 6 + 7 * 2) + 7 + 4 * 5) + 5 * 6 * 9
4 * 7 * (3 * 2) + 4
(5 + 4 + (8 + 3 + 7 * 2)) * (6 + (5 + 7 + 3 * 8 + 4) * 5 + 6 * 6 * 5) + 7
2 * 5 + (5 + 4 + 3) + (9 * 3 + (7 * 6 * 9 * 4 * 3 * 2)) * 3 + 2
(8 * 2 + 3) + 5 * 2 * 9 + 9 + (3 + 4)
9 + 6 * ((4 * 7 * 9 * 5 * 4 * 5) + 8 * 8 * 7) * 7
5 * 4 + ((3 + 2 * 5 * 6 + 7) + 7) + 2
3 * 9 + 4 * 9
9 + 7 + (7 + 5 + 3 * (5 + 7 * 8 * 7 + 5 + 7)) + (7 * 6 + 5 * 8) + (8 + (2 + 3 * 3 + 4) + (6 * 9 * 9) * 8) * 6
8 * (2 * 7 * 3 * 4) + 9 * 3 + 7
6 + (8 + (7 + 5 * 8 * 5) + 5 * 6 + (8 * 6) + 6) * 3
7 + 3 * 4 * 6 + 9
8 + 8 + ((8 * 9 + 6 + 3 * 9) + 3 + 4 * 8)
9 + 4 + 6 + 3 + 2 + (2 * 6 + 8 + 3)
(5 * 2) + 4 + 7 * 9 + (5 + 5 + 3 * 5)
5 * 5 * 2 * 5 + (9 + 7 + 5)
(2 * 5) + 7
5 + 7 * 9 + 3 * 5
(8 * 7 + 9 * 5) + 3 * (6 * 5 + (2 * 7 * 2 * 7 + 7 * 2) + 4) + 3
(6 + 6 + 6 + 9) + 9 + (3 * 5 + 4 + (6 * 3) * 4) * 3 + (8 + 7 * 5 * (3 * 3) + 6) * 3
((2 * 8 * 3 + 2 * 6 * 5) * 5 + (7 * 3 + 5 + 6 * 9 * 4) * (5 * 6 + 8 + 4 * 7 * 5)) + 6 + (9 * (9 + 7 * 8 * 3) + 7 * (5 * 9 + 6 + 5 + 4 + 8) * 8 + 8) * 5
2 * (5 + 2 * 2 * 3 + (4 + 3)) * (6 + 6 + 2 * 9 + 9 * 3) * 8 * 8
9 * (9 + 3 + 8 + 5) * (2 * 5 * (6 + 8) * 9) * (4 + 3 * 8 * 9 * 4 + 4) * (3 * 9 * 8 + (6 * 6 + 9 + 5) + 2 * (8 + 2 * 7))
2 * 5 * 9 * 8 * ((7 * 2 * 3) + 3)
2 * (6 * 7 * 2 * 4 + (5 * 4 + 7 + 3 + 7) + 5) * (7 + (6 + 3) * (8 + 8) * 3 * (5 + 2)) * 3 * 8 * 7
2 * 5 * (4 * 9 + 2 + 5 * 2) + 6 * 5 + (6 * 6 * 4 * 8 * 4)
4 + 8 * 4 + 4 * 3 + (7 + 2 * 2 * 5 * 2 + 8)
(8 * (4 + 5 + 9 * 9 + 8) * 4 + (8 + 7 + 9 * 4 * 4 + 3)) * 7 * 8 * 3
8 * 9 + ((2 + 5 + 8 * 9 + 5) + 2) * 7 * 4 + 5
3 + (5 * 8 * 6 * (7 + 4 * 2 + 2 * 4 * 2) + (9 + 6) * 9) + 4
9 * 7 + 4 + (7 + 9 + (9 * 9 + 8 * 4 * 5 * 8) + 5) + 3
2 * 2 + 6 + (3 * 9 + 6 + (4 * 4 * 6 + 2 * 5)) * 5
6 * 3 * (3 + 8 * 7) + 9
7 * 2 * 6 * (3 * 3 * 8 * (2 + 7 * 9 + 8))
9 * 7 + 6 * (7 * (3 + 6 + 7) + 3) + (9 * 6 + (2 + 9 * 3) + (7 * 8 * 8 + 6 * 3 * 5) * 9)
3 * 4 * 4 * 6 + 2 + (6 * 3)
4 * (5 + 7) + 8
5 * 3 * 9 + 9 + 9 * 2
8 + (8 * 9) * 7 + 6 * 9
9 + 9 * (3 * 8) * 3 + 2
6 + (8 + 6 + 2) * (9 * 9 * 8)
5 + 4 * 3 + (2 * 2 * (2 + 3 + 4 + 7 * 3) + 5 + 3) + 6
9 * 2 + 3 * 8 * 9
5 * 2 * 7 * ((5 + 6 * 4 + 6 + 3 + 5) * 7 + 9 + 4) * (7 + 3 * 7)
2 + ((5 + 3 * 4 + 2) * 2 * 6 + (8 * 8 + 8) * 3 * (3 * 8 * 5 * 6 + 5))
5 + (6 + 9 + 4 + (3 * 7)) * (4 + 6 * 5 * (7 + 8 * 3 + 3 * 9) + (9 + 8 + 3))
4 * 2 + 9 + (9 * 6 * 9 * (9 * 4 + 3 * 2 * 6 + 8) + 7 + 9) * (5 + 7 * 9 * 5) + (8 + 9 + 4 * 5 * 8)
7 + 8 * 3 + (5 + 2 * 2 + 6 * 8) + 7
8 + ((9 * 7 + 5 * 8 + 3 + 6) * 4) + 6 * 4 + 4 + 3
(6 + 2 + 4 + 7) * (2 + 6 * 7 * (4 * 3 + 9 + 5 * 5) + 5 + (2 + 3 * 5 * 5 * 6)) * 2
(6 + 9) + 4 * 9
4 * (4 * 5 + 9 * (9 + 5 * 7 * 6 * 7 + 9))
2 * 5 + ((7 + 3 * 3 * 9 + 8 + 4) * 4 * 6) + 3 + 6 + (4 + (2 * 7) + 5)
(7 + (4 * 5 + 2 + 2 * 2 + 8)) * 5 + 5 + (3 + 8 + 6 * 6) * 9
5 + 4 + 4 + 7 * (2 + 6 + (3 + 6 + 7) + 6 * 9) * (2 + 8)
8 + ((4 * 3 * 2) + 4) + 5 * 7 * 3 * 5
4 * 4 + 9 + (8 + (6 * 5 * 2 + 8 * 3 + 8) + 4 * (2 + 6 * 2 + 4 + 3 + 2) * (4 + 5))
(9 + 8 * 8 + (5 * 8 * 7 * 8 + 9 * 6)) * 9 + 5 * 2
7 + 8 * (2 + (5 + 7 + 3 + 9 * 8 + 8) * (2 * 9 * 7) + 3 + 4) * 8 + 5 + 2
5 + 2 * (5 * 7 * 6 * 4 * 2 + (7 + 2 + 7 + 9 + 4))
6 * 8 * 7 * 8 * 9 + 9
5 + 8 + 7 * 5 * (8 * 8 * 5 + 7 + 9) + 6
9 + 2 * 3 * 5
8 * 5 + (2 + (4 + 9 + 5 * 6 + 8) + 9 * (4 + 4 * 5 * 3) * (5 * 7 * 8 + 3 * 3 + 3) + 5)
7 + 3 + (2 * 2 + 5 * 8 + 3) + (8 + 3 + (6 * 5 + 4 * 5))
6 * ((2 * 6 + 6 * 2 + 5 + 4) * 8 + 8 * 9) * (5 * 2 + 4 + 6 * 3) + ((6 + 8 + 8 + 6 + 7 * 6) + 8 * 9 * 2 * 2 * (8 + 3 + 7 * 5 * 3)) * ((5 + 9) * 4) + 4
(3 * 8 * 5) + 8 + (3 + 7 + 2 * 3 * 8) * 5
7 + 3 * 9 + (2 * (2 + 9 + 9 + 8 + 9) * (8 * 6)) * 4 * 9
7 + 9 + (3 + 7 + 2 + 6)
4 * (6 + (3 + 6 + 3) * (9 * 7 * 4 + 3 + 4) + 8 * 7 + 4)
((9 + 6) * 3 + 2 * 5) + (6 * 5 + 4 + 3)
3 + (4 * (2 + 4 + 4 + 2)) * 4 * 7 + 5 + 5
(5 * 9 * 2 * (7 * 9 * 8) + 2) + 6 + 2 + 8 + 9
5 + 4 * 4 + (2 * 3 + 8 + 8) * 6 * (9 * 8 + (8 * 9 * 5) + 9)
3 * 5 * (8 + 3 + 7) + 4 + 6
6 + 7 * (9 + (2 + 7 + 2 * 2)) * 3
(9 * (4 * 3)) + 9 * 4 + (9 * 5 + 5 * (6 * 2 + 8 * 8) + 2) + 9 + 8
6 * 7 + 7
7 + (9 * 6 * 8 + 9 * 2) * 4 * (9 * 4 * 6 + (8 * 5 * 8)) * 7
8 + 5 + ((8 + 2 * 6) + (9 * 3 * 8)) + 7
4 * 8 * (6 + (4 + 5) + 5 * 3)
(3 * 2 + 6) + 3 + 3 + 8 * 6 * 7
9 * 3 * 3 + (4 * (6 + 3) * 4) + 2 * 9
5 + 9 + 7 + 4 * (9 * 3)
((8 * 9) + (7 + 5 + 6) + 3 * (5 + 7 + 6)) + 5 + (3 * 8 * 3) * 2
9 + 6 * 5 * ((4 * 4) + 7 * 3) + (3 * 6)
7 + (8 + 7) + 4 * (3 + 3) * 7 * 9
((6 + 7 + 4 + 7) * 7 + 9 + (9 * 7 + 5 + 7 + 7) + 9 + (7 + 3 + 2 * 6 + 9)) + 2 + (4 * 7 + 9 * 3 * 2 * (5 + 9 + 3)) * 5
9 * (3 + (9 * 9)) + 9 * 8 + 4 * 2
(8 * 8 + 6 + 9 + 8 + 2) + 6 * 5 + 5 * 4
3 + 3 + 4 * (6 * 6) + 2 * 8
(5 * 9) * (8 * (2 + 6 * 9) * 7 + 7)
8 * 5 + (8 + 8 + 8 * 4) + 3 * 8 * (8 + 6 * 3 + 4)
4 * 9 + (5 * (8 * 3) + 4) * 5 + (3 * 3)
(2 + 2 * 4 * 3) + 8 * ((2 * 6 + 5 + 6 * 2) * 3) + 2
((5 * 4 + 2 + 7 * 6) + (7 * 5 + 4) + 9 + 7 + 7) + 3
2 + 3 + 9 * 9 + (9 * (2 + 8 + 7) * 3)
3 * 7
(4 + 2 * 5) + 2
5 * 5 * (5 + (8 + 8 + 8) + 3 * 2 * 4) * 9 * 2 + 8
4 + 5 * 3 * 5 + (4 + (3 + 8 + 4) + 7) + 7
(4 + 7 + 6 + 2 * 7) + 7
4 * 2 * 4
(4 * 4 + (6 * 6 * 7 * 2) * 4 * 6 * 7) * ((9 + 5 + 9) + 8) * (5 + 8 + 2 + (9 + 8 * 2 + 9 * 8) * 8 + 3) * 6
5 + 8 * 9 + ((7 * 9 * 3 * 7) * 2 + (2 + 2 + 3 * 6 + 6) + 5 + 4)
3 * 8 + 2 + (7 + 8 + (8 + 7 + 7 * 6 + 2) + (3 + 2) + 5)
4 + 4 * 6 * 5
4 * 9 * ((9 + 2) + 4 + 2 * 5) * ((6 * 9 * 5 + 8) * (7 + 7)) * (8 * 7 + 9 + 7 * (2 + 9 + 9 + 4 + 8) + 9) * 6
(8 * (2 + 3 + 7 * 3 + 2) * 2 * 4 + 7) + 4 + 3 * 2
(6 + (2 * 5 + 3 * 2 * 4 * 7)) * 6 + 4 + 6 + 9 + 9
(8 + 8 * 6 * (4 + 3 + 4 + 8 * 2 * 4) + 7) + 2
8 + 9
8 + 8 * 4 + 4 * ((9 * 2) + 2)
(3 + 3 + 9 * 9 + 5 * 2) + 5 + 7
2 + (7 * 5 * 2)
8 + (5 + 3 + 8 * (3 + 2) * 6) + 9 * 9 * 8 * 9
8 + (2 * 5 + (9 * 7 * 4 * 2) * (7 * 4) * 4 * 6) * 9 + 3
4 * 7 + 4 * 4 * (2 + (2 * 8 + 2 * 5 + 2) * 7)
8 * 5 + 8 + (6 * 9 * 8 * 2 + 5 + (4 * 5 + 4 + 3 + 3)) + 4
9 + 9 * 2 * 9 + (5 + 2 + 6 + 3 * (5 * 2 + 8 * 9 + 6 + 7))
4 * 9 + 2
4 + 4 * (3 + (4 + 9 * 8 * 7 * 3 * 3) * 2 + 9) + (2 * 7) + 8
((5 + 8 + 5 * 2 * 5 * 3) * 5 * 6 + 2) + (5 * 9 * 6 + 2 * (4 + 8 + 9 * 9 * 8 * 3) * 2) + (8 * 6 + 2)
3 + 7 + (9 * (2 * 6 + 3) + 4) * (3 + 4 * 8)
((2 * 2 + 5 * 6 + 7 * 2) * 5 + 9 + 6) * 5
(8 * 6 * (3 + 8) + 9 + 7 * 5) * 3 * 2 * 3 * 5 * 5
((2 + 9 * 4 + 8) * (5 + 5 + 6) * 6 + 9 * 8 + (6 + 9)) * (9 + 8) * 6 * 6 + 9 + 7
(6 * 5 * 6 * 5 * 3) * 6 * 9 * 9
(5 * 4 * (5 * 3 * 3) * (5 + 6 + 2 + 2 * 9 * 3)) + (3 + 6 * 3 * 3 + 3 * (8 * 5 + 3)) * (9 + 3 * 9) + (7 + 4 + 3 * 8 * 8)
(4 + (9 + 2 * 3 + 9 + 6) + 2) + 2 * 7 * 5
9 + 8 + (3 + (7 * 7 + 2 * 8 + 6 * 2) * 8 * 6 * (9 + 7 + 4))
(7 + 3) * 7 * (4 + 4 * (2 + 3 + 4 + 6) + 7) + 6 + 2
(8 * (5 * 9 * 6) * 3 * (7 * 5)) + 5 + 3
(2 * 6 + (7 + 5) * 7 + 3) * 5 + 3 * 2
((9 + 4) * 6 * 2 * 3 + 6) * ((2 + 6 + 4 * 7 + 4 * 7) * (7 + 9 + 2) * 2) + 7 * 2
3 * (9 + 9 + 5 + (9 + 7 * 7 + 8 + 2 + 6) + (9 * 8 + 8 * 8 * 7) * 3) + (7 + 9 * 4 + (6 + 4) + 2) + 9
9 + (2 * 5 + 9) + 9 + 7
3 * 9 + ((2 + 4 * 4) * 3 + 5 * 3 * 5 + (4 + 8 * 3 * 4)) + 6 * 5
3 + (7 * 2 + (4 + 6 * 6)) * 2 + (4 * 5 + 2 + 6 + (7 * 6 + 6 + 7)) * 6 + 9
6 + 5 * (3 + 5 + 2 + (9 + 6 * 3) + 3 + 7) * 3
4 * ((4 + 4 * 8 + 7 + 2 + 4) * (4 + 4 + 8 * 4 + 4 + 3) + 9 * (6 * 4 * 9 * 9) * 2 * (6 + 6 * 9 * 3 + 4)) + 7
9 + 8
7 + (9 + (5 * 6 * 5 * 3 * 3))
7 * 9 + 4 + 6 + ((9 * 2 + 9) * 7 * 9) + 6
((8 + 7 * 8 * 6 * 9 + 2) + 4 + 6 * 9 * (5 * 6 * 9 * 8) * 7) * 5 + 5
2 + 2 * (4 + 3 + 6 + 4 + 5) * (7 * 5 * 5 * 6 + 4 + (6 * 8 * 4 + 7))
(3 + (9 + 2 * 3)) + 2 * 7
(5 + 8 * 5 * (9 * 6 + 4 * 6 + 5)) + 5 * ((3 * 9 + 7) + 9 + (2 * 6 * 4 * 3 + 4 * 4) + 7 + (5 * 4 * 9 + 9 * 7) * 5)
((7 + 2 * 5 * 3) + 4) * 8
6 * (3 + 7 * (2 + 6) + 6 + (9 * 8 * 7) * (5 * 4 + 7 + 8 * 8)) + 6 * 6
(6 + 9 * (2 + 2 * 2 * 3 * 7 + 8) * 3 * 5 * 4) + 2
5 + 2 + (9 + 4 * 7 + 3 + 8) * (4 + 8 * (3 + 2 * 7 * 4)) + 8 + (4 + 5)
(8 * 9 + 9 + 4 * 5) + 2 * 2 * 9 + (3 + 9) + 5
4 * 7 + ((5 + 7) * 3) * 9 * 9
6 + 6 * 4 * ((8 + 9 * 7 * 3 + 9 * 8) + 4) * 3 * 4
4 * (6 * (9 * 9 + 4 * 2 * 3) * 2) + 8 * 5 * 3
7 + 4 * (8 * 2 * 2 * 3 * 8 * 8) * 7 + 2 + 5
8 * ((2 * 3 * 5 * 9 * 2 + 6) * 4 * (7 + 3 * 4 + 7 * 5 + 5) * 3) * 7 + ((9 + 8 + 5) * 8 * (5 * 8 * 9 + 3 + 9) * 5)
5 * (7 + 2 + 9) + 9 * (5 + 8) + 3 * 6
6 * ((9 * 5 + 7) * (8 + 9 + 9 * 7 + 3 + 4))
((7 + 2 * 6 * 5) * 7 + 2) * 8 * 7
9 + ((7 + 8 * 9 * 4 * 4 + 6) + 8) * (9 + (7 + 2 + 6 * 3))
(3 + 6 * (6 * 9 * 4)) + 6 + 5 * 9 + (4 * 6 * 8) * ((7 + 2 * 9 * 4 + 4) + 9 + (6 + 2) + 5)
2 + 4 + 6 + 2 * ((8 * 3 * 2 + 7 * 6 + 3) + 4 + 5 + 5 * 5)
6 + ((6 * 5 * 3 + 9) + (7 + 7 * 8 + 9 * 7 + 6))
(9 + 3 * 3 + (6 * 4 * 2 * 9 + 7 + 4) * 2) * 9 * 2
4 * ((8 + 4) * 2) * (7 + 6 + 3)
9 * 2 + (9 + (7 * 4) * 9 + 8 + (4 + 4) + 7) + (6 * 6 * 3 * 3) * ((9 * 4) * 5 * (6 + 3 + 8) + 5 * 7) + 2
5 + ((9 + 3 + 4 + 2) + (5 + 3) + (4 * 2)) * 7
(8 * 7) + 9 + 6 + 7 * 9 * ((5 + 8 + 5 * 5 + 7 + 2) * 2 + 6)
(9 * 3 * 6) * 4 + 5 * 4 * 3
5 * ((7 + 4 * 5 + 8) + 2) * 9 + 3
2 * 2 + ((2 * 2) * (7 * 5 * 6 + 9)) * 2
4 + ((5 * 5 + 2 + 2) * 3 * 6 + (4 * 3 * 3 + 4 + 7)) * 3 + 3 + (4 + (6 + 9) + 4 + 6 * (2 * 3) * (5 + 8 * 2 * 8)) + 9
2 * 9 + 5
2 + ((6 + 7 + 9) * 9 + 9) + 9 * 5
2 + 7 * (9 * 7 + (6 + 5 + 2)) + 8 + 5
3 * (7 * 4 + 8 * 8 * 6 * 8) + 5 + 2
8 + (5 * 2 * 3 + 5 + 8 * 3) * 3 * (9 * (2 + 8) * (7 + 3 + 5 + 4 * 9) * 6 + 5 + (8 + 9)) + 4 + 3
4 + 7 * ((8 * 5 * 2) + 3) + 2
4 + 6
(5 * (7 * 6 + 3 + 4) + 9 + (8 + 9) + (5 * 6) * 4) * 8
6 + ((7 + 5 + 7 * 3 + 8 + 3) * 5 * 2 * 4 + 5 + 4)
5 + 4 + ((6 + 6 + 5 + 7 * 8) * (2 + 4 * 3 * 8 + 3) + (4 + 3) + 2) + 9
7 * 3 + 6 + 6 * 4 * 6
(4 * 9 + 2 + 4 + 9) * 6 + 6 * (4 * 9 * (6 * 9 * 3 * 6 * 2 * 7) + 5 + 3 * 3) + 3 * 8
(5 + (4 * 8) + (5 * 5)) + (2 + 5 * 8)
9 + 3 * 3 * 8 + (3 + 4 * 2 + (6 * 7 * 2 + 4 + 6 * 9) * 4) * 3
3 * 6 + 2 + (8 * 6 * 6 + 8 + 8) * ((7 + 3 * 4 * 5) * 4 + 9 * (7 + 4 + 5 * 9 + 8 + 3) * (7 * 8 * 5 + 5 + 7 + 6)) + 4
6 + 4 + (5 + 7 * 6)
5 + 3 * 8 + 6 + 3
6 + 2 + 9 + 8 + (7 + (8 + 2 * 8 + 3 + 8) * 8) * (8 * 8 * (7 + 9 * 2 + 7 * 4) * 4 + (7 + 6 + 7 * 4 + 5))
3 + 8 + 4 + (8 + 7) * ((7 + 5) + 8 + 4 + (9 * 7 * 8 * 6) + (7 + 6 + 8 * 3)) + 5
4 + 2 + 6 * (8 + 2 * 2 * 7) * 2 * 8
2 + 6 * 4 + 6 + (8 + 4 + 6 * 8 + (6 + 4 * 9 * 8 * 3 + 6) * (3 * 5 * 2 + 2 + 7 * 2)) * 3
6 + 6 * 4 + ((9 * 8 * 5) * 4 * 9 * (2 + 9 * 4 + 8 * 8) * 7)
3 * 3 + (2 + 9 * 6 + 3) * ((3 + 2 * 2 + 8 * 8 * 3) + 8 * 9) * 4 + 9
(2 * 7 + 2 * 2) * 8 + 6
5 + (3 + 9 + 3 + 9 * 4 + 6) + 3 * 7 * 5 * 5
((9 + 7 * 4 * 5 + 6 * 8) + 5 * 3 * (2 * 7 + 3 + 5 * 4 + 9)) * 5 * 8
7 + 2 + (5 + (8 + 2 * 2 * 9 + 6) * 4 + 2 * 5) * 3 + 5
7 + (8 + 6 * (9 + 6 * 3 * 9 * 8 + 7))
7 + 2 + 7 * (9 + 4 + 3 * 3 + 9)
7 + ((5 + 7 * 4 * 3) + 4 * (9 * 5 + 2 * 5 * 6 + 2)) * 3 * ((3 + 3 + 4 + 8) * (4 * 5 * 7 * 4 + 9) + 8 + 3) * 7
(3 * 9 * 8 + 8 + (5 * 3 + 6 * 3 + 2) + (8 + 9 + 3)) * 5 * 4 * 4 * 3
9 * 6 + (9 * 6 + 3 * (7 * 4 * 2 + 9) + 3)
(3 + 6 * (6 * 5 * 8 * 9) + (7 + 5 * 5 + 5 + 8 * 8)) * 6 + (9 + 8 + 7 * 5 + (8 + 3 * 4 + 8 * 9) * 7) * 8 + 6
(9 * 7 + (4 * 8 + 9 + 6) * 3 * 7 * (9 * 7)) + (5 * 9 * (3 * 4 * 7 + 6) * (8 * 9 + 5 + 2 + 9))
5 * (8 * 3) + 9 * ((8 * 3 * 4) * (6 * 2) * 3 + 6 * 6 * 8) * ((2 * 3 * 6 + 4 * 2 + 5) * 8 * 6 * 2)
3 + (4 * (6 + 5 * 3 + 9 + 3) * 2 * (8 + 7 * 8 * 7 + 5) * (8 + 8)) + (8 * 5 + 8 + 6 * 9 * 4) + 8 * 4 + 3
(3 * 6 * 7 * (3 + 7 * 4) * 8 * 8) * 5 + 6 * 6 + (4 * (9 + 5 * 8 * 9 * 6 * 6) * 3) + ((7 * 8 * 6 + 2 + 5 * 6) * 2 + 3 + 5 * (3 * 8) + 6)
(2 + 4 * 9) + (7 + 2 + 7 * 7 * (3 + 8 * 4 + 2) * (7 + 5)) * 9 * 7
4 + (8 + 2 + 5 + 2 + 9 + 4) + 7 + 6 * 4
3 * 8 + (8 + 5) * (7 + 5 + 6)
5 + (5 + (7 + 5)) * 8 * 6 * ((9 + 3 * 2 * 5 + 2 + 9) * 2 + 5 + 3 * 6) * ((2 + 2 * 9) * 6 * 8 * 7 * (4 * 5) * 6)
7 + 3 * 6 + ((5 + 2 + 6 + 5 + 5 * 4) * 4 * 9)
5 * 4 + 8 * 3
(8 + 6 * 6 + 5) + 9 + (6 + 3) + 7 + 6
================================================
FILE: advent-of-code/2020/inputs/19
================================================
2: 12 16 | 41 26
55: 92 16 | 84 26
107: 48 26 | 29 16
91: 16 86 | 26 120
56: 19 16 | 30 26
33: 69 16 | 127 26
65: 112 16 | 76 26
23: 16 16 | 44 26
102: 16 116 | 26 132
39: 16 26 | 26 26
40: 23 26 | 76 16
108: 16 53 | 26 51
22: 110 26 | 55 16
42: 1 16 | 47 26
14: 112 26 | 46 16
117: 115 26 | 76 16
120: 26 6 | 16 59
72: 26 130 | 16 66
131: 102 26 | 20 16
93: 16 16 | 26 16
58: 97 26 | 104 16
69: 26 88 | 16 46
54: 76 16 | 116 26
1: 26 64 | 16 28
48: 13 26 | 61 16
92: 85 26 | 117 16
49: 124 26 | 98 16
6: 44 44
24: 112 26
17: 112 16 | 116 26
115: 44 16 | 16 26
113: 16 128 | 26 89
106: 26 132 | 16 6
16: "b"
67: 44 16 | 26 26
104: 44 88
41: 26 132 | 16 76
38: 16 59 | 26 46
89: 16 24 | 26 62
80: 18 26 | 35 16
98: 46 26
101: 16 132 | 26 46
85: 16 59
126: 16 67 | 26 59
9: 26 49 | 16 80
10: 26 67 | 16 59
34: 26 93 | 16 23
4: 70 26 | 107 16
100: 123 26 | 63 16
109: 118 16 | 54 26
77: 16 50 | 26 99
88: 26 26 | 16 16
81: 67 26
18: 16 115 | 26 88
123: 57 16 | 103 26
60: 26 18 | 16 43
94: 26 23 | 16 59
0: 8 11
57: 46 16 | 125 26
110: 26 58 | 16 60
20: 44 76
15: 56 26 | 33 16
114: 26 132 | 16 23
7: 16 6 | 26 115
28: 16 3 | 26 25
51: 112 16 | 23 26
43: 88 16 | 116 26
111: 26 6 | 16 93
62: 26 132 | 16 112
76: 16 26 | 26 16
27: 96 26 | 45 16
50: 26 93 | 16 76
132: 16 26
35: 16 115 | 26 132
53: 16 46 | 26 116
75: 104 26 | 81 16
82: 26 9 | 16 100
78: 26 116 | 16 125
19: 16 39 | 26 132
37: 26 41 | 16 127
45: 91 16 | 108 26
59: 26 26 | 26 16
116: 26 16
84: 7 16 | 94 26
86: 16 6 | 26 88
63: 94 26 | 17 16
103: 115 26 | 59 16
130: 16 34 | 26 20
99: 39 26 | 6 16
26: "a"
64: 16 15 | 26 21
97: 67 16 | 23 26
83: 105 26 | 27 16
21: 75 16 | 52 26
30: 26 125 | 16 112
3: 16 121 | 26 74
105: 26 73 | 16 113
125: 16 16
13: 16 88 | 26 39
32: 72 26 | 122 16
122: 16 77 | 26 2
90: 4 26 | 32 16
12: 26 6 | 16 39
29: 68 26 | 101 16
79: 106 26 | 111 16
61: 132 16 | 46 26
31: 83 26 | 90 16
96: 16 87 | 26 5
118: 26 93 | 16 116
44: 26 | 16
25: 37 16 | 71 26
52: 10 26 | 7 16
124: 125 16 | 6 26
66: 26 36 | 16 14
127: 16 116 | 26 39
68: 26 46 | 16 6
70: 79 26 | 109 16
128: 126 16 | 40 26
8: 42
71: 26 114 | 16 78
73: 129 16 | 131 26
5: 16 65 | 26 118
11: 42 31
119: 16 112 | 26 6
95: 16 88 | 26 59
87: 119 16 | 14 26
121: 35 26 | 95 16
47: 22 26 | 82 16
46: 16 16 | 16 26
129: 12 16 | 17 26
112: 26 26
36: 67 26 | 125 16
74: 16 10 | 26 38
aaaaaababbaaababaaaabbbb
aabbabbabbbbbaaaababbbbbaaabbaabababbaaabababbab
baabaabaaabbaaaaaaabaabb
aabaaababababbbaabababaaaaaaabba
babbaabaaaabbabbabbaabba
aabbabbbaaaaaaabaabaabaa
aaabaabbaaabaabbaaaaababaabaabbabbabaaababaabaabbaabaabbaabaaaabbabababa
abbabaabbbaabbbbaabaababaabbaabbbabbbabbaabbabbaabaabbbbbaaabaababbabbba
abaaabaababaaabbbaaabbbb
baabbabbaaababbbabaabaab
abababbabbabbbaabaaaaaab
bbabbaababbbbbbbbaababba
abaaaaaaabbaaaaabbaabbba
abbbbaabbabbbaabbabbbbbbaaababbaabaaaababaaabbbabaaaaabbbababaabbbaababb
aabaaabbaaabbbaababbbaaaaabbaaababbbababbbabaabbabbaabbbbbabbbbbaaaababbabbabaaa
aaabbbababbbabababbaabba
babbbbabbbaabaabbbbaabba
ababbbbbbbbaaabababbaaaabbaabaaabbbabbab
bbabaaaaabababaababaabaaabababbb
bbabbabbabbaaaabbbaababbbaaaabaabbaaaaaa
baaaabaabbabbabbabbbbbbaabbbbbbbbbaababbbbabbaabaabababb
babbaaaabaababaabaababab
bbbababaababaabbbabaabbb
baaababbbbbbbababbabbabaaaaabbaa
baababaababbabbbabbababaabbaaabababbaaab
bbbaaabbbabbbaaaaaabaabaabbbbaabbaaabbba
aabbabaaaaaabaabababaabbbbbaabbaaababbbb
aaababbbaabaabbababaababbbaaabbabaaaabab
bbbbbbbbabbbaaaabbbbaaaa
abbbbaaaaabaababbbbaabba
abbbbaaaaabbbabbbbbaabbbaaabbabbabbababaababbaaa
bababbabaaabbaaaaabaabaababababa
aabaabbabbabaabaaaabbaaabbbbbbbabbbbbabbabbbbabb
abbaaabaaaaaaaaabaaabbbaabbbaaabbaaaaabaaaabbbbaaaabbaab
aabaaababbaaabbbaabbbaaabaabbbbabbbaaabaabbaababababaaba
aaaaaabaabbaaaababbaabba
aaaaaaaabaaabbaabaabaaabbbababaaabbabbab
bbabbabaaabbababaabababb
aabbbbabbaaabbbabaababaaaaabbbba
baaaaaaabbbababbabbaaabaaabababbaababaaaababaaabaababaaa
bbbaabbbabaaaabaaaabbbaa
baaaabaabbababaabaabaaaa
bbbbbaabbaaaaaaabbaaabaa
aabbbbabbbbaaabbabbbbaab
babaababbabbabbabbababbbaaabbbbb
babbbbabbbaabaaabbbaabaa
abbbbaaaabbaaaaabbabbbaaabbbaababaababbbaaaababbaaabbbbbaabaaaaa
baabbbbabbbbbaabbbaabbba
aabbabbbaaabaaaabbaabbbb
babaabaabaaaabbaabababbb
aabbabbbbabbaababbaaaaaa
bbaababbababbbbbbbbbaaab
bbbbbbabaaabbabbabaababbbbbbbbaa
baabbaaabbabaabbbbbababb
abbbbbbaaabaaabbaababbbb
bababbbabbabaabbbabbaabaaabbbabaababbababbababab
aababbababbbbbaabaababab
babbbaaaaaaaaaabbbabaaba
abbbaaabbaaaabaaababaabbaabaaaaaabbaabbaabaabababbabaaaa
aababaabaabbaaaabababaab
babababbaaaaaabaabababababbbabbbbbababaabaababba
bbbbbabbbbaababaabaabbbbbababababaabbaba
baabbbbabbabaabbbaababbb
abbbbbabbababbbbbbaaabbabababbabaabbaabbabaaabbaaaaabababaabbaababbbabbaaaabaaaa
aababababaaaabbbaaaabbbaaaaabbbb
ababbaabbbaaaabaaaabaaab
abbbbbbaaababaabbabbabbababbbaaabbaababa
bbaabaabbbbaabbbbbaaabbbabbababbbbbbaabb
abbababbabababbbaabaaaaa
abbbaaaaaaaaabaabababbab
bbaababbabababbaababaabbabbbbbabbbabbbbb
babbabbabaabbaabaababbbb
bbbbbaaaaabbabbabbaaaaab
aaababababbbabaababbabab
baababbbaaabbaababaaaabbabbaabbb
aababaabaabaaaabbbbabaabbbbbbbabaabbbbaa
aaaaaaaabbbbaabbbbbababaabbaabbbaaababba
bbbababbbbaabbabbbababbaabababababbaaabaababaaab
baababaaaabbbabbabbbabbababbababbabbaaab
baabbbbaaabbbababbaaaabb
bbababbbabbbbaaaabbabbab
babbabbbabbbabaabaabbbbb
aabaabbabbababaabbbbaaaa
aabbbabbbbababaabaaaaaab
aaabaaaabbbabaabaabbabaabbbabbbb
aababaabbbbbabaaaaaaabba
babaabbabbababbbbaabbbaabbbbbaababbbbabbbbabbbab
abaaabbbbbababbbbabbbbba
abbbbaaaaabbbabaaababbaa
ababbbaaabbbabbbbabbaabb
aaaaaaabaaaaabaababbbbabbabbbbababaabbaa
aaaabbabbaaababbbbbabababbabaabaaabbbabbbbbbbabbaaabbbbbbabbabab
bbbaaabbbbbbaabbaaabbbba
bbbaaababbabbabbbaabaabb
abbbbbbbaababbbbbbbbabbaabaabbaababbbaba
aaaaaabbbbbbbababbaababbbaabbbba
baaaabaaabbababaabaabaaaababbbbbbababaaabbbbbabb
bbabbbaabbbaabbbbabaaabbbabaaabaabbbbbbbaaaaabba
aaaaaabaabababbabbbbabba
ababbaababababbaaaaabbba
aabaababbabbbbabbbbaabbbabaaaaaaaabaaababaabbbbb
baabbabbbbaaabbabababbaaaaaababb
aaabbaabababbabaababaaab
abbaaaabaaaaaabbaaabbbaa
ababbababbabbabababbaaaababbabbabbbabaabbababaabbbabbbbaabbbbabbabbabbbb
baaaaaaabbababbababaabbabaaaabbaaabababaabaaaaabaabbbbaa
aabbaaaabbaaababbbaaabbaabbbababababaaaa
aaaaabbbaaabababbaabbaabbaaaaaba
bbababaabaaabaabbbbbabbb
aababaabaaaaabbbabaaabaaabababbb
bbbabababbaaaabbabaaabbabbabaaba
bababbaaabaaaaaababbaabb
aaaaaabbaaabaaaabaababab
baaabaabbabaababaabbbbabaabaabbbbbbabbbabbaabbaa
aaaaabaaaaabbabbbbbbbabb
babbabaaaaabaaaaabbbbabb
bbbbbaababbbbbbabbbaaabbabbbabbbbabbaabbbababbbb
aaabababbbabbabbaaaabaababbaabbbaabababb
bbaaababaaaaabaabaabbbbabbabbabbbabbbbbabaaabbba
aabaaabbababbbbbbbbbaaaa
aababbabbbaabaaabbabbaabaabbababbabbbbbb
bababaaabbbbbaabbbbabaabbaabaaba
aaaabaaaaaaaaababbaaaaabbbbababbbabbbaab
aabaaaabbaaabaabaababbaa
aabaababbbbabaabbaaabbba
bbbbababbbabaaabbabbaabbababaaabbbbbabba
aabbaaaaabbaaaababbbaabb
aaabaaaaaaaaaaaabaaababaabbbabbbaababaabbaabaabbbbaabbabbbbabbaa
abaaaaaaabbbabbbababbbaabaabaabb
abbaaaaaaabbaaaababbbaab
bbabaabbaaaaaabbabaabbba
bbabaabbabbbabaababbbbba
baabbbbaaaabaabaaabaabaa
bbabbbbbbbaabbbaaabbaabbbbaabbabbabbbabbbbabbbab
aaabababbbabbaababababababbbbabaabababaaaaaaabba
aabbbaaaaababbabbbaaabbabbaaaabaabbbbaaaabbaabba
ababaabbaabbbabaabaaaabbbbabbbbbbaaabbbb
baababbbabbbabbbaababaaa
bbbbbaaaabababababbabaab
bbbbbaabbbabbaabbaaaaaba
abaaabbbbabaababbabaaababbaababa
aabbbbabbabaaabbbbababaaabaaaabbbabaabaa
babbabbbababbbbbbaabbbbaabbabbab
abababababbaaaaaaaabbbba
aabbbabbbbabaaabbabbbbabaabaaaabbbbabaaaaaabbbba
aabbbabbbbaababbbbbbbaab
bbaaaababbbababaaaabbbbaabbbaaabbababbbb
abbabbaabaaaabababaabababaaabbaaababbbbaababbabbaaabbabaababbaab
aaabababaaaabaabaaaaaaabbbababbababbabbababbaaab
babaabbabaabbabbbbbaabaa
babbabbbbbaabaaabbbbbabaabbbabbabbaaaabbabbbabaabbbaaaaa
bbbababaaabaaabbabababaabaaababbbabaaaaaabbaabba
baabbabbababbbaaaaaabbaa
aabaabababbbbbaabaababba
ababbbaaababbbaaaaabbbaa
abbabbbabbaababbaababbbb
aababaababaabaaabbabaaababaabababbabbbab
aaaabaaaaabbbbabaabbbabbbbaababbbbbbaaab
bbbbababbbbbababaaaabbaa
abbbaaaabbbaaabaabbbaaab
bbabaaabbbbbabaababbaaaabbbaaabbbaaaaabaabbbabbbbbabbbbbbaaaaabbaaabbbabbbbaabababaaabaa
aaabbaabaabbababaaaaabba
bbabaaaaabbbaabaaabbabaaaabbabbbaaabaabbbbaabbab
bbaabaaaaabbbaaababaabaaabbabaab
bbbbababababaabbbaaababa
baabaaaaabbababaaababaabaabbbabaabbabababbababbaabaaaabaabbbbaaaabaabbbbbaabbbbb
bbababaaababababbababaaabbbabbbaaaaababa
bbaabaaaabbbbbbbaaaabbbb
aabaabbaababbbbbbaaababb
abbbaaaaaabbabbababaaabaabbabaabababaaaabababbbb
abbbbbaaaaaabbabbbabaaabbaaaaaaabbbabbab
bbabbabbbbabbabbaabbaabb
aabbabbababbaababbbabbba
abababbabaababaababbbbaababbabab
bbababbabbaabbbbbbbaaaaabababaabaaaaabba
abaaaabbbaabbaabbaabaabb
ababbaababbabbbaabaababa
abaaaabaaabbbabbbaabbaaaababaaaabbbabbbabbaaaaaa
aabbababbbabbbaaabaabbba
abbabbbaaaaaabbbaabbabaabbaaabbbababbabbabaaabba
aabbbabaaaabbbabbabbbbbabbabaabbabaababa
babaabbaabaabaaababbabbaababababaabababa
abbaaaaaaaabbbabbbaaabbbbaaaaaba
bbaaabbbbbaaabbabababbab
aabbababbbbaabbbaababbba
abaaabbaaabaabbbbaaaabab
babbaabaaabbbbabbaaabbaabbaaaabb
bbabbabbababbbaabbaababa
babbbababbabbbbabbbaabbbbbaaaabaabbbababaabbabbabbabbaaababbbbaaaabaaaabbbaabaabaaabbabb
bbabbabbbbbbbbabbabbbbbb
bbbaaabbabaaabaaabbababbbabababbbbabaaabaaaababb
babaaababbaababbababbababbbabaabbbbbbabbabbaaababbabaabaaababbaa
aabbbbabbaaaabbaaabaabbabaabbabbabbbaaabaaaababa
abbaaaaaabbababbbbbbbabb
baabbbaaabbaababbbbabbaa
ababbabababbbaabbbaabbbb
abababbabaabbbabbaababaaababaabbbbbabbaabbaabbababbabbababbbbabbaabbbaaaaabbaababaabbaba
aabaababababbbaabbaabbab
babaabbabbbbaabbaababbaa
baabbaabbbbbbababaabbaaaabababaabaabbbabbbbbabaa
abbabababbaabaabbbaababa
baababbbaabaaabaabaaabbbaabababa
bbabaabbbbbbbaabbabaabbb
babaabbaabaabbbaaabaabbbbabbabaababbabbb
babaababbbaababbbbaabaaaabbbbabaabbabbbbaaaabbba
ababaabaababbbbaaaaabbba
aabbbabbaabbbbabaabbabbbabbbaababaaaaaaaabbabbbb
aaabaaaaaabaabbaaabaaaaa
abbababbabbbaababbbaabba
abababbababbbbabbaaaaaab
aaaabaabaaabbbabbbaabbab
abbbbbbbbaababbbbabbabab
ababaabbbbbbbbababbbbaab
aaaaaaabaabbabababaaaaaaaaabababbabbbbaa
bbaabaaaaabbbabbbaaabbba
baabbaaababbabaabbbbaaba
bbbaabbbabbabbbabaaaaaab
aaaaababbbbabbaababbabababaabbab
aaabbbababbbabbaabaabbbb
abababaaabababababbaabba
ababbbaaabbaabaaabbabbbb
bbabaabbbaabbbbabaaabaaa
ababbaabaaaabaabbbbbbbab
baabaaabbbaabaaaaabaaaabbaabbbabbbbabbbbaabababb
abbaabbbabaababaabaabaaaabbbaaaababbaabbbabaabaa
aababbabbababaaaababbbba
bbabbabaabaaaaaaabaaaaaabbaababbaaaabbaababbbbaabbabbbbaaabbabaa
aaaaaaabbbaababbababbbaabbabbabaaababbaabbabbbbbaabababa
aaabaaaabaaabaababaabbab
baaaaaaabaabaaababaaaabaaabbaabb
bbaabaabaabaaaabbbbbaaab
abaabbbaaaabaaaaabbbababaaabaaaaaaaabaaaababbbabbbababbaaabbabbb
abaaabbbabbbbbabbabaaaaa
ababbababbbabaababbbbabb
babaababaaaaaaaaaaabbbabaaaababa
aabaaabbaaaaabbbaaabbaba
baaabbaaaabaaababaababaaaabaaabaaaabaaaaabbbaaba
aaaaabbbbabbaabaaaabbaabbbbbbabb
aabbbbababbbaaaabbaaaaab
bbbabaabaabaaaabbabaaaaa
abbbbaaaabbbaabaabaabbbb
abbaaaaababbaaaaabbbabbabaaaaaba
abbbaabaabbbaababbababab
bbbaaabbbaabaababaaabbab
aabaabababbbaaaabbbbaaba
baababbbbaababbbbabbbbabbbbababbabbbbaab
bbbbababaababaabbbbbbaaabbaaaabaabbbbaaabbbabbba
baaabbaabaabbbabaaaaabaaaabbaabb
aabaaababbbabababbbabbbb
aabbaababaabbbbabaaaaaba
aaaabbababbaababbabbbabb
ababababaaaabbababaaabab
aaabaabababbbbababbabbbbaabbaaabaabaaabbbbbababbabbabbabaaabbbba
aabaaabbaabaaabbbbbaaabbbbbabaaa
bbbaabbbbabaaababbbbbbabababbbbbaaabbabbabbabbaa
abbaaaabbaabaababbbaaaab
baaaabaaabaaaabbbbabbbab
bbabbababbbbbbbbbabaabbb
babaaabaaabbabbabbababab
bbabbabaabbbababbbbabbba
abaaaabababbbaaabbabbabaaabaaabb
aaaabbabaaaaaaabbabbbaba
abaaaaaabaabbaaababbbbabaabbabbabbbaaaaaaaabbbba
ababbabaabbbbbaaaabaabaa
abbbaababaaababbaabaaaaa
bbbabaabbbaabbbbbaaabaaa
bbabbabbbaaabbaabaaabbba
babbabaabbabbaababaabbba
abbababaababababaabbbbaa
baabbbabaaaaabbbbabbbbbb
aabbabaaaabbabbaabbbaaab
abbbbbaaaabaaaabbbbabbbb
bbbaabbbbbbbabaaababaaaa
ababbaabbbaababbbbaaababbaaabaabbbaababbbbbbbbaa
bbbabbababbbbbaaaabbbabbbbbaabbabbaaaaabbaabbaaaabbbbabaaababaaa
aababaaababbbaababaabbbaaababbbabbbbbbaa
babbabbbaaaabbabaaabaaab
aabbbaaaaaabaabaababaaab
babaaabaaabbbaaaabaabbba
aabaaaababbbabbaabaababa
bbbbbbaaabbabbaaabaabaabaaabbabaaaababbbabbbabbb
aababaababbaaaabbabbaabb
abbbaaaabaaabbaabbabababbaabaabb
aaaaaabbabbaaaaababababa
bbbbabaabbbaaabaaababbbb
babaabababbbabbabbbabaaa
bbbaaabbbaabbbbaaaabbbaa
abbabbbababbbaaabaabbabbababbabbababbbbaaaabbabababbbbabaabbaaba
abababbabbbaaababaabbaba
aabbababaaabbbbbbbaaaabbbbbbbbababbbabaabbabbbbb
abaabaaabbababbbbaaaabababaabbaaaaaabbbbbbbbaaaabbbbbbaabbaababa
aabbabbaababbbbbbbbbaaaa
aaaaaabbaabbababbbaaaaaa
bbbaaababbbbbbabaaabbaabbbbaabba
bbabbabbabbbabbabbabbbab
bbaabaaabbaabbbbabbbaabb
babbbaaaaababaabbbbbbabb
abaaabaaabaaaabaaabbbbbb
bbababaaabbbabbaabbbabbbbabbbbbaababaaba
abababaabbabaabbbbaaabbabaabbbababbaabbb
babbaabaabbbabbaabaabbbb
baabbbbabbababbabaababba
bbaaabbbaabbaaaabaaababbbabbabaabaabbbbb
aaaabbabbbbbbbbbaaaabbabbaaaabbb
bbbbabaaabbaababbbaabbab
baaaabbaabaaaaaababbabaabaaababa
aabaabbabbaaaababababbaababbabab
abaaaaaabaaababbabbaaabb
abbbabbabbbbabaabbbbaaba
babababbbbabbbaaaabbbabbaaaaaabbbabbabbbaabaaaabababaaaa
aaaabaababbbbbbaabaabbaa
ababbbaaababababababbaaa
ababbbaabababaaabbbbbabb
abbababbaabaaabbbbbaabab
babaababbababbbabbbbabbb
abbbbabbabbbaabbabaaaaabbaaabbbbbabbaaababaababa
baabbbbaaaabbabbbbbababb
aaaaabaaabbabbbababbbbaabaaabbaabbbabbba
baabaaabaabbbaaaabaaabba
aabaabbabbbbbababaababbb
aabbbabaabaaaaaaabaabbaa
abaabababaabaababbbbbbaabbabaabbaabaabbb
aabaaabbbbabbabaabaaaababbaababaaabbbaab
abaaaaaabababbbaabbbaabb
bbabaabbaaabaaaababbbabaabbaabba
bbbbabababbbabababaababb
babbaaabababbabaabbabababaaababbbbabbbbbbbabbabbbaaaabaaabbbbbba
abbbbbbbbbbbabababbabbaaabbaaaababbbbabaaabbaaaaaababbbbbbaababbbbaabaabababaabbababaabbbbbbbbba
bbbaaababaaaabbabaaababbababbaabbbbbbbba
babbabbaaaabbbabababbabb
ababaabbabbabbbabbabbbba
aaabbaabababbbaaababaaab
ababbbabaababbaaababbaaa
baaaabaaaabbaaaaabaababa
baaababbababababbbabbaaa
ababbabababaabababaabaabaaaabbbbbbaaaaababaabbaabbaaaabb
abbbbbaaaaaaabbbabbabaab
aaaaaaabbbaaababbbbaaababaababaaababbaaa
aaabbbabbabaabaaaabbbaab
abbbabbabbababaaaaabbbbb
abbbbabaaaaabbbaabbabaab
bbabaabbaabbbaaabaabbbbb
ababbaababbabbbabbabbaabbbaaaaabbbbbbbba
aabaaabababbbbaabaabaabb
aabbbaaabaabaaabbbbabbaa
babbbaaababbaabaabbbabbbababbaabababaaba
aababaabbabbabbababbbbabaabbbbabbbbbaaaaaabaabaa
aabaaaabbbaabbbabaabaaababaaabababbbabbbabbaaababbaabaababbabbbbabbabaaa
abbbabbbbabbbbaaaabbbabbaabaaabaabaababbbbbabaaa
babababbaababbababbabaaa
aaaaabbbabbbabbabbbaabba
bbaabaaaabaabbabababaaab
babbabaaaaaaaababaaababbbaabbbaaabaabaab
abbbbbbbabbaabaabbbbbbaa
aabaaaaabaaaaaabaaaaabbaaabababa
abababbabbabbabbaabaabbb
aabbbaaaabababbaabbaaaabbbababab
baababaababbabaaaabaaabaaabbbababbbbabbabbabbaaababbbbba
bbababaabaaaabbaababbababbabaaaaabbabbab
abbbbbbbabbbbbaaaaaabbba
bababbbabbbaaabaaabbbabbabaaabaaaabbabbbababbbbbababbbab
abababaaaaaaaababbbaabaa
babbabbbaabbabbbaababaaa
abbaabaababaaaabbbbbabbaaaabbabbbbbababaabbbbbabbaaaaabbbbaaaabaaabbaaab
aaababababbaaaabbaaaabbb
aaaaaabaaaaabaabaaaabbaa
bbaaabbbabbbbbbaaabbaaaaababbabbbaaabbba
bbbaabbbbbabbbaaabbbbbab
aabbaabaabbbababbaaabbbb
bbabbbabbbaabbaaabbbbbbababaaabaabbababbaabbaabbbaabaaaabaababbb
aaaabaaaabbbabaababbbbaabaaaaaba
abbbabbaabaaabbbabbababaaaaabbabbaabbaaaababbbab
baaabaabaabbaaaabbababbbabbaaaababbbbbab
bbbbbbababaaabaabbaaaaaa
baaabbaaaabaaabaaaabaaab
bbbaaabaaabbabbaabbabaab
babaabababbbbbbaaaaabbba
aaabbbabaaaaaaaabababbab
bbbbababaabbabbababbbbbb
aaaaabaaaaaaaababaaaaabb
aaaaaaaababbbbababbbabbaabababbb
abbbbbbaaababaababbbbaab
aaaaaabababaababaaaaabba
aabbaaaabababbabaabaababbbaabbbbabbbaaaaaabbabaaabaabbbb
ababbbbaabbabbbabbbbbaaababababbaababaaabaaaaaab
bbabbabbbabaaabaaabbbbaa
baaaabbaaabbbabaabaabaaabbabbababbbbbbbbaaabaaaababbbbbabaaabbabbabbbbbaaaababaa
abbababaaaabababbbabbaaa
babaabbabbbaabbbaaaabbaa
abbbbbaaaabaabbaaabbabbaabbabaaaabbabaaa
abababbababaaabaabbababaaaaabbababaaaaaaabababbaabaabbbabbaaaabb
bbbaabbbababaabbabaaaaab
aabaabaaabbabaabbbaaabaa
abababaabaabbaababbabbbb
babaabbaaaaaaaabaaaaabba
bbaabbbaababaaaaaaaababa
bbabaaaaabaaaaaaaaabaaaabbbabababaabbbababaaabba
abaaabaaabaaaabbbaaaabab
aabbabaaaaaaabbbababbbba
abababaabbbbaabbaabbaaabbbbbaaaabababababababaaaabbbbaaaaaaaabbbbabbbaaa
abbbabbabababbaaabaabbaa
aaabaaaaaabbaaaabbaabbba
aabaabbababbabbaaabbabbbababbaab
bbbbbaabaaabaaabaabbaabbbbaababa
================================================
FILE: advent-of-code/2020/inputs/2
================================================
1-4 m: mrfmmbjxr
5-16 b: bbbbhbbbbpbxbbbcb
7-8 x: qxrxmxccxxx
9-11 k: kkkkkkktmkhk
8-12 g: sgwvdxzhkvndv
6-9 v: zvmvvmvvvd
8-19 f: ffffsplmfflffhtfrfj
5-16 p: pppppppppspppjpcp
2-3 w: wwmw
7-19 j: jjjjjjjjjjjjjjjjjjvj
5-9 q: wqzqqqqqq
14-15 g: gggggggggglggfgg
4-6 p: tppzkppdt
11-14 p: vppgpktpppppptpppqp
5-9 f: bfflffrfgf
7-9 p: ppppptbzn
1-3 l: lllvn
2-4 g: qvcdg
1-3 m: wsmdv
1-5 v: vvvvvvvv
10-14 l: lckqlgjllltlwbl
3-4 t: bsttftltjhbqbgtm
15-17 j: jjzjjjjjhjjjjjjpzjj
2-3 t: thtt
6-17 f: ffwkwzjtjktvsfmfhvsf
3-5 b: rqxbb
4-7 m: nbcmcwmmxrxqvtjfmm
1-2 v: gzvvvv
1-3 w: hkwhv
7-8 p: pppppppp
3-4 h: hhnwh
2-4 t: ttrtjtththkr
3-4 w: wwww
4-6 s: xsntgrftmpx
4-7 s: ssskssmsbs
10-15 m: bmmrbmmmmlmmmmmm
12-13 w: wqpwdmwllnjwx
5-14 n: nnnnlnnnnnnnnmnn
5-6 k: kktkfczk
5-7 r: nrdrtrvr
4-6 c: ccqchcc
2-9 l: fnldtfnbxjlvnlsnjhml
1-13 d: dlchvkccnwrcc
5-7 j: jjjjjjj
3-5 z: zzzzz
6-12 f: ffffflvmfhfx
8-10 w: wwwwwwwwww
3-4 r: rrbtr
3-11 b: bbbrbbvphbxbqk
16-17 n: nqhknnnnsnnnnnnnnnb
18-20 k: kkkkkkkkkkkkkkkkkhtj
3-15 r: ktvzqbmbrvczprfcw
9-11 q: qnqqdqqqgrrqsqq
3-5 p: pvppp
7-11 m: mfcdmmxmmmp
7-8 t: ttttktnt
5-6 b: bbpbbbv
14-16 z: zzzzzzzzzrzzblzw
11-12 j: jkjjjkjjjjjjgj
7-9 q: qqqqqqqqqq
10-11 f: cfffffffffff
4-6 c: nccccc
7-8 r: gmdlqfpwmrr
6-8 v: nvvpdnjx
8-12 x: xxlxxbbxxxxx
8-10 s: ssxssssssss
5-12 z: zhzdfzgdzzhzlz
11-12 k: qbkhvqjpqzfq
2-11 w: wwmlttwjflwdjcpclww
2-16 w: twkkmcrxmvjtwxlwsksf
6-8 s: sssfxbskvs
5-6 s: ssnsxsbs
10-19 l: ndzmdxqlnllxsbbwvsl
2-4 g: gggg
5-10 x: zxxxsxxxxxxxsxx
7-15 f: ffbrbdtzvdffktxfm
7-8 m: xmkmmmmmtmm
9-13 s: hksrdhzlsdmps
15-17 b: bbbbbbbrbbbbbbbrbb
3-5 x: xxxxxxx
2-6 t: wtltztnct
3-15 v: vvwvvvvvhvvvbwwvmdvr
12-14 p: ppphsppppppbphp
8-9 t: ttttvttttttt
2-3 c: cchvj
8-9 z: vzzzzzzgl
11-12 q: qqmqqqqqqqsnqqqqqqq
12-13 d: dddddddddddmd
8-9 t: wttttttqt
7-8 p: ppppvvcw
4-5 g: gncgj
12-13 s: sssssssssssmw
7-9 f: pswpnjftf
11-16 p: ppppnpkpkzppcpzbppp
1-12 q: ksqrqpqnqmqxqb
2-10 l: lllllllllll
17-18 z: zzzzzzzzzzzxzzzzzz
11-12 g: qggbjgggggssgggrk
3-4 s: bpss
6-8 v: vwvvvrvvv
3-4 t: tglktt
4-12 l: kvrnzqslwrdkfll
12-16 b: fbbbbbnbbvbbbbbcbbb
5-6 t: ttttzz
5-8 w: sqwhwwxw
8-9 z: zzzvztzrzzzz
3-6 l: llvdlt
7-8 r: mrcvnrrr
10-11 k: kkkkkkkkkmc
1-3 n: nnnmn
4-16 c: dqlcbclcrxkkszvcv
9-10 g: fxssmlmgbh
5-6 p: nwpfpp
3-7 w: cwhgrfshdwhwwll
14-16 l: llllllllllllllpll
3-4 f: ffff
4-9 d: dcdddxzvmrd
4-11 w: jwwnwwwwwvx
3-4 t: ttvc
4-17 r: rrsrrrrrrrrrbtrrrr
8-9 x: wqxxxcfdx
6-8 d: qgddwddtdddlc
12-13 v: vvjvvvvvzvvtvv
3-4 g: sghxg
3-4 b: ckbbmprfbbmzgqtkbw
5-6 x: xxxxxv
10-13 f: zpfffbfchxfffffjff
5-6 f: ffffwf
12-19 l: mlllllplllldllnsllql
4-5 v: vvvvp
5-8 w: vjwvghggwww
1-3 n: lnnn
16-18 p: ppppppvpppppwppppppp
15-18 z: zzzzzzzzzzzzzzjzzg
4-6 b: bbmbbb
5-7 z: wzlwzmzzzzzzzzzzzwz
8-12 p: gppmpppvppkzpcnpb
16-19 h: hhbhhhhhhhhhhhlnhhw
2-3 n: nnnn
3-10 m: mmntfkdjftmtmmbm
3-5 j: jjjjw
4-6 z: zjnzzzdzz
1-7 s: zsvsssf
6-7 v: vtvvvcg
3-12 f: qsrtmnxkvlcmt
5-11 q: mqgqqqqqrpch
5-9 g: msxkggnggg
3-8 v: vvvvhvjvdvxtr
4-6 k: jcklxdhkwhsqhq
6-7 x: vppxbhcjzxdqx
2-3 n: ntrg
7-8 g: gggwgjdhg
1-3 d: dddd
14-18 l: llllllllwlllxllllllz
8-19 g: ggggghggkhgrtzcgrrk
7-14 q: phzxvmbxxfsfwr
8-14 r: hbjmdrhnpxnwgz
15-17 d: dddddpddddldddtdgddd
6-7 k: kkkkkgkkq
2-12 w: wwzwwwwwwwwww
5-8 q: qqqqqqqzqqwqqzqcq
5-6 z: czzzrz
14-15 b: bbbrzhbbbbnxbgbb
12-13 d: dgddddddddtvddddvbz
3-5 v: vvvvv
13-16 q: qqqqqvzwqqqqqqqq
2-3 n: jpznnwfpchs
7-10 w: jwwpwkwwwpw
6-7 b: bbcnbcjxbbb
14-17 w: wqtwwwwwnwcwwbsww
3-14 w: gwwwwwwwhwwnxwwwww
4-9 w: mwllcfjfwwwjp
9-12 n: nnnnnnnhnwjnn
2-4 j: jjjjj
3-6 t: mrmttccttqt
16-17 p: ppmjpgptzgbppphfbp
12-17 v: vvvvvvvvvvvvvfvvvv
13-15 x: xxxxxxxxxxxxxxgx
2-4 d: dddddddd
2-5 t: ttmvt
13-14 j: jjjjjjjjjjjjtj
3-5 r: ggmrdf
7-8 f: ffdfflszfsfffqff
10-11 t: ttpttttttrgtt
8-12 j: jjjjqdhzjhjdj
19-20 z: zbzzzzzzzzzzzzzzzzrq
7-11 b: bbbbbhbbbxbbb
4-9 p: gzmkkbtpkzpgthklpq
2-5 b: bbbbxgb
4-13 k: kkkkkkzktckkkwkjkk
10-12 q: vrxznfqqnqgq
15-16 m: mmmmkmmmmmmmmmmmm
15-18 h: hlhhvhchthhhhtphhh
2-3 m: mftzmc
6-11 s: ksssssssssszs
5-6 q: qqqpqkq
7-8 n: nnfnnnnpn
6-8 c: chfcllrvxcnnjhtc
6-8 k: kkkkkxlk
2-4 s: tsspb
9-12 q: qqqqqqqqqqqqqq
17-20 h: hhhhhhhhhhhhhhhhhhhh
6-13 r: rrrrrgrrrrrrn
4-8 f: fffrfffz
13-14 n: nbnnnngnnnnnnpz
8-11 f: fvffsfqftcffff
3-5 w: vwhxz
8-10 x: nmxxknlptx
3-4 p: pppt
17-18 v: vvvvvvhkvvvvvnvvjlvv
10-15 z: twnsdkmgpvzfmzg
3-5 n: njnjnkghp
10-12 q: qvqqqqqqqqqq
6-7 r: rrrrrrrr
3-4 t: qltt
2-16 f: gffflcvtpfkfcjfrjvfs
3-5 s: swssp
11-13 l: lrpllllllvtslwllllld
1-3 n: nnnn
3-5 g: jjggnvg
4-5 b: bvbbb
13-15 l: llvllllllllllnll
5-6 j: hjjjjfsj
3-4 b: bkfbnb
5-8 z: zdzzzzzzzrzzz
3-4 r: rrrx
2-12 c: mczhvchkmjdrjh
12-16 x: sjxbcgdqtpfxflsxx
2-4 c: tcxf
4-5 w: kwjww
1-2 r: rrrwzc
4-7 d: ddddddkdd
5-6 q: qqqqqp
13-16 l: flljlllvnzlllllclldl
3-6 j: jjjpjj
3-4 g: gxgg
10-11 n: nnnnnnnnnnn
2-5 j: ztchj
4-6 j: pjzzrmjvhcxn
4-11 c: jchcccgccckc
11-12 d: dddddddddddd
6-7 n: nznnnnnntnnnnzpjfjnn
8-9 k: kbkkkkkkk
13-18 x: xbxxmxqxxxmxkxsxxxx
7-16 r: rrrrrrzrrrrrrrjmrrr
3-5 h: hhqhd
1-2 b: bbmb
2-3 n: rlnntn
2-8 q: qnfqnqhx
2-5 b: bjbbh
5-11 t: twtjnpttqtvtttptt
16-17 w: wtmwwhxtgwrrswwfblll
8-16 g: ggggghshggdggggcpwg
1-3 l: lsllzl
11-13 n: nnnvncnnmvnqnnnnn
6-7 s: ssqssss
10-18 t: tttnmjxttjttttttdzt
4-10 n: nkvncgtdpz
16-18 p: cphtrgffcpphfspxppgp
2-6 k: kkhgkskkm
6-20 r: fhrwtrzwrddfrndnrlgr
2-8 w: lkwnccgw
6-10 x: lxxxxxxgxwxxxrxqxx
4-9 q: tqtpgqjzdmqfq
9-12 k: kkkkkqbkkckkkjkql
5-9 r: rrrrrrrhcr
17-20 h: hhshshhhhhhhshhhbhhq
7-9 s: dngddfsss
12-13 q: qqqqqqqqqqqcq
2-6 v: vqtvvvv
8-10 c: cccfcncccccc
14-15 m: mmmmmmmmmmmmmmdm
7-14 s: ssslssfdssflvvsj
2-5 z: wcllj
2-11 n: cvnrlftcjct
8-16 k: krzkfbkkqkhnsjkjgkk
2-7 q: mvhvqnzdjw
5-8 l: lgbnlnclkllll
4-12 l: llllmllrlgllrklnlrbt
7-10 j: jjjjjjnjjcjsj
1-2 k: dgwmgsn
2-5 z: zjmxc
6-7 c: ccccccccc
14-17 k: bkkkkkkkkkkkndkkkk
2-4 x: xxjxtxbq
7-9 w: drjcfwzwwwfwwfzxww
4-5 p: pppwc
4-5 r: rrrvm
1-8 r: qrrrmrrrrr
16-18 l: llllllllldllltlklk
1-11 p: pwcpppbppppppp
5-19 w: wwwwwwwwwwwwwwwcwww
17-18 k: kkkkkwkkkkkkkkkkkxk
12-15 f: fsffffffflfqgfx
6-13 d: zddpdvddrvrdxq
1-10 f: ffffffrfkb
13-14 x: xxxxxxxxxxxxxxx
16-20 j: jjjjjjjdwjjfjjjjjjdj
8-11 r: rrrrrrrrrrrr
15-16 x: dxjxxxdxxxxxxxxxwxx
3-9 m: mjhqdgkmzmsmtdmhfn
2-7 k: kkkhwgtxlkmkqkk
11-15 m: mmgmmmmnsjmmlmmm
1-2 v: wvvk
8-14 s: zssssssssssssts
3-4 z: ztbzzr
4-10 x: xxkmqxxxxx
3-5 p: pkppppppppzpp
3-15 q: qpqmkqfqqlqqdfqtkqq
16-17 d: ddddddzbxcdddcddq
4-5 s: nqssf
4-5 s: sssbks
4-5 s: tsjlhsbsmt
1-5 z: zzzbztzf
1-4 l: pvsgtvt
3-6 b: bbbjbb
2-4 d: wkdvd
16-18 w: wwwwwwwrwwwwwwwzwkw
15-17 t: tqttjttttttttvtttt
5-9 q: qcqqqqdtqq
8-11 s: sssssssfssssssssssss
5-6 x: xxxvcpbxr
13-15 d: ddwdtctnjdcdpch
5-6 z: zzzwzzzq
3-7 v: bsphcnvwvtvphdp
3-4 q: vhcprqqgdmlfpwqqw
11-18 b: bfbbbfbbbbvhwbbbzlb
12-15 c: cccccccccccccqfcc
4-10 j: jjjjjjjjjjjw
8-14 s: ssssssspmssssssssms
6-15 b: jxnbdvxbbbcbrsbxrs
10-12 s: ssssjsssssfs
8-12 f: ffffdfkqflfpf
8-9 w: wwwwwwwwz
7-10 z: fzzlzzbtmthzzzz
2-3 k: kqzzb
11-12 s: ssssssssssls
16-17 r: rrrrhrrrrrrrrrrnr
3-11 b: czpbpbzswgcddm
4-8 z: cnzztzgzqz
18-19 m: mjmmmmmmmmmmmmmmmpk
10-13 q: gqqqqqqsxqqqqdtqkq
10-11 x: nxmbxxxrgpmxxxfnxxxz
2-5 x: xbxzrxd
9-14 l: llllpljlllfllwv
1-2 m: mmmmmm
1-3 b: fblbbfbbbbbtbbgbbb
3-4 g: gnnccg
8-9 f: fffffffkffff
5-6 r: rrrrhf
7-8 l: lwlwllllllctl
5-7 j: jrjjwgjvkkncnjbqc
3-4 b: bbsbb
4-13 c: jmcczvkbxccdf
4-5 g: wgrgg
7-8 d: dgddddzh
3-8 h: hhbhhhhhhhh
15-16 l: llldllllllldlllllll
11-15 r: rrgrrrrrrrnrrgxr
10-11 l: lllllllllll
4-5 x: xfdbjsmbbcxdphvlfkxr
9-12 m: rqmnmrmhcmmms
3-8 b: tzsnnndnbwgbskbb
4-10 v: vvkvvdrvwvc
9-11 j: jjjdjjjjjsj
6-11 b: hbbmbbbbbbjbtrbbbz
13-16 v: vvpvvvbvcvvvvvvvv
11-14 j: jjjjjjljjjtjjmj
7-11 v: cvdglnvjxkvvgptxvp
1-6 t: ttjqtttzt
7-10 f: ffwpzfxjfgffzf
4-7 d: dddgddp
4-19 n: mjbdzqxhtfbnbfxrpgnh
6-13 d: ddddddddddddd
2-4 t: rhkd
5-9 c: ccrcxzjdzccx
3-4 j: fwjj
15-19 q: qqqtxqqqqqqqqqqqqqqq
1-11 c: gcccccmccctcc
3-5 d: dxhhdr
8-12 k: pkvrkkkvkkmbkcxjwktk
9-11 p: ppnpppppxppp
11-12 p: dppcsppppppqppp
7-8 b: bbbbbbmbqp
7-8 c: cbccccccc
8-9 b: bbbbbbbcrbb
2-6 z: gzlnpzpkhjwwqtswcrz
5-6 d: dddsdkd
1-5 w: dxwkgwwwwwwmwwwww
4-7 q: qqqnwqlqrqdcqpq
6-9 m: lmmmdmmvmmmm
7-8 h: hhhghhxh
2-3 j: jjjj
1-4 r: rrrw
4-7 m: mmjmmrm
4-5 j: vljjrj
19-20 j: jjjjjtjjjjjjjjjjjjgx
2-6 h: xhltfh
5-11 s: ssssjsssssss
3-4 b: bbbb
1-5 g: chgmtgnn
6-7 j: jjjjjjz
3-8 c: cccccrccccc
3-17 s: sslstssssssssspsgs
17-18 x: bxxxxxxxqxxxxxxxkwxx
9-10 q: qfqqzqqqsddqqqqqqq
6-10 k: kmkkkxvqkrk
5-9 f: kffffffffcdfffffplf
5-6 r: rrrrrz
2-5 d: hdgzt
7-10 k: zkrllwkkkjrkqfkkk
9-11 b: bbrkbbbbcbqqb
8-12 g: gfgkgggggggggggggg
12-14 s: sssjsspstlvlsrsssss
4-8 g: pqgzcgvgflgntlp
13-14 j: jjjjjjjjjjjjjx
4-6 k: kkkmqpk
3-5 j: sjjbjlvjjvjr
2-9 c: ckccjxzcrcctbfn
10-12 n: hvnnnnxnntnlnn
11-15 m: mmrmmmdmmmlmmmjqm
6-8 p: qpzrrpcpbxg
5-8 w: xwdzcgclxwsvfwtwbxnw
3-8 q: qzqzhlzc
2-3 v: hvvvvltft
5-12 s: tgvsswttkwfssnsqjsxk
5-17 b: bbbbbbbbbbbrbcbbbhb
3-6 p: ppjpzw
3-5 k: kkxvkswk
4-8 v: vbvrvxvgrvvwwvvm
3-12 v: njvvgvdcjvvtvvcnvg
4-5 n: bnnnrn
8-9 l: jlvxdlpll
12-14 w: fkwwwwwwcwwjwmwc
1-4 q: wmqrzpqhj
4-7 t: tctsttlt
13-14 h: hhhhhhhhhhhhhf
2-3 j: jmjjjjj
5-6 v: vvvvlv
5-13 v: fnxvvvvvnvqvvvvvws
16-17 l: gllllllllllgwqlll
1-2 s: pnpfsqw
6-13 g: ntzqggvbnwxrgskg
5-12 k: krxmbxqbkhxlnvdxdkkq
14-18 d: ddddddddjdddbdddddd
4-7 z: zzzzxzzs
15-18 d: dddddddddbddddpddh
8-11 x: slxxxxxjkxxxrsdx
4-6 n: nnnfzzn
1-4 h: gslcmnhhfhvz
1-4 d: tddqds
2-3 c: fccp
2-5 k: mkqrknj
9-16 g: gpggdggwgwgwglggg
2-5 h: hhjds
4-5 b: zbnvld
6-14 m: mfqmnmqtdmmzmm
7-8 j: thvcsgjn
1-5 x: xwjdxdqjtc
4-17 r: fqbrqrnpslndrmjdhpjp
4-5 c: ccccw
5-6 v: vvvvdm
5-12 n: nnqzjntfnnnd
3-4 c: nccqlccq
1-10 p: nrvvzpppqpn
9-16 v: jvvrpvvvvvzvhhvvgz
12-13 s: sjsslsssfxxkrssstkss
1-3 t: vtwbh
5-16 q: sxxfrqhqtvzbzqwg
5-9 z: dnzlhzzzsdzz
15-16 d: pdddddjddpkdddtdddd
3-4 p: pplqppp
7-9 s: scsslshsqssw
2-3 v: vxvxv
8-9 w: wqwwwwwgshww
8-9 k: kkkkkkkkc
9-10 v: vhfvvnvvtvvb
1-12 z: zzzbzzzzzzzdzzzz
6-7 b: bbbbbwhb
12-13 z: zzzsvtlzzzzzz
1-3 s: pssssssxw
8-9 w: xwwwwwwdzw
1-4 x: xxkxxx
10-12 f: fffffffpffvffff
18-19 w: wwspwwzwwqcrwwhwwww
6-8 s: ssssstsks
5-6 j: jjcjgm
2-5 p: wprwpxbdkrfpmppqpd
8-18 n: nnnnnnnnnnnnnnnnnn
4-11 c: txncpqclrlc
2-10 f: ffcffftfffxrxf
1-4 t: ttttttt
4-9 f: zdpjffffbfbl
6-7 f: kfsffffffm
1-4 b: bbdn
6-12 k: kkhkkkkdqkbkjkkkl
3-4 n: kmnn
4-11 l: kllcllldllclll
7-19 w: pfwdwdnkblwzgkfnfmh
3-9 z: zzphzdnhqwlzzwzz
15-16 h: hhhhhhhnhhhhhhhd
1-4 l: vllll
2-13 l: hdhvgdrlltlmjptzq
1-3 p: njvpltppbkxpfpppp
1-2 j: kkjv
10-11 c: ccccccmcccjcc
5-8 v: tqvmvtwvzfczvvvvw
6-9 x: xxmxxxfxxxxx
1-10 z: zgzzztmdtkzzpxztbgpp
10-12 g: ggwzjgdsgbnggl
5-6 j: jvxjvjj
4-7 x: xnxxmgxxtjxxkj
13-14 d: ddddmddddddddd
12-15 c: cccccccccccnccc
16-17 n: nnnnnnnntnnnnngnmn
1-12 m: bzckgvmmbdcxtgtmb
4-7 l: ljllllljl
5-11 w: wzvzwwrkmtwh
11-13 l: lmtpwxlllhlgllwvqnp
6-10 f: fvgkffqvcfffdbfff
3-5 j: kbfjjj
1-2 h: hhztdpbttnc
8-10 b: bbbbjbbqkbbbd
1-13 c: hccvcxtcclpckzd
6-10 w: wwwwwtwwzrwwf
2-3 j: fjnnj
2-4 j: njtjjjxrjv
4-5 w: fwwzw
7-9 k: qbnkghdbqlz
2-9 s: dsdftlzsszlf
4-5 v: vvvvd
1-2 w: fbfwwb
4-7 t: tttttmt
3-10 h: hhhhnhhhskhh
3-8 w: qwswwswfl
1-3 p: pmpgpp
2-7 n: nmmgnssmtn
2-3 j: djvjgjp
6-13 x: jxxbxxgnxvbxx
6-10 v: vrvvvvvvdz
2-3 b: bbbbjrkwnc
1-2 h: fshnf
1-5 n: htsknrzqnntknfnjx
5-9 d: kkgtwrdjmxkzc
12-13 x: xxxxxxxxxxxxx
2-10 m: wmmmmmdpmmmmh
2-12 n: xttqcmfkvnlkzskjhmzn
6-9 m: mmmmmxmkp
10-16 m: gmmdqmjmflmmmmmcmmm
13-14 p: pprprppppspxfgnptppp
1-16 b: gcnbbnbbmsjxnbppcb
10-11 d: dkdddddfjmpvdddd
1-9 f: zlfwstnzp
14-15 n: nnnnnndnnnnnrnnvcndn
2-6 l: lvvldlzdzgdf
6-10 z: zzzzztzzzhzz
13-14 n: nnnnnnnnnnnngln
8-9 z: zjqztzztqzzbxzz
2-3 v: dwcv
4-6 m: kmmmkmm
5-9 g: wtgfgdmxkx
3-5 b: vbzbf
10-11 w: wwwwwwwvwwz
2-8 s: sztstsnssq
2-6 l: lldzcslxdwghmn
1-2 n: vmznndnnnbrhknjwzkzx
3-4 k: kknp
1-5 h: hhhhhhh
12-13 z: zzzzzlszzzzzxz
1-12 m: mtbspfpdgpznrsmvgq
11-13 q: qqqqkqnqhqrqrq
14-18 d: dtdrdddddddddxfddddd
1-6 q: bqqqqqgqqqq
1-7 c: dlmvcsztzpx
4-6 g: gmgggg
5-6 s: ssswsssgdghv
8-9 k: kkkkkkkgn
1-17 s: ssssssssssksssssss
4-5 b: qqtlsh
5-6 g: gggggg
2-11 r: drkpvrrlrtrvrjhpd
3-7 k: fkkhmddh
6-7 h: hhhwhnfph
3-4 p: ptppmwpnps
3-6 w: hwcshlrm
7-8 d: dtddqddzn
1-6 s: sslsbssbsg
12-15 n: tbnnjknnkwnnnnsnnnz
8-9 z: zzzzzzzzz
2-5 w: kjnwn
4-7 m: mmmtdjmmmmtl
4-7 h: dqfhzrqhfhntzhkhhdvb
3-5 g: zvflgg
5-12 s: lvsvqnvssgcx
11-19 p: pcppvppplpwppppjlps
5-19 p: gkpmfxlmppczdnhbqcw
5-17 b: mdzljsdvxdmbbbbddvrw
1-5 s: shpdss
2-5 t: btggtltvw
1-6 b: sbbbbbb
3-6 w: wwpsfkwnrrr
13-18 f: ffffwfffsfffwffffn
4-5 m: mpmmmxmmggvnb
5-6 z: pwsqhcztlf
8-11 d: ddddddddddlf
1-2 t: xttt
6-8 m: mmmpmvmmm
16-17 h: hhhhhhhhhhhhhhhrw
1-5 g: gpgpgg
3-7 p: gplrpzp
11-18 t: ftqnxttzttxtgttntrtt
10-11 z: zzzzzzdzzlgzzz
3-10 z: lzfzzzzszbzzztj
2-10 l: khdbddnxltnk
4-8 b: tbbcjsnbrbhfb
3-6 x: xgsxmn
9-13 t: ttttttttmtttt
7-11 l: fllllllzllmdshrll
18-19 g: hffqfwssgqpcnmddkcw
3-4 m: mmhvmc
1-3 w: vwnw
5-6 r: rrrrrb
2-4 j: rjqj
5-7 b: kgblcbbdrb
3-5 g: jgggggg
1-11 v: vvrvvhxvrvvnrvvv
3-14 w: ncwphcwvjwhdpwqkg
6-7 x: xxxfqmkvxx
13-14 v: vvvvvvvvvvvvkt
2-12 x: xzcvvxhhwwxxc
6-14 m: mdtnmjmhmnmmmmm
15-16 z: zzzzzzzzzznzzzzzzz
4-6 s: mcssdssjshscvcl
11-12 b: bnbbbmbjsbxbbbbbj
7-13 c: cccfhccczccwcccsc
3-4 m: cgtmmm
5-10 l: hxhbggrllmtgn
6-8 d: sdfdddlv
4-9 x: xxxxxvxxcx
11-12 c: rcmqkzjccccrdccmc
1-3 g: jgng
4-5 l: lvlll
9-16 n: rnnnqjnvqnnnlnnwdnnn
4-10 x: crdxgxrfjhr
1-5 f: tgdffffffqf
15-16 q: qqqqqqqqvqbfqknqqqqq
9-11 s: sssnffssksq
3-4 v: vqvvv
5-19 z: jthjzpgmwjbftzvmnpzk
3-10 w: mpxhrrnqdvncwssqwlxz
14-15 b: bzbbbbbsbbbbbbbbbbb
3-5 j: jpjvjjrjtmjj
3-6 w: wwmwwzw
1-6 c: ccccvzcccm
10-11 m: mmvwgmjmmmrqjmmmglm
2-3 f: fffw
6-12 m: bmbzmmrshmmz
5-6 n: nnnnnn
4-5 k: kmsgkwvkk
6-8 t: tttttbttt
4-5 j: vtmvsqjl
5-6 q: qshzdqqk
1-3 w: dwgw
8-9 q: qbqqqqqwq
5-10 m: lmmmkgmmwb
6-9 n: nnnlnnnnn
4-5 t: tntct
6-8 g: hgngghgw
6-9 t: gttwtgvpgtlt
6-7 l: lllllll
4-5 j: jhjkjjm
13-15 h: hhhhhhhhhhhhxnh
1-4 m: mmmmm
4-6 q: cqrtqsdqqzrknf
9-13 f: fffffffffzfvff
2-16 p: prxdxjpkppgpxsjwpppp
3-4 r: rrzh
1-2 g: cglblsnkg
1-3 f: xqnfwjmmwqffd
13-14 q: qqqqqqqqqqqqvjqq
18-19 g: dggggggggggggggggvgg
5-6 s: dsssssss
4-6 z: szdzzb
9-12 t: xtltpgftttmtt
10-16 m: mqmmmmmmmcmmmmqx
3-7 c: cpccngcvccm
2-16 s: jsdfsjsjtswhkvmsskj
2-3 c: kccc
4-16 k: qhndnqmrvjcczfkpds
4-6 n: nnnrkxl
9-10 s: ssssssssds
2-3 z: hfzcz
2-3 s: sssz
8-10 b: qbbbjbbbbw
7-16 k: gcvskkjkkkkwkzkz
7-9 n: nnnnnnhnnnn
1-10 q: qjxqmqxcgg
9-11 l: jdhjbbcnlzll
7-14 l: llrlxlllllltlnl
3-6 f: wfdqfbrf
3-8 t: ttzttmtvttzpl
10-12 v: vfvvvvvvvsvv
5-6 v: vvvvvm
11-13 t: ttttxtttttptttctttt
3-4 k: kkdm
4-6 n: nnnlnt
13-15 m: mmmmmbmmmbmmmmmm
5-6 l: klllnl
2-3 f: flzff
3-4 r: frrs
1-5 d: cqwkvsdqdvb
9-15 l: jvtfqczlnlwdpclxwp
12-14 t: ttttttlqtpttnt
11-12 m: mmmmmmmmmmmm
4-5 j: jjjkbjjjjj
9-12 w: wwwwwwwwkwxkwcb
6-12 q: tcqrqqqqxjqqqqmqhq
5-6 m: mmmsmmmm
2-5 t: mttbttprttddtv
10-13 t: tttttttttttztt
10-11 f: kmqfxttfkfd
5-7 v: vrlzpvjtvv
6-7 l: nlllllj
1-5 q: szdbqqkqqtkmssq
3-4 q: kcmlwqzczwms
13-16 b: bsbbbbbbbbrbsbbpzbb
9-11 d: dddsdbddkdkdd
2-15 j: xkjnntffvvxfnntcv
4-6 v: hvvvcvqvrwv
9-12 j: qjjjjdjgqhrjjfjrdj
8-10 v: vvvvvvvnvnvv
4-9 t: ttttthttt
8-16 g: ggggklggcggggxgg
1-3 z: wpqz
4-5 g: wgdnmxccgj
8-11 r: rrrrrrrxrrmd
1-9 f: ffffsfgdbsqfffzf
7-8 q: qzqqqqrrq
12-13 n: nnnnnnnnnnnnnn
8-12 j: jpjjjmjjjjjzj
1-4 j: nvjw
7-13 z: zzzzsnzxzznzrzgzzzz
14-16 z: zzzzzzzzzzzzzzzm
1-4 x: xxxxnxh
8-15 k: gnrkktkpcmklkksnkk
2-4 h: klph
11-16 c: ccckzdccgckpcccsc
15-16 l: dlllllllllllllll
2-3 s: dsxss
1-4 v: jvvv
2-8 t: ktkdtxkt
1-3 t: ftftttttt
4-5 k: kkkbkk
4-6 g: llqcggg
4-14 r: fmdvrrwlstlbjr
2-16 p: rpdfhpbqfwxlxhhc
6-8 j: jjjjjjjjj
1-7 f: fnnffblbqffkrff
1-3 k: rfqwlnnkzdq
15-16 s: ssssswssssssskssss
11-13 z: zzzzngfzzzzzz
5-7 h: hhbhhcnhfghhhv
2-7 j: zjrmjgmjdkp
5-8 z: bzzzpzzrzzzz
12-16 j: jtjnjjjjgjjjjjjsj
5-9 s: ssssssssms
2-3 s: ssss
13-14 d: ddddddddddddkt
12-13 r: wfdtrknrhvrrc
6-8 p: vpxphxngzhnkppppfp
2-3 j: jtjx
3-6 k: tkkvjkb
2-6 t: tvftftvbfx
5-7 z: zzzqzzz
14-15 h: whdhxhhhhhhhfxzhhh
3-4 g: ngjgg
9-10 z: zzzzztzztq
2-7 f: fffffqfszchff
4-6 f: lfqjnzccffjslsdf
5-6 z: lpzzzzsz
11-13 t: tttttwtttttttttttt
2-6 z: zzzzzz
9-10 m: mmmmmmmmjm
5-6 w: xwggfcwvwlx
1-4 j: jjjjjljjjjjjj
8-10 t: ttttttwttt
5-12 x: zxxxxxxpxxxn
3-4 v: vvlrv
3-6 h: hhhwhlxhlrhl
2-5 p: cptsjktp
4-11 j: bmjjjjjjnwwdk
15-17 p: ppppppppppfpppvpp
7-11 m: wnnmmwmtmmxmm
9-19 k: kkkkkjkkhwkcvkkkmknw
11-15 s: sspssbshssscssssss
1-8 s: sssssmssssssssssss
4-8 x: xxxxdxxx
9-10 n: nnnrnlnnnnnnnnnnnnnn
10-11 d: ddddddddddn
5-9 z: tzzzqzbmzzzqzjkzlr
9-20 f: fffffnfffffffsfnffff
5-6 g: gvggggg
13-14 x: xxxxxxxxxxxxxxx
6-7 v: vvvzvvvv
5-10 l: kbcvlfvlszndtlldjlh
4-9 s: vkcsdvszthkwmmmxs
3-4 b: jbmb
2-4 w: nmwm
5-10 z: tztzzfzgdzzszq
2-8 k: kzkkkkzwf
16-17 d: vxvzdgzwssqdcgbdb
4-5 b: bbbbb
7-9 w: wwfwwwjwln
5-12 k: ljkkkqfvqtkkxsd
5-7 q: qqqqhqqq
8-9 n: vnnnnnnpstnn
5-10 m: mmgzmmmmmm
3-14 q: qgbvqjxqnqqqqqqq
2-4 c: cccc
3-7 b: szbbkbdbmbbzbqs
1-5 m: mhmmc
3-6 n: nnlvnnvnq
2-3 c: mccc
11-12 m: ddmmmmxmmmmwfmmm
8-10 n: nnnnnrnnnn
1-12 g: sgbggglnggddgggsngrx
7-9 p: phppppppp
4-5 q: qxqqqq
3-7 v: vwsvvrvxvvvvvvwvvdlv
8-18 j: jmjcjjltjmjwjzrllgcj
2-14 r: rdrrrrrrrrrrrp
2-4 r: cxcbkmr
6-9 r: vtlnnvbcndqhrxkkjp
2-3 s: hxssnsswzc
10-16 r: csrsrxrrrrrrfrfdrr
7-9 w: wwbwmvrwdxww
12-14 p: pppbpppppppgpt
2-7 n: nnnnnnnn
3-12 f: mhjxfxgbbvffpclfffg
10-14 l: lllskllljllllll
11-16 l: lwlklllglzllllllll
13-14 h: hhhhhhhhhhhhhdhhhh
1-2 t: tttb
1-6 z: zzzrrzzbf
1-6 v: jrvzvvrs
3-6 g: jggbnl
17-18 x: xxxxxxxxxxxxxxxxrx
8-17 f: xnmffffbwfdcfrdfw
3-9 k: jmkdvkdnk
7-9 m: mmmmmmdml
9-11 c: cdmshccckqmcccccckp
16-17 g: gggggngggggggggggdg
7-8 n: nnknnnnnnn
3-13 n: fjhgrspsnkmnf
14-17 z: zzzzzzzzzzzzzqzzzzzt
13-14 r: rrrtrrfsvrzngw
7-8 k: kvkvkpvc
1-2 b: bbpbb
1-7 n: tchnrtbtldnmnnvvnn
3-4 s: sssssjv
1-9 l: cllllztmlllrzfl
9-10 x: qjxxxxxxdhxxxxxh
6-7 p: ppppfppv
3-8 q: mkqzqqbqzjrqbq
6-8 x: xxxxxxxx
1-7 f: ffffffff
5-16 b: jbbbbbqcbbbbbbfb
9-11 c: ccccccccccq
1-2 x: fqkx
4-12 z: znzzzzzzzzzzzzz
3-4 l: lglll
9-11 m: mmmmmmmmmms
14-17 x: xrxpxgkxxzdrxxxxckxv
3-5 t: gxjbbfcpmkbkxbtwbt
5-6 j: jmjjjj
14-15 g: ggggggggggggggx
6-7 l: lllllbl
2-14 q: qqtsqkqvqqqpxzqqcqq
2-4 w: fwhw
4-5 m: mzmtkm
2-4 g: ghghgp
5-6 r: rrrrnl
1-4 h: chghhw
7-12 r: rrrzglvrrrrsrr
1-7 x: xxcxdwxjmx
5-12 r: rrgrrffwtrrnrrqrrjnr
2-5 r: srdqrlxrkrrdkr
3-4 t: ttdg
11-12 s: bfjrkqqgdtlwrskmfrp
3-5 n: nnrnfzsnm
10-15 z: zzzzhzzqqczxwzqztv
2-7 f: ffgdfgff
7-10 d: ddtbdddddjtdqfdddfq
2-9 k: gkrkkkkkkkkhkqkx
13-14 n: nngnlnnnhnnnnnnnn
6-9 r: qrxrxzrff
7-9 m: mmmmmtmqqmml
11-12 p: pppppppppppp
10-13 j: jjjjjjjjjznvbjj
1-2 c: ccvc
7-8 m: mmmmtdmckkpmcbkjmm
5-8 j: sjptjjbjjjjj
6-8 d: jchdwrhd
5-6 z: lqzzzzkrzzvzwbbzktp
6-8 l: ztbltlll
2-3 z: zkrxzp
7-18 g: phgpgggqgzgnmwlpkwd
8-9 f: hffffffqf
17-19 p: pppppphpppppppppzpp
2-3 z: zzzfg
1-2 v: bfvj
4-8 b: bcbbbbbb
15-16 s: ppsnsssssssnssss
2-3 m: mnsm
2-4 h: hwfshh
9-15 h: hhwhhhhxhhhhhhh
17-18 n: nnnnnnnnnnnnnnnnnn
7-11 n: nnnnnqpnlbgqnqnshn
15-16 j: cdjmbcwdppvvjqvv
6-11 p: ppplppppxpt
4-5 r: rrrrrr
10-11 w: wwwwwwwwwww
3-7 p: pzppzspppmkxbldwpnwf
2-12 w: zwdljlzwgxfwvtdm
2-10 f: mzfjqfspgfrfhst
14-15 m: mzmmmvhwmdmmdpz
1-12 r: vrxrrtrxgvrd
4-5 n: nnnnnnpn
6-12 x: xkbwfsxxxxxkxxxxk
4-6 n: mncnxn
9-10 f: ffffpfqftbf
3-5 b: bzwbk
4-7 c: ncdcccc
11-12 t: dgdkrjgsgtlf
8-11 z: rqzdjqznrpkzmblbt
1-3 z: zfzx
2-4 z: kzgzkp
6-10 v: jvvvvvvvvs
2-9 v: vrvvvvvvvc
5-6 q: qqqqqqc
6-10 p: ppdknlgpqkp
10-13 z: zzzzzzzzzzzzvz
19-20 g: dtckblrmggknmxwnrjgg
4-18 p: ppcjpqfpcxtphlppmhcx
6-7 n: nnsnnknthn
10-11 f: fffffffffff
2-4 f: ffccltsfgk
6-11 d: dsqddtddddjcnssrcd
7-13 x: xxxxxqlxxxxfw
12-13 r: rrrdrrrrrmrrrr
15-17 p: pqppppppppppvppppppp
7-8 j: jjjjjrdp
4-6 v: vvvvvt
1-4 t: tltftjtjhz
9-15 j: jjjjjjhjjjjjjjkjj
6-7 c: ccccccccz
8-9 x: xxjxxxxxsx
4-5 h: hhrhh
2-3 g: cgnm
8-10 l: llqlgllzlvrllg
12-13 c: cvnbccpzzxcccfh
3-8 z: zbzrwzzzwrzbqnr
6-7 n: nnnnnnn
8-11 j: tjqjrjggjxxjggjj
7-12 l: bsvxdhljlcsj
3-6 j: jjfjjjjb
2-3 z: dzztwhmzqdx
9-12 v: vvvvvvmvzvvcv
13-14 v: vvvzvvvvvvvvvk
6-7 g: fgggghgng
13-14 h: wcghlwdbjhpdphkcv
1-2 t: nncsg
6-7 w: kwjwwxlwz
4-5 z: zzztvz
3-4 n: nvbvngnw
15-17 z: zzzzzzzzzzzzzzzzzzp
8-10 r: rrrstrgxrhrr
8-10 g: cggggggvgcg
1-4 m: mmvbz
3-14 j: bdbhbjnjnrldhwlbrkrj
1-4 r: rrkrnnd
2-3 f: fvwc
4-13 c: ccccvcgwbhwrcqf
3-9 c: jcghltcfkjchxmccccbs
3-5 h: hhhshm
5-9 h: hhhsjhhhhgthfgldw
4-12 h: mcwvwwphwwbc
6-11 g: gqgggvggggh
9-15 x: xxxxxxxxxxxxxxsx
16-18 t: rmqqtbtvttsdtjvbttl
9-20 f: cllnvlfkfrwzpqxwqgnn
9-18 v: vvvvvvvvzvvvvvvzvxvv
4-5 f: fzffbfvfff
1-5 p: pppppp
1-7 z: zjvchwzqjrtxzgz
4-9 v: vvvvvvvvvv
5-8 w: cwwwzwwb
7-8 r: rrrrxrrr
8-9 f: sgdcqfhfcfsflb
3-7 g: gdgtnfggq
================================================
FILE: advent-of-code/2020/inputs/20
================================================
Tile 2011:
.##...#..#
.#.#.#...#
.......###
.....##.#.
#...#.....
##...#...#
#.#.#....#
##..##....
.....#.#..
##.#......
Tile 3407:
#..#..#.#.
#..##....#
..#.......
......#...
......##.#
..#.#..#..
.#.#....##
##...#...#
#.#.##....
#.##..#...
Tile 3733:
##..###.#.
##.#.#..#.
.....###..
......#...
.##...##..
..##......
#.#.#.#..#
.#..##...#
....######
.#...#.#.#
Tile 2267:
..##.#..##
..#....#..
#..#...#..
.....##..#
##..##.###
#.#.....##
#.#...##..
#.......##
..#.....##
###.###.##
Tile 3853:
.####..#.#
.........#
......#..#
..#...#...
...#.....#
..........
....####.#
#........#
#....###..
.#..##...#
Tile 1531:
#.#..#....
.#..#.##..
.....#..#.
#....##...
#.#...#...
.#...###..
##.....#..
..##..#.#.
##....##..
###..###.#
Tile 3907:
#..##.##.#
##.##.##..
........#.
......##.#
#.##..#..#
#....#..#.
.##.##....
#.#.##....
.#..#.....
#.###...##
Tile 3329:
#.##..####
##....#..#
...#..#.#.
#..#..#..#
###..#...#
##.#.##..#
.#.##.....
##.#..####
.....#.#.#
#..#..#.##
Tile 3449:
...#.#..##
......#.##
#......##.
..##..#..#
...##.....
##.....##.
##..#.....
#...##...#
#.##...#.#
..#.#...##
Tile 1187:
#.#.......
...#.##.##
#.#.##...#
##..#....#
#..#..#..#
#.#.##...#
.....####.
..#...#...
.....#....
#.##...##.
Tile 1543:
.##.####.#
.##..#..#.
#..#.....#
###..#.#.#
.#.##.#.##
#...##.#..
#..#.#####
#...#.#..#
#..##...#.
..#..##..#
Tile 3631:
#..###...#
.#.##....#
#......###
#......#..
#.#......#
##..##...#
###.#..##.
...#..#..#
...#......
####.##..#
Tile 3917:
##.#######
.....##..#
..#..#...#
#......#..
##.#..###.
#....#.#..
.......##.
#....#..#.
.##....#..
#########.
Tile 1373:
####....#.
#......##.
.....#....
.##......#
#........#
#..##..#..
##..#.....
#......#..
.#..#.#..#
##...####.
Tile 2663:
..#.##....
.#..##..#.
.......#.#
##..#..#.#
..##.##.#.
....#.#..#
##.#.....#
#..#....##
###.#..###
...#.#....
Tile 3529:
...#.####.
.#.##....#
...#.##.##
#..#...#.#
#.#..#.#..
........#.
##........
....##...#
#..#....##
.###....##
Tile 2297:
...##....#
#...##...#
#......#..
##.......#
.#...#..##
.#....#.#.
#....##..#
#....###.#
##.......#
###..#..#.
Tile 2789:
..#.##.##.
#.#..#....
#......#.#
#......#.#
..#..#....
#...#.....
...#....#.
#......#.#
.....#...#
...#....#.
Tile 3461:
..###.####
##....####
#.###.#...
##......##
#.#......#
##......##
#..#...#..
.........#
......#.#.
#.#..#.###
Tile 2939:
##.####...
.......#.#
###.##..#.
.####....#
#.#....###
#.....#..#
##.....#..
..#....##.
#.#.......
.......#..
Tile 2903:
##.#.#.#.#
##.##..#..
.........#
#......##.
....#..###
###.#.#...
...#.....#
#.....#..#
##..#.....
....#.#.#.
Tile 1993:
.##..#####
....#....#
.#..#...##
...#......
...#..#...
#...#.##.#
#....#...#
#..#....#.
..#..#..#.
.###.#####
Tile 1669:
.##.##...#
###.###..#
###...##.#
##.#...###
#.#.#.####
.##....###
.####.#.#.
#.#.##...#
#.#..###..
....#.##.#
Tile 3823:
##.......#
###...##..
##.....##.
...##.##.#
..#......#
.##...#.##
.##.#..#..
###.#.....
......#...
.##.#....#
Tile 3929:
#....###.#
..........
.........#
#.###....#
...#.##...
.#.#.###..
#...##....
#..#.#..##
#......###
..####.#..
Tile 2521:
....##..#.
...###.#.#
.#....###.
#.#...#.#.
##....#...
#....##...
#...##.#.#
....##....
#.....####
#.#.##....
Tile 3361:
....##..#.
#.##.#...#
..##..#.##
#..#.#....
...##...#.
..#...###.
.#####...#
#.#####...
#.#..#..##
#.#####.##
Tile 1259:
..##....##
..#...#...
#.#.#..#.#
#........#
.##......#
##..##...#
###..###..
##....#..#
..###.#.#.
....#....#
Tile 2729:
.##..####.
#.##.#....
.....#.#.#
..#......#
#.#....#.#
..#..#..#.
##...####.
#...##....
.#.......#
..#..##.##
Tile 3511:
#...##.###
#...#.##.#
......##.#
#.........
#.##..#.#.
....#....#
...#.##...
##.##.###.
..#......#
#...##.#.#
Tile 3119:
.....##.##
#.....####
..#..#.#..
.#..##.#.#
.##.....#.
...#...#.#
..#.#.#..#
#.........
#.......#.
########.#
Tile 1427:
###..#.#..
#.#.....#.
.####...##
.#..#.....
..#.......
.#...#.#..
..#..##...
..##......
###..#.#..
...##.....
Tile 3307:
...#...#..
.###....#.
..#.#..#..
#......#.#
##.####...
#.##.#.##.
.##..###.#
...#......
....#.#.##
.#.####.##
Tile 2081:
.....####.
...#....##
#.#..#..##
#...#...#.
.#..##.###
...#.##.#.
#.......#.
##...#....
....#..#..
#.#...#.#.
Tile 1741:
##.##....#
#..##.##.#
.#..#..##.
.#.#..##.#
.###......
#.####....
..#..#.##.
####.#....
##....#...
#.#..#.#..
Tile 1481:
#.#...#...
#.#.##.###
#.......#.
#.#.#.....
.####...##
####....#.
#.#..#....
...#.#...#
........#.
#....####.
Tile 3719:
.###..#...
..#..##...
#..#...#.#
.##.#.#.##
..####.#..
#...###.##
.#..###...
...#.....#
#..#..#.##
.##.#.#.##
Tile 2797:
..##.#.#..
....#....#
..###...##
..........
.......#.#
.........#
#.#.......
####.####.
#.#..##.#.
.#.#...#.#
Tile 1319:
..####.###
.#.##.#.#.
##.##.#.##
#.##..##..
#..##..##.
.##.#..#..
#.#..#...#
..#.#...##
#..#..###.
#.###..###
Tile 2053:
.##....###
##..#.....
#.#...#.#.
.........#
.#.#..##..
..#..##.##
#.##.#.#..
......#..#
#.#.###..#
#...###.##
Tile 1867:
.#.###..#.
#...#..#..
#.....##..
#....#..#.
#.......##
#...#....#
.#..####.#
###......#
.##.##.##.
.##.##....
Tile 2131:
##.##..#.#
##..####.#
...####...
#....##..#
..##....##
##....#...
..#..##..#
.###..##..
..#..#...#
....#..###
Tile 1777:
###..##...
#.#.#...##
#..##....#
.........#
#..#..#..#
#...#.#..#
#..#......
.#..#.#..#
##....#..#
....##.#.#
Tile 3037:
##..#..#..
##......#.
...###...#
.####....#
#..#......
#...#.#...
..#####.#.
#..##.....
......#...
..##.#.###
Tile 2749:
..###.##..
####.....#
#..####.#.
#...#....#
#.........
#.......##
.####..##.
..##..###.
#.##....#.
#.#...#...
Tile 3919:
#.#....##.
.#....#.##
......##..
.#....##..
#.......#.
#..#...#..
#.#..###..
##...##..#
..#..##.#.
.####.#...
Tile 1231:
.#.#.#####
........#.
##...#..##
....#....#
.......#.#
.#.......#
...#..#.#.
.........#
...##.#.#.
####.#.###
Tile 2441:
##.......#
##.....##.
.#......##
#.###...##
#.......#.
....#...#.
#.#...##..
##.....#..
.#.#.#.###
#########.
Tile 3659:
....#.#...
##.#####.#
...#....##
.#.##..#.#
#.##.....#
#.#...#...
#.....#...
......#...
#.......#.
###...####
Tile 2411:
.##...#.#.
#..#.##..#
#....##...
#...#.....
#......#.#
#........#
.#.##.....
#...#..#..
...#.##.#.
##.#...#.#
Tile 1999:
...###....
.##.......
.#...##.#.
..#......#
#.......##
###...####
.#......##
.###....##
..##..##..
##..#.#.##
Tile 3623:
###....#..
....##.#..
..#...#...
.#......##
#..#..#...
#.#####...
....##...#
.#..#.....
#..#.#.#.#
#....#...#
Tile 2851:
#.##.##.##
##..###...
...#.##.#.
.....#....
##....#..#
#.##....##
##.#.####.
#..#..#...
...##....#
...##..#.#
Tile 3673:
.#####.#..
#.....#.##
.#........
..#..#....
.##..#....
#.........
#.##..##..
......#..#
#.......#.
###..##..#
Tile 2399:
##..#....#
#.######..
.#.#.#####
##.#..#...
.#....#..#
###..###.#
#..#..#.##
#..##....#
.##....#..
#.#....##.
Tile 3727:
#..##.#...
###....#.#
.##..##.##
.#...#..#.
..#.....#.
.#.#.....#
####.....#
..#..#....
..##..#..#
###.###..#
Tile 2311:
#..#...#..
..#.....##
....#.#..#
..#....##.
.....#.#.#
#........#
..#...##.#
#.#.#...##
##.#.#..#.
..#...#...
Tile 1009:
.#.###.##.
....#...#.
#....#....
#.##...##.
#....#.#.#
#.###.....
.##..#.##.
.#..#.##.#
##..#....#
.###.##.##
Tile 3313:
##.#..####
.#...#..##
..#....#..
...#...#.#
######....
...#......
..........
.#...#.##.
...#.#....
###.#.#.##
Tile 1733:
.#.#.###..
.##...##.#
###..#.#.#
#.#...##..
#.....##.#
##........
##.##.#..#
.#....#.#.
####.#.##.
####....#.
Tile 3947:
.####...##
.....#....
#.#.......
.....#...#
..#....#..
#...#..#..
...#......
##.#....#.
..##..#...
..#.#.#.##
Tile 1583:
#..###....
....#.#..#
...##.#..#
.##....##.
.......###
#.......##
...#.##..#
##.....#.#
###..#..#.
#...##....
Tile 3911:
.###...###
.#.......#
###.#....#
.###......
..#.#.#...
....#.#...
#..#...#..
#...#..#.#
.#.#..#..#
.#.#....#.
Tile 2833:
.#####...#
..##....##
#####.....
.#..##..##
#.#..#.#..
#..###.#..
#.#.##...#
...#..#..#
...#..##..
#.#.......
Tile 1117:
...#####.#
.##...#...
.........#
##......#.
....#..#.#
.###..#.##
###..##...
..##.#...#
#..#.##..#
.#..###...
Tile 2693:
...#.#...#
##..#...##
.#.....##.
...#.#....
.###.....#
...#......
##.......#
#........#
....#.....
..#..###..
Tile 3527:
..##.##...
.#.#......
##..#...##
#..##.#...
#...#...#.
#.#.#....#
#..##..##.
........#.
......##.#
.#####...#
Tile 2417:
.###.#...#
....#....#
###....###
..........
.#...###..
.#####.##.
#.#.....##
.....#...#
..#..#.#.#
###.##.#.#
Tile 1723:
..#####.##
#..##..#..
#..##...#.
..#.....##
..#...#...
....#...##
....#.....
#...#....#
...#..###.
.##.##....
Tile 2251:
.....#####
..#......#
#....#..#.
.#.##.#..#
.....#..##
........##
..........
.#...#...#
.#..#..#..
#.#..##.#.
Tile 3761:
#.#.#...#.
#.#.#.#.#.
#..#....#.
#.........
##.##..#.#
...#......
##..#.....
#...###.#.
..###....#
..##.##...
Tile 1697:
.#...#....
..##..#...
#........#
##..#...##
......##.#
...##...#.
..##...#..
.####....#
..#......#
##.#.#.#.#
Tile 1879:
..#...#.#.
#.#.....##
..#..#..##
.......#.#
#...#...#.
........##
##.#.....#
..###...#.
.....#.#..
#....#..##
Tile 1901:
##.#.#.###
.....#....
##.#.....#
#.#.#.#...
.#........
####.#...#
#.#...##.#
.##.##.##.
..##...##.
#.#...##..
Tile 1063:
..#######.
.....#.##.
...#......
#........#
#........#
#.#..##...
...#...#.#
###...#..#
#.#.....#.
.###..#.##
Tile 2389:
.###.###.#
...#...#..
..#.....#.
...#..#...
.#...#....
#...##..#.
#...##.#..
#.#.#.....
##...#..#.
##.#.#..#.
Tile 2393:
..#..#.#..
..#..##...
....#.#...
#..#.....#
##........
#.##...#..
....##...#
...##....#
...##.#.##
#.#.#.####
Tile 3067:
.....##..#
.#........
#..##..#..
#.#...#.##
#..###.#.#
#...#...##
#.##.#..##
...##...#.
.##...#.##
#.....#...
Tile 1747:
.#######.#
#...##....
....###..#
##...#.#..
#..#.#..#.
#..#.#.#.#
..###.##..
#.#.##..##
..........
###.#####.
Tile 3797:
..#######.
#.#.#.....
..........
#..##.##..
##..##.#..
#.#.#...#.
.###.#..#.
##...##.#.
#..##.##.#
.##.#.##.#
Tile 1811:
##..###...
.......##.
......#..#
..##....#.
##..######
#...#...#.
####......
#..#.##...
#..##....#
###.#...##
Tile 1087:
.##.##..#.
.#.##...##
.#......##
.#.....##.
...#.#.##.
###.#..###
###.#...##
####..#...
##...#...#
...#.#...#
Tile 1181:
...##...##
....#..##.
.#...#..##
##.#...#.#
..#.#.#.##
##.......#
#...#.###.
#.#.....#.
.#......##
..#.#.#..#
Tile 3821:
.#...#.#..
..#....###
..##.#..#.
#...#.#..#
#.###...#.
..##..##..
#.#.#..#.#
....####.#
#.........
..#.#.....
Tile 3457:
#..#....##
#........#
#.#..#.#.#
##.....#..
.....###.#
.#.##....#
#.....#..#
##...#...#
.#.....#.#
##.##...##
Tile 1657:
###..#.###
....#..###
..#...#..#
...###..#.
.....####.
#......#..
.##...#.#.
.#.#.#.##.
....#...#.
...#.##.#.
Tile 2503:
.#....##..
#.#...#...
##..####..
.#.#.....#
#.#..##...
...###...#
...##....#
.....#...#
.....##...
..#...####
Tile 2843:
....#####.
#.......##
#...#.##..
.#.#.#...#
..#.##...#
..#..#.###
.......#..
....#..###
......#.#.
#.####.##.
Tile 2273:
#....##..#
##.#....#.
#.###...#.
#.........
...#......
####......
#.##.....#
#..##..#..
#.......##
.#..#..###
Tile 2953:
.#.#.###..
#...##.#..
.#........
....#....#
...##..##.
#.....#...
#.....#...
#...#.##..
.#......#.
###..#..##
Tile 1021:
##.#.###.#
##....##..
#......#..
...#...#.#
#.##.....#
......#...
#..#......
.##...#...
#...#...##
.##...#..#
Tile 3643:
#...#.....
...#...#..
......#.##
.....###..
.....#.###
.....#.#..
.......##.
##..#.#...
#......#..
..#.####..
Tile 1609:
##.#.#..##
..........
#.#..#.#..
####...###
.#...#..#.
##....##..
#.#.##..##
#...##....
##....#.#.
###..#.#..
Tile 1949:
#.#.#.##..
#.#.......
#.#......#
###.#....#
...#.##...
#...#.....
.#...#....
...##.#...
.#..#....#
.##..###.#
Tile 1153:
.##.##..#.
..#......#
#.#.....#.
##.##..##.
#.#......#
....#....#
.#.##....#
#.#..#...#
..#...#.##
#.#.##..##
Tile 1367:
.###.#####
.........#
#.##....##
....##..##
.#.#.....#
####..##..
..#.###..#
.#..##.#.#
..#.....##
#...##.###
Tile 1061:
..####....
.......#.#
#.....#...
#..#.##..#
#.##....#.
.#...#.#.#
###.....##
..#...#...
...#.##.##
.#....#...
Tile 1193:
...#....##
...###..##
#..##....#
#....#....
#...#..#.#
..##.##..#
.#.###...#
##....#..#
#...#..##.
####.#....
Tile 3617:
#..#.#..#.
#.#.#.##..
#.##.#..##
#.#.#.....
###......#
##....#..#
.....##.#.
#......###
...###..##
.##.#..#.#
Tile 1093:
#..##...#.
.#.#.#...#
#........#
.#...##..#
....#.#.##
#.....#.##
#........#
...#..#...
#.##..##..
.#...#..##
Tile 1549:
##..#.###.
..#......#
#.#..#..#.
........##
....#..#.#
#.#.#.#...
...##..#..
######...#
#....##..#
.####..#.#
Tile 2281:
###.######
.#.#......
#.#..##...
.#.#...###
..#...#..#
..##.....#
.......#..
#....##..#
....#..#..
..####..##
Tile 3049:
.....##...
#..#......
#....##...
#...#.#...
###...##.#
##....#...
##...##..#
#...#.....
.#.#.##...
######...#
Tile 1523:
##..###.#.
.......#..
##..####..
.#...#...#
.....#..#.
.##.#.#..#
##.#.....#
###..#..#.
...##.....
##.##.....
Tile 3671:
.#.#.###.#
.........#
...#..#...
...#.#....
.#...#.###
###.#.#.##
..#......#
..........
#..##.###.
#.##.####.
Tile 3221:
...##.##.#
#....#...#
##..###...
#...##.#..
##........
##.....#..
###.......
.......#.#
#.#..###.#
#..#.#...#
Tile 1861:
.....##..#
##...#.#.#
#...#....#
....##...#
#..##..#.#
...#.#...#
##........
#.#.#.#...
#.........
##......#.
Tile 2111:
#....##.##
..#....#.#
......##.#
#..#..#...
..#..##.#.
##..###.#.
.#..#.#..#
.#.#...#..
#.##.#...#
#.#..##..#
Tile 1049:
..#.######
.#......#.
.........#
....##..#.
.#....#..#
....##..##
..#......#
#..#.#...#
##........
.#.##..##.
Tile 1871:
.##.##.#.#
#...#.....
#..#.#..##
.###..#.##
.....#....
#....#.#.#
#..##....#
.#.##....#
.#...##.##
.##.#.####
Tile 3389:
...###..#.
.#...#..#.
###.......
.#...#.#.#
.#.#.#.#.#
#..##.###.
..###..##.
#...#.....
#.#...#...
##.##.#.##
Tile 2699:
.#..#.####
#...#.#.#.
##.....#.#
#....#...#
..#...#...
...###..##
#.#.##..#.
...###.##.
#....##.#.
#..#..#.#.
Tile 3181:
#.##.#..##
#......##.
........#.
##.###....
##.......#
#.........
##...#...#
#.#.#....#
...#.....#
#..###....
Tile 3469:
..##...#.#
...##..#.#
##.##.#.##
.#####.###
..#......#
.#......##
..#..####.
##.#.#..#.
.#......##
#..##.#...
Tile 1249:
##.###...#
.#........
....#..#.#
#.....#..#
#.###..#..
.#.......#
.....#.#..
##....#...
.#...##..#
.#..###.##
Tile 1907:
.####.####
#....###.#
...#.#..#.
..#..#..##
#..##...##
#.#.......
#...##...#
#..#...#..
.#...###..
...###.##.
Tile 2539:
...#.##.#.
##.....#.#
#..##.....
#####.....
#..#.#..#.
###..#....
....#..#.#
.......#.#
#.#.....#.
#..#####.#
Tile 1217:
.#.###.###
.........#
#.....#...
##..#.#...
..#.#.....
......##.#
.#.......#
#.#.#.#...
...###.#..
..####...#
Tile 2377:
.#...##..#
..#...#..#
........##
.........#
.#....#...
.###.....#
#....#....
.#...###.#
...#..#..#
###.#..###
Tile 2767:
.####..#..
##....#..#
#..#....#.
#..#.#####
###....#..
..#..#.###
#...#.....
#.#......#
.#...#..#.
#.#.#.####
Tile 2879:
#.....#..#
.#..#..#.#
##....##..
..........
#...#...#.
##.......#
#.###.#..#
.......##.
....####..
..##...##.
Tile 2683:
.##..##...
.#........
#..#.##..#
.#.#..##.#
........##
#.#......#
....#.##.#
#.##.#..#.
#.#.#...#.
#...##.#.#
Tile 2003:
.#.#.###.#
#..##.#...
##...##...
.#...##..#
.#..##.##.
#...##...#
#...#.#...
.#...#.##.
..........
######....
Tile 1511:
#..#.#..##
......#...
#.#.#..#.#
##..#....#
##......#.
#.........
.....#.#..
..##......
...##...##
..##...###
Tile 3967:
.##..###.#
....#....#
#.##...#.#
#......#.#
#.....####
..##....#.
#.#.#....#
....#.....
##.#.....#
#.###.###.
Tile 3343:
##.#.#....
.......#.#
..#......#
..##.#..#.
##....##.#
.#.#......
...#..#.##
#..#.##..#
.#.#.#.#..
..##..#..#
Tile 2269:
##........
#........#
.........#
...##..###
.###.##.##
#....##..#
.#..#.##.#
##.#...#..
##....#.##
..#.#....#
Tile 2063:
#...#.##.#
##.......#
.#..#.....
.##...###.
.#.....#..
..#.....#.
..#####.#.
#####...##
##.#...##.
.#.....##.
Tile 2857:
...##.####
##......##
#.#.#.#...
.#.###....
......#...
.........#
.#......##
.#.#.....#
#.#.#.....
..##.#.#..
Tile 3167:
.....#....
...###....
...##.....
.....#..##
..#.###..#
#..#....#.
..####....
.......#..
#...##..##
#...###...
Tile 2551:
.#.###....
#.##..#.#.
..###.#.#.
#..####.##
.......##.
..##.#....
.#..#....#
####....#.
#.##..###.
#....#.###
Tile 2707:
..###..#.#
.....#.###
#....#...#
##....##.#
...#..#.##
.##.#..##.
#...#.#.#.
#.....#..#
..##.##.#.
######.#.#
Tile 3607:
...#..#.#.
#.#..#..##
..##...#.#
##.#.....#
##...##...
#.#..#....
#........#
.#..##..##
####...###
##.#..####
Tile 2113:
....#.....
.....#...#
...#..#..#
##..#.#...
...##.....
#.##..#..#
.....#..##
#..#.#....
#.#.###...
.#.####..#
Tile 2371:
##.##...##
#.#......#
##.#......
#......#.#
....#....#
##...#.#.#
#...#...##
#....#...#
..#..#...#
......#..#
Tile 2741:
###..#####
#..#..##.#
##...##...
##........
...##...#.
.##.....#.
.#..#.#.#.
#.#......#
..##....##
.###......
Tile 3779:
..#.....#.
##.......#
..#.#.##.#
.###.#.##.
.#..####..
#####.#..#
...#.....#
#...#.....
.........#
.##...#.#.
Tile 1483:
##.#..##..
#.#....#.#
..........
....#.#..#
#...#....#
#....#...#
..##.#..#.
#..###.###
..##.#....
..#.##....
Tile 2927:
####.#####
.###......
#..##..#.#
##...#....
##.#..#...
.##.#.....
.#........
..........
#........#
.##....#..
Tile 2153:
#.#..#####
#..#...#..
#.......##
##..#.####
....##.#.#
#.#.##....
.#..##.#..
..#.##..#.
#.#####..#
...#.##.##
Tile 1453:
.....###..
...#......
.#.#..#..#
.#..#...##
.####..#..
...#..##..
....#.#.##
.##....##.
##......#.
.##.#...##
Tile 2423:
#..##.###.
##...##..#
#.........
.#...#..##
#.........
.....##...
#...#.....
.......#..
#....#....
..##...###
Tile 1933:
#.##.###.#
##....#...
#..##...#.
.......#..
##....#..#
....#..##.
#..#......
.#........
..#.#.....
##....###.
Tile 3191:
.#####.#.#
##.#.....#
....#...#.
##.#......
...#...##.
..#..#...#
#..#..#...
#..#......
..#.######
.###..#..#
================================================
FILE: advent-of-code/2020/inputs/21
================================================
vzkbf lxrsn mnj bjqfl brqg kcddk nkjc bgblpf xxhp cfb pzqgtb cggl cjhv vplz dlhfnjb jtfmtpd ccmvjbn jgrrd dvjxl tdrxvd vlqz pfbz txvctk kqvhbt qcmgxlj kgf znvmcx ldkt lshjmc nrlf rjf mcvc tzkfgq fpgmtjg srvfk nhhbtd mdtrqk hqxp bgxpfm ncx sckjj vqn npxrdnd xvsxb bcvlvk tflkk sjdmzj zmkx jpvvt vvlbp fqpt lmcqt khmm gfgbq plgvrz klnrvd xmcdn hrrt (contains dairy)
dvjxl sjpkc xdqx cfb jnmsr jzvjxf czcfdv zmvpzp srvfk tsch qqq qdhk pxf ttlvf jtfmtpd ndqk mrqgvd fqpt ctbvdq bgxpfm znvmcx sgczbl jpvvt zkjh kskbk mjzpgzs jxvc qvkdgn tdrxvd fzdltb csxkh mnj vbvbbh ldkt bcxxjq fpgmtjg nvxk hcrgt mqvf kqvhbt hnpd tmckpp lmcqt pzqgtb npxrdnd fdhfpn nbhhmfx dntsjl zbfqrn cmtvkq xmcdn xjsgl hrhzg zfrkt bxgzl zkfsg xzn zmmrgdf fkpjn dhz (contains shellfish, fish, nuts)
rxjq qdhk hlzkpt tsch xl tcff vmhhjm xjsgl pfbz xhxkf ftqpg ctnb zhvhng zmvpzp djmbx dptsqvq fkpjn pzqgtb lg kcddk ngrcb tflkk fsbll svvjknm khmm mjzpgzs jpvvt lkvdg mcvc gmsnc lmcqt npxrdnd xtnsbgc xkzsk vlqz cfgc dvzz qtpvndc qlrrrgb zkfsg mzlzxcc ltrhm mk zmmrgdf pfhsdp hqtzllj ldkt dqntj mqvf vtrchx slkjz hrhzg tmckpp lbdlb mdqdgf pnpg dscxjl sgczbl gscxfbd nfkzd mnj cjhv zmkx rrtkdz njjvq rjf xxhp bcxxjq lfvdf sqg dvjxl fqpt vjpnd gkkcjs flrjj bnfhd mmlq tsrqc nbhhmfx bgblpf ctbvdq xbrtdm srvfk cfb (contains nuts, peanuts)
kskbk qdhk cxbkg xpmx xskgz dvzz xdqx tsdcm pgcxql fkpjn rxjq bcxxjq mdh ngrcb sqg zmkx mdtrqk nfqkt tzkfgq dntsjl jzvjxf dmtcj dscxjl plgvrz npxrdnd jgrrd ftqpg hrrt zkjh dgbndg lmcqt fqpt kqvhbt hrhzg cfb qvkdgn flrjj tsch mcvc xvsxb blnsd pxf zhvhng ldkt jtfmtpd sckjj zmmrgdf xkgpch vzkbf cmtvkq mzlzxcc sfmbms mk (contains soy, shellfish)
xvsbr cbdl lmcqt kqvhbt pxf ldkt kskbk zhvhng jzvjxf nfkzd mk fsjcf srvfk bqrsxn lkvdg cshq npxrdnd zfrkt vmhhjm znvmcx zpzzt slkjz ndqk fqpt qvkdgn ftqpg jnmsr cfb tsch lshjmc mnj xlqp hrrt mqqzg sqg kcddk mqvf xzn hqxp cmtvkq (contains peanuts, nuts)
lkvdg xhxkf fpgmtjg szfxqq lshjmc cggl jxvc xmcdn tdrxvd jgrrd vvlbp hrhzg lxrsn xtnsbgc mzlzxcc ftqpg kcddk jmvt dgbndg cvd tsch pgcxql fqpt plgvrz tmckpp mmlq jpvvt xxhp dntsjl bxgzl mmhmx cfb svvjknm fsjcf rzc jtfmtpd xzn pzqgtb vjpnd hndcnf xskgz qdhk mdqdgf npxrdnd flrjj zkfsg mqvf lmcqt ctbvdq znvmcx khmm nhhbtd zpzzt hrrt tzkfgq slkjz xl mk pgct mrqgvd njjvq zhvhng kskbk blnsd gxmk vtrchx hjkqqr qtpvndc klnrvd xqbtls bgxpfm (contains fish, dairy)
lmcqt vrl hmnln rjf ttlvf cfb cggl rxjq qpdd plgvrz mdh pfhsdp xpmx zhvhng dscxjl mrqgvd bxgzl mk lxrsn nrlf vvlbp fpgmtjg tsrqc dhz ccmvjbn npxrdnd ltrhm xvsxb sjpkc hcrgt cshq hlzkpt jpvvt xdqx xjsgl pzqgtb xhxkf tdrxvd hjkqqr fqpt tfnsz bcxxjq hclf ctbvdq mzlzxcc kgf gfgbq sckjj tflkk bgxpfm zkfsg vmhhjm qlrrrgb jnmsr qcmgxlj bcvlvk srvfk hrhzg jtfmtpd ngrcb jbmxr flrjj szfxqq csqrvk bggz ldkt mdtrqk sqg zfrkt slkjz tsch (contains sesame, soy)
cxbkg fsjcf vqn xzn sjdmzj qcmgxlj cfb mrqgvd bcvlvk bggz hrrt npxrdnd dntsjl lfvdf tsch cmtvkq xjsgl pxf kcddk vdqtgt dgbndg ldkt xhxkf dptsqvq gscxfbd tmckpp bxgzl znvmcx mmlq flrjj xpmx kgf mmhmx tdrxvd dvjxl fqpt plgvrz zmvpzp zmkx xskgz ltrhm lmcqt csxkh (contains eggs, soy)
srvfk tsch szfxqq lmcqt xjsgl mqvf mrqgvd dhz kcddk mmhmx fqpt vvlbp gscxfbd jfl cjhv zbfqrn cfb vplz pgct jxvc mdtrqk sgczbl pbkr nfkzd lxrsn gmsnc blnsd fpgmtjg mjzpgzs fsbll rzc xvsxb mnj lkvdg kqvhbt hjkqqr njjvq klnrvd bgxpfm kskbk nsdk tsdcm bnfhd lfvdf hndcnf fkpjn jzvjxf bqrsxn txvctk xmcdn ldkt tsrqc zkjh slkjz dptsqvq lbdlb jtfmtpd jnmsr bjqfl zpqh csqrvk dscxjl cbdl dqntj sqg rbkr mzlzxcc bvzs nvxk hrrt vlqz fdhfpn pfbz mxfgnv pzqgtb hqtzllj (contains shellfish, sesame, dairy)
xl hjkqqr fsbll mmhmx kcddk xkzsk kqvhbt jtfmtpd xlqp bgxpfm zmkx fpgmtjg fdhfpn zhvhng gxmk mjzpgzs tcff szfxqq mxfgnv rzc zmvpzp svvjknm sqg bcvlvk dqntj lfvdf jbmxr lmcqt pgt xjsgl tsdcm hnpd mnj vbvbbh plgvrz rxjq mdh mdtrqk tsch ldkt fqpt qpdd mqqzg vdqtgt jvxqc ccmvjbn hclf cfb ttlvf cxbkg vjpnd dmtcj vtrchx qqq nbh jmvt xskgz (contains sesame, peanuts)
fqpt pfhsdp fkpjn tsch dscxjl tdrxvd klnrvd mnj czcfdv kqvhbt mzlzxcc mxfgnv dvjxl rrtkdz cggl nfkzd pgct bnfhd bxgzl djmbx lkvdg bjqfl xlqp xhxkf nkjc csxkh sjpkc lmcqt vbvbbh cshq npxrdnd mk plgvrz ldkt rzc qqq dlhfnjb hrrt xqbtls mjzpgzs cfb bqrsxn jvxqc fpgmtjg dptsqvq rbkr mcvc lshjmc cxbkg bcxxjq nrlf pnpg zpqh vzkbf zkfsg mmlq ndqk nbhhmfx zkjh kcddk vmhhjm fzdltb ccmvjbn bvzs (contains dairy)
zmmrgdf zpzzt cmtvkq sgczbl jtfmtpd xskgz znvmcx hjkqqr vqn jpvvt mmlq hclf svvjknm pnpg lxrsn dmtcj vtrchx tmckpp lmcqt hmnln xdqx nhhbtd xqbtls gmsnc npxrdnd fqpt zkfsg brqg cxbkg mjzpgzs rbkr pfbz dptsqvq mnj vdqtgt kgf ldkt jxvc ftqpg zkjh hrhzg ttlvf kcddk jmvt cfb vbvbbh khmm xmcdn tcff mdtrqk fdhfpn srvfk (contains sesame)
qpdd vrl sgczbl qdhk cfb cxbkg bgblpf kcddk tsch hnpd bxgzl jzvjxf svvjknm rbkr xzn lshjmc zkjh xjsgl ftqpg fdhfpn hqtzllj sjdmzj ldkt cggl xskgz jxvc bcxxjq tflkk vqn jvxqc blnsd xdqx lg tsdcm ngrcb vzkbf jmvt jtfmtpd gfgbq xl fqpt csqrvk zmkx nsdk xlqp rjf mnj mzlzxcc plgvrz cvd jbmxr sqg cfgc bqrsxn mqqzg cjhv zpzzt vdqtgt jfl mmlq vlqz pgt xtnsbgc vjpnd gxmk dscxjl lmcqt lxrsn (contains dairy)
pnpg lmcqt nbh zpzzt dptsqvq tdrxvd mdqdgf ncx gmsnc sckjj klnrvd dscxjl znvmcx dvjxl bgxpfm vdqtgt hmnln jvxqc gxmk tsch ngrcb csxkh slkjz jmvt xkzsk prnjsm hqtzllj jtfmtpd fdhfpn cshq xjsgl jzvjxf kcddk jbmxr xdqx jpvvt cmtvkq fqpt cfb npxrdnd (contains nuts, sesame, soy)
flrjj zhvhng tsdcm xkzsk jtfmtpd mqqzg dntsjl npxrdnd tdrxvd znvmcx mzlzxcc vbvbbh gfgbq lbdlb mxfgnv khmm bcvlvk bjqfl zkfsg jzvjxf xvsbr hrhzg xkgpch czcfdv tsch pxf nhhbtd lmcqt rxjq njjvq kqvhbt cfb bgblpf tfnsz bggz csxkh kcddk fsbll gxmk zfrkt xxhp slkjz mmlq vtrchx ldkt dlhfnjb ftqpg (contains peanuts, fish, nuts)
tsrqc lmcqt czcfdv pfhsdp xl zpqh qdhk jtfmtpd vtrchx csqrvk xmcdn nfkzd tfnsz blnsd fsjcf bgxpfm klnrvd srvfk mnj jbmxr sckjj xjsgl mqvf mxfgnv mdtrqk nbh gkkcjs bjqfl mjzpgzs zfrkt svvjknm lg pnpg pzqgtb kcddk mdh gscxfbd xvsxb nhhbtd qcmgxlj tsch mzlzxcc cjhv xqbtls spkl cmtvkq qpdd xkgpch rzc xpmx bgblpf vvlbp gfgbq dscxjl tmckpp fqpt vplz vlqz cfb vmhhjm npxrdnd fpgmtjg vbvbbh gmsnc zkjh cxbkg cfgc ctnb znvmcx mcvc pgt txvctk (contains nuts, shellfish)
mrqgvd xvsbr cggl zmvpzp xxhp xbrtdm qqq bgxpfm cfb cfgc tsrqc kcddk mdqdgf bqrsxn bcvlvk bxgzl ldkt pgt lfvdf qlrrrgb jtfmtpd nvxk fqpt jxvc mmlq sjdmzj ngrcb zmmrgdf jbmxr pgct lg hnpd dscxjl npxrdnd jpvvt ndqk gkkcjs zfrkt bggz ncx bnfhd xskgz mnj dptsqvq hcrgt zkfsg sjpkc bjqfl pxf tflkk dvzz srvfk xmcdn fdhfpn mmhmx dlhfnjb ctnb vplz rzc nsdk xqbtls cvd jgrrd cbdl mdtrqk czcfdv mcvc bgblpf vqn pbkr lmcqt xhxkf (contains fish)
vzkbf dvjxl nrlf cbdl xskgz sfmbms mdqdgf cjhv szfxqq ldkt mmhmx mzlzxcc qvkdgn fqpt gmsnc mmlq kskbk tzkfgq djmbx pgcxql kgf sjdmzj xkzsk vjpnd slkjz pgct kcddk pnpg nfqkt sckjj xlqp xvsxb qlrrrgb vtrchx bjqfl tsch cmtvkq dgbndg spkl cfb vvlbp lmcqt bgxpfm dntsjl jpvvt ctbvdq nbhhmfx mxfgnv xqbtls xjsgl bqrsxn prnjsm cxbkg fsjcf jtfmtpd ccmvjbn xtnsbgc (contains sesame)
khmm xxhp prnjsm vvlbp tdrxvd mdh jvxqc jgrrd jnmsr bnfhd bqrsxn ldkt xpmx cfb jbmxr vlqz zpzzt npxrdnd mnj pgct tfnsz dqntj hjkqqr hrrt nsdk gfgbq dlhfnjb qlrrrgb jpvvt tsch mrqgvd kskbk rrtkdz qdhk fzdltb nfqkt hndcnf dptsqvq xvsbr fqpt xl lfvdf lmcqt jtfmtpd (contains shellfish, soy, dairy)
qpdd ldkt jfl vtrchx pbkr srvfk hmnln gkkcjs jtfmtpd djmbx fqpt cfb dhz vdqtgt hlzkpt zmvpzp tsch lg blnsd pgct qtpvndc ctbvdq mqvf flrjj vqn jzvjxf gxmk ccmvjbn jnmsr mdqdgf hclf cbdl vlqz hndcnf mxfgnv fsbll csxkh mmlq sqg dvjxl fzdltb gscxfbd npxrdnd lshjmc sckjj klnrvd nfqkt mqqzg dptsqvq nkjc xskgz tsdcm nvxk mjzpgzs lmcqt pxf dlhfnjb qvkdgn vplz szfxqq cshq kgf jbmxr mzlzxcc tmckpp zpqh (contains soy)
zhvhng xmcdn gscxfbd xxhp jnmsr svvjknm ctbvdq dptsqvq ldkt hcrgt rzc cggl hnpd djmbx lmcqt xl nfkzd jpvvt kcddk dntsjl xlqp fqpt mzlzxcc qcmgxlj pzqgtb sgczbl vmhhjm nvxk tsdcm dmtcj vqn zkjh srvfk xtnsbgc jgrrd pxf vjpnd tsch sckjj ncx fkpjn cfgc lfvdf plgvrz kskbk cfb pfbz cshq ndqk bcvlvk khmm brqg sjpkc ccmvjbn cbdl lbdlb vplz nhhbtd jtfmtpd sqg (contains soy)
hrhzg xvsbr rjf pfhsdp dvzz fsjcf klnrvd slkjz mxfgnv tsch rrtkdz rzc cfb srvfk pxf vvlbp pnpg mdqdgf lbdlb tcff hqtzllj jtfmtpd brqg mmhmx fqpt sfmbms xkzsk dptsqvq nrlf ldkt pgcxql vzkbf vjpnd znvmcx pbkr npxrdnd nkjc ltrhm cxbkg vplz lmcqt jvxqc prnjsm tmckpp pzqgtb jnmsr bgblpf vtrchx mqqzg pgct zfrkt svvjknm nvxk cbdl dgbndg ctbvdq rxjq mdtrqk nsdk hclf szfxqq nbh xlqp fkpjn dhz gxmk hjkqqr hndcnf tfnsz xkgpch mnj zmvpzp sqg zhvhng (contains soy)
fkpjn ttlvf vlqz dscxjl dvzz vjpnd sqg srvfk qdhk gscxfbd xzn njjvq ldkt vmhhjm xskgz svvjknm xkgpch brqg hjkqqr mdtrqk sgczbl gfgbq pfbz nbh qqq xvsxb hclf lmcqt kqvhbt npxrdnd zbfqrn fqpt dqntj qcmgxlj pgct zmkx fdhfpn szfxqq ltrhm lg hqtzllj vdqtgt jvxqc hcrgt sckjj jtfmtpd zpqh kcddk fsbll zpzzt djmbx vplz cfb pnpg (contains nuts)
hqxp lshjmc rrtkdz nvxk pfhsdp tcff jmvt mqqzg qdhk vdqtgt bqrsxn bxgzl mqvf kskbk qcmgxlj jvxqc nfqkt gmsnc hjkqqr qpdd ttlvf mdtrqk mmhmx ctbvdq vvlbp bggz hmnln xpmx lmcqt npxrdnd cggl prnjsm fqpt nkjc pgcxql qvkdgn xhxkf ftqpg gkkcjs mmlq sqg rjf cxbkg dqntj cvd zmvpzp slkjz pxf dscxjl tsch xtnsbgc jtfmtpd cbdl kqvhbt zfrkt fzdltb klnrvd bvzs sjpkc kcddk ldkt hcrgt zpqh sjdmzj nbh qlrrrgb dvzz vmhhjm txvctk tdrxvd vbvbbh vzkbf zhvhng zpzzt vqn fsjcf svvjknm xvsbr qtpvndc xl lkvdg nfkzd bgxpfm bcxxjq znvmcx (contains sesame)
jtfmtpd blnsd mmlq fkpjn pgt ldkt xzn tsch mcvc jzvjxf jfl cxbkg tzkfgq vqn klnrvd nhhbtd xdqx fqpt jvxqc sckjj vrl bggz xvsbr hlzkpt vlqz jbmxr bgblpf bcvlvk rbkr jgrrd bjqfl jnmsr ctnb nvxk vvlbp lmcqt cfb djmbx lkvdg zmkx sqg qcmgxlj mqvf svvjknm xqbtls hmnln nrlf lxrsn dhz zhvhng pfbz rrtkdz npxrdnd znvmcx qpdd txvctk jmvt gfgbq tsrqc bgxpfm bqrsxn ftqpg ccmvjbn gscxfbd dptsqvq xkgpch pbkr cvd xtnsbgc xlqp (contains shellfish, soy, peanuts)
mcvc dgbndg vzkbf dptsqvq gscxfbd jzvjxf vtrchx lfvdf vplz ltrhm pbkr jtfmtpd sgczbl spkl khmm dntsjl mxfgnv njjvq lkvdg cshq qcmgxlj ldkt vjpnd qlrrrgb jmvt dscxjl bnfhd tsch sjdmzj csxkh hndcnf nbh ccmvjbn kcddk djmbx nfqkt bgxpfm mqvf cfb mjzpgzs txvctk dlhfnjb mdtrqk cxbkg lmcqt mk bggz hqtzllj fqpt dqntj qvkdgn nfkzd cmtvkq hjkqqr mmlq rxjq (contains sesame, peanuts)
lg pxf jpvvt ndqk pzqgtb mmlq zmmrgdf sqg xlqp xvsbr lbdlb qcmgxlj gmsnc xpmx mqvf jtfmtpd pgt dvzz vvlbp sgczbl spkl lshjmc hrrt zkfsg szfxqq hclf qdhk bvzs npxrdnd dqntj bjqfl fqpt tcff ttlvf lmcqt hqtzllj xdqx nsdk ldkt ccmvjbn tsch ftqpg tzkfgq kcddk hrhzg rbkr (contains soy, eggs, dairy)
tfnsz bcvlvk mjzpgzs prnjsm tsch xkzsk vzkbf lmcqt mqvf dvzz cxbkg zhvhng npxrdnd vqn fsbll ttlvf hclf vmhhjm bcxxjq fpgmtjg tcff mmlq plgvrz hrrt qcmgxlj kcddk vplz ctnb pgct mk mxfgnv pxf qpdd nrlf jnmsr rbkr dptsqvq rrtkdz jtfmtpd ldkt srvfk xpmx lfvdf bxgzl ctbvdq xjsgl gfgbq slkjz xskgz mqqzg cmtvkq nhhbtd nsdk mdtrqk cfb sfmbms hjkqqr jzvjxf pgt qlrrrgb xlqp ftqpg tdrxvd hqtzllj (contains dairy, shellfish)
mrqgvd rxjq cmtvkq xzn fqpt mjzpgzs mqqzg xdqx kqvhbt pfbz tdrxvd lmcqt mcvc ftqpg mdh szfxqq tsch nrlf npxrdnd ndqk slkjz jtfmtpd cfb hlzkpt prnjsm cjhv vtrchx lbdlb sckjj sjdmzj gxmk nbhhmfx dgbndg gkkcjs lxrsn dscxjl dntsjl bnfhd zpqh ldkt pgt cbdl (contains fish)
jvxqc nbhhmfx jbmxr hclf nfqkt ctbvdq gxmk ctnb brqg fzdltb bnfhd dscxjl blnsd jtfmtpd flrjj bcxxjq bgblpf csxkh gfgbq fpgmtjg fdhfpn mcvc rjf zpzzt nbh vjpnd ldkt fqpt rbkr mnj pbkr vvlbp tmckpp xzn zkfsg cfb tsrqc lmcqt kcddk xvsbr ndqk sckjj djmbx vlqz lfvdf lxrsn tsch (contains dairy, soy)
jfl qvkdgn nkjc mcvc ltrhm nhhbtd cjhv nfqkt znvmcx zmvpzp fdhfpn dlhfnjb hndcnf dvjxl pxf bnfhd vbvbbh mjzpgzs xbrtdm cfb lbdlb plgvrz hclf lfvdf pgt hrhzg hjkqqr dscxjl jxvc tcff lmcqt mzlzxcc slkjz rxjq dntsjl bggz fzdltb svvjknm xtnsbgc vqn szfxqq pzqgtb rjf zmkx xlqp khmm tsch ngrcb nbhhmfx zkjh mmhmx blnsd lxrsn jtfmtpd kcddk zkfsg tzkfgq sfmbms mdqdgf ldkt czcfdv kqvhbt nvxk fsbll pnpg hqxp fqpt rbkr vlqz (contains nuts, dairy)
tfnsz mjzpgzs zbfqrn mxfgnv nrlf ncx ccmvjbn qqq rbkr prnjsm xskgz jtfmtpd kqvhbt fqpt zhvhng zpqh pgct lmcqt ltrhm hrrt pgcxql hcrgt nfkzd qdhk ndqk mrqgvd xvsbr xjsgl ldkt tmckpp fkpjn npxrdnd xxhp cggl jzvjxf qvkdgn cvd vjpnd qtpvndc xdqx mdtrqk kcddk dptsqvq fsjcf cfb gxmk xbrtdm flrjj dntsjl (contains fish, shellfish, nuts)
sfmbms mjzpgzs mcvc hcrgt xxhp kcddk zmkx ldkt mdh npxrdnd cfb tdrxvd tzkfgq nbhhmfx vvlbp vtrchx jfl xzn rrtkdz zkjh dntsjl hmnln fsjcf rbkr tmckpp qlrrrgb xjsgl mdqdgf lfvdf jgrrd mmhmx hrhzg gkkcjs jxvc pzqgtb vjpnd lg dlhfnjb fkpjn pgcxql mrqgvd tsch vbvbbh bcvlvk tsrqc vmhhjm lmcqt jtfmtpd flrjj sckjj kgf zfrkt nhhbtd kqvhbt (contains eggs)
zhvhng xskgz vlqz qcmgxlj npxrdnd cxbkg xvsbr bcvlvk xkzsk jmvt ftqpg jfl nrlf fkpjn sqg cshq lxrsn dptsqvq rrtkdz lg bjqfl mnj dqntj xzn jtfmtpd bvzs gmsnc cvd svvjknm fdhfpn cbdl bggz ndqk lshjmc dntsjl nhhbtd sjdmzj pfhsdp tsch xmcdn zmkx cfb xkgpch mrqgvd szfxqq lmcqt fqpt kgf qdhk kcddk jpvvt pnpg jgrrd dscxjl jvxqc nkjc vtrchx pzqgtb fzdltb jzvjxf (contains soy, dairy, sesame)
bjqfl jmvt vrl blnsd jxvc bgxpfm sjpkc tflkk mjzpgzs fsbll vjpnd czcfdv lfvdf ncx mmhmx ctbvdq vdqtgt jpvvt hjkqqr txvctk lg ccmvjbn rzc mk dvzz xbrtdm tzkfgq vvlbp flrjj nfqkt ldkt jnmsr kcddk zpzzt lkvdg xl mqvf hrhzg vtrchx cfgc pgt xlqp xskgz dvjxl nkjc mxfgnv mcvc hqxp xpmx tmckpp pxf nfkzd cggl kqvhbt kgf fdhfpn plgvrz zhvhng jbmxr qcmgxlj fqpt bcxxjq jtfmtpd lmcqt csqrvk fsjcf tsch brqg mdqdgf fkpjn nbh srvfk hndcnf cfb mnj lbdlb mzlzxcc xmcdn qpdd hnpd hclf xzn svvjknm dptsqvq (contains soy, nuts, peanuts)
nrlf zfrkt pfbz dhz bcxxjq bxgzl dgbndg vplz jtfmtpd cggl spkl ftqpg ncx cjhv npxrdnd hrrt khmm sqg djmbx sjdmzj cshq lmcqt lshjmc fzdltb hjkqqr njjvq lbdlb nbhhmfx ttlvf zpqh tfnsz fqpt qqq kcddk gxmk qlrrrgb prnjsm xmcdn tzkfgq dmtcj txvctk mdh rzc pgct ldkt ctbvdq kskbk hnpd zbfqrn vlqz tdrxvd cfb (contains peanuts, eggs)
sjdmzj dgbndg cfb tdrxvd hnpd dntsjl xskgz pfbz fpgmtjg mmhmx tzkfgq lmcqt ngrcb xvsxb npxrdnd khmm mdtrqk sgczbl hcrgt tsrqc sfmbms fdhfpn xjsgl kcddk nbhhmfx ccmvjbn hjkqqr xmcdn pbkr szfxqq mnj hqxp rzc zpqh hrrt xqbtls jtfmtpd gscxfbd fkpjn mzlzxcc dqntj ldkt mk fqpt pzqgtb gfgbq xkgpch qvkdgn rjf nfqkt bvzs hclf dhz dptsqvq (contains eggs, fish, peanuts)
xmcdn kcddk lg zbfqrn tzkfgq pxf qtpvndc ldkt rxjq fqpt flrjj jfl sjdmzj rzc nvxk lxrsn vvlbp zmvpzp tsch zhvhng ngrcb cfb blnsd bqrsxn djmbx jnmsr cfgc hqxp mmhmx mk mxfgnv njjvq jxvc xkgpch ncx tsdcm fsjcf fpgmtjg cvd klnrvd jpvvt nkjc xvsxb tmckpp pfbz dvjxl ctnb nhhbtd rrtkdz mdtrqk prnjsm zmkx nbh tcff czcfdv tdrxvd xxhp lmcqt vtrchx cxbkg zfrkt slkjz xl mjzpgzs dvzz cmtvkq jtfmtpd xpmx xdqx vzkbf (contains shellfish, soy, nuts)
hrrt dlhfnjb dntsjl xjsgl hclf rzc rxjq djmbx mzlzxcc jnmsr mjzpgzs xvsbr xvsxb ttlvf zbfqrn mmhmx fdhfpn lmcqt tflkk rbkr npxrdnd jgrrd fpgmtjg mdtrqk vplz sfmbms hmnln bgblpf qvkdgn lbdlb bqrsxn cfb lfvdf cxbkg hcrgt hnpd ngrcb cggl ndqk kcddk xkgpch jbmxr dgbndg fkpjn nbhhmfx tmckpp bcvlvk hndcnf qdhk cjhv slkjz tsch zhvhng qtpvndc blnsd ccmvjbn xskgz nrlf hlzkpt dqntj fqpt ldkt bnfhd vrl sjpkc pbkr (contains sesame, peanuts, dairy)
================================================
FILE: advent-of-code/2020/inputs/22
================================================
Player 1:
6
25
8
24
30
46
42
32
27
48
5
2
14
28
37
17
9
22
40
33
3
50
47
19
41
Player 2:
1
18
31
39
16
10
35
29
26
44
21
7
45
4
20
38
15
11
34
36
49
13
23
43
12
================================================
FILE: advent-of-code/2020/inputs/24
================================================
neswsewswseswseenwseneswseswswswseswse
nwnenwwnwnwneswnenweswnwnwnwnenwswnese
wnewwwwwwwwswwwsewnwwswnee
wseeeeeeesesenesenweseseeseesw
nenenenwneenwnenenwnwswnenwseswsenwenw
sesenwsesesenweseeseseesesesesenwsesesw
sesesewseswsewesenwneseswswwsesesesenese
ewnenenenenewwneeneneneneseneenew
eswswswwseswswsesese
ewnwnwnwnwnwnwwswwwnwnwew
swswswswswesewswswsweeswswswneswwsww
nwwwesesewnwwwnewwwwwwenwsew
wnesenwneeneneswnesenewnenwnesenwnenw
swseswweseswswswswswseewse
nenewnwsenwnwnenwnwnwnwnwnwnwnw
neneneswnwnwnenenwwsenenenenenenenwsenenw
eeseeeeneneseenwseeweseeeeswe
seneswesesesesewsw
swswwsweswseneswswswseswnweswsesenwwswsw
swnwnwsenwwnwnwnwwenwnwwnwwwnwnenw
sesewseseseseseesesenwse
neneneneenenenwneswneenene
swswswewswnwsewswswseswseswswseswswswne
nenwnwnewneeenenwswneneneseneswneesw
neswwseswnwswswsesewesenwnwswsenewe
neeneneenesenwneswnenenwnwwnwnenesenesw
seseswswswneswswswswnwswneswsewseseesw
wnwwseswnwenewenwnweewswswswsenw
eswwenweseewesenw
swsewneenewnwseseweeswneeseneew
eeeeeseenweeee
eseswenwwseseseese
sesesesenesesesesewseesewseneeweesese
wwnwnwnwnwesenwnwwnwwsw
eeswnwnweesweeenwsewswswenewnesw
swswswswswswnweswswswsweswnwswswswneswsw
wwnwwnwnwwnwnwenwsenwsewwnwswnwnenw
seseeseseseseswneswsenwsenwsesesesesw
enwnwwnwnwsweneseswsenwwenwnwnwenw
seeenenwewweseseseswseewenesesee
weswswwswwswwswwswwnwswseneswwwnw
eeeeneseeneeeswneenweneneeewnesw
nwwswswnweswswwwesewswswswwsw
seeseneswneswswnwenwenwnwwneseswneee
neneneseneneswneenenenenwnenene
enenenewneswenesenwneneseneenenewne
senwseseseesweseesenwnesesesesesenesesew
seesesesewsewnweseeeeneeseseeese
wneseswenwswnenwnwwswseseswneesenew
nesenwswwnwwseewnewwwsewwnwwsw
seseeswswneswneesewnwnwenesewse
wswnwswswwwweswswswwsw
eeeeweeseeneee
swnwswnwseeeswenwnweswnwswswsewswswswne
nenesenwnweenwneeneswneneeneeneeswnesw
senenenwwnweneswnwnwwnwnwnwenwnwnenenwne
swewseeneswneweneeneeeswnwneneeee
nenwwwswwnesweewwseswswswswewwew
sesesewnwseneseswsenesesesenesewesesesese
nwnenenwwnwwswsewswewswnwseeeew
nwwweeseneeesweeeeeewew
wwnwwwewwwwnwsewwwsew
neewnwnwnwswswnwnwnwswnwnwnwnwnwnenwnw
eeeeenweeseeswseeeseesweneew
wwwseswswswnewwwswwseneswswswsww
nenesweneweeswswwnewnwnenweenee
nwwwswwwwsenwwwnwwwwwenwsenww
nwnwnwewnwnwwseenwnwseneenwwnwnwnwse
wnwnwsewnwnwsenenw
wwesewnwswenwswseenwneswswseswnwwww
nwnwsewwwwwswwenwnwwnewsewwewnw
wnewsenwsewseneseseeseseseseseneesee
neneneneneeneswneswswnenenenenenenenwnw
enwnwnwsenewnenenwnwnwnwewnwnwwnenw
wwwseneseswseeneesenesenewseswenwsw
newneeneneneswnenwneneeseneneenenee
neeswnwswswnewwnwewwswnwseewseswe
seseesesewsesenwweweswesese
wsewnwswswswswswswswnwseswswseeneneswwsw
senewneseswseseswswenesenwswswswswswswsesw
wswneswwwswswwwwswswneswseewwe
newwwwswwwwwwnwsewewwww
sesewsenewseneswwnewswswswseswnenene
nwneneneewnwswnenwnenwneseneenwneneswsenw
eweeesweseseneneseeeeeenwsee
wswenwenwswswseswsw
sweenweeseneenweeeene
nenwseneeeeseswnweeeeeswwneenee
wewnweswwwwswwsewswnewwwswwswsw
swseneeswwswwswwwswswswseswswswswne
wneneneneneswnwwneeenwneneneenwnenw
swnwnenwnwnwenwnenwnenwnwswnenwswnwenwnenw
nenwnenwwnwnwweswneseneseneneneswnwnwsw
weenwswnwnwwwnwnenwsenwnenw
seseseeneeswseseeseesewswswsewsenwnwne
nwwswwswwswwseswnewweseseswswwne
newwenwewnwnwnwswnwswwenwnwsewnwnw
seswneswswswwswswswnwswswesweeswswswnwsw
swswswseswswseneewsewwwneswwswneseswne
eenwseeeeneeeeeseewswseewe
wwwwwwwwwnesww
senwewenwseseeeeseswseseseeesee
neswnwnwnwwenwnwwwsewnenwnesesewswne
ewesweseneneeeseesewsewewsenwnenw
newwswwweswsweswwwswwwwwwwe
nweeenesweseneweenesewene
enenweseseneneswwneswewseswseeew
seneswsenwnenwseseswsenwseseseswsesesew
seswnenwwnwswnweeeweseswnwnweesw
wwnwwwwenwenwwnwwewnwnwnwnwnwsw
swswnwswnewswswswswwwswsweeswswnwswswsw
nenenenenenewenenenenenenesene
swseeseswneseswneswswseswswswwswnwneswsw
sewseneseseeeeseneew
nwenenwsweeswwnwnweenwswswswenwnww
eeeseseswsenwwweeswnesenwswswneww
nwnenenenenenenenenwneseneneswneneenwsene
seneseesweeeesee
eneswseeeseseswseeeewnweesewenee
wwsewswswswneswswswnew
neseeswneneswneneneenwnenwnew
eseseewsewewneseeenwenwesesese
nenenenenenewneneeneneenee
sewewsesenwwwseeneneswnenesesesenw
nenenwneswneswwneseswneenwnwneeswnwnwe
seeeenwseeseeseeeswneeneweewsee
nwenwswnwnwenwswnenwnwnwswnenwnewneenw
eswwnwneswswsenwwenenwseswseseesene
eesewswseseeenwwnweseewwnese
neneseneneswneneenewnwneneneswnwneneene
esesenwswesesewwnesenwewswswsenwswse
sesewnwnwwnenewnwwwswsewne
wnenwnwnwneenwnweswwnwswsenweswsesene
wnwneneseeesewsesenwnesw
esesenwnwswsewswnwseneeseseseesesenwse
swnwnweseeeeeeeeesenwsewnwsese
nwswnwswsweswseseseseswswswswswwneseeswsw
wneenwseewsenwsesesewneswsesweesee
wnewswwsenenwnwsewnwnwnwnenwnwsww
swewswnewwneswwnweeenweenenesene
sewneswseneseseswswswseseseseswneseswse
eeeenweeeneeseseewneeesweese
wnwneswswnwnwnenwsenenwsenwnenwnwnenesw
weneswnweneeneeesesweeneenenww
seswneseseseswsesesesese
neeeneneswneneweenenwnenwswneesene
swswswsewnwnwseseeswswswnwswswsweswnene
seseswseswwnenesese
nwneswwseneneneeewwseneneenwesww
wnwnenenenwsenwnwe
nwwenenwenwswsenwwwsewswwnenwnwesw
nwnesenwnwswsenwnwwnwwnenwwnewnwww
sweeenweeeeenwsweeeeeeswneee
eeseseswnwnweeeeneeseeesewnwee
seswsesewweneswseswnweswneswsewneswsw
wwwwsenewnwwwwwnesewswwneww
swwnwnwseseswewsenwswswewnw
wenwwnenwsweswnewsewswwsewnwweesw
seeseeneeeeswwenwseeeswseeeee
nenwneswnewseswnenenwsenewnenenenwsene
neneneneswenenenwwneeswneenenenenenene
enwnwnwnenwwsenenewnwnene
nenenwneswnwseeswnenwneseeneneeswnene
nenenesenwnewnwnwnesenwnenwnwnwwnwnene
wwwseseeneswseswnwsewswswseneeene
wwwseesesenwwwwwnwwnewwswsw
wwswswwnwnwesewseswwnweswnwseeww
neswnwswnwswenesewnew
wewsewnwnwnwnwnwnenwnwwnwnwnw
swsesweswneswnwneneeswswwwswswswsesenw
wwweswwwswwwswswwswnw
seseswseswsweswnwseswswsweseswseseswnw
eswwneswswswneeswseswwwswswewene
swsewnwneswnwswswseeswsewnwseswnwseese
neweswswswswswsweseswnwnwnesenwswneswsew
nenenenenewneneneneneeneswnwwnenenee
newnwwsesenwseeseseseeeesweneseee
eneeeeeseeeeeswee
wswweneneseseswswseseneswswseswswwsw
ewnenwneeseneeneneneseeneneweneee
swwwswwenwnewswseneswswswswwwwsw
eeneesweenweeeeeneweeeesew
nwwsenwnwnenweseeweewsewsenewswnesw
nwwnwnwnwnwnwnwwenwnwnwnwnwnewswsenw
nwnenwnenwnenenweswnwnenwnwne
sesenenwenwnenweseneneeneneseenenew
seseeeeseeswenwse
seseseeenwseseeeewsweseesenwee
seseseseeseswnwsesweneseswsenwsesesesese
swwseswswseswswwwneswswwwswnesw
nwnwswwneeswnwnwwnwnwwsewnwwnwew
newneswseswwwswwwwnewwsenwwswswswse
nwwnwnwswenwnwwwnwnweswnwwewnwswnw
wwsewwwwwneewwwwswswnwweww
nwnwnwswnwnwnwnwnenwnwnwnwnwnw
nwnwnwnwwnwswswwewwnewwne
swwneeswwnwnenenenenenenenenenenenwnese
eeneeneeeweeeewnesenweeeesw
eseewwswwwnewwwnewwsewwwew
eswwsenenwsenewesesesewesesesenenwse
swswswswswswwwnwswseswsw
eeseenewswwnesewweneeeenweseese
wneseswswneswnwnewnewsenewnesewwsww
swsenwseneswneswswswswnwswseswwwswswwsw
nwnwnwsenwnwnwnwnwnwnwnwnwnwnwseswswnene
nwsweseeseseswsenwenwseenwsw
seswseneseswseswnwnwsewswe
swsweeenwnweneswe
enwwnwwnenwnwwewnwwwswsewnwnww
nwewwsweewswsweswnwewneswnw
wnenenwnenwnwwseneneneeneswnenesenene
enwwswesewesene
nenenwneneswnewenwnenenwswseenwwnwwsesw
senwnwseswswswswswseseswswsenwwswswswseee
eeeseeseeeewee
neeswnweenweeswnwswwenenwneswneeene
neseenenwseeeenwesweswwwswenenene
nwnwwnwnwswseneneswwnenwsenwnwnwewnwswne
sesesenwseseseseesenwseseswsesenwsesese
nwesewseswsesesese
wwswseswnwswwswnwsenesewsenwwwnene
swnwwnenenwnwnwnenwnwnenwnwsenwnwne
nenesenesenenenwneenenenwsesenwnesewnw
senwwwswwnwwnwwnwwnwwnewsewsew
eswnwswswwswswswwswsww
wneneseneewnenene
sewesweeeeeeseneweseseseneese
eeeseenwesweweewseenweee
sesesenesenwsesewseswsesweseswsenenwsw
eenwnwwswswneewswnwnwswwswenewne
senwnwenenewwnwnwwwesenwnwnwnwnwew
seewwseneswenweeeseseseseeeseenw
swwswswsenwswswwswneswwswwenwswnesesw
esenenwseeneenenenwenenewneeewnene
wwswseswsenwwwswnwswenewnewswsw
neeeeeeswenwseeneeneseeeenew
nwswswnwnwswsesewswswswneswnweseseseese
swseseewseseneeseseseeseneswsesenwe
swwswwnwneseneeswswseswswwnwswnenwew
seswsewseneneseseswwsesewseswseesenesw
swseswswseswswnweswswswesewwswswenw
wswnwnwsweneswenwnwsenewsenwwswnew
swewwwnwnwwwwwnwww
seeseseenesewseeeeeenesewneswesw
sewseseswseswswseswsesesesweswwne
nwnwwnwesewseswneswnwnwswnewwwneww
nenenewneenenenenenenewenenene
eeeesewswneeeseeeeeswwenwnene
esweenweeeeenee
swesesewswsenewsesese
seseswseswse
gitextract_j8jnmwhq/
├── .git-hooks/
│ ├── install-hooks
│ └── prepare-commit-msg
├── .gitignore
├── README
├── Rakefile
├── advent-of-code/
│ ├── 2020/
│ │ ├── 01.1.pl
│ │ ├── 01.2.pl
│ │ ├── 02.1.pl
│ │ ├── 02.2.pl
│ │ ├── 03.1.pl
│ │ ├── 03.2.pl
│ │ ├── 04.1.pl
│ │ ├── 04.2.pl
│ │ ├── 05.1.pl
│ │ ├── 05.2.pl
│ │ ├── 06.1.pl
│ │ ├── 06.2.pl
│ │ ├── 07.1.pl
│ │ ├── 07.2.pl
│ │ ├── 08.1.pl
│ │ ├── 08.2.pl
│ │ ├── 09.1.pl
│ │ ├── 09.2.pl
│ │ ├── 10.1.pl
│ │ ├── 10.2.pl
│ │ ├── 11.1.pl
│ │ ├── 11.2.pl
│ │ ├── 12.1.pl
│ │ ├── 12.2.pl
│ │ ├── 13.1.pl
│ │ ├── 13.2.pl
│ │ ├── 14.1.pl
│ │ ├── 14.2.pl
│ │ ├── 15.1.pl
│ │ ├── 15.2.pl
│ │ ├── 16.1.pl
│ │ ├── 16.2.pl
│ │ ├── 17.1.pl
│ │ ├── 17.2.pl
│ │ ├── 18.1.pl
│ │ ├── 18.2.pl
│ │ ├── 19.1.pl
│ │ ├── 19.2.pl
│ │ ├── 20.1.pl
│ │ ├── 20.2.pl
│ │ ├── 21.1.pl
│ │ ├── 21.2.pl
│ │ ├── 22.1.pl
│ │ ├── 22.2.pl
│ │ ├── 23.1.pl
│ │ ├── 23.2.pl
│ │ ├── 24.1.pl
│ │ ├── 24.2.pl
│ │ ├── 25.1.pl
│ │ ├── 25.2.pl
│ │ └── inputs/
│ │ ├── 1.1
│ │ ├── 10
│ │ ├── 11
│ │ ├── 12
│ │ ├── 13
│ │ ├── 14
│ │ ├── 16
│ │ ├── 17
│ │ ├── 18
│ │ ├── 19
│ │ ├── 2
│ │ ├── 20
│ │ ├── 21
│ │ ├── 22
│ │ ├── 24
│ │ ├── 3
│ │ ├── 3.sample
│ │ ├── 4
│ │ ├── 4.sample
│ │ ├── 5
│ │ ├── 6
│ │ ├── 7
│ │ ├── 8
│ │ └── 9
│ ├── 2021/
│ │ ├── .gitignore
│ │ ├── day01/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day02/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day03/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day04/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day05/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day06/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day07/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day08/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day09/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day10/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day11/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day12/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day13/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day14/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day15/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day16/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day17/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day18/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day19/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day20/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day21/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day22/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day23/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day24/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ ├── day25/
│ │ │ ├── Cargo.toml
│ │ │ └── src/
│ │ │ └── main.rs
│ │ └── inputs/
│ │ ├── 01
│ │ ├── 02
│ │ ├── 03
│ │ ├── 04
│ │ ├── 05
│ │ ├── 06
│ │ ├── 07
│ │ ├── 08
│ │ ├── 09
│ │ ├── 10
│ │ ├── 11
│ │ ├── 12
│ │ ├── 13
│ │ ├── 14
│ │ ├── 15
│ │ ├── 16
│ │ ├── 17
│ │ ├── 18
│ │ ├── 19
│ │ ├── 20
│ │ ├── 21
│ │ ├── 22
│ │ ├── 23
│ │ ├── 24
│ │ └── 25
│ └── 2022/
│ ├── .gitignore
│ ├── day01/
│ │ ├── day01.nimble
│ │ └── src/
│ │ └── day01.nim
│ ├── day02/
│ │ ├── day02.nimble
│ │ └── src/
│ │ └── day02.nim
│ ├── day03/
│ │ ├── day03.nimble
│ │ └── src/
│ │ └── day03.nim
│ ├── day04/
│ │ ├── day04.nimble
│ │ └── src/
│ │ └── day04.nim
│ ├── day05/
│ │ ├── day05.nimble
│ │ └── src/
│ │ └── day05.nim
│ ├── day06/
│ │ ├── day06.nimble
│ │ └── src/
│ │ └── day06.nim
│ ├── day07/
│ │ ├── day07.nimble
│ │ └── src/
│ │ └── day07.nim
│ ├── day08/
│ │ ├── day08.nimble
│ │ └── src/
│ │ └── day08.nim
│ ├── day09/
│ │ ├── day09.nimble
│ │ └── src/
│ │ └── day09.nim
│ ├── day10/
│ │ ├── day10.nimble
│ │ └── src/
│ │ └── day10.nim
│ ├── day11/
│ │ ├── day11.nimble
│ │ └── src/
│ │ └── day11.nim
│ ├── day12/
│ │ ├── day12.nimble
│ │ └── src/
│ │ └── day12.nim
│ ├── day13/
│ │ ├── day13.nimble
│ │ └── src/
│ │ └── day13.nim
│ ├── day14/
│ │ ├── day14.nimble
│ │ └── src/
│ │ └── day14.nim
│ ├── day15/
│ │ ├── day15.nimble
│ │ └── src/
│ │ └── day15.nim
│ ├── day16/
│ │ ├── day16.nimble
│ │ └── src/
│ │ └── day16.nim
│ ├── day17/
│ │ ├── day17.nimble
│ │ └── src/
│ │ └── day17.nim
│ ├── day18/
│ │ ├── day18.nimble
│ │ └── src/
│ │ └── day18.nim
│ ├── day19/
│ │ ├── day19.nimble
│ │ └── src/
│ │ └── day19.nim
│ ├── day20/
│ │ ├── day20.nimble
│ │ └── src/
│ │ └── day20.nim
│ └── inputs/
│ ├── 01
│ ├── 02
│ ├── 03
│ ├── 04
│ ├── 05
│ ├── 06
│ ├── 07
│ ├── 08
│ ├── 09
│ ├── 10
│ ├── 11
│ ├── 12
│ ├── 13
│ ├── 14
│ ├── 15
│ ├── 16
│ ├── 17
│ ├── 18
│ ├── 19
│ └── 20
├── git-hooks/
│ └── prepare-commit-msg
├── go/
│ └── gopl/
│ ├── .ruby-version
│ ├── 01/
│ │ ├── 01/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 02/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 03/
│ │ │ ├── echo.go
│ │ │ └── echo_test.go
│ │ ├── 04/
│ │ │ ├── dup.go
│ │ │ ├── dup_test.go
│ │ │ └── fixtures/
│ │ │ ├── first
│ │ │ ├── second
│ │ │ └── third
│ │ ├── 05/
│ │ │ └── lissajous.go
│ │ ├── 06/
│ │ │ └── lissajous.go
│ │ ├── 07/
│ │ │ └── fetch.go
│ │ ├── 08/
│ │ │ └── fetch.go
│ │ └── 09/
│ │ └── fetch.go
│ ├── Gemfile
│ ├── README.markdown
│ └── Thorfile
├── haskell/
│ ├── aryth/
│ │ ├── Ast.hs
│ │ ├── Interpreter.hs
│ │ ├── Parser.hs
│ │ └── World.hs
│ ├── programming_haskell/
│ │ ├── Chapter01.hs
│ │ ├── Chapter04.hs
│ │ ├── Chapter05.hs
│ │ ├── Chapter06.hs
│ │ ├── Chapter07.hs
│ │ ├── Chapter09.hs
│ │ ├── Nim.hs
│ │ └── README
│ └── real_world_haskell/
│ ├── Find.hs
│ ├── Glob.hs
│ ├── PgmParser.hs
│ ├── PgmSimple.hs
│ ├── Traverse.hs
│ ├── json/
│ │ ├── Main.hs
│ │ ├── Prettify.hs
│ │ ├── PrettyJSON.hs
│ │ ├── PrettyStub.hs
│ │ ├── PutJSON.hs
│ │ ├── README
│ │ └── SimpleJSON.hs
│ └── sample/
│ └── foo.pgm
├── java/
│ └── tdd_by_example/
│ ├── Money.java
│ ├── MoneyTest.java
│ └── README
├── other/
│ ├── 7languages/
│ │ ├── erlang/
│ │ │ ├── day1/
│ │ │ │ ├── count_to_ten.erl
│ │ │ │ ├── result_of.erl
│ │ │ │ └── word_count.erl
│ │ │ └── day2/
│ │ │ ├── pseudo_dict.erl
│ │ │ ├── tictactoe.erl
│ │ │ └── total_price.erl
│ │ ├── io/
│ │ │ ├── day2/
│ │ │ │ ├── 1/
│ │ │ │ │ ├── loop.io
│ │ │ │ │ └── recursive.io
│ │ │ │ ├── 2.io
│ │ │ │ ├── 3.io
│ │ │ │ ├── 4.io
│ │ │ │ ├── 5.io
│ │ │ │ ├── 6.io
│ │ │ │ ├── 7.io
│ │ │ │ ├── 8.io
│ │ │ │ └── reflection.io
│ │ │ └── day3/
│ │ │ ├── 1.io
│ │ │ ├── 2.io
│ │ │ ├── 3.io
│ │ │ ├── 3.xml.io
│ │ │ ├── actors.io
│ │ │ ├── builder.io
│ │ │ ├── coroutine.io
│ │ │ ├── futures.io
│ │ │ └── phonebook.io
│ │ ├── prolog/
│ │ │ ├── day1/
│ │ │ │ ├── food.prolog
│ │ │ │ ├── friends.prolog
│ │ │ │ └── map.prolog
│ │ │ ├── day2/
│ │ │ │ ├── 2.1.prolog
│ │ │ │ ├── 2.2.2.prolog
│ │ │ │ ├── 2.2.prolog
│ │ │ │ ├── 2.3.prolog
│ │ │ │ ├── concatenate.prolog
│ │ │ │ ├── fibonacci.prolog
│ │ │ │ └── list_math.prolog
│ │ │ ├── day3/
│ │ │ │ ├── queens.prolog
│ │ │ │ └── sudoku.prolog
│ │ │ └── other/
│ │ │ └── einstein.prolog
│ │ └── scala/
│ │ ├── day1/
│ │ │ ├── 1.scala
│ │ │ └── 2.scala
│ │ ├── day2/
│ │ │ ├── 1.scala
│ │ │ ├── 2.scala
│ │ │ ├── 3.scala
│ │ │ └── censored_words.txt
│ │ └── day3/
│ │ └── sizer.scala
│ └── clrs/
│ ├── .gitignore
│ ├── .powrc
│ ├── .ruby-version
│ ├── .rvmrc
│ ├── 01/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ └── problems/
│ │ └── 01.markdown
│ ├── 02/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ ├── 01.c
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.c
│ │ ├── 01.run.py
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ └── 04.test.c
│ ├── 03/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ └── 08.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ └── 08.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.markdown
│ │ ├── 05.markdown
│ │ └── 06.markdown
│ ├── 04/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.run.c
│ │ │ ├── 03.test.c
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ └── 05.test.c
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.dot
│ │ │ ├── 02.markdown
│ │ │ ├── 03.dot
│ │ │ ├── 03.markdown
│ │ │ ├── 04.dot
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.dot
│ │ │ ├── 07.markdown
│ │ │ ├── 08.dot
│ │ │ ├── 08.markdown
│ │ │ ├── 09.dot
│ │ │ └── 09.markdown
│ │ ├── 05/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 06/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 04.markdown
│ │ ├── 05.markdown
│ │ ├── 05.py
│ │ ├── 05.test.py
│ │ ├── 06.c
│ │ ├── 06.markdown
│ │ └── 06.test.c
│ ├── 05/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ └── 02.markdown
│ ├── 06/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.dot
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ └── 03.markdown
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 05/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.dot
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.c
│ │ │ ├── 06.markdown
│ │ │ ├── 06.test.c
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.py
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.c
│ │ ├── 03.markdown
│ │ └── 03.test.c
│ ├── 07/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ └── 02.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.run.c
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ └── problems/
│ │ ├── 01.c
│ │ ├── 01.dot
│ │ ├── 01.markdown
│ │ ├── 01.test.c
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.markdown
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ ├── 04.test.c
│ │ ├── 05.markdown
│ │ ├── 06.c
│ │ ├── 06.markdown
│ │ └── 06.test.c
│ ├── 08/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.c
│ │ ├── 03.markdown
│ │ ├── 03.test.c
│ │ ├── 04.c
│ │ ├── 04.markdown
│ │ ├── 04.test.c
│ │ ├── 05.c
│ │ ├── 05.markdown
│ │ ├── 05.test.c
│ │ ├── 06.markdown
│ │ ├── 07.c
│ │ ├── 07.markdown
│ │ ├── 07.run.c
│ │ └── 07.test.c
│ ├── 09/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ └── 02.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 08.py
│ │ │ ├── 08.test.py
│ │ │ └── 09.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 10/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ ├── 06.markdown
│ │ │ ├── 07.c
│ │ │ ├── 07.markdown
│ │ │ ├── 07.test.c
│ │ │ ├── 08.c
│ │ │ ├── 08.markdown
│ │ │ └── 08.test.c
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ └── 05.test.c
│ │ ├── 04/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ └── 03.markdown
│ ├── 11/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.run.py
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ └── 05.run.py
│ │ ├── 05/
│ │ │ └── 01.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 12/
│ │ ├── 01/
│ │ │ ├── 01.dot
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.c
│ │ │ ├── 04.markdown
│ │ │ ├── 04.test.c
│ │ │ └── 05.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.c
│ │ │ ├── 02.markdown
│ │ │ ├── 02.test.c
│ │ │ ├── 03.c
│ │ │ ├── 03.markdown
│ │ │ ├── 03.test.c
│ │ │ ├── 04.dot
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 03/
│ │ │ ├── 01.c
│ │ │ ├── 01.markdown
│ │ │ ├── 01.test.c
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.c
│ │ │ ├── 05.debug.c
│ │ │ ├── 05.markdown
│ │ │ ├── 05.test.c
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 02.c
│ │ ├── 02.markdown
│ │ ├── 02.test.c
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── 13/
│ │ ├── 01/
│ │ │ ├── 01.draw.py
│ │ │ ├── 01.markdown
│ │ │ ├── 02.draw.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.draw.py
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.draw.py
│ │ │ └── 07.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ └── 05.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.draw.py
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.draw.py
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.draw.py
│ │ │ └── 07.markdown
│ │ ├── misc/
│ │ │ ├── red_black_tree.py
│ │ │ └── red_black_tree_test.py
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.test.py
│ │ ├── 02.markdown
│ │ ├── 03.markdown
│ │ ├── 03.py
│ │ ├── 03.test.py
│ │ ├── 04.markdown
│ │ ├── 04.py
│ │ └── 04.test.py
│ ├── 14/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 07.py
│ │ │ ├── 07.test.py
│ │ │ ├── 08.markdown
│ │ │ ├── 08.py
│ │ │ └── 08.test.py
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.test.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ └── 04.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.test.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ ├── 06.test.py
│ │ │ ├── 07.markdown
│ │ │ ├── 07.py
│ │ │ └── 07.test.py
│ │ ├── misc/
│ │ │ ├── augmentable_tree.py
│ │ │ ├── augmentable_tree_test.py
│ │ │ ├── interval_tree.py
│ │ │ ├── interval_tree_test.py
│ │ │ └── order_statistic_tree.py
│ │ └── problems/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.test.py
│ │ ├── 02.markdown
│ │ ├── 02.py
│ │ └── 02.test.py
│ ├── 15/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.dot
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ └── 05.test.py
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.run.py
│ │ │ ├── 05.markdown
│ │ │ └── 06.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 01.py
│ │ │ ├── 01.run.py
│ │ │ ├── 02.markdown
│ │ │ ├── 02.py
│ │ │ ├── 02.test.py
│ │ │ ├── 03.markdown
│ │ │ ├── 03.py
│ │ │ ├── 03.test.py
│ │ │ ├── 04.markdown
│ │ │ ├── 04.py
│ │ │ ├── 04.test.py
│ │ │ ├── 05.markdown
│ │ │ ├── 05.py
│ │ │ ├── 05.test.py
│ │ │ ├── 06.markdown
│ │ │ ├── 06.py
│ │ │ └── 06.test.py
│ │ └── 05/
│ │ ├── 01.markdown
│ │ ├── 01.py
│ │ ├── 01.run.py
│ │ ├── 02.markdown
│ │ ├── 02.py
│ │ ├── 02.run.py
│ │ ├── 03.markdown
│ │ └── 04.markdown
│ ├── C/
│ │ ├── 01/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ ├── 10.markdown
│ │ │ ├── 11.markdown
│ │ │ ├── 12.markdown
│ │ │ ├── 13.markdown
│ │ │ ├── 14.markdown
│ │ │ └── 15.markdown
│ │ ├── 02/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ └── 10.markdown
│ │ ├── 03/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ ├── 09.markdown
│ │ │ └── 10.markdown
│ │ ├── 04/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ ├── 07.markdown
│ │ │ ├── 08.markdown
│ │ │ └── 09.markdown
│ │ ├── 05/
│ │ │ ├── 01.markdown
│ │ │ ├── 02.markdown
│ │ │ ├── 03.markdown
│ │ │ ├── 04.markdown
│ │ │ ├── 05.markdown
│ │ │ ├── 06.markdown
│ │ │ └── 07.markdown
│ │ └── problems/
│ │ └── 01.markdown
│ ├── Gemfile
│ ├── Rakefile
│ ├── build/
│ │ ├── app.rb
│ │ ├── build.rb
│ │ ├── ext/
│ │ │ ├── debug_helpers.h
│ │ │ ├── drawing.py
│ │ │ └── test.h
│ │ ├── lib/
│ │ │ ├── catalog.rb
│ │ │ ├── chapter_number.rb
│ │ │ ├── exercise.rb
│ │ │ ├── generator.rb
│ │ │ ├── graph.rb
│ │ │ ├── problem.rb
│ │ │ ├── renderer.rb
│ │ │ ├── runtimes/
│ │ │ │ ├── c.rb
│ │ │ │ └── python.rb
│ │ │ ├── runtimes.rb
│ │ │ └── solution.rb
│ │ ├── public/
│ │ │ └── css/
│ │ │ └── clrs.scss
│ │ └── views/
│ │ ├── catalog.erb
│ │ ├── exercise.erb
│ │ ├── layout.erb
│ │ └── problem.erb
│ ├── config.ru
│ ├── notes/
│ │ ├── week-01.markdown
│ │ ├── week-02.markdown
│ │ ├── week-03.markdown
│ │ ├── week-04.markdown
│ │ ├── week-05.markdown
│ │ ├── week-06.markdown
│ │ ├── week-07.markdown
│ │ └── week-08.markdown
│ └── target/
│ └── .gitignore
├── ruby/
│ └── understanding-computation/
│ ├── .gitignore
│ ├── 03/
│ │ ├── 03.rb
│ │ ├── example.rb
│ │ ├── lib/
│ │ │ ├── dfa.rb
│ │ │ ├── dfa_design.rb
│ │ │ ├── dfa_rulebook.rb
│ │ │ ├── dot.rb
│ │ │ ├── fa_rule.rb
│ │ │ ├── grammar.treetop
│ │ │ ├── index.html
│ │ │ ├── nfa.rb
│ │ │ ├── nfa_design.rb
│ │ │ ├── nfa_rulebook.rb
│ │ │ ├── nfa_simulation.rb
│ │ │ └── pattern.rb
│ │ └── rulebooks.rb
│ ├── 04/
│ │ ├── 04.rb
│ │ ├── lib/
│ │ │ ├── dpda.rb
│ │ │ ├── dpda_design.rb
│ │ │ ├── dpda_rulebook.rb
│ │ │ ├── lexical_analyzer.rb
│ │ │ ├── npda.rb
│ │ │ ├── npda_design.rb
│ │ │ ├── npda_rulebook.rb
│ │ │ ├── pda_configuration.rb
│ │ │ ├── pda_rule.rb
│ │ │ ├── simple_parser.rb
│ │ │ └── stack.rb
│ │ └── rulebooks.rb
│ └── Rakefile
├── scala/
│ ├── expr/
│ │ ├── .gitignore
│ │ ├── README.markdown
│ │ ├── project/
│ │ │ ├── build/
│ │ │ │ └── Expressions.scala
│ │ │ └── build.properties
│ │ └── src/
│ │ ├── main/
│ │ │ └── scala/
│ │ │ └── expr/
│ │ │ ├── ActorEvaluation.scala
│ │ │ ├── BadInputException.scala
│ │ │ ├── Callable.scala
│ │ │ ├── Env.scala
│ │ │ ├── Evaluation.scala
│ │ │ ├── Expr.scala
│ │ │ ├── ExprException.scala
│ │ │ ├── Lambda.scala
│ │ │ ├── Parser.scala
│ │ │ ├── Printer.scala
│ │ │ ├── ScalaCode.scala
│ │ │ └── repl/
│ │ │ ├── Command.scala
│ │ │ ├── ConsoleShell.scala
│ │ │ ├── InteractiveInterpreter.scala
│ │ │ ├── JLineShell.scala
│ │ │ ├── REPL.scala
│ │ │ └── Shell.scala
│ │ └── test/
│ │ └── scala/
│ │ └── expr/
│ │ ├── EnvSpec.scala
│ │ ├── EvaluationSpec.scala
│ │ ├── ExprGen.scala
│ │ ├── ExpressionSpec.scala
│ │ ├── LambdaSpec.scala
│ │ ├── ParsingSpec.scala
│ │ ├── PrintingExpressionsSpec.scala
│ │ ├── PropertiesSpec.scala
│ │ ├── ScalaCodeSpec.scala
│ │ └── repl/
│ │ ├── CommandSpec.scala
│ │ ├── REPLSpec.scala
│ │ └── RecordingShell.scala
│ └── programming_in_scala/
│ ├── .gitignore
│ ├── README
│ ├── project/
│ │ ├── build/
│ │ │ └── ProgrammingInScala.scala
│ │ └── build.properties
│ └── src/
│ ├── main/
│ │ └── scala/
│ │ ├── actorsimulation/
│ │ │ ├── Adders.scala
│ │ │ ├── Circuit.scala
│ │ │ ├── Clock.scala
│ │ │ ├── Demo.scala
│ │ │ └── Simulant.scala
│ │ ├── arithmetic/
│ │ │ └── Expr.scala
│ │ ├── layout/
│ │ │ ├── Element.scala
│ │ │ └── Spiral.scala
│ │ └── simulation/
│ │ ├── BasicCircuitSimulation.scala
│ │ ├── CircuitSimulation.scala
│ │ ├── Simulation.scala
│ │ └── StairwayBookSimulation.scala
│ └── test/
│ └── scala/
│ ├── arithmetic/
│ │ ├── ExprFormatterSpec.scala
│ │ └── SimplificationSpec.scala
│ └── layout/
│ ├── CompositionSpec.scala
│ ├── FactoryMethodsSpec.scala
│ └── SpiralSpec.scala
├── scheme/
│ ├── eopl/
│ │ ├── .gitignore
│ │ ├── .ruby-version
│ │ ├── .rvmrc
│ │ ├── 01/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ ├── 32.scm
│ │ │ ├── 33.scm
│ │ │ ├── 34.scm
│ │ │ ├── 35.scm
│ │ │ ├── 36.scm
│ │ │ └── tests/
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 27-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 30-tests.scm
│ │ │ ├── 31-tests.scm
│ │ │ ├── 32-tests.scm
│ │ │ ├── 33-tests.scm
│ │ │ ├── 34-tests.scm
│ │ │ ├── 35-tests.scm
│ │ │ └── 36-tests.scm
│ │ ├── 02/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ └── tests/
│ │ │ ├── 01-tests.scm
│ │ │ ├── 03-tests.scm
│ │ │ ├── 05-tests.scm
│ │ │ ├── 06-tests.scm
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 10-tests.scm
│ │ │ ├── 11-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 14-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 30-tests.scm
│ │ │ └── 31-tests.scm
│ │ ├── 03/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ ├── 09.scm
│ │ │ ├── 10.scm
│ │ │ ├── 11.scm
│ │ │ ├── 12.scm
│ │ │ ├── 13.scm
│ │ │ ├── 14.scm
│ │ │ ├── 15.scm
│ │ │ ├── 16.scm
│ │ │ ├── 17.scm
│ │ │ ├── 18.scm
│ │ │ ├── 19.scm
│ │ │ ├── 20.scm
│ │ │ ├── 21.scm
│ │ │ ├── 22.scm
│ │ │ ├── 23.scm
│ │ │ ├── 24.scm
│ │ │ ├── 25.scm
│ │ │ ├── 26.scm
│ │ │ ├── 27.scm
│ │ │ ├── 28.scm
│ │ │ ├── 29.scm
│ │ │ ├── 30.scm
│ │ │ ├── 31.scm
│ │ │ ├── 32.scm
│ │ │ ├── 33.scm
│ │ │ ├── 34.scm
│ │ │ ├── 35.scm
│ │ │ ├── 36.scm
│ │ │ ├── 37.scm
│ │ │ ├── 38.scm
│ │ │ ├── 39.scm
│ │ │ ├── 40.scm
│ │ │ ├── 41.scm
│ │ │ ├── 42.scm
│ │ │ ├── 43.scm
│ │ │ ├── 44.scm
│ │ │ ├── cases/
│ │ │ │ ├── let/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ ├── letrec/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ ├── nameless/
│ │ │ │ │ ├── all.scm
│ │ │ │ │ ├── env.scm
│ │ │ │ │ ├── eval.scm
│ │ │ │ │ ├── parser.scm
│ │ │ │ │ ├── test-helpers.scm
│ │ │ │ │ └── tests.scm
│ │ │ │ └── proc/
│ │ │ │ ├── all.scm
│ │ │ │ ├── env.scm
│ │ │ │ ├── eval.scm
│ │ │ │ ├── parser.scm
│ │ │ │ ├── test-helpers.scm
│ │ │ │ └── tests.scm
│ │ │ └── tests/
│ │ │ ├── 06-tests.scm
│ │ │ ├── 07-tests.scm
│ │ │ ├── 08-tests.scm
│ │ │ ├── 09-tests.scm
│ │ │ ├── 10-tests.scm
│ │ │ ├── 11-tests.scm
│ │ │ ├── 12-tests.scm
│ │ │ ├── 13-tests.scm
│ │ │ ├── 14-tests.scm
│ │ │ ├── 15-tests.scm
│ │ │ ├── 16-tests.scm
│ │ │ ├── 17-tests.scm
│ │ │ ├── 18-tests.scm
│ │ │ ├── 19-tests.scm
│ │ │ ├── 20-tests.scm
│ │ │ ├── 21-tests.scm
│ │ │ ├── 22-tests.scm
│ │ │ ├── 23-tests.scm
│ │ │ ├── 24-tests.scm
│ │ │ ├── 25-tests.scm
│ │ │ ├── 26-tests.scm
│ │ │ ├── 27-tests.scm
│ │ │ ├── 28-tests.scm
│ │ │ ├── 29-tests.scm
│ │ │ ├── 31-tests.scm
│ │ │ ├── 32-tests.scm
│ │ │ ├── 33-tests.scm
│ │ │ ├── 34-tests.scm
│ │ │ ├── 35-tests.scm
│ │ │ ├── 36-tests.scm
│ │ │ ├── 37-tests.scm
│ │ │ ├── 38-tests.scm
│ │ │ ├── 39-tests.scm
│ │ │ ├── 40-tests.scm
│ │ │ ├── 41-tests.scm
│ │ │ ├── 42-tests.scm
│ │ │ ├── 43-tests.scm
│ │ │ ├── 44-tests.scm
│ │ │ └── helpers/
│ │ │ ├── let.scm
│ │ │ ├── letrec.scm
│ │ │ ├── nameless.scm
│ │ │ └── proc.scm
│ │ ├── 04/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ ├── 06.scm
│ │ │ ├── 07.scm
│ │ │ ├── 08.scm
│ │ │ └── cases/
│ │ │ └── explicit-refs/
│ │ │ ├── all.scm
│ │ │ ├── env.scm
│ │ │ ├── eval.scm
│ │ │ ├── parser.scm
│ │ │ ├── test-helpers.scm
│ │ │ └── tests.scm
│ │ ├── B/
│ │ │ ├── 01.scm
│ │ │ ├── 02.scm
│ │ │ ├── 03.scm
│ │ │ ├── 04.scm
│ │ │ ├── 05.scm
│ │ │ └── tests/
│ │ │ ├── 01-tests.scm
│ │ │ ├── 03-tests.scm
│ │ │ ├── 04-tests.scm
│ │ │ └── 05-tests.scm
│ │ ├── Gemfile
│ │ ├── Guardfile
│ │ ├── Thorfile
│ │ ├── build/
│ │ │ ├── exercise.rb
│ │ │ └── templates/
│ │ │ ├── exercise.scm
│ │ │ └── test.scm
│ │ ├── notes/
│ │ │ ├── week-01.markdown
│ │ │ ├── week-02.markdown
│ │ │ └── week-03.markdown
│ │ └── support/
│ │ └── eopl.scm
│ └── sicp/
│ ├── .gitignore
│ ├── 01/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ └── tests/
│ │ ├── 03-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 27-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ └── 46-tests.scm
│ ├── 02/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── 80.scm
│ │ ├── 81.scm
│ │ ├── 82.scm
│ │ ├── 83.scm
│ │ ├── 84.scm
│ │ ├── 85.scm
│ │ ├── 86.scm
│ │ ├── 87.scm
│ │ ├── 88.scm
│ │ ├── 89.scm
│ │ ├── 90.scm
│ │ ├── 91.scm
│ │ ├── 92.scm
│ │ ├── 93.scm
│ │ ├── 94.scm
│ │ ├── 95.scm
│ │ ├── 96.scm
│ │ ├── 97.scm
│ │ ├── showcase/
│ │ │ └── picturelang/
│ │ │ └── main.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 20-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 27-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 34-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ ├── 46-tests.scm
│ │ ├── 47-tests.scm
│ │ ├── 48-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 57-tests.scm
│ │ ├── 58-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 65-tests.scm
│ │ ├── 66-tests.scm
│ │ ├── 67-tests.scm
│ │ ├── 68-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 73-tests.scm
│ │ ├── 74-tests.scm
│ │ ├── 75-tests.scm
│ │ ├── 78-tests.scm
│ │ ├── 79-tests.scm
│ │ ├── 80-tests.scm
│ │ ├── 82-tests.scm
│ │ ├── 83-tests.scm
│ │ ├── 84-tests.scm
│ │ ├── 85-tests.scm
│ │ ├── 86-tests.scm
│ │ ├── 87-tests.scm
│ │ ├── 88-tests.scm
│ │ ├── 89-tests.scm
│ │ ├── 90-tests.scm
│ │ ├── 91-tests.scm
│ │ ├── 92-tests.scm
│ │ ├── 93-tests.scm
│ │ ├── 94-tests.scm
│ │ ├── 96-tests.scm
│ │ └── 97-tests.scm
│ ├── 03/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── 80.scm
│ │ ├── 81.scm
│ │ ├── 82.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 23-tests.scm
│ │ ├── 24-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 28-tests.scm
│ │ ├── 29-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 37-tests.scm
│ │ ├── 50-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 55-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 64-tests.scm
│ │ ├── 66-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 70-tests.scm
│ │ ├── 71-tests.scm
│ │ ├── 72-tests.scm
│ │ ├── 73-tests.scm
│ │ ├── 74-tests.scm
│ │ ├── 76-tests.scm
│ │ ├── 80-tests.scm
│ │ ├── 81-tests.scm
│ │ └── 82-tests.scm
│ ├── 04/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── 53.scm
│ │ ├── 54.scm
│ │ ├── 55.scm
│ │ ├── 56.scm
│ │ ├── 57.scm
│ │ ├── 58.scm
│ │ ├── 59.scm
│ │ ├── 60.scm
│ │ ├── 61.scm
│ │ ├── 62.scm
│ │ ├── 63.scm
│ │ ├── 64.scm
│ │ ├── 65.scm
│ │ ├── 66.scm
│ │ ├── 67.scm
│ │ ├── 68.scm
│ │ ├── 69.scm
│ │ ├── 70.scm
│ │ ├── 71.scm
│ │ ├── 72.scm
│ │ ├── 73.scm
│ │ ├── 74.scm
│ │ ├── 75.scm
│ │ ├── 76.scm
│ │ ├── 77.scm
│ │ ├── 78.scm
│ │ ├── 79.scm
│ │ ├── showcase/
│ │ │ ├── amb/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── analyzing/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── evaluator/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ ├── lazy/
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ └── tests.scm
│ │ │ └── query/
│ │ │ ├── database.scm
│ │ │ ├── evaluator.scm
│ │ │ ├── main.scm
│ │ │ ├── test-helpers.scm
│ │ │ └── tests.scm
│ │ └── tests/
│ │ ├── 01-tests.scm
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 05-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 07-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 09-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 13-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 20-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 31-tests.scm
│ │ ├── 33-tests.scm
│ │ ├── 34-tests.scm
│ │ ├── 35-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 45-tests.scm
│ │ ├── 48-tests.scm
│ │ ├── 49-tests.scm
│ │ ├── 51-tests.scm
│ │ ├── 52-tests.scm
│ │ ├── 53-tests.scm
│ │ ├── 54-tests.scm
│ │ ├── 55-tests.scm
│ │ ├── 56-tests.scm
│ │ ├── 57-tests.scm
│ │ ├── 58-tests.scm
│ │ ├── 59-tests.scm
│ │ ├── 60-tests.scm
│ │ ├── 61-tests.scm
│ │ ├── 62-tests.scm
│ │ ├── 63-tests.scm
│ │ ├── 67-tests.scm
│ │ ├── 68-tests.scm
│ │ ├── 69-tests.scm
│ │ ├── 75-tests.scm
│ │ ├── 76-tests.scm
│ │ ├── 77-tests.scm
│ │ ├── 78-tests.scm
│ │ ├── 79-tests.scm
│ │ └── helpers/
│ │ └── query.scm
│ ├── 05/
│ │ ├── 01.scm
│ │ ├── 02.scm
│ │ ├── 03.scm
│ │ ├── 04.scm
│ │ ├── 05.scm
│ │ ├── 06.scm
│ │ ├── 07.scm
│ │ ├── 08.scm
│ │ ├── 09.scm
│ │ ├── 10.scm
│ │ ├── 11.scm
│ │ ├── 12.scm
│ │ ├── 13.scm
│ │ ├── 14.scm
│ │ ├── 15.scm
│ │ ├── 16.scm
│ │ ├── 17.scm
│ │ ├── 18.scm
│ │ ├── 19.scm
│ │ ├── 20.scm
│ │ ├── 21.scm
│ │ ├── 22.scm
│ │ ├── 23.scm
│ │ ├── 24.scm
│ │ ├── 25.scm
│ │ ├── 26.scm
│ │ ├── 27.scm
│ │ ├── 28.scm
│ │ ├── 29.scm
│ │ ├── 30.scm
│ │ ├── 31.scm
│ │ ├── 32.scm
│ │ ├── 33.scm
│ │ ├── 34.scm
│ │ ├── 35.scm
│ │ ├── 36.scm
│ │ ├── 37.scm
│ │ ├── 38.scm
│ │ ├── 39.scm
│ │ ├── 40.scm
│ │ ├── 41.scm
│ │ ├── 42.scm
│ │ ├── 43.scm
│ │ ├── 44.scm
│ │ ├── 45.scm
│ │ ├── 46.scm
│ │ ├── 47.scm
│ │ ├── 48.scm
│ │ ├── 49.scm
│ │ ├── 50.scm
│ │ ├── 51.scm
│ │ ├── 52.scm
│ │ ├── showcase/
│ │ │ ├── compiler/
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── explicit-evaluator-text.scm
│ │ │ │ ├── helpers.scm
│ │ │ │ ├── main.scm
│ │ │ │ ├── operations.scm
│ │ │ │ ├── syntax.scm
│ │ │ │ └── tests.scm
│ │ │ ├── explicit/
│ │ │ │ ├── controller-text.scm
│ │ │ │ ├── evaluator.scm
│ │ │ │ ├── main.scm
│ │ │ │ ├── operations.scm
│ │ │ │ └── tests.scm
│ │ │ └── simulator/
│ │ │ ├── sample-machines.scm
│ │ │ ├── simulator.scm
│ │ │ └── tests.scm
│ │ ├── support/
│ │ │ ├── 51/
│ │ │ │ ├── evaluator.c
│ │ │ │ └── tests.scm
│ │ │ ├── 52/
│ │ │ │ ├── build.scm
│ │ │ │ ├── compiler.scm
│ │ │ │ ├── metacircular-evaluator.scm
│ │ │ │ ├── runtime.c
│ │ │ │ ├── syntax.scm
│ │ │ │ └── tests.scm
│ │ │ └── bin/
│ │ │ └── .gitignore
│ │ └── tests/
│ │ ├── 02-tests.scm
│ │ ├── 03-tests.scm
│ │ ├── 04-tests.scm
│ │ ├── 06-tests.scm
│ │ ├── 08-tests.scm
│ │ ├── 09-tests.scm
│ │ ├── 10-tests.scm
│ │ ├── 11-tests.scm
│ │ ├── 12-tests.scm
│ │ ├── 13-tests.scm
│ │ ├── 15-tests.scm
│ │ ├── 16-tests.scm
│ │ ├── 17-tests.scm
│ │ ├── 18-tests.scm
│ │ ├── 19-tests.scm
│ │ ├── 21-tests.scm
│ │ ├── 22-tests.scm
│ │ ├── 23-tests.scm
│ │ ├── 24-tests.scm
│ │ ├── 25-tests.scm
│ │ ├── 30-tests.scm
│ │ ├── 32-tests.scm
│ │ ├── 36-tests.scm
│ │ ├── 38-tests.scm
│ │ ├── 39-tests.scm
│ │ ├── 40-tests.scm
│ │ ├── 41-tests.scm
│ │ ├── 42-tests.scm
│ │ ├── 43-tests.scm
│ │ ├── 44-tests.scm
│ │ ├── 47-tests.scm
│ │ ├── 50-tests.scm
│ │ ├── 51-tests.scm
│ │ ├── 52-tests.scm
│ │ └── helpers/
│ │ ├── compiler.scm
│ │ ├── evaluator.scm
│ │ ├── memory.scm
│ │ ├── monitored-stack.scm
│ │ ├── sample-machines.scm
│ │ └── simulator.scm
│ ├── README.markdown
│ ├── Rakefile
│ ├── notes/
│ │ ├── week-01.markdown
│ │ ├── week-02.markdown
│ │ ├── week-03.markdown
│ │ ├── week-04.markdown
│ │ ├── week-05.markdown
│ │ ├── week-06.markdown
│ │ ├── week-07.markdown
│ │ ├── week-08.markdown
│ │ ├── week-09.markdown
│ │ ├── week-10.markdown
│ │ ├── week-11.markdown
│ │ ├── week-12.markdown
│ │ ├── week-13.markdown
│ │ ├── week-14.markdown
│ │ ├── week-15.markdown
│ │ ├── week-16.markdown
│ │ ├── week-17.markdown
│ │ ├── week-18.markdown
│ │ └── week-19.markdown
│ └── tests.watchr
└── textmate/
└── PLT Scheme.tmbundle/
├── README
├── Syntaxes/
│ └── Scheme.tmLanguage
└── info.plist
SYMBOL INDEX (2152 symbols across 254 files)
FILE: advent-of-code/2021/day01/src/main.rs
function main (line 3) | fn main() {
function numbers (line 8) | fn numbers() -> Vec<i64> {
function first (line 16) | fn first() -> usize {
function second (line 20) | fn second() -> usize {
FILE: advent-of-code/2021/day02/src/main.rs
type Direction (line 3) | enum Direction {
function main (line 11) | fn main() {
function directions (line 16) | fn directions() -> Vec<Direction> {
function first (line 33) | fn first() -> i64 {
function second (line 48) | fn second() -> i64 {
FILE: advent-of-code/2021/day03/src/main.rs
function main (line 3) | fn main() {
function input (line 8) | fn input() -> Vec<String> {
function ones (line 16) | fn ones(numbers: &Vec<String>) -> Vec<usize> {
function decimal (line 29) | fn decimal(digits: &Vec<usize>) -> usize {
function first (line 37) | fn first() -> usize {
function filter (line 50) | fn filter<F>(numbers: Vec<String>, position: usize, f: F) -> Vec<String>
function iterate (line 63) | fn iterate<F>(numbers: &Vec<String>, f: F) -> usize
function second (line 81) | fn second() -> usize {
FILE: advent-of-code/2021/day04/src/main.rs
type Cell (line 3) | struct Cell {
type Board (line 8) | struct Board {
method iter (line 14) | fn iter(&self) -> impl Iterator<Item=&Cell> {
method iter_mut (line 18) | fn iter_mut(&mut self) -> impl Iterator<Item=&mut Cell> {
method mark (line 22) | fn mark(&mut self, number: i64) {
method is_winning (line 28) | fn is_winning(&self) -> bool {
method unmarked_sum (line 33) | fn unmarked_sum(&self) -> i64 {
function parse_input (line 38) | fn parse_input() -> (Vec<i64>, Vec<Board>) {
function main (line 72) | fn main() {
FILE: advent-of-code/2021/day05/src/main.rs
type Point (line 5) | struct Point {
type Line (line 11) | struct Line {
method is_diagonal (line 49) | fn is_diagonal(&self) -> bool {
method points (line 53) | fn points(&self) -> Vec<Point> {
function parse_input (line 16) | fn parse_input() -> Vec<Line> {
function range (line 40) | fn range(a: i64, b: i64) -> Box<dyn Iterator<Item = i64>> {
function intersections (line 71) | fn intersections<'a>(lines: impl Iterator<Item = &'a Line>) -> usize {
function main (line 82) | fn main() {
FILE: advent-of-code/2021/day06/src/main.rs
function parse_input (line 3) | fn parse_input() -> Vec<usize> {
function iterate (line 8) | fn iterate(numbers: &[usize; 9], iterations: usize) -> usize {
function main (line 23) | fn main() {
FILE: advent-of-code/2021/day07/src/main.rs
function parse_input (line 3) | fn parse_input() -> Vec<i64> {
function main (line 11) | fn main() {
FILE: advent-of-code/2021/day08/src/main.rs
type InputLine (line 4) | struct InputLine {
function parse_input (line 9) | fn parse_input() -> Vec<InputLine> {
function bits (line 24) | fn bits(n: u8) -> u32 {
function bitset (line 28) | fn bitset<'a>(number: &'a str) -> u8 {
function consume (line 36) | fn consume<F>(patterns: &mut Vec<u8>, f: F) -> u8
function decrypt (line 43) | fn decrypt(line: &InputLine) -> usize {
function main (line 65) | fn main() {
FILE: advent-of-code/2021/day09/src/main.rs
function parse_input (line 3) | fn parse_input() -> Vec<Vec<u8>> {
function low_points (line 19) | fn low_points(map: &Vec<Vec<u8>>) -> Vec<(usize, usize)> {
function fill (line 40) | fn fill(map: &mut Vec<Vec<u8>>, point: (usize, usize)) -> usize {
function main (line 65) | fn main() {
FILE: advent-of-code/2021/day10/src/main.rs
function score (line 3) | fn score(input: &str) -> (usize, usize) {
function main (line 29) | fn main() {
FILE: advent-of-code/2021/day11/src/main.rs
type Board (line 3) | type Board = Vec<Vec<usize>>;
function advance (line 5) | fn advance(board: &mut Board, h: usize, w: usize) -> usize {
function first (line 40) | fn first(board: &Board, h: usize, w: usize) -> usize {
function second (line 51) | fn second(board: &Board, h: usize, w: usize) -> usize {
function main (line 66) | fn main() {
FILE: advent-of-code/2021/day12/src/main.rs
type Graph (line 3) | type Graph<'a> = HashMap<&'a str, Vec<&'a str>>;
function is_small (line 5) | fn is_small(cave: &str) -> bool {
function parse_input (line 9) | fn parse_input(text: &str) -> Graph {
function paths (line 24) | fn paths(graph: &Graph) -> (usize, usize) {
function main (line 59) | fn main() {
FILE: advent-of-code/2021/day13/src/main.rs
type Point (line 3) | type Point = (usize, usize);
type Fold (line 4) | type Fold = (char, usize);
function parse_input (line 6) | fn parse_input() -> (HashSet<Point>, Vec<Fold>) {
function fold (line 38) | fn fold(points: HashSet<Point>, fold: Fold) -> HashSet<Point> {
function draw (line 52) | fn draw(points: &HashSet<Point>) {
function main (line 68) | fn main() {
FILE: advent-of-code/2021/day14/src/main.rs
type Pair (line 3) | type Pair = (u8, u8);
type RuleSet (line 4) | type RuleSet = HashMap<Pair, u8>;
type Histogram (line 5) | type Histogram = HashMap<Pair, usize>;
function expand (line 7) | fn expand(pairs: Histogram, rules: &RuleSet) -> Histogram {
function parse_input (line 23) | fn parse_input() -> (String, RuleSet) {
function histogram (line 43) | fn histogram(polymer: &str) -> Histogram {
function solve (line 55) | fn solve(polymer: &str, rules: &RuleSet, iterations: usize) -> usize {
function main (line 78) | fn main() {
FILE: advent-of-code/2021/day15/src/main.rs
function parse_input (line 7) | fn parse_input() -> Vec<Vec<i64>> {
function adjancent (line 20) | fn adjancent(x: usize, y: usize, h: usize, w: usize) -> Vec<(usize, usiz...
function five_expand (line 39) | fn five_expand(grid: &Vec<Vec<i64>>) -> Vec<Vec<i64>> {
function lowest_risk (line 55) | fn lowest_risk(grid: &Vec<Vec<i64>>) -> i64 {
function main (line 81) | fn main() {
FILE: advent-of-code/2021/day16/src/main.rs
type Bit (line 21) | type Bit = u8;
type LiteralValue (line 22) | type LiteralValue = u64;
type Version (line 23) | type Version = u8;
type TypeId (line 24) | type TypeId = u8;
type Result (line 25) | type Result = i64;
type Packet (line 28) | enum Packet<T> {
function bits (line 33) | fn bits(char: u8) -> [Bit; 4] {
function read_number (line 50) | fn read_number<N, I>(stream: &mut I, size: usize) -> N
function read_literal (line 60) | fn read_literal<I>(stream: &mut I) -> LiteralValue
function read_packet (line 81) | fn read_packet<T>(mut stream: &mut dyn Iterator<Item = Bit>, eval: fn(Pa...
function eval (line 109) | fn eval(packet: Packet<Result>) -> Result {
function stream_input (line 125) | fn stream_input() -> impl Iterator<Item = Bit> {
function main (line 134) | fn main() {
FILE: advent-of-code/2021/day17/src/main.rs
function parse_input (line 3) | fn parse_input() -> (i64, i64, i64, i64) {
function main (line 17) | fn main() {
FILE: advent-of-code/2021/day18/src/main.rs
type Part (line 4) | enum Part {
type Snailfish (line 13) | type Snailfish = Vec<Part>;
function parse_number (line 15) | fn parse_number(text: &str) -> Snailfish {
function explode (line 27) | fn explode(snailfish: Snailfish) -> Snailfish {
function split (line 86) | fn split(snailfish: Snailfish) -> Snailfish {
function reduce (line 110) | fn reduce(snailfish: Snailfish) -> Snailfish {
function add (line 130) | fn add(mut first: Snailfish, mut second: Snailfish) -> Snailfish {
function magnitude (line 141) | fn magnitude(snailfish: &Snailfish) -> u64 {
function parse_input (line 166) | fn parse_input() -> Vec<Snailfish> {
function main (line 174) | fn main() {
FILE: advent-of-code/2021/day19/src/main.rs
type Number (line 7) | type Number = i16;
type Matrix (line 11) | struct Matrix([[Number; 4]; 4]);
method translate (line 90) | fn translate(point: Point) -> Matrix {
method rotations (line 99) | fn rotations() -> Vec<Matrix> {
type Point (line 15) | struct Point([Number; 4]);
method new (line 121) | fn new(x: Number, y: Number, z: Number) -> Point {
method manhattan (line 125) | fn manhattan(&self, other: &Point) -> Number {
type Variation (line 17) | struct Variation {
type Scanner (line 22) | struct Scanner {
type Beacons (line 28) | type Beacons = Vec<Point>;
type Output (line 31) | type Output = Point;
function sub (line 33) | fn sub(self, rhs: &Point) -> Self::Output {
type Output (line 44) | type Output = Matrix;
function mul (line 46) | fn mul(self, rhs: &Matrix) -> Self::Output {
type Output (line 62) | type Output = Point;
function mul (line 64) | fn mul(self, rhs: &Point) -> Self::Output {
function parse_input (line 130) | fn parse_input() -> Vec<Beacons> {
function overlap_transformation (line 148) | fn overlap_transformation(first: &Scanner, second: &Scanner) -> Option<M...
function prepare_scanners (line 170) | fn prepare_scanners() -> Vec<Scanner> {
function merge (line 200) | fn merge(scanners: &mut Vec<Scanner>) {
function main (line 225) | fn main() {
FILE: advent-of-code/2021/day20/src/main.rs
type Number (line 3) | type Number = i32;
type Point (line 4) | type Point = (Number, Number);
function parse_input (line 6) | fn parse_input() -> (String, HashSet<Point>) {
function iterate (line 26) | fn iterate(points: &HashSet<Point>, decoder: &String, mode: bool) -> Has...
function main (line 68) | fn main() {
FILE: advent-of-code/2021/day21/src/main.rs
type Game (line 4) | struct Game {
method from (line 11) | fn from(positions: (u16, u16)) -> Game {
method is_finished (line 18) | fn is_finished(&self, winning_score: u16) -> bool {
method leader (line 22) | fn leader(&self) -> usize {
method play (line 30) | fn play(&self, roll: u16) -> Game {
function parse_input (line 44) | fn parse_input() -> (u16, u16) {
function increment_position (line 53) | fn increment_position(position: u16, count: u16) -> u16 {
function first (line 57) | fn first(positions: (u16, u16)) -> u64 {
function second (line 76) | fn second(positions: (u16, u16)) -> u64 {
function main (line 111) | fn main() {
FILE: advent-of-code/2021/day22/src/main.rs
type Num (line 3) | type Num = i64;
type Interval (line 6) | struct Interval {
method new (line 12) | fn new(from: Num, to: Num) -> Interval {
method truncate (line 19) | fn truncate(&self, other: &Interval) -> Interval {
method overlaps (line 23) | fn overlaps(&self, other: &Interval) -> bool {
method len (line 27) | fn len(&self) -> Num {
method split (line 31) | fn split(a: &Interval, b: &Interval) -> [Interval; 3] {
type Cuboid (line 43) | struct Cuboid {
method truncate (line 50) | fn truncate(&self, interval: Interval) -> Cuboid {
method overlaps (line 58) | fn overlaps(&self, other: &Cuboid) -> bool {
method subtract (line 62) | fn subtract(&self, other: &Cuboid) -> Vec<Cuboid> {
method volume (line 84) | fn volume(&self) -> Num {
function parse_input (line 89) | fn parse_input() -> Vec<(Cuboid, bool)> {
function solve (line 120) | fn solve(input: Vec<(Cuboid, bool)>) -> Num {
function main (line 137) | fn main() {
FILE: advent-of-code/2021/day23/src/main.rs
type Cost (line 5) | type Cost = i32;
type Point (line 6) | type Point = (usize, usize);
type Game (line 9) | struct Game {
method all_moves (line 58) | fn all_moves(&self) -> Vec<(Game, Cost)> {
method possible_moves (line 78) | fn possible_moves(&self, point: Point) -> Vec<Point> {
method at (line 106) | fn at(&self, point: Point) -> &u8 {
method at_mut (line 110) | fn at_mut(&mut self, point: Point) -> &mut u8 {
method room_slot (line 114) | fn room_slot(&self, char: u8) -> Option<usize> {
method can_cross (line 128) | fn can_cross(&self, from: usize, to: usize) -> bool {
method depth (line 136) | fn depth(&self) -> usize {
method walk (line 140) | fn walk(&self, from: Point, to: Point) -> Game {
method should_stay (line 151) | fn should_stay(&self, point: Point) -> bool {
method can_exit (line 158) | fn can_exit(&self, point: Point) -> bool {
method is_solved (line 162) | fn is_solved(&self) -> bool {
function is_amphipod (line 13) | fn is_amphipod(char: u8) -> bool {
function is_empty (line 17) | fn is_empty(char: u8) -> bool {
function is_room (line 21) | fn is_room(point: Point) -> bool {
function is_hallway (line 25) | fn is_hallway(point: Point) -> bool {
function cost (line 29) | fn cost(from: Point, to: Point, char: u8) -> Cost {
function weight (line 33) | fn weight(char: u8) -> Cost {
function dedicated_room (line 43) | fn dedicated_room(char: u8) -> usize {
function is_entrance (line 53) | fn is_entrance(y: usize) -> bool {
function parse_input (line 170) | fn parse_input() -> Game {
function solve (line 181) | fn solve(game: Game) -> Cost {
function unfold (line 208) | fn unfold(game: &Game) -> Game {
function main (line 225) | fn main() {
FILE: advent-of-code/2021/day24/src/main.rs
type Num (line 3) | type Num = i32;
function main (line 5) | fn main() {
FILE: advent-of-code/2021/day25/src/main.rs
function main (line 3) | fn main() {
FILE: go/gopl/01/01/echo.go
function main (line 15) | func main() {
function echo (line 19) | func echo(args []string) {
FILE: go/gopl/01/01/echo_test.go
function TestEcho (line 8) | func TestEcho(t *testing.T) {
FILE: go/gopl/01/02/echo.go
function main (line 14) | func main() {
function echo (line 18) | func echo(args []string) {
FILE: go/gopl/01/02/echo_test.go
function TestEcho (line 8) | func TestEcho(t *testing.T) {
FILE: go/gopl/01/03/echo.go
function main (line 15) | func main() {
function echo1 (line 19) | func echo1(out io.Writer, args []string) {
function echo2 (line 28) | func echo2(out io.Writer, args []string) {
function echo3 (line 37) | func echo3(out io.Writer, args []string) {
FILE: go/gopl/01/03/echo_test.go
function TestEcho1 (line 25) | func TestEcho1(t *testing.T) {
function TestEcho2 (line 40) | func TestEcho2(t *testing.T) {
function TestEcho3 (line 55) | func TestEcho3(t *testing.T) {
function BenchmarkEcho1 (line 70) | func BenchmarkEcho1(b *testing.B) {
function BenchmarkEcho2 (line 77) | func BenchmarkEcho2(b *testing.B) {
function BenchmarkEcho3 (line 84) | func BenchmarkEcho3(b *testing.B) {
FILE: go/gopl/01/04/dup.go
function main (line 15) | func main() {
function dup2 (line 19) | func dup2(out io.Writer, files []string) {
function countLines (line 48) | func countLines(f *os.File, filename string, counts map[string]int, loca...
FILE: go/gopl/01/04/dup_test.go
function TestDup (line 10) | func TestDup(t *testing.T) {
FILE: go/gopl/01/05/lissajous.go
constant foregroundIndex (line 20) | foregroundIndex = 0
constant backgroundIndex (line 21) | backgroundIndex = 1
function main (line 24) | func main() {
function lissajous (line 28) | func lissajous(out io.Writer) {
FILE: go/gopl/01/06/lissajous.go
constant foregroundIndex (line 26) | foregroundIndex = 0
constant backgroundIndex (line 27) | backgroundIndex = 1
function main (line 30) | func main() {
function lissajous (line 34) | func lissajous(out io.Writer) {
FILE: go/gopl/01/07/fetch.go
function main (line 14) | func main() {
FILE: go/gopl/01/08/fetch.go
function main (line 13) | func main() {
FILE: go/gopl/01/09/fetch.go
function main (line 13) | func main() {
FILE: java/tdd_by_example/Money.java
class Money (line 5) | public class Money implements Expression {
method Money (line 9) | public Money(int amount, String currency) {
method equals (line 14) | @Override
method dollar (line 20) | public static Money dollar(int amount) {
method franc (line 24) | public static Money franc(int amount) {
method times (line 28) | public Expression times(int multiplier) {
method currency (line 32) | public String currency() {
method plus (line 36) | public Expression plus(Expression addend) {
method reduce (line 40) | public Money reduce(Bank bank, String to) {
method toString (line 44) | @Override
type Expression (line 50) | interface Expression {
method reduce (line 51) | Money reduce(Bank bank, String to);
method times (line 52) | Expression times(int multiplier);
method plus (line 53) | Expression plus(Expression addend);
class Sum (line 56) | class Sum implements Expression {
method Sum (line 60) | public Sum(Expression augend, Expression addend) {
method reduce (line 65) | public Money reduce(Bank bank, String to) {
method plus (line 70) | public Expression plus(Expression addend) {
method times (line 74) | public Expression times(int multiplier) {
class Bank (line 79) | class Bank {
method reduce (line 83) | public Money reduce(Expression source, String to) {
method addRate (line 87) | public void addRate(String from, String to, int amount) {
method rate (line 91) | int rate(String from, String to) {
class Pair (line 97) | class Pair {
method Pair (line 101) | Pair(String from, String to) {
method equals (line 106) | @Override
method hashCode (line 112) | @Override
FILE: java/tdd_by_example/MoneyTest.java
class MoneyTest (line 4) | public class MoneyTest extends TestCase {
method testMultiplication (line 5) | public void testMultiplication() {
method testEquality (line 11) | public void testEquality() {
method testSimpleAddition (line 17) | public void testSimpleAddition() {
method testCurrency (line 25) | public void testCurrency() {
method testPlusReturnsSumm (line 30) | public void testPlusReturnsSumm() {
method testReduceSum (line 39) | public void testReduceSum() {
method testReduceMoney (line 46) | public void testReduceMoney() {
method testReduceMoneyDifferentCurreny (line 52) | public void testReduceMoneyDifferentCurreny() {
method testIdentityRate (line 59) | public void testIdentityRate() {
method testMixedAddition (line 63) | public void testMixedAddition() {
method testSumPlusMoney (line 72) | public void testSumPlusMoney() {
method testSumTimes (line 82) | public void testSumTimes() {
FILE: other/clrs/02/03/02.c
function merge (line 3) | void merge(int A[], int p, int q, int r) {
function merge_sort (line 30) | void merge_sort(int A[], int p, int r) {
FILE: other/clrs/02/03/02.test.c
function TEST (line 4) | TEST(trivial_case) {
function TEST (line 13) | TEST(chapter_example) {
function TEST (line 22) | TEST(exercise_example) {
function TEST (line 31) | TEST(reversed_merge) {
FILE: other/clrs/02/03/05.c
function binary_search (line 2) | int binary_search(int A[], int length, int v) {
FILE: other/clrs/02/03/05.test.c
function TEST (line 4) | TEST(array_empty) {
function TEST (line 11) | TEST(array_one_element) {
function TEST (line 21) | TEST(array_odd_elements) {
function TEST (line 39) | TEST(array_even_elements) {
FILE: other/clrs/02/problems/01.c
function merge (line 7) | void merge(int A[], int p, int q, int r) {
function merge_sort (line 42) | void merge_sort(int A[], int p, int r) {
function insertion_sort (line 51) | void insertion_sort(int A[], int p, int r) {
function selection_sort (line 65) | void selection_sort(int A[], int p, int r) {
function mixed_sort_insertion (line 78) | void mixed_sort_insertion(int A[], int p, int r) {
function mixed_sort_selection (line 91) | void mixed_sort_selection(int A[], int p, int r) {
FILE: other/clrs/02/problems/01.py
function insertion_sort (line 3) | def insertion_sort(A, p, r):
function merge (line 12) | def merge(A, p, q, r):
function merge_sort (line 41) | def merge_sort(A, p, r):
function mixed_sort (line 48) | def mixed_sort(A, p, r):
FILE: other/clrs/02/problems/01.run.c
function randomize_array (line 20) | void randomize_array(int array[], unsigned length, unsigned int seed) {
function check_sorted (line 27) | void check_sorted(int array[], int length) {
function main (line 37) | int main() {
FILE: other/clrs/02/problems/01.run.py
function report_time (line 8) | def report_time(name, func):
FILE: other/clrs/02/problems/04.c
function merge (line 3) | int merge(int A[], int p, int q, int r) {
function merge_sort (line 31) | int merge_sort(int A[], int p, int r) {
FILE: other/clrs/02/problems/04.test.c
function TEST (line 4) | TEST(trivial_case) {
function TEST (line 11) | TEST(problem_example) {
function TEST (line 18) | TEST(chapter_example) {
function TEST (line 26) | TEST(reversed_array) {
FILE: other/clrs/04/01/03.c
type max_subarray (line 7) | typedef struct {
function max_subarray (line 15) | max_subarray find_maximum_subarray_brute(int A[], unsigned low, unsigned...
function max_subarray (line 35) | max_subarray find_max_crossing_subarray(int A[], unsigned low, unsigned ...
function max_subarray (line 63) | max_subarray find_maximum_subarray(int A[], unsigned low, unsigned high) {
function max_subarray (line 85) | max_subarray find_maximum_subarray_mixed(int A[], unsigned low, unsigned...
FILE: other/clrs/04/01/03.run.c
function randomize_array (line 23) | void randomize_array(int array[], unsigned length, unsigned int seed) {
function check_right_answer (line 30) | void check_right_answer(max_subarray expected, max_subarray actual) {
function main (line 39) | int main() {
FILE: other/clrs/04/01/03.test.c
function TEST (line 4) | TEST(chapter_example_brute) {
function TEST (line 13) | TEST(chapter_example_divide_and_conquer) {
function TEST (line 22) | TEST(chapter_example_mixed) {
FILE: other/clrs/04/01/04.c
type max_subarray (line 3) | typedef struct {
function max_subarray (line 9) | max_subarray find_max_crossing_subarray(int A[], unsigned low, unsigned ...
function max_subarray (line 42) | max_subarray find_maximum_subarray(int A[], unsigned low, unsigned high) {
FILE: other/clrs/04/01/04.test.c
function TEST (line 4) | TEST(chapter_example) {
function TEST (line 13) | TEST(negative_numbers) {
function TEST (line 21) | TEST(trivial_case_negative_numbers) {
function TEST (line 29) | TEST(trivial_case_positive_numbers) {
FILE: other/clrs/04/01/05.c
type max_subarray (line 1) | typedef struct {
function max_subarray (line 7) | max_subarray find_maximum_subarray(int A[], unsigned low, unsigned high) {
FILE: other/clrs/04/01/05.test.c
function TEST (line 6) | TEST(chapter_example) {
function TEST (line 15) | TEST(negative_numbers) {
function TEST (line 24) | TEST(trivial_case_negative_numbers) {
function TEST (line 33) | TEST(trivial_case_positive_numbers) {
function TEST (line 45) | TEST(comparison_with_brute_force) {
function max_subarray (line 58) | max_subarray find_maximum_subarray_brute(int A[], unsigned low, unsigned...
function generate_random_array (line 76) | void generate_random_array(int array[], unsigned size, unsigned seed) {
FILE: other/clrs/04/02/02.c
type matrix (line 7) | typedef struct {
function get (line 17) | int get(matrix m, int x, int y) {
function put (line 21) | void put(matrix m, int x, int y, int value) {
function matrix (line 27) | matrix create_matrix(int size, int *data) {
function matrix (line 38) | matrix submatrix(matrix A, int x, int y, int size) {
function plus (line 57) | void plus(matrix C, matrix A, matrix B) {
function minus (line 65) | void minus(matrix C, matrix A, matrix B) {
function add (line 73) | void add(matrix T, matrix S) {
function sub (line 80) | void sub(matrix T, matrix S) {
function zero (line 88) | void zero(matrix m) {
function print_matrix (line 98) | void print_matrix(matrix m) {
function strassen (line 112) | void strassen(matrix C, matrix A, matrix B) {
FILE: other/clrs/04/02/02.test.c
function multiply (line 10) | void multiply(matrix C, matrix A, matrix B) {
function TEST (line 24) | TEST(random_matches) {
FILE: other/clrs/04/problems/05.py
class GoodChip (line 3) | class GoodChip:
method good (line 4) | def good(self):
method check (line 7) | def check(self, other):
class BadChip (line 10) | class BadChip:
method good (line 11) | def good(self):
method check (line 14) | def check(self, other):
function jig (line 17) | def jig(a, b):
function diogenes (line 20) | def diogenes(chips, verbose = False):
FILE: other/clrs/04/problems/05.test.py
function generate_chips (line 12) | def generate_chips(count):
class DiogenesTest (line 20) | class DiogenesTest(unittest.TestCase):
method test_correctness (line 21) | def test_correctness(self):
FILE: other/clrs/04/problems/06.c
type array (line 1) | typedef struct array {
function get (line 8) | int get(array A, int i, int j) {
function array (line 12) | array half(array a) {
function height (line 17) | int height(array array) {
function min_index (line 21) | int min_index(array A, int row, int left, int right) {
function find_minimums (line 33) | void find_minimums(array A, int *mins) {
FILE: other/clrs/04/problems/06.test.c
function TEST (line 4) | TEST(large_example) {
function TEST (line 20) | TEST(small_example) {
FILE: other/clrs/06/02/05.c
type heap (line 5) | typedef struct {
function max_heapify (line 11) | void max_heapify(heap A, int i) {
FILE: other/clrs/06/02/05.test.c
function TEST (line 4) | TEST(chapter_example) {
function TEST (line 15) | TEST(exercise_6_2_1_example) {
FILE: other/clrs/06/05/03.c
type heap_t (line 9) | typedef struct {
function heap_minimum (line 15) | int heap_minimum(heap_t *heap) {
function min_heapify (line 19) | void min_heapify(heap_t *heap, int i) {
function heap_extract_min (line 43) | int heap_extract_min(heap_t *heap) {
function heap_decrease_key (line 57) | void heap_decrease_key(heap_t *heap, int i, int key) {
function min_heap_insert (line 72) | void min_heap_insert(heap_t *heap, int key) {
FILE: other/clrs/06/05/03.test.c
function TEST (line 4) | TEST(heap_minumum) {
function TEST (line 11) | TEST(heap_extract_min) {
function TEST (line 24) | TEST(heap_decrease_key) {
function TEST (line 34) | TEST(min_heap_insert) {
FILE: other/clrs/06/05/06.c
type heap_t (line 9) | typedef struct {
function heap_increase_key (line 15) | void heap_increase_key(heap_t *heap, int i, int key) {
FILE: other/clrs/06/05/06.test.c
function TEST (line 4) | TEST(heap_increase_key) {
FILE: other/clrs/06/problems/01.py
class heap (line 5) | class heap:
method __init__ (line 6) | def __init__(self, items, size = None):
method __getitem__ (line 10) | def __getitem__(self, key):
method __setitem__ (line 13) | def __setitem__(self, key, value):
method __len__ (line 16) | def __len__(self):
function left (line 19) | def left(i):
function right (line 22) | def right(i):
function parent (line 25) | def parent(i):
function max_heapify (line 32) | def max_heapify(A, i):
function build_max_heap (line 46) | def build_max_heap(A):
function heap_increase_key (line 55) | def heap_increase_key(A, i, key):
function max_heap_insert (line 63) | def max_heap_insert(A, key):
function build_max_heap2 (line 68) | def build_max_heap2(A):
FILE: other/clrs/06/problems/02.c
type heap_t (line 8) | typedef struct {
function max_heapify (line 15) | void max_heapify(heap_t *heap, int i) {
function extract_max (line 33) | int extract_max(heap_t *heap) {
function increase_key (line 41) | void increase_key(heap_t *heap, int i, int key) {
function insert (line 55) | void insert(heap_t *heap, int key) {
FILE: other/clrs/06/problems/02.test.c
function TEST (line 4) | TEST(extract_min) {
function TEST (line 16) | TEST(insert) {
FILE: other/clrs/06/problems/03.c
type cell (line 6) | typedef struct {
type tableau_t (line 11) | typedef struct {
function cell (line 17) | cell up(cell c) {
function cell (line 22) | cell down(cell c) {
function cell (line 27) | cell left(cell c) {
function cell (line 32) | cell right(cell c) {
function cell (line 37) | cell make_cell(int i, int j) {
function within (line 42) | bool within(tableau_t *tableau, cell c) {
function get (line 46) | int get(tableau_t *tableau, cell c) {
function set (line 51) | void set(tableau_t *tableau, cell c, int value) {
function init_empty_tableau (line 56) | void init_empty_tableau(tableau_t *tableau) {
function extract_min (line 62) | int extract_min(tableau_t *tableau) {
function insert (line 101) | void insert(tableau_t *tableau, int key) {
function sort (line 137) | void sort(int *array, int size_sqrt) {
function find (line 153) | bool find(tableau_t *tableau, int key) {
FILE: other/clrs/06/problems/03.test.c
function TEST (line 4) | TEST(extract_min) {
function TEST (line 20) | TEST(insert) {
function TEST (line 35) | TEST(sort) {
function TEST (line 44) | TEST(find) {
FILE: other/clrs/07/01/02.py
function partition (line 1) | def partition(numbers, start = 0, end = None):
function quicksort (line 21) | def quicksort(numbers, start = 0, end = None):
FILE: other/clrs/07/01/02.test.py
class PartitionTest (line 10) | class PartitionTest(unittest.TestCase):
method test_normal_partition (line 11) | def test_normal_partition(self):
method test_partition_with_repetition (line 17) | def test_partition_with_repetition(self):
method test_quicksort (line 21) | def test_quicksort(self):
FILE: other/clrs/07/04/05.c
function quicksort (line 7) | void quicksort(int A[], int p, int r) {
function modified_quicksort (line 15) | void modified_quicksort(int A[], int p, int r) {
function limited_quicksort (line 20) | void limited_quicksort(int A[], int p, int r, int treshold) {
function partition (line 28) | int partition(int A[], int p, int r) {
function insertion_sort (line 50) | void insertion_sort(int A[], int p, int r) {
FILE: other/clrs/07/04/05.run.c
function randomize_array (line 19) | void randomize_array(int array[], unsigned length, unsigned int seed) {
function check_sorted (line 26) | void check_sorted(int array[], int length) {
function main (line 36) | int main() {
FILE: other/clrs/07/04/05.test.c
function TEST (line 4) | TEST(trivial_case) {
FILE: other/clrs/07/problems/01.c
function hoare_partition (line 3) | int hoare_partition(int A[], int p, int r) {
function quicksort (line 21) | void quicksort(int A[], int p, int r) {
FILE: other/clrs/07/problems/01.test.c
function TEST (line 4) | TEST(partitioning) {
function TEST (line 14) | TEST(sorting) {
FILE: other/clrs/07/problems/02.c
type pivot_t (line 5) | typedef struct {
function quicksort (line 13) | void quicksort(int A[], int p, int r) {
function pivot_t (line 21) | pivot_t randomized_partition(int A[], int p, int r) {
function pivot_t (line 30) | pivot_t partition(int A[], int p, int r) {
FILE: other/clrs/07/problems/02.test.c
function TEST (line 10) | TEST(partitioning) {
function TEST (line 21) | TEST(sorting) {
function TEST (line 30) | TEST(large_array) {
function randomize_array (line 42) | void randomize_array(int array[], unsigned length, unsigned int seed) {
function is_sorted (line 49) | bool is_sorted(int array[], int length) {
FILE: other/clrs/07/problems/04.c
function tail_recursive_quicksort (line 12) | void tail_recursive_quicksort(int A[], int p, int r) {
function partition (line 30) | int partition(int A[], int p, int r) {
function increment_stack_depth (line 48) | void increment_stack_depth() {
function decrement_stack_depth (line 55) | void decrement_stack_depth() {
function reset_stack_depth_counter (line 59) | void reset_stack_depth_counter() {
FILE: other/clrs/07/problems/04.test.c
function TEST (line 11) | TEST(sorting) {
function TEST (line 20) | TEST(stack_depth) {
function TEST (line 32) | TEST(large_array) {
function randomize_array (line 46) | void randomize_array(int array[], unsigned length, unsigned int seed) {
function is_sorted (line 53) | bool is_sorted(int array[], int length) {
FILE: other/clrs/07/problems/06.c
type interval (line 4) | typedef struct {
function intersects (line 9) | bool intersects(interval a, interval b) { return a.left <= b.right && b....
function before (line 10) | bool before(interval a, interval b) { return a.right < b.left; }
function after (line 11) | bool after(interval a, interval b) { return a.left > b.right; }
function interval (line 15) | interval partition(interval A[], int p, int r) {
function fuzzy_sort (line 56) | void fuzzy_sort(interval array[], int p, int r) {
FILE: other/clrs/07/problems/06.test.c
function TEST (line 4) | TEST(intersects) {
function TEST (line 17) | TEST(sorting) {
function randomize_array (line 28) | void randomize_array(interval array[], unsigned length, unsigned int see...
function is_sorted (line 36) | bool is_sorted(interval array[], int length) {
FILE: other/clrs/08/problems/02.c
type item (line 3) | typedef struct {
function stable_linear_sort (line 12) | void stable_linear_sort(item *A, int size) {
function linear_in_place_sort (line 38) | void linear_in_place_sort(item *A, int size) {
function stable_in_place_sort (line 54) | void stable_in_place_sort(item *A, int size) {
function in_place_counting_sort (line 64) | void in_place_counting_sort(item *A, int size, int range) {
FILE: other/clrs/08/problems/02.test.c
function TEST (line 14) | TEST(stable_linear) {
function TEST (line 24) | TEST(linear_in_place) {
function TEST (line 33) | TEST(stable_in_place) {
function TEST (line 43) | TEST(in_place_counting_sort) {
function generate_binary_array (line 54) | void generate_binary_array(item *A, int size, int from, int to) {
function assert_sorted (line 62) | void assert_sorted(item *A, int size) {
function assert_stable (line 70) | void assert_stable(item *A, int size) {
function next_id (line 78) | int next_id() {
FILE: other/clrs/08/problems/03.c
type item (line 17) | typedef struct {
function sort_numbers (line 46) | void sort_numbers(item *A, int size, int max_digits) {
function sort_strings (line 56) | void sort_strings(item *A, int size, int max_length) {
function partition (line 71) | void partition(item *A, int size, int max_dimension, int *groups, dimens...
function radix_sort (line 92) | void radix_sort(item *A, int left, int right, int digits, key_f key) {
function counting_sort (line 100) | void counting_sort(item *A, int left, int right, int dimension, key_f ke...
function count_digits (line 121) | int count_digits(int n) {
function nth_digit (line 129) | int nth_digit(int n, int d) {
function item_nth_digit (line 135) | int item_nth_digit(item i, int d) {
function item_digits (line 139) | int item_digits(item i) {
function item_string_length (line 143) | int item_string_length(item a) {
function item_nth_char (line 147) | int item_nth_char(item a, int n) {
FILE: other/clrs/08/problems/03.test.c
function TEST (line 18) | TEST(sort_numbers) {
function TEST (line 28) | TEST(sort_strings) {
function compare_strings (line 38) | int compare_strings(item a, item b) {
function compare_numbers (line 42) | int compare_numbers(item a, item b) {
function assert_sorted (line 46) | void assert_sorted(item *A, int size, compare_f compare) {
function assert_stable (line 54) | void assert_stable(item *A, int size, compare_f compare) {
function next_id (line 62) | int next_id() {
function generate_random_numbers (line 67) | int generate_random_numbers(item *numbers) {
function generate_random_strings (line 92) | int generate_random_strings(item *strings) {
FILE: other/clrs/08/problems/04.c
type jug (line 3) | typedef int jug;
function quadratic_pair (line 10) | void quadratic_pair(jug *red, jug *blue, int size) {
function quick_pair (line 23) | void quick_pair(jug *red, jug *blue, int p, int r) {
function partition (line 31) | int partition(jug *red, jug *blue, int p, int q) {
function cmp (line 79) | int cmp(jug red, jug blue) {
FILE: other/clrs/08/problems/04.test.c
function TEST (line 11) | TEST(quadratic_pairing) {
function TEST (line 22) | TEST(quick_pairing) {
function generate_jugs (line 33) | void generate_jugs(int *red, int *blue) {
function assert_paired (line 49) | void assert_paired(int *red, int *blue) {
FILE: other/clrs/08/problems/05.c
type item (line 6) | typedef struct {
type heap_t (line 11) | typedef struct {
type sort_state_t (line 17) | typedef struct {
function k_sort (line 36) | void k_sort(int *numbers, int size, int k) {
function merge_k_sorted (line 49) | void merge_k_sorted(int *numbers, int size, int k) {
function state_took_column (line 80) | int state_took_column(sort_state_t *state, int index) {
function merge (line 114) | void merge(int A[], int p, int q, int r, int k, int s) {
function merge_sort (line 139) | void merge_sort(int A[], int p, int r, int k, int s) {
function item (line 161) | item heap_minimum(heap_t *heap) {
function min_heapify (line 165) | void min_heapify(heap_t *heap, int i) {
function item (line 189) | item heap_extract_min(heap_t *heap) {
function heap_decrease_key (line 203) | void heap_decrease_key(heap_t *heap, int i, item key) {
function min_heap_insert (line 218) | void min_heap_insert(heap_t *heap, item key) {
function item (line 230) | item min_heap_push_pop(heap_t *heap, item new) {
FILE: other/clrs/08/problems/05.test.c
function TEST (line 14) | TEST(k_sorting) {
function TEST (line 22) | TEST(merging_k_sorted) {
function assert_k_sorted (line 31) | void assert_k_sorted(int *numbers, int k) {
function generate_random_array (line 40) | void generate_random_array(int *numbers) {
FILE: other/clrs/08/problems/07.c
type number (line 8) | typedef unsigned int number;
type column_t (line 10) | typedef struct {
function columnsort (line 25) | void columnsort(number *A, size_t r, size_t s, column_sorter sort_column...
function compare (line 65) | int compare(const void *a, const void *b) {
function check_dimensions (line 82) | void check_dimensions(size_t r, size_t s) {
function sort (line 103) | void sort(number *A, column_t column) {
function sequential_sort_columns (line 111) | void sequential_sort_columns(number *numbers, column_t *columns, int siz...
type job_t (line 123) | typedef struct {
function threaded_sort_columns (line 134) | void threaded_sort_columns(number *numbers, column_t *columns, int size) {
FILE: other/clrs/08/problems/07.run.c
function current_utc_time (line 9) | void current_utc_time(struct timespec *ts) {
type timespec (line 24) | struct timespec
function main (line 40) | int main() {
FILE: other/clrs/08/problems/07.test.c
function TEST (line 16) | TEST(single_process_columnsort) {
function TEST (line 23) | TEST(paralel_sort) {
function assert_sorted (line 30) | void assert_sorted(number *A, size_t size) {
function randomize (line 38) | void randomize(number *A, size_t size) {
function print_mesh (line 49) | void print_mesh(number *A, size_t r, size_t s) {
FILE: other/clrs/09/02/03.c
function randomized_select (line 8) | int randomized_select(int *A, int p, int r, int i) {
function partition (line 26) | int partition(int *A, int p, int r) {
function randomized_partition (line 44) | int randomized_partition(int *A, int p, int r) {
FILE: other/clrs/09/02/03.test.c
function TEST (line 9) | TEST(ith_order_statistic) {
function generate_array (line 22) | void generate_array(int *numbers, int size) {
FILE: other/clrs/09/03/05.py
function select (line 1) | def select(items, n):
function median (line 13) | def median(items):
FILE: other/clrs/09/03/05.test.py
class SelectionTest (line 9) | class SelectionTest(unittest.TestCase):
method test_select (line 10) | def test_select(self):
FILE: other/clrs/09/03/06.py
function k_quantiles (line 3) | def k_quantiles(items, k):
function median_index (line 31) | def median_index(n):
function partition (line 37) | def partition(items, element):
function select (line 52) | def select(items, n):
FILE: other/clrs/09/03/06.test.py
function shuffled (line 9) | def shuffled(n):
function visualize (line 14) | def visualize(n, k):
class QuantilesTest (line 24) | class QuantilesTest(unittest.TestCase):
method test_k_quantiles (line 25) | def test_k_quantiles(self):
method test_visualized_quantiles (line 32) | def test_visualized_quantiles(self):
FILE: other/clrs/09/03/08.py
function two_array_median (line 1) | def two_array_median(a, b):
function median_index (line 12) | def median_index(n):
FILE: other/clrs/09/03/08.test.py
function shuffled (line 9) | def shuffled(n):
class QuantilesTest (line 14) | class QuantilesTest(unittest.TestCase):
method test_k_quantiles (line 15) | def test_k_quantiles(self):
FILE: other/clrs/10/01/05.c
type deque_t (line 6) | typedef struct {
function init_deque (line 12) | void init_deque(deque_t *deque) {
function is_empty (line 17) | int is_empty(deque_t *deque) {
function push (line 21) | void push(deque_t *deque, int n) {
function unshift (line 36) | void unshift(deque_t *deque, int n) {
function pop (line 50) | int pop(deque_t *deque) {
function shift (line 65) | int shift(deque_t *deque) {
FILE: other/clrs/10/01/05.test.c
function TEST (line 4) | TEST(using_as_a_stack) {
function TEST (line 24) | TEST(using_as_queue) {
function TEST (line 39) | TEST(unshifting) {
function TEST (line 54) | TEST(wrapping_around_on_push) {
function TEST (line 70) | TEST(wrapping_around_on_shift) {
FILE: other/clrs/10/02/05.c
type node_t (line 3) | typedef struct node_t {
type list_t (line 8) | typedef struct {
function init_list (line 12) | void init_list(list_t *list) {
function destroy_list (line 17) | void destroy_list(list_t *list) {
function insert (line 28) | void insert(list_t *list, int key) {
function node_t (line 35) | node_t *search(list_t *list, int key) {
function delete (line 51) | void delete(list_t *list, int key) {
FILE: other/clrs/10/02/05.test.c
function TEST (line 4) | TEST(inserting_and_searching) {
function TEST (line 20) | TEST(deleting) {
function TEST (line 42) | TEST(deleting_an_element_inserted_multiple_times) {
FILE: other/clrs/10/02/07.c
type node_t (line 3) | typedef struct node_t {
type list_t (line 8) | typedef struct {
function init_list (line 12) | void init_list(list_t *list) {
function destroy_list (line 17) | void destroy_list(list_t *list) {
function insert (line 28) | void insert(list_t *list, int key) {
function reverse (line 35) | void reverse(list_t *list) {
FILE: other/clrs/10/02/07.test.c
function TEST (line 4) | TEST(inserting_and_searching) {
FILE: other/clrs/10/02/08.c
type node_t (line 4) | typedef struct node_t {
type list_t (line 9) | typedef struct {
function node_t (line 14) | node_t *xor(node_t *left, node_t *right) {
function init_list (line 18) | void init_list(list_t *list) {
function destroy_list (line 23) | void destroy_list(list_t *list) {
function insert (line 36) | void insert(list_t *list, int key) {
function get (line 52) | int get(list_t *list, int index) {
function node_t (line 70) | node_t *search(list_t *list, int key) {
function delete (line 88) | void delete(list_t *list, int key) {
function reverse (line 118) | void reverse(list_t *list) {
FILE: other/clrs/10/02/08.test.c
function TEST (line 4) | TEST(inserting_and_searching) {
function TEST (line 21) | TEST(deleting) {
function TEST (line 39) | TEST(reversing) {
FILE: other/clrs/10/03/02.c
type list_t (line 6) | typedef int list_t;
type obj_t (line 7) | typedef int obj_t;
function init_storage (line 17) | void init_storage() {
function list_t (line 26) | list_t allocate_object() {
function free_object (line 37) | void free_object(list_t list) {
function list_t (line 42) | list_t cons(obj_t key, list_t list) {
function delete (line 56) | void delete(list_t list) {
function obj_t (line 68) | obj_t get(list) {
function list_t (line 73) | list_t next(list) {
FILE: other/clrs/10/03/02.test.c
function TEST (line 4) | TEST(adding_elements) {
function TEST (line 19) | TEST(removing_elements) {
function TEST (line 36) | TEST(removing_and_adding) {
FILE: other/clrs/10/03/05.c
type list_t (line 6) | typedef int list_t;
type obj_t (line 7) | typedef int obj_t;
function init_storage (line 17) | void init_storage() {
function list_t (line 26) | list_t allocate_object() {
function free_object (line 37) | void free_object(list_t list) {
function list_t (line 42) | list_t cons(obj_t key, list_t list) {
function delete (line 56) | void delete(list_t list) {
function obj_t (line 68) | obj_t get(list) {
function list_t (line 73) | list_t next_obj(list) {
function list_t (line 78) | list_t compatify_list(list_t list) {
FILE: other/clrs/10/03/05.test.c
function TEST (line 4) | TEST(compactify) {
FILE: other/clrs/10/04/02.c
type tree_t (line 1) | struct tree_t {
type tree_t (line 7) | typedef struct tree_t tree_t;
function print_tree (line 10) | void print_tree(tree_t *tree) {
function reset_storage (line 24) | void reset_storage() {
function store (line 28) | void store(int key) {
FILE: other/clrs/10/04/02.test.c
function tree_t (line 6) | tree_t* make_tree(int key) {
function tree_t (line 15) | tree_t* make_left(tree_t *parent, int key) {
function tree_t (line 22) | tree_t* make_right(tree_t *parent, int key) {
function TEST (line 29) | TEST(quote_printing_unquote) {
FILE: other/clrs/10/04/03.c
type tree_t (line 3) | struct tree_t {
type tree_t (line 9) | typedef struct tree_t tree_t;
function print_tree (line 12) | void print_tree(tree_t *tree) {
function reset_storage (line 34) | void reset_storage() {
function store (line 38) | void store(int key) {
FILE: other/clrs/10/04/03.test.c
function tree_t (line 6) | tree_t* make_tree(int key) {
function tree_t (line 15) | tree_t* make_left(tree_t *parent, int key) {
function tree_t (line 22) | tree_t* make_right(tree_t *parent, int key) {
function TEST (line 29) | TEST(quote_printing_unquote) {
FILE: other/clrs/10/04/04.c
type tree_t (line 3) | struct tree_t {
type tree_t (line 9) | typedef struct tree_t tree_t;
function print_tree (line 12) | void print_tree(tree_t *tree) {
function reset_storage (line 25) | void reset_storage() {
function store (line 29) | void store(int key) {
FILE: other/clrs/10/04/04.test.c
function tree_t (line 6) | tree_t *make_tree(int key) {
function tree_t (line 15) | tree_t *make_child(tree_t *parent, int key) {
function tree_t (line 22) | tree_t *make_sibling(tree_t *left, int key) {
function TEST (line 29) | TEST(quote_printing_unquote) {
FILE: other/clrs/10/04/05.c
type tree_t (line 1) | struct tree_t {
type tree_t (line 7) | typedef struct tree_t tree_t;
function print_tree (line 10) | void print_tree(tree_t *tree) {
function reset_storage (line 35) | void reset_storage() {
function store (line 39) | void store(int key) {
FILE: other/clrs/10/04/05.test.c
function tree_t (line 6) | tree_t* make_tree(int key) {
function tree_t (line 15) | tree_t* make_left(tree_t *parent, int key) {
function tree_t (line 22) | tree_t* make_right(tree_t *parent, int key) {
function TEST (line 29) | TEST(quote_printing_unquote) {
FILE: other/clrs/10/problems/02.c
type list_t (line 8) | struct list_t {
type list_t (line 13) | typedef struct list_t list_t;
function list_t (line 15) | list_t *insert_sorted(list_t *list, int key) {
function list_t (line 35) | list_t *delete_key(list_t *list, int key) {
function list_t (line 61) | list_t *prepend(list_t *list, int key) {
function find_min (line 70) | int find_min(list_t *list) {
function list_t (line 84) | list_t *link_together(list_t *a, list_t *b) {
function list_t (line 100) | list_t *merge_sorted(list_t *a, list_t *b) {
type heap1 (line 129) | typedef struct {
function heap1 (line 133) | heap1 *make_heap1() {
function insert1 (line 139) | void insert1(heap1 *heap, int key) {
function minimum1 (line 143) | int minimum1(heap1 *heap) {
function extract_min1 (line 147) | int extract_min1(heap1 *heap) {
function heap1 (line 155) | heap1 *union1(heap1 *ha, heap1 *hb) {
type heap2 (line 169) | typedef struct {
function heap2 (line 173) | heap2 *make_heap2() {
function insert2 (line 179) | void insert2(heap2 *heap, int key) {
function minimum2 (line 183) | int minimum2(heap2 *heap) {
function extract_min2 (line 187) | int extract_min2(heap2 *heap) {
function heap2 (line 193) | heap2 *union2(heap2 *ha, heap2 *hb) {
FILE: other/clrs/10/problems/02.test.c
function heap1 (line 4) | heap1 *build1(int first, ...) {
function heap2 (line 19) | heap2 *build2(int first, ...) {
function TEST (line 34) | TEST(heap1) {
function TEST (line 47) | TEST(heap2) {
FILE: other/clrs/11/02/04.c
type value_t (line 10) | typedef int value_t;
type element_t (line 12) | struct element_t
type element_t (line 14) | typedef struct element_t {
type hash_t (line 29) | typedef struct {
function hash_value (line 36) | int hash_value(value_t value) {
function remove_from_free_list (line 40) | void remove_from_free_list(hash_t *hash, element_t *element) {
function return_to_free_list (line 46) | void return_to_free_list(hash_t *hash, element_t *element) {
function element_t (line 56) | element_t *allocate(hash_t *hash) {
function reallocate (line 66) | void reallocate(hash_t *hash, element_t *element) {
function hash_t (line 89) | hash_t *make_hash() {
function element_t (line 115) | element_t *search(hash_t *hash, value_t value) {
function insert (line 131) | void insert(hash_t *hash, value_t value) {
function delete (line 155) | void delete(hash_t *hash, value_t value) {
function print_hash (line 199) | void print_hash(hash_t *hash) {
FILE: other/clrs/11/02/04.test.c
function TEST (line 4) | TEST(insertion) {
function TEST (line 12) | TEST(deletion) {
function TEST (line 21) | TEST(deleting_second_in_chain) {
function TEST (line 33) | TEST(deleting_first_in_chain) {
function TEST (line 45) | TEST(deleting_duplicates) {
function TEST (line 48) | TEST(inserting_duplicates) {
function TEST (line 60) | TEST(inserting_colisions) {
function TEST (line 70) | TEST(inserting_in_foreign_slots) {
function TEST (line 82) | TEST(complicated_example) {
FILE: other/clrs/11/03/02.py
function consthash (line 4) | def consthash(digits, m):
FILE: other/clrs/11/03/02.test.py
function digits_to_number (line 10) | def digits_to_number(digits):
class HashingTest (line 16) | class HashingTest(unittest.TestCase):
method test_select (line 17) | def test_select(self):
FILE: other/clrs/11/03/04.py
function h (line 8) | def h(k):
FILE: other/clrs/11/04/01.py
function populate (line 1) | def populate(m, keys, probe):
function linear (line 19) | def linear(m):
function quadratic (line 23) | def quadratic(m, c1, c2):
function double (line 27) | def double(m):
FILE: other/clrs/11/04/05.py
function fn (line 5) | def fn(a):
FILE: other/clrs/12/01/04.c
type tree_t (line 1) | struct tree_t {
type tree_t (line 6) | typedef struct tree_t tree_t;
function preorder (line 10) | void preorder(tree_t *tree, callback_t *callback) {
function postorder (line 18) | void postorder(tree_t *tree, callback_t *callback) {
FILE: other/clrs/12/01/04.test.c
function reset_storage (line 10) | void reset_storage() {
function store (line 14) | void store(tree_t *tree) {
function tree_t (line 18) | tree_t *s(int key, tree_t *left, tree_t *right) {
function TEST (line 26) | TEST(preorder_walk) {
function TEST (line 44) | TEST(postorder_walk) {
FILE: other/clrs/12/02/02.c
type tree_t (line 1) | struct tree_t {
type tree_t (line 7) | typedef struct tree_t tree_t;
function tree_t (line 9) | tree_t *minimum(tree_t *tree) {
function tree_t (line 13) | tree_t *maximum(tree_t *tree) {
FILE: other/clrs/12/02/02.test.c
function tree_t (line 6) | tree_t *s(int key, tree_t *left, tree_t *right) {
function TEST (line 20) | TEST(minumum) {
function TEST (line 34) | TEST(maximum) {
FILE: other/clrs/12/02/03.c
type tree_t (line 1) | struct tree_t {
type tree_t (line 7) | typedef struct tree_t tree_t;
function tree_t (line 9) | tree_t *maximum(tree_t *tree) {
function tree_t (line 14) | tree_t *predecessor(tree_t *tree) {
FILE: other/clrs/12/02/03.test.c
function tree_t (line 6) | tree_t *s(int key, tree_t *left, tree_t *right) {
function TEST (line 20) | TEST(predecessor) {
FILE: other/clrs/12/03/01.c
type node_t (line 3) | struct node_t {
type node_t (line 9) | typedef struct node_t node_t;
type tree_t (line 11) | typedef struct {
function tree_t (line 15) | tree_t *make_tree() {
function node_t (line 21) | node_t *make_node(int key) {
function node_t (line 32) | node_t *insert_node(node_t *node, int key) {
function node_t (line 54) | node_t *insert(tree_t *tree, int key) {
function node_t (line 64) | node_t *search(tree_t *tree, int key) {
FILE: other/clrs/12/03/01.test.c
function TEST (line 6) | TEST(insert) {
FILE: other/clrs/12/03/05.c
type node_t (line 3) | struct node_t {
type node_t (line 9) | typedef struct node_t node_t;
type tree_t (line 11) | typedef struct {
function tree_t (line 15) | tree_t *make_tree() {
function node_t (line 21) | node_t *make_node(int key) {
function node_t (line 32) | node_t *insert(tree_t *tree, int key) {
function node_t (line 63) | node_t *find_parent(tree_t *tree, node_t *node) {
function find_parent_and_predecessor (line 80) | void find_parent_and_predecessor(tree_t *tree, node_t *node, node_t **pa...
function transplant (line 106) | void transplant(tree_t *tree, node_t *parent, node_t *target, node_t *so...
function delete_tree (line 116) | void delete_tree(tree_t *tree, node_t *node) {
function node_t (line 142) | node_t *search(tree_t *tree, int key) {
function inorder_walk (line 160) | void inorder_walk(node_t *node, callback_t callback) {
function successor_walk (line 167) | void successor_walk(node_t *node, callback_t callback) {
FILE: other/clrs/12/03/05.debug.c
function height (line 8) | int height(node_t *tree) {
function node_t (line 14) | node_t **make_array(int size) {
function size (line 18) | int size(node_t *node) {
function space (line 23) | void space(int i) {
function level_pad (line 27) | int level_pad(int h) {
function print_node (line 32) | void print_node(node_t *tree) {
function print_tree (line 38) | void print_tree(tree_t *tree) {
FILE: other/clrs/12/03/05.test.c
function randomized_numbers (line 8) | void randomized_numbers(int seed, int max, int target[], int count) {
function cmp (line 28) | int cmp(const void *pa, const void *pb) {
function reset_buffer (line 40) | void reset_buffer() {
function append_to_buffer (line 45) | void append_to_buffer(node_t *node) {
function check_successor_invariant (line 49) | void check_successor_invariant(tree_t *tree) {
function TEST (line 60) | TEST(inserting) {
function TEST (line 77) | TEST(inorder_walk) {
function TEST (line 97) | TEST(randomized_successor_walk) {
function TEST (line 120) | TEST(deleting_case_a) {
function TEST (line 140) | TEST(deleting_case_a_2) {
function TEST (line 154) | TEST(deleting_case_b) {
function TEST (line 175) | TEST(deleting_case_c) {
function TEST (line 192) | TEST(deleting_case_d) {
function TEST (line 220) | TEST(deleting_in_random_trees) {
FILE: other/clrs/12/problems/02.c
type node_t (line 4) | struct node_t {
type node_t (line 10) | typedef struct node_t node_t;
type radix_tree_t (line 12) | typedef struct {
function node_t (line 18) | node_t *make_node() {
function radix_tree_t (line 26) | radix_tree_t *make_radix_tree() {
function insert (line 32) | void insert(radix_tree_t *tree, const char *string) {
function walk (line 53) | void walk(node_t *node, callback_t callback) {
function walk_sorted (line 59) | void walk_sorted(radix_tree_t *tree, callback_t callback) {
FILE: other/clrs/12/problems/02.test.c
function append (line 11) | void append(const char *s) {
function TEST (line 15) | TEST(sort) {
FILE: other/clrs/13/03/02.draw.py
function dot (line 10) | def dot(tree):
FILE: other/clrs/13/03/02.py
class Color (line 4) | class Color(Enum):
class Node (line 9) | class Node:
method __init__ (line 10) | def __init__(self, color, key, parent, left, right):
class Tree (line 18) | class Tree:
method __init__ (line 19) | def __init__(self):
method insert (line 27) | def insert(self, key):
method fixup (line 53) | def fixup(self, z):
method left_rotate (line 85) | def left_rotate(self, x):
method right_rotate (line 104) | def right_rotate(self, y):
FILE: other/clrs/13/04/03.draw.py
function dot (line 10) | def dot(tree):
FILE: other/clrs/13/04/03.py
class Color (line 5) | class Color(Enum):
class Node (line 10) | class Node:
method __init__ (line 11) | def __init__(self, color, key, parent, left, right):
method sexp (line 18) | def sexp(self, nil):
method black_height (line 26) | def black_height(self, nil):
class Tree (line 38) | class Tree:
method __init__ (line 39) | def __init__(self):
method __str__ (line 47) | def __str__(self):
method search (line 50) | def search(self, key):
method nodes (line 63) | def nodes(self):
method insert (line 80) | def insert(self, key):
method insert_fixup (line 106) | def insert_fixup(self, z):
method delete (line 138) | def delete(self, z):
method delete_fixup (line 166) | def delete_fixup(self, x):
method minimum (line 219) | def minimum(self, node):
method transplant (line 225) | def transplant(self, u, v):
method left_rotate (line 234) | def left_rotate(self, x):
method right_rotate (line 253) | def right_rotate(self, y):
FILE: other/clrs/13/04/03.test.py
class RedBlackTest (line 9) | class RedBlackTest(unittest.TestCase):
method generate (line 10) | def generate(self, m, n):
method assertContains (line 15) | def assertContains(self, tree, numbers):
method assertProperties (line 20) | def assertProperties(self, tree):
method test_insertions (line 34) | def test_insertions(self):
method test_properties (line 44) | def test_properties(self):
method test_deletion (line 53) | def test_deletion(self):
FILE: other/clrs/13/04/07.draw.py
function dot (line 10) | def dot(tree):
FILE: other/clrs/13/misc/red_black_tree.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree):
method sexp (line 31) | def sexp(self):
method black_height (line 41) | def black_height(self):
method isRed (line 52) | def isRed(self):
method isBlack (line 55) | def isBlack(self):
method isNil (line 58) | def isNil(self):
method isNotNil (line 61) | def isNotNil(self):
method __bool__ (line 64) | def __bool__(self):
method child (line 67) | def child(self, direction):
method set_child (line 75) | def set_child(self, direction, child):
method other (line 86) | def other(self, direction):
method rotate (line 89) | def rotate(self, direction):
method left_rotate (line 108) | def left_rotate(self):
method right_rotate (line 111) | def right_rotate(self):
method transplant (line 114) | def transplant(self, other):
method set (line 123) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 133) | def minimum(self):
class Tree (line 148) | class Tree:
method __init__ (line 149) | def __init__(self):
method __str__ (line 152) | def __str__(self):
method search (line 155) | def search(self, key):
method nodes (line 168) | def nodes(self):
method insert (line 185) | def insert(self, key):
method insert_fixup (line 209) | def insert_fixup(self, node):
method delete (line 233) | def delete(self, key):
method delete_fixup (line 264) | def delete_fixup(self, node):
FILE: other/clrs/13/misc/red_black_tree_test.py
class RedBlackTest (line 6) | class RedBlackTest(unittest.TestCase):
method generate (line 7) | def generate(self, m, n):
method assertContains (line 12) | def assertContains(self, tree, numbers):
method assertProperties (line 17) | def assertProperties(self, tree):
method test_insertions (line 30) | def test_insertions(self):
method test_properties (line 40) | def test_properties(self):
method test_deletion (line 49) | def test_deletion(self):
FILE: other/clrs/13/problems/01.py
class Color (line 5) | class Color(Enum):
function other (line 16) | def other(direction):
function isBlackOrNil (line 25) | def isBlackOrNil(node):
class Node (line 29) | class Node:
method __init__ (line 30) | def __init__(self, color, key, left=None, right=None):
method __str__ (line 36) | def __str__(self):
method isRed (line 41) | def isRed(self):
method isBlack (line 44) | def isBlack(self):
method child_direction (line 47) | def child_direction(self, child):
method child (line 57) | def child(self, direction):
method set_child (line 65) | def set_child(self, direction, child):
method with_replaced_child (line 73) | def with_replaced_child(self, replacement, child):
method replace_child (line 83) | def replace_child(self, replacement, child):
method other (line 95) | def other(self, direction):
method sexp (line 98) | def sexp(self):
method copy (line 109) | def copy(self, key=UNCHANGED, color=UNCHANGED, left=UNCHANGED, right=U...
method left_rotate (line 123) | def left_rotate(self):
method right_rotate (line 127) | def right_rotate(self):
method rotate (line 131) | def rotate(self, direction):
method minimum_with_ancestors (line 141) | def minimum_with_ancestors(self):
function update_ancestor_chain (line 162) | def update_ancestor_chain(inserted, replaced, ancestors):
class Tree (line 177) | class Tree:
method __init__ (line 178) | def __init__(self, root=None):
method __str__ (line 181) | def __str__(self):
method search (line 189) | def search(self, key):
method black_heights (line 202) | def black_heights(self):
method nodes (line 229) | def nodes(self):
method insert (line 246) | def insert(self, key):
method insert_fixup (line 275) | def insert_fixup(self, current, ancestors):
method search_with_ancestors (line 315) | def search_with_ancestors(self, key):
method delete (line 331) | def delete(self, key):
method delete_fixup (line 372) | def delete_fixup(self, ancestors):
FILE: other/clrs/13/problems/01.test.py
function Red (line 9) | def Red(key, left=None, right=None):
function Black (line 13) | def Black(key, left=None, right=None):
class RedBlackTest (line 17) | class RedBlackTest(unittest.TestCase):
method generate (line 18) | def generate(self, m, n):
method assertContains (line 23) | def assertContains(self, tree, numbers):
method assertDoesNotContain (line 28) | def assertDoesNotContain(self, tree, numbers):
method assertInAndOut (line 32) | def assertInAndOut(self, tree, included, excluded):
method assertProperties (line 36) | def assertProperties(self, tree):
method test_simple_insertion (line 50) | def test_simple_insertion(self):
method test_exercise_insertion_properties (line 69) | def test_exercise_insertion_properties(self):
method test_insertions (line 81) | def test_insertions(self):
method test_delete_empty (line 108) | def test_delete_empty(self):
method test_exercise_deletion_properties (line 113) | def test_exercise_deletion_properties(self):
method test_delete_fixup_case_1 (line 135) | def test_delete_fixup_case_1(self):
method test_delete_fixup_case_2 (line 150) | def test_delete_fixup_case_2(self):
method test_delete_fixup_case_3 (line 165) | def test_delete_fixup_case_3(self):
method test_delete_fixup_case_4 (line 181) | def test_delete_fixup_case_4(self):
method test_deletion (line 203) | def test_deletion(self):
FILE: other/clrs/13/problems/03.py
class Node (line 4) | class Node:
method __init__ (line 5) | def __init__(self, key, height=-1, left=None, right=None):
method __str__ (line 11) | def __str__(self):
method left_rotate (line 20) | def left_rotate(self):
method right_rotate (line 31) | def right_rotate(self):
function height (line 45) | def height(node):
class AVL (line 49) | class AVL:
method __init__ (line 50) | def __init__(self):
method __str__ (line 53) | def __str__(self):
method nodes (line 61) | def nodes(self):
method insert (line 76) | def insert(self, key):
method search (line 103) | def search(self, key):
FILE: other/clrs/13/problems/03.test.py
class AVLTreeTest (line 9) | class AVLTreeTest(unittest.TestCase):
method assertBinarySearchTreeProperties (line 10) | def assertBinarySearchTreeProperties(self, tree):
method assertAVLProperties (line 17) | def assertAVLProperties(self, tree):
method testInsertionWithLeftRotation (line 38) | def testInsertionWithLeftRotation(self):
method testInsertionWithLeftRightRotation (line 48) | def testInsertionWithLeftRightRotation(self):
method testInsertionWithRightRotation (line 58) | def testInsertionWithRightRotation(self):
method testInsertionWithRightLeftRotation (line 68) | def testInsertionWithRightLeftRotation(self):
method testInsertion (line 78) | def testInsertion(self):
method testRandomInsertion (line 97) | def testRandomInsertion(self):
FILE: other/clrs/13/problems/04.py
class Node (line 4) | class Node:
method __init__ (line 5) | def __init__(self, key, priority, left=None, right=None):
method __str__ (line 11) | def __str__(self):
method left_rotate (line 20) | def left_rotate(self):
method right_rotate (line 28) | def right_rotate(self):
class Treap (line 39) | class Treap:
method __init__ (line 40) | def __init__(self):
method __str__ (line 43) | def __str__(self):
method nodes (line 51) | def nodes(self):
method insert (line 66) | def insert(self, key, priority=None):
method search (line 84) | def search(self, key):
FILE: other/clrs/13/problems/04.test.py
class TreapTest (line 9) | class TreapTest(unittest.TestCase):
method assertBinarySearchTreeProperties (line 10) | def assertBinarySearchTreeProperties(self, tree):
method assertTreapProperties (line 17) | def assertTreapProperties(self, treap):
method testInsertion (line 24) | def testInsertion(self):
method testSameTreapWithExample (line 34) | def testSameTreapWithExample(self):
method testRandomTreap (line 55) | def testRandomTreap(self):
FILE: other/clrs/14/01/03.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree, size):
method sexp (line 32) | def sexp(self):
method black_height (line 42) | def black_height(self):
method isRed (line 53) | def isRed(self):
method isBlack (line 56) | def isBlack(self):
method isNil (line 59) | def isNil(self):
method isNotNil (line 62) | def isNotNil(self):
method __bool__ (line 65) | def __bool__(self):
method child (line 68) | def child(self, direction):
method set_child (line 76) | def set_child(self, direction, child):
method other (line 87) | def other(self, direction):
method rotate (line 90) | def rotate(self, direction):
method left_rotate (line 112) | def left_rotate(self):
method right_rotate (line 115) | def right_rotate(self):
method transplant (line 118) | def transplant(self, other):
method set (line 127) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 137) | def minimum(self):
method select (line 145) | def select(self, i):
method rank (line 160) | def rank(self):
class Tree (line 179) | class Tree:
method __init__ (line 180) | def __init__(self):
method __str__ (line 183) | def __str__(self):
method search (line 186) | def search(self, key):
method nodes (line 199) | def nodes(self):
method select (line 216) | def select(self, i):
method insert (line 219) | def insert(self, key):
method insert_fixup (line 245) | def insert_fixup(self, node):
method delete (line 269) | def delete(self, key):
method delete_fixup (line 310) | def delete_fixup(self, node):
FILE: other/clrs/14/01/03.test.py
class OrderStatisticTreeTest (line 9) | class OrderStatisticTreeTest(unittest.TestCase):
method test_rank_when_inserting (line 10) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 24) | def test_rank_when_deleting(self):
method generate (line 49) | def generate(self, m, n):
method assertContains (line 54) | def assertContains(self, tree, numbers):
method assertProperties (line 59) | def assertProperties(self, tree):
method test_insertions (line 72) | def test_insertions(self):
method test_properties (line 82) | def test_properties(self):
method test_deletion (line 91) | def test_deletion(self):
FILE: other/clrs/14/01/04.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree, size):
method sexp (line 32) | def sexp(self):
method black_height (line 42) | def black_height(self):
method isRed (line 53) | def isRed(self):
method isBlack (line 56) | def isBlack(self):
method isNil (line 59) | def isNil(self):
method isNotNil (line 62) | def isNotNil(self):
method __bool__ (line 65) | def __bool__(self):
method child (line 68) | def child(self, direction):
method set_child (line 76) | def set_child(self, direction, child):
method other (line 87) | def other(self, direction):
method rotate (line 90) | def rotate(self, direction):
method left_rotate (line 112) | def left_rotate(self):
method right_rotate (line 115) | def right_rotate(self):
method transplant (line 118) | def transplant(self, other):
method set (line 127) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 137) | def minimum(self):
method select (line 145) | def select(self, i):
method rank (line 160) | def rank(self):
method key_rank (line 172) | def key_rank(self, key):
class Tree (line 187) | class Tree:
method __init__ (line 188) | def __init__(self):
method __str__ (line 191) | def __str__(self):
method search (line 194) | def search(self, key):
method key_rank (line 207) | def key_rank(self, key):
method nodes (line 210) | def nodes(self):
method select (line 227) | def select(self, i):
method insert (line 230) | def insert(self, key):
method insert_fixup (line 256) | def insert_fixup(self, node):
method delete (line 280) | def delete(self, key):
method delete_fixup (line 321) | def delete_fixup(self, node):
FILE: other/clrs/14/01/04.test.py
class OrderStatisticTreeTest (line 9) | class OrderStatisticTreeTest(unittest.TestCase):
method test_key_rank (line 10) | def test_key_rank(self):
method test_rank_when_inserting (line 33) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 47) | def test_rank_when_deleting(self):
method generate (line 72) | def generate(self, m, n):
method assertContains (line 77) | def assertContains(self, tree, numbers):
method assertProperties (line 82) | def assertProperties(self, tree):
method test_insertions (line 95) | def test_insertions(self):
method test_properties (line 105) | def test_properties(self):
method test_deletion (line 114) | def test_deletion(self):
FILE: other/clrs/14/01/05.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree, size):
method sexp (line 32) | def sexp(self):
method black_height (line 42) | def black_height(self):
method isRed (line 53) | def isRed(self):
method isBlack (line 56) | def isBlack(self):
method isNil (line 59) | def isNil(self):
method isNotNil (line 62) | def isNotNil(self):
method __bool__ (line 65) | def __bool__(self):
method child (line 68) | def child(self, direction):
method set_child (line 76) | def set_child(self, direction, child):
method other (line 87) | def other(self, direction):
method rotate (line 90) | def rotate(self, direction):
method left_rotate (line 112) | def left_rotate(self):
method right_rotate (line 115) | def right_rotate(self):
method transplant (line 118) | def transplant(self, other):
method set (line 127) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 137) | def minimum(self):
method select (line 145) | def select(self, i):
method rank (line 160) | def rank(self):
method key_rank (line 172) | def key_rank(self, key):
method nth_successor (line 180) | def nth_successor(self, n):
class Tree (line 202) | class Tree:
method __init__ (line 203) | def __init__(self):
method __str__ (line 206) | def __str__(self):
method search (line 209) | def search(self, key):
method key_rank (line 222) | def key_rank(self, key):
method nodes (line 225) | def nodes(self):
method select (line 242) | def select(self, i):
method insert (line 245) | def insert(self, key):
method insert_fixup (line 271) | def insert_fixup(self, node):
method delete (line 295) | def delete(self, key):
method delete_fixup (line 336) | def delete_fixup(self, node):
FILE: other/clrs/14/01/05.test.py
class OrderStatisticTreeTest (line 9) | class OrderStatisticTreeTest(unittest.TestCase):
method test_nth_successor (line 10) | def test_nth_successor(self):
method test_key_rank (line 34) | def test_key_rank(self):
method test_rank_when_inserting (line 57) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 71) | def test_rank_when_deleting(self):
method generate (line 96) | def generate(self, m, n):
method assertContains (line 101) | def assertContains(self, tree, numbers):
method assertProperties (line 106) | def assertProperties(self, tree):
method test_insertions (line 119) | def test_insertions(self):
method test_properties (line 129) | def test_properties(self):
method test_deletion (line 138) | def test_deletion(self):
FILE: other/clrs/14/01/06.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree, rank=0):
method sexp (line 32) | def sexp(self):
method black_height (line 42) | def black_height(self):
method isRed (line 53) | def isRed(self):
method isBlack (line 56) | def isBlack(self):
method isNil (line 59) | def isNil(self):
method isNotNil (line 62) | def isNotNil(self):
method __bool__ (line 65) | def __bool__(self):
method child (line 68) | def child(self, direction):
method set_child (line 76) | def set_child(self, direction, child):
method other (line 87) | def other(self, direction):
method rotate (line 90) | def rotate(self, direction):
method depth (line 114) | def depth(self):
method left_rotate (line 124) | def left_rotate(self):
method right_rotate (line 127) | def right_rotate(self):
method transplant (line 130) | def transplant(self, other):
method set (line 139) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 149) | def minimum(self):
method select (line 157) | def select(self, i):
method rank_in_tree (line 169) | def rank_in_tree(self):
class Tree (line 187) | class Tree:
method __init__ (line 188) | def __init__(self):
method __str__ (line 191) | def __str__(self):
method display (line 194) | def display(self):
method search (line 213) | def search(self, key):
method nodes (line 226) | def nodes(self):
method select (line 243) | def select(self, i):
method insert (line 246) | def insert(self, key):
method insert_fixup (line 271) | def insert_fixup(self, node):
method delete (line 295) | def delete(self, key):
method delete_fixup (line 337) | def delete_fixup(self, node):
FILE: other/clrs/14/01/06.test.py
class OrderStatisticTreeTest (line 9) | class OrderStatisticTreeTest(unittest.TestCase):
method test_rank_when_inserting (line 10) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 24) | def test_rank_when_deleting(self):
method generate (line 49) | def generate(self, m, n):
method assertContains (line 54) | def assertContains(self, tree, numbers):
method assertProperties (line 59) | def assertProperties(self, tree):
method test_insertions (line 72) | def test_insertions(self):
method test_properties (line 82) | def test_properties(self):
method test_deletion (line 91) | def test_deletion(self):
FILE: other/clrs/14/01/07.py
function inversions (line 5) | def inversions(array):
class Color (line 15) | class Color(Enum):
function other (line 23) | def other(direction):
class Node (line 32) | class Node:
method __init__ (line 33) | def __init__(self, color, key, parent, left, right, tree, size):
method sexp (line 42) | def sexp(self):
method black_height (line 52) | def black_height(self):
method isRed (line 63) | def isRed(self):
method isBlack (line 66) | def isBlack(self):
method isNil (line 69) | def isNil(self):
method isNotNil (line 72) | def isNotNil(self):
method __bool__ (line 75) | def __bool__(self):
method child (line 78) | def child(self, direction):
method set_child (line 86) | def set_child(self, direction, child):
method other (line 97) | def other(self, direction):
method rotate (line 100) | def rotate(self, direction):
method left_rotate (line 122) | def left_rotate(self):
method right_rotate (line 125) | def right_rotate(self):
method transplant (line 128) | def transplant(self, other):
method set (line 137) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 147) | def minimum(self):
method select (line 155) | def select(self, i):
method rank (line 170) | def rank(self):
class Tree (line 189) | class Tree:
method __init__ (line 190) | def __init__(self):
method __str__ (line 193) | def __str__(self):
method search (line 196) | def search(self, key):
method rank (line 209) | def rank(self, key):
method nodes (line 212) | def nodes(self):
method select (line 229) | def select(self, i):
method insert (line 232) | def insert(self, key):
method insert_fixup (line 260) | def insert_fixup(self, node):
method delete (line 284) | def delete(self, key):
method delete_fixup (line 325) | def delete_fixup(self, node):
FILE: other/clrs/14/01/07.test.py
function count_inversions (line 9) | def count_inversions(numbers):
class OrderStatisticTreeTest (line 18) | class OrderStatisticTreeTest(unittest.TestCase):
method test_inversions (line 19) | def test_inversions(self):
FILE: other/clrs/14/01/08.py
function count_chords (line 5) | def count_chords(chords):
class Color (line 32) | class Color(Enum):
function other (line 40) | def other(direction):
class Node (line 49) | class Node:
method __init__ (line 50) | def __init__(self, color, key, parent, left, right, tree, size):
method sexp (line 59) | def sexp(self):
method black_height (line 69) | def black_height(self):
method isRed (line 80) | def isRed(self):
method isBlack (line 83) | def isBlack(self):
method isNil (line 86) | def isNil(self):
method isNotNil (line 89) | def isNotNil(self):
method __bool__ (line 92) | def __bool__(self):
method child (line 95) | def child(self, direction):
method set_child (line 103) | def set_child(self, direction, child):
method other (line 114) | def other(self, direction):
method rotate (line 117) | def rotate(self, direction):
method left_rotate (line 139) | def left_rotate(self):
method right_rotate (line 142) | def right_rotate(self):
method transplant (line 145) | def transplant(self, other):
method set (line 154) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 164) | def minimum(self):
method select (line 172) | def select(self, i):
method rank (line 187) | def rank(self):
class Tree (line 206) | class Tree:
method __init__ (line 207) | def __init__(self):
method __str__ (line 210) | def __str__(self):
method size (line 213) | def size(self):
method search (line 216) | def search(self, key):
method nodes (line 229) | def nodes(self):
method select (line 246) | def select(self, i):
method insert (line 249) | def insert(self, key):
method insert_fixup (line 275) | def insert_fixup(self, node):
method delete (line 299) | def delete(self, key):
method delete_fixup (line 340) | def delete_fixup(self, node):
FILE: other/clrs/14/01/08.test.py
function naive_chord_count (line 9) | def naive_chord_count(chords):
class OrderStatisticTreeTest (line 29) | class OrderStatisticTreeTest(unittest.TestCase):
method test_diameters (line 30) | def test_diameters(self):
method test_random_circle (line 60) | def test_random_circle(self):
FILE: other/clrs/14/02/01.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree, size, pred, ...
method sexp (line 34) | def sexp(self):
method black_height (line 44) | def black_height(self):
method isRed (line 55) | def isRed(self):
method isBlack (line 58) | def isBlack(self):
method isNil (line 61) | def isNil(self):
method isNotNil (line 64) | def isNotNil(self):
method __bool__ (line 67) | def __bool__(self):
method child (line 70) | def child(self, direction):
method set_child (line 78) | def set_child(self, direction, child):
method other (line 89) | def other(self, direction):
method rotate (line 92) | def rotate(self, direction):
method left_rotate (line 114) | def left_rotate(self):
method right_rotate (line 117) | def right_rotate(self):
method transplant (line 120) | def transplant(self, other):
method set (line 129) | def set(self, parent=None, left=None, right=None, color=None, succ=Non...
method minimum (line 143) | def minimum(self):
method select (line 151) | def select(self, i):
method rank (line 166) | def rank(self):
class Tree (line 185) | class Tree:
method __init__ (line 186) | def __init__(self):
method __str__ (line 191) | def __str__(self):
method search (line 194) | def search(self, key):
method nodes (line 207) | def nodes(self):
method select (line 224) | def select(self, i):
method insert (line 227) | def insert(self, key):
method insert_fixup (line 279) | def insert_fixup(self, node):
method delete (line 303) | def delete(self, key):
method delete_fixup (line 353) | def delete_fixup(self, node):
FILE: other/clrs/14/02/01.test.py
class OrderStatisticTreeTest (line 9) | class OrderStatisticTreeTest(unittest.TestCase):
method test_things (line 10) | def test_things(self):
method test_rank_when_inserting (line 28) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 42) | def test_rank_when_deleting(self):
method generate (line 67) | def generate(self, m, n):
method assertContains (line 72) | def assertContains(self, tree, numbers):
method assertProperties (line 77) | def assertProperties(self, tree):
method assertForwardWalk (line 90) | def assertForwardWalk(self, tree, numbers):
method assertBackwardWalk (line 101) | def assertBackwardWalk(self, tree, numbers):
method test_insertions (line 112) | def test_insertions(self):
method test_properties (line 124) | def test_properties(self):
method test_deletion (line 135) | def test_deletion(self):
FILE: other/clrs/14/03/01.py
class Interval (line 5) | class Interval:
method __init__ (line 6) | def __init__(self, low, high):
method __eq__ (line 11) | def __eq__(self, other):
method __contains__ (line 15) | def __contains__(self, n):
method __repr__ (line 18) | def __repr__(self):
method overlaps (line 23) | def overlaps(self, other):
class Color (line 27) | class Color(Enum):
function other (line 35) | def other(direction):
function max_maybe (line 43) | def max_maybe(*args):
class Node (line 46) | class Node:
method __init__ (line 47) | def __init__(self, color, interval, parent, left, right, max, tree):
method sexp (line 56) | def sexp(self):
method black_height (line 66) | def black_height(self):
method isRed (line 77) | def isRed(self):
method isBlack (line 80) | def isBlack(self):
method isNil (line 83) | def isNil(self):
method isNotNil (line 86) | def isNotNil(self):
method __bool__ (line 89) | def __bool__(self):
method child (line 92) | def child(self, direction):
method set_child (line 100) | def set_child(self, direction, child):
method other (line 111) | def other(self, direction):
method rotate (line 114) | def rotate(self, direction):
method left_rotate (line 145) | def left_rotate(self):
method right_rotate (line 148) | def right_rotate(self):
method transplant (line 151) | def transplant(self, other):
method set (line 160) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 170) | def minimum(self):
class IntervalTree (line 185) | class IntervalTree:
method __init__ (line 186) | def __init__(self):
method __str__ (line 189) | def __str__(self):
method find (line 192) | def find(self, interval):
method search (line 205) | def search(self, interval):
method nodes (line 218) | def nodes(self):
method insert (line 235) | def insert(self, interval):
method max_fixup (line 261) | def max_fixup(self, node):
method insert_fixup (line 271) | def insert_fixup(self, node):
method delete (line 295) | def delete(self, interval):
method delete_fixup (line 333) | def delete_fixup(self, node):
FILE: other/clrs/14/03/01.test.py
class IntervalTest (line 9) | class IntervalTest(unittest.TestCase):
method test_contains (line 10) | def test_contains(self):
method test_overlaps (line 18) | def test_overlaps(self):
class IntervalTreeTest (line 27) | class IntervalTreeTest(unittest.TestCase):
method test_simple_interval_tree (line 28) | def test_simple_interval_tree(self):
method test_overlapping (line 65) | def test_overlapping(self):
method test_properties (line 75) | def test_properties(self):
method assertProperties (line 104) | def assertProperties(self, tree):
FILE: other/clrs/14/03/04.py
class Interval (line 5) | class Interval:
method __init__ (line 6) | def __init__(self, low, high):
method __eq__ (line 11) | def __eq__(self, other):
method __hash__ (line 15) | def __hash__(self):
method __contains__ (line 18) | def __contains__(self, n):
method __repr__ (line 21) | def __repr__(self):
method overlaps (line 26) | def overlaps(self, other):
class Color (line 30) | class Color(Enum):
function other (line 38) | def other(direction):
function max_maybe (line 46) | def max_maybe(*args):
class Node (line 49) | class Node:
method __init__ (line 50) | def __init__(self, color, interval, parent, left, right, max, tree):
method sexp (line 59) | def sexp(self):
method black_height (line 69) | def black_height(self):
method isRed (line 80) | def isRed(self):
method isBlack (line 83) | def isBlack(self):
method isNil (line 86) | def isNil(self):
method isNotNil (line 89) | def isNotNil(self):
method __bool__ (line 92) | def __bool__(self):
method child (line 95) | def child(self, direction):
method set_child (line 103) | def set_child(self, direction, child):
method other (line 114) | def other(self, direction):
method rotate (line 117) | def rotate(self, direction):
method left_rotate (line 148) | def left_rotate(self):
method right_rotate (line 151) | def right_rotate(self):
method transplant (line 154) | def transplant(self, other):
method set (line 163) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 173) | def minimum(self):
class IntervalTree (line 188) | class IntervalTree:
method __init__ (line 189) | def __init__(self):
method __str__ (line 192) | def __str__(self):
method find (line 195) | def find(self, interval):
method search (line 208) | def search(self, interval):
method search_all (line 221) | def search_all(self, interval):
method nodes (line 239) | def nodes(self):
method insert (line 256) | def insert(self, interval):
method max_fixup (line 282) | def max_fixup(self, node):
method insert_fixup (line 292) | def insert_fixup(self, node):
method delete (line 316) | def delete(self, interval):
method delete_fixup (line 354) | def delete_fixup(self, node):
FILE: other/clrs/14/03/04.test.py
class IntervalTreeTest (line 10) | class IntervalTreeTest(unittest.TestCase):
method test_search_all (line 11) | def test_search_all(self):
FILE: other/clrs/14/03/06.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Extra (line 22) | class Extra:
method __init__ (line 23) | def __init__(self, minimum, maximum, gap):
class Node (line 29) | class Node:
method __init__ (line 30) | def __init__(self, color, key, parent, left, right, extra, tree):
method sexp (line 39) | def sexp(self):
method black_height (line 49) | def black_height(self):
method isRed (line 60) | def isRed(self):
method isBlack (line 63) | def isBlack(self):
method isNil (line 66) | def isNil(self):
method isNotNil (line 69) | def isNotNil(self):
method __bool__ (line 72) | def __bool__(self):
method child (line 75) | def child(self, direction):
method set_child (line 83) | def set_child(self, direction, child):
method other (line 94) | def other(self, direction):
method rotate (line 97) | def rotate(self, direction):
method left_rotate (line 119) | def left_rotate(self):
method right_rotate (line 122) | def right_rotate(self):
method transplant (line 125) | def transplant(self, other):
method set (line 134) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 144) | def minimum(self):
method maximum (line 152) | def maximum(self):
method recalculate (line 160) | def recalculate(self):
class MinGapTree (line 179) | class MinGapTree:
method __init__ (line 180) | def __init__(self):
method __str__ (line 183) | def __str__(self):
method min_gap (line 186) | def min_gap(self):
method search (line 189) | def search(self, key):
method nodes (line 202) | def nodes(self):
method insert (line 219) | def insert(self, key):
method insert_fixup (line 246) | def insert_fixup(self, node):
method delete (line 270) | def delete(self, key):
method delete_fixup (line 307) | def delete_fixup(self, node):
method extras_fixup (line 340) | def extras_fixup(self, node):
FILE: other/clrs/14/03/06.test.py
class MinGapTreeTest (line 10) | class MinGapTreeTest(unittest.TestCase):
method test_example_from_book (line 11) | def test_example_from_book(self):
method generate (line 33) | def generate(self, m, n):
method assertContains (line 38) | def assertContains(self, tree, numbers):
method assertProperties (line 43) | def assertProperties(self, tree):
method test_insertions (line 59) | def test_insertions(self):
method test_properties (line 69) | def test_properties(self):
method test_deletion (line 78) | def test_deletion(self):
FILE: other/clrs/14/03/07.py
function overlap (line 4) | def overlap(rectangles):
class Rectangle (line 30) | class Rectangle:
method __init__ (line 31) | def __init__(self, top, bottom, left, right):
method overlaps (line 40) | def overlaps(self, other):
method __repr__ (line 44) | def __repr__(self):
class Interval (line 48) | class Interval:
method __init__ (line 49) | def __init__(self, low, high):
method __eq__ (line 54) | def __eq__(self, other):
method __contains__ (line 58) | def __contains__(self, n):
method __repr__ (line 61) | def __repr__(self):
method overlaps (line 66) | def overlaps(self, other):
class Color (line 70) | class Color(Enum):
function other (line 78) | def other(direction):
function max_maybe (line 86) | def max_maybe(*args):
class Node (line 89) | class Node:
method __init__ (line 90) | def __init__(self, color, interval, parent, left, right, max, tree):
method sexp (line 99) | def sexp(self):
method black_height (line 109) | def black_height(self):
method isRed (line 120) | def isRed(self):
method isBlack (line 123) | def isBlack(self):
method isNil (line 126) | def isNil(self):
method isNotNil (line 129) | def isNotNil(self):
method __bool__ (line 132) | def __bool__(self):
method child (line 135) | def child(self, direction):
method set_child (line 143) | def set_child(self, direction, child):
method other (line 154) | def other(self, direction):
method rotate (line 157) | def rotate(self, direction):
method left_rotate (line 188) | def left_rotate(self):
method right_rotate (line 191) | def right_rotate(self):
method transplant (line 194) | def transplant(self, other):
method set (line 203) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 213) | def minimum(self):
class IntervalTree (line 228) | class IntervalTree:
method __init__ (line 229) | def __init__(self):
method __str__ (line 232) | def __str__(self):
method find (line 235) | def find(self, interval):
method search (line 248) | def search(self, interval):
method nodes (line 261) | def nodes(self):
method insert (line 278) | def insert(self, interval):
method max_fixup (line 304) | def max_fixup(self, node):
method insert_fixup (line 314) | def insert_fixup(self, node):
method delete (line 338) | def delete(self, interval):
method delete_fixup (line 376) | def delete_fixup(self, node):
FILE: other/clrs/14/03/07.test.py
function overlapper (line 10) | def overlapper(rectangles):
class OverlapingRectanglesTest (line 20) | class OverlapingRectanglesTest(unittest.TestCase):
method test_simple_cases (line 21) | def test_simple_cases(self):
method test_randomly_generated (line 36) | def test_randomly_generated(self):
FILE: other/clrs/14/misc/augmentable_tree.py
class Color (line 5) | class Color(Enum):
function other (line 13) | def other(direction):
class Node (line 22) | class Node:
method __init__ (line 23) | def __init__(self, color, key, parent, left, right, tree):
method sexp (line 31) | def sexp(self):
method __str__ (line 39) | def __str__(self):
method black_height (line 42) | def black_height(self):
method isRed (line 53) | def isRed(self):
method isBlack (line 56) | def isBlack(self):
method isNil (line 59) | def isNil(self):
method isNotNil (line 62) | def isNotNil(self):
method __bool__ (line 65) | def __bool__(self):
method child (line 68) | def child(self, direction):
method set_child (line 76) | def set_child(self, direction, child):
method other (line 87) | def other(self, direction):
method rotate (line 90) | def rotate(self, direction):
method left_rotate (line 112) | def left_rotate(self):
method right_rotate (line 115) | def right_rotate(self):
method transplant (line 118) | def transplant(self, other):
method set (line 127) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 137) | def minimum(self):
class AugmentableTree (line 152) | class AugmentableTree:
method __init__ (line 153) | def __init__(self):
method __str__ (line 156) | def __str__(self):
method search (line 159) | def search(self, key):
method nodes (line 172) | def nodes(self):
method insert (line 189) | def insert(self, key):
method recalculate_ancestors (line 217) | def recalculate_ancestors(self, node):
method insert_fixup (line 222) | def insert_fixup(self, node):
method delete (line 246) | def delete(self, key):
method delete_fixup (line 283) | def delete_fixup(self, node):
FILE: other/clrs/14/misc/augmentable_tree_test.py
class Interval (line 6) | class Interval:
method __init__ (line 7) | def __init__(self, low, high):
method __eq__ (line 12) | def __eq__(self, other):
method __lt__ (line 16) | def __lt__(self, other):
method __contains__ (line 19) | def __contains__(self, n):
method __repr__ (line 22) | def __repr__(self):
method overlaps (line 27) | def overlaps(self, other):
function max_maybe (line 31) | def max_maybe(*args):
class IntervalTree (line 35) | class IntervalTree(AugmentableTree):
method augment_node (line 36) | def augment_node(self, node):
method recalculate_node (line 40) | def recalculate_node(self, node):
method find (line 47) | def find(self, interval):
class IntervalTreeTest (line 61) | class IntervalTreeTest(unittest.TestCase):
method test_simple_interval_tree (line 62) | def test_simple_interval_tree(self):
method test_overlapping (line 99) | def test_overlapping(self):
method test_properties (line 109) | def test_properties(self):
method assertProperties (line 138) | def assertProperties(self, tree):
function node_size (line 158) | def node_size(node):
function select_node (line 161) | def select_node(node, i):
function rank_node (line 174) | def rank_node(node):
class OrderStatisticTree (line 185) | class OrderStatisticTree(AugmentableTree):
method augment_node (line 186) | def augment_node(self, node):
method recalculate_node (line 191) | def recalculate_node(self, node):
method select (line 194) | def select(self, i):
class OrderStatisticTreeTest (line 198) | class OrderStatisticTreeTest(unittest.TestCase):
method test_rank_when_inserting (line 199) | def test_rank_when_inserting(self):
method test_rank_when_deleting (line 213) | def test_rank_when_deleting(self):
method generate (line 238) | def generate(self, m, n):
method assertContains (line 243) | def assertContains(self, tree, numbers):
method assertProperties (line 248) | def assertProperties(self, tree):
method test_insertions (line 261) | def test_insertions(self):
method test_properties (line 271) | def test_properties(self):
method test_deletion (line 280) | def test_deletion(self):
FILE: other/clrs/14/misc/interval_tree.py
class Interval (line 5) | class Interval:
method __init__ (line 6) | def __init__(self, low, high):
method __eq__ (line 11) | def __eq__(self, other):
method __contains__ (line 15) | def __contains__(self, n):
method __repr__ (line 18) | def __repr__(self):
method overlaps (line 23) | def overlaps(self, other):
class Color (line 27) | class Color(Enum):
function other (line 35) | def other(direction):
function max_maybe (line 43) | def max_maybe(*args):
class Node (line 46) | class Node:
method __init__ (line 47) | def __init__(self, color, interval, parent, left, right, max, tree):
method sexp (line 56) | def sexp(self):
method black_height (line 66) | def black_height(self):
method isRed (line 77) | def isRed(self):
method isBlack (line 80) | def isBlack(self):
method isNil (line 83) | def isNil(self):
method isNotNil (line 86) | def isNotNil(self):
method __bool__ (line 89) | def __bool__(self):
method child (line 92) | def child(self, direction):
method set_child (line 100) | def set_child(self, direction, child):
method other (line 111) | def other(self, direction):
method rotate (line 114) | def rotate(self, direction):
method left_rotate (line 145) | def left_rotate(self):
method right_rotate (line 148) | def right_rotate(self):
method transplant (line 151) | def transplant(self, other):
method set (line 160) | def set(self, parent=None, left=None, right=None, color=None):
method minimum (line 170) | def minimum(self):
class IntervalTree (line 185) | class IntervalTree:
method __init__ (line 186) | def __init__(self):
method __str__ (line 189) | def __str__(self):
method find (line 192) | def find(self, interval):
method search (line 205) | def search(self, interval):
method nodes (line 218) | def nodes(self):
method insert (line 235) | def insert(self, interval):
method max_fixup (line 261) | def max_fixup(self, node):
method insert_fixup (line 271) | def insert_fixup(self, node):
method delete (line 295) | def delete(self, interval):
method delete_fixup (line 332) | def delete_fixup(self, node):
FILE: other/clrs/14/misc/interval_tree_test.py
class IntervalTest (line 6) | class IntervalTest(unittest.TestCase):
method test_contains (line 7) | def test_contains(self):
method test_overlaps (line 15) | def test_overlaps(self):
class IntervalTreeTest (line 24) | class IntervalTreeTest(unittest.TestCase):
method test_simple_interval_tree (line 25) | def test_simple_interval_tree(self):
method test_overlapping (line 62) | def test_overlapping(self):
method test_properties (line 72) | def test_properties(self):
method assertProperties (line 101) | def assertProperties(self, tree):
FILE: other/clrs/14/misc/order_statistic_tree.py
function node_size (line 3) | def node_size(node):
function select_node (line 6) | def select_node(node, i):
function rank_node (line 19) | def rank_node(node):
class OrderStatisticTree (line 30) | class OrderStatisticTree(AugmentableTree):
method augment_node (line 31) | def augment_node(self, node):
method recalculate_node (line 36) | def recalculate_node(self, node):
method select (line 39) | def select(self, i):
FILE: other/clrs/14/problems/01.py
class Endpoint (line 6) | class Endpoint:
method __init__ (line 7) | def __init__(self, value, weight): self.value, self.weight = value, we...
method __lt__ (line 8) | def __lt__(self, other): return (self.value, -self.weight) < (other.va...
method __eq__ (line 9) | def __eq__(self, other): return (self.value, self.weight) == (other.va...
method isLow (line 10) | def isLow(self): return self.weight == 1
function weight (line 13) | def weight(node):
function optimal (line 17) | def optimal(node):
class OverlapTree (line 21) | class OverlapTree(AugmentableTree):
method __init__ (line 22) | def __init__(self, intervals = []):
method augment_node (line 28) | def augment_node(self, node):
method recalculate_node (line 33) | def recalculate_node(self, node):
method max_overlap (line 46) | def max_overlap(self):
method insert_interval (line 49) | def insert_interval(self, interval):
method delete_interval (line 53) | def delete_interval(self, interval):
FILE: other/clrs/14/problems/01.test.py
class Interval (line 7) | class Interval:
method __init__ (line 8) | def __init__(self, low, high):
method elements (line 12) | def elements(self):
function naive_max_overlap (line 16) | def naive_max_overlap(intervals):
class OverlapTreeTest (line 28) | class OverlapTreeTest(unittest.TestCase):
method test_simple_case (line 29) | def test_simple_case(self):
method test_random_case (line 41) | def test_random_case(self):
FILE: other/clrs/14/problems/02.py
function josephus (line 6) | def josephus(n, m):
FILE: other/clrs/14/problems/02.test.py
function naive_josephus (line 9) | def naive_josephus(n, m):
class JosephusTest (line 22) | class JosephusTest(unittest.TestCase):
method test_simple_permutation (line 23) | def test_simple_permutation(self):
method test_permutations (line 26) | def test_permutations(self):
FILE: other/clrs/15/01/03.py
function cut_rod (line 1) | def cut_rod(length, prices, cut_cost=0):
FILE: other/clrs/15/01/03.test.py
class RodCuttingTest (line 6) | class RodCuttingTest(unittest.TestCase):
method setUp (line 7) | def setUp(self):
method test_cutting_without_a_cost (line 10) | def test_cutting_without_a_cost(self):
method test_cutting_with_a_cost (line 23) | def test_cutting_with_a_cost(self):
method test_equivalence_to_costless (line 27) | def test_equivalence_to_costless(self):
FILE: other/clrs/15/01/04.py
function memoized_cut_rod (line 1) | def memoized_cut_rod(length, prices):
FILE: other/clrs/15/01/04.test.py
class MemoizedRodCuttingTest (line 6) | class MemoizedRodCuttingTest(unittest.TestCase):
method setUp (line 7) | def setUp(self):
method test_cutting_without_a_cost (line 10) | def test_cutting_without_a_cost(self):
FILE: other/clrs/15/01/05.py
function fibonacci (line 1) | def fibonacci(n):
FILE: other/clrs/15/01/05.test.py
class FibonacciTest (line 6) | class FibonacciTest(unittest.TestCase):
method test_cutting_without_a_cost (line 7) | def test_cutting_without_a_cost(self):
FILE: other/clrs/15/02/01.py
function subscript (line 6) | def subscript(n):
function order (line 17) | def order(dimensions):
FILE: other/clrs/15/03/04.py
function subscript (line 6) | def subscript(n):
function optimal (line 17) | def optimal(choices, i, j):
function order (line 26) | def order(dimensions):
function greedy (line 50) | def greedy(dimensions):
FILE: other/clrs/15/03/04.run.py
function report (line 6) | def report(message, answers):
FILE: other/clrs/15/04/01.py
function lcs (line 1) | def lcs(x, y):
FILE: other/clrs/15/04/02.py
function lcs (line 1) | def lcs(x, y):
FILE: other/clrs/15/04/02.test.py
class LongestCommonSubsequenceTest (line 6) | class LongestCommonSubsequenceTest(unittest.TestCase):
method test_lcs (line 7) | def test_lcs(self):
FILE: other/clrs/15/04/03.py
function lcs (line 1) | def lcs(x, y):
FILE: other/clrs/15/04/03.test.py
class LongestCommonSubsequenceTest (line 6) | class LongestCommonSubsequenceTest(unittest.TestCase):
method test_lcs (line 7) | def test_lcs(self):
FILE: other/clrs/15/04/04.py
function lcs_twice (line 1) | def lcs_twice(x, y):
function lcs_once_plus_const (line 25) | def lcs_once_plus_const(x, y):
FILE: other/clrs/15/04/04.test.py
class LongestCommonSubsequenceTest (line 6) | class LongestCommonSubsequenceTest(unittest.TestCase):
method test_example_one (line 7) | def test_example_one(self):
method test_example_two (line 14) | def test_example_two(self):
FILE: other/clrs/15/04/05.py
function mono (line 1) | def mono(items):
FILE: other/clrs/15/04/05.test.py
class LongestMonotonicallyIncreasingSubsequenceTest (line 6) | class LongestMonotonicallyIncreasingSubsequenceTest(unittest.TestCase):
method test_examples (line 7) | def test_examples(self):
FILE: other/clrs/15/04/06.py
function mono (line 1) | def mono(items):
FILE: other/clrs/15/04/06.test.py
function quadratic (line 7) | def quadratic(items):
class FasterLongestMonotonicallyIncreasingSubsequenceTest (line 30) | class FasterLongestMonotonicallyIncreasingSubsequenceTest(unittest.TestC...
method test_examples (line 31) | def test_examples(self):
method test_comparison (line 46) | def test_comparison(self):
FILE: other/clrs/15/05/01.py
function table (line 3) | def table(h, w):
function optimal (line 6) | def optimal(p, q):
function dump_tree (line 30) | def dump_tree(root):
FILE: other/clrs/15/05/02.py
function table (line 3) | def table(h, w):
function optimal (line 6) | def optimal(p, q):
function dump_tree (line 30) | def dump_tree(root):
FILE: other/clrs/build/ext/debug_helpers.h
function fprint_array (line 3) | void fprint_array(FILE *stream, int array[], int length) {
FILE: other/clrs/build/ext/drawing.py
function unique_number (line 9) | def unique_number():
class RedBlackTrees (line 15) | class RedBlackTrees:
class Node (line 16) | class Node:
method __init__ (line 17) | def __init__(self, value, left=None, right=None, label=None, extra=[]):
method dot (line 25) | def dot(self, nils=True):
method name (line 69) | def name(self):
method node (line 72) | def node(self):
method bfs (line 78) | def bfs(self):
class Red (line 90) | class Red(Node):
method attributes (line 91) | def attributes(self):
class Black (line 94) | class Black(Node):
method attributes (line 95) | def attributes(self):
class Gray (line 98) | class Gray(Node):
method attributes (line 99) | def attributes(self):
function svg (line 103) | def svg(dot):
function process (line 109) | def process(drawings):
FILE: other/clrs/build/ext/test.h
function test_initialize (line 23) | void test_initialize() {
function test_report_assertion_error (line 35) | void test_report_assertion_error(const char *assertion_name) {
function test_report_results (line 44) | int test_report_results() {
function run_test (line 64) | void run_test(const char *name, void (*code)()) {
function abort_test (line 78) | void abort_test() {
function assert_same_arrays (line 96) | void assert_same_arrays(int a[], int b[], int l1, int l2) {
function assert_equals (line 121) | void assert_equals(int a, int b) {
function assert_true (line 136) | void assert_true(int v) {
function assert_false (line 145) | void assert_false(int v) {
function assert_null (line 164) | void assert_null(void *v) {
function assert_not_null (line 173) | void assert_not_null(void *v) {
function fail (line 192) | void fail(const char *message, ...) {
FILE: other/clrs/build/lib/catalog.rb
class Catalog (line 1) | class Catalog
method locate (line 7) | def locate
method initialize (line 12) | def initialize(root_dir)
method chapters (line 16) | def chapters
method solutions (line 20) | def solutions
method positions (line 25) | def positions
method previous (line 30) | def previous(solution)
method next (line 34) | def next(solution)
method load_solutions_and_positions (line 40) | def load_solutions_and_positions
method find_chapters (line 61) | def find_chapters
method find_sections (line 75) | def find_sections(chapter)
method find_exercises (line 82) | def find_exercises(chapter, section)
method find_problems (line 88) | def find_problems(chapter)
method glob (line 97) | def glob(dir, pattern, extension = nil, &block)
FILE: other/clrs/build/lib/chapter_number.rb
class ChapterNumber (line 1) | class ChapterNumber
method initialize (line 2) | def initialize(name)
method name (line 10) | def name
method short_name (line 18) | def short_name
method inspect (line 22) | def inspect
FILE: other/clrs/build/lib/exercise.rb
class Exercise (line 1) | class Exercise
method initialize (line 4) | def initialize(chapter, section, number)
method components (line 10) | def components
method name (line 14) | def name
method title (line 18) | def title
method location (line 22) | def location
FILE: other/clrs/build/lib/generator.rb
type Generator (line 1) | module Generator
function generate (line 4) | def generate
function copy_static_files (line 19) | def copy_static_files
function generate_css (line 24) | def generate_css
function generate_solutions (line 28) | def generate_solutions(catalog)
function generate_catalog (line 45) | def generate_catalog(catalog)
function generate_exercise (line 49) | def generate_exercise(exercise, catalog)
function generate_problem (line 53) | def generate_problem(problem, catalog)
function generate_drawings (line 57) | def generate_drawings(solution)
function generate_graph (line 63) | def generate_graph(solution)
function write_file (line 68) | def write_file(filename, content)
FILE: other/clrs/build/lib/graph.rb
type Graph (line 1) | module Graph
function render_png (line 4) | def render_png(pathname)
function render_svg (line 8) | def render_svg(pathname)
function compile_to_svg (line 12) | def compile_to_svg(code)
function list_drawings (line 20) | def list_drawings(pathname)
function render_drawing (line 24) | def render_drawing(pathname, number)
function run_draw (line 30) | def run_draw(pathname, *args)
FILE: other/clrs/build/lib/problem.rb
class Problem (line 1) | class Problem
method initialize (line 4) | def initialize(chapter, number)
method components (line 9) | def components
method name (line 13) | def name
method title (line 17) | def title
method location (line 21) | def location
FILE: other/clrs/build/lib/renderer.rb
type Renderer (line 1) | module Renderer
function render_catalog (line 4) | def render_catalog(catalog)
function render_exercise (line 12) | def render_exercise(exercise, catalog = nil)
function render_problem (line 23) | def render_problem(problem, catalog = nil)
function render_code (line 34) | def render_code(path, language)
function render_css (line 39) | def render_css
function render_view (line 46) | def render_view(name, context, &block)
function make_context (line 51) | def make_context(hash = {})
function markdown (line 59) | def markdown
function process (line 66) | def process(markdown_code)
class Markdown (line 72) | class Markdown < Redcarpet::Render::HTML
method postprocess (line 73) | def postprocess(html)
FILE: other/clrs/build/lib/runtimes.rb
type Runtimes (line 1) | module Runtimes
function for (line 4) | def for(language)
FILE: other/clrs/build/lib/runtimes/c.rb
type Runtimes (line 1) | module Runtimes
type C (line 2) | module C
function run_test (line 5) | def run_test(location, capture_output = false)
function run (line 15) | def run(location, capture_output = false)
function write_test_file (line 25) | def write_test_file(test_path, runner_path)
function compile (line 48) | def compile(code_path, target_path)
function execute (line 57) | def execute(executable_path, capture_output)
FILE: other/clrs/build/lib/runtimes/python.rb
type Runtimes (line 1) | module Runtimes
type Python (line 2) | module Python
function run (line 5) | def run(location, capture_output = false)
function run_test (line 10) | def run_test(location, capture_output = false)
function execute (line 17) | def execute(path, capture_output = false)
FILE: other/clrs/build/lib/solution.rb
type Solution (line 1) | module Solution
function location_path (line 4) | def location_path
function extension_exists? (line 8) | def extension_exists?(extension)
function markdown_path (line 12) | def markdown_path
function graph_path (line 16) | def graph_path
function draw_path (line 20) | def draw_path
function html_url (line 24) | def html_url
function languages (line 28) | def languages
function test_languages (line 34) | def test_languages
function run_languages (line 40) | def run_languages
function code? (line 46) | def code?
function tested? (line 50) | def tested?
function graph? (line 54) | def graph?
function drawings? (line 58) | def drawings?
function code_path (line 62) | def code_path(language)
function test_path (line 66) | def test_path(language)
function runner_path (line 70) | def runner_path(language)
function displayed_drawings (line 74) | def displayed_drawings
function run (line 78) | def run(language)
function run_test (line 82) | def run_test(language)
function run_and_capture_output (line 86) | def run_and_capture_output(language)
function run_tests (line 90) | def run_tests
function run_all (line 96) | def run_all
FILE: ruby/understanding-computation/03/example.rb
type Chapter03 (line 4) | module Chapter03
function generate_example (line 7) | def generate_example(base_path)
FILE: ruby/understanding-computation/03/lib/dfa.rb
class DFA (line 1) | class DFA < Struct.new(:current_state, :accept_states, :rulebook)
method accepting? (line 2) | def accepting?
method read_character (line 6) | def read_character(character)
method read_string (line 10) | def read_string(string)
FILE: ruby/understanding-computation/03/lib/dfa_design.rb
class DFADesign (line 1) | class DFADesign < Struct.new(:start_state, :accept_states, :rulebook)
method to_dfa (line 4) | def to_dfa
method accepts? (line 8) | def accepts?(string)
method reverse (line 12) | def reverse
method minimize (line 29) | def minimize
FILE: ruby/understanding-computation/03/lib/dfa_rulebook.rb
class DFARulebook (line 1) | class DFARulebook < Struct.new(:rules)
method next_state (line 2) | def next_state(state, character)
method rule_for (line 6) | def rule_for(state, character)
FILE: ruby/understanding-computation/03/lib/dot.rb
type Dot (line 1) | module Dot
type Design (line 2) | module Design
function to_dot (line 3) | def to_dot
type Rule (line 28) | module Rule
function states (line 29) | def states
function to_dot (line 33) | def to_dot
function state_repr (line 43) | def state_repr
function next_state_repr (line 47) | def next_state_repr
function repr (line 53) | def repr(state)
function draw (line 58) | def self.draw(design, file_base, open=false)
function repr (line 67) | def self.repr(state)
function reset_gensym (line 75) | def self.reset_gensym
function shorten_set (line 80) | def self.shorten_set(set_of_sets)
function gensym (line 93) | def self.gensym(state)
FILE: ruby/understanding-computation/03/lib/fa_rule.rb
class FARule (line 1) | class FARule < Struct.new(:state, :character, :next_state)
method applies_to? (line 4) | def applies_to?(state, character)
method follow (line 9) | def follow
method inspect (line 13) | def inspect
FILE: ruby/understanding-computation/03/lib/nfa.rb
class NFA (line 1) | class NFA < Struct.new(:current_states, :accept_states, :rulebook)
method accepting? (line 2) | def accepting?
method read_character (line 6) | def read_character(character)
method read_string (line 10) | def read_string(string)
method current_states (line 16) | def current_states
FILE: ruby/understanding-computation/03/lib/nfa_design.rb
class NFADesign (line 1) | class NFADesign < Struct.new(:start_state, :accept_states, :rulebook)
method accepts? (line 4) | def accepts?(string)
method to_nfa (line 8) | def to_nfa(current_states = Set[start_state])
method to_dfa_design (line 12) | def to_dfa_design
FILE: ruby/understanding-computation/03/lib/nfa_rulebook.rb
class NFARulebook (line 1) | class NFARulebook < Struct.new(:rules)
method next_states (line 2) | def next_states(states, character)
method follow_rules_for (line 6) | def follow_rules_for(state, character)
method rules_for (line 10) | def rules_for(state, character)
method follow_free_moves (line 14) | def follow_free_moves(states)
method alphabet (line 24) | def alphabet
FILE: ruby/understanding-computation/03/lib/nfa_simulation.rb
class NFASimulation (line 1) | class NFASimulation < Struct.new(:nfa_design)
method next_state (line 2) | def next_state(state, character)
method rules_for (line 8) | def rules_for(state)
method discover_states_and_rules (line 14) | def discover_states_and_rules(states)
method to_dfa_design (line 25) | def to_dfa_design
FILE: ruby/understanding-computation/03/lib/pattern.rb
type Pattern (line 1) | module Pattern
function parse (line 2) | def self.parse(string)
function bracket (line 6) | def bracket(outer_precendence)
function inspect (line 14) | def inspect
function matches? (line 18) | def matches?(string)
class Empty (line 23) | class Empty
method to_s (line 26) | def to_s
method precendence (line 30) | def precendence
method to_nfa_design (line 34) | def to_nfa_design
class Literal (line 43) | class Literal < Struct.new(:character)
method to_s (line 46) | def to_s
method precendence (line 50) | def precendence
method to_nfa_design (line 54) | def to_nfa_design
class Concatenate (line 64) | class Concatenate < Struct.new(:first, :second)
method to_s (line 67) | def to_s
method precendence (line 71) | def precendence
method to_nfa_design (line 75) | def to_nfa_design
class Choose (line 92) | class Choose < Struct.new(:first, :second)
method to_s (line 95) | def to_s
method precendence (line 99) | def precendence
method to_nfa_design (line 103) | def to_nfa_design
class Repeat (line 122) | class Repeat < Struct.new(:pattern)
method to_s (line 125) | def to_s
method precendence (line 129) | def precendence
method to_nfa_design (line 133) | def to_nfa_design
FILE: ruby/understanding-computation/04/lib/dpda.rb
class DPDA (line 1) | class DPDA < Struct.new(:current_configuration, :accept_states, :rulebook)
method accepting? (line 2) | def accepting?
method next_configuration (line 6) | def next_configuration(character)
method stuck? (line 14) | def stuck?
method read_character (line 18) | def read_character(character)
method read_string (line 22) | def read_string(string)
method current_configuration (line 28) | def current_configuration
FILE: ruby/understanding-computation/04/lib/dpda_design.rb
class DPDADesign (line 1) | class DPDADesign < Struct.new(:start_state, :bottom_character,
method accepts? (line 3) | def accepts?(string)
method to_dpda (line 7) | def to_dpda
FILE: ruby/understanding-computation/04/lib/dpda_rulebook.rb
class DPDARulebook (line 1) | class DPDARulebook < Struct.new(:rules)
method next_configuration (line 2) | def next_configuration(configuration, character)
method rule_for (line 6) | def rule_for(configuration, character)
method applies_to? (line 10) | def applies_to?(configuration, character)
method follow_free_moves (line 14) | def follow_free_moves(configuration)
FILE: ruby/understanding-computation/04/lib/lexical_analyzer.rb
class LexicalAnalyzer (line 1) | class LexicalAnalyzer < Struct.new(:string)
method analyze (line 21) | def analyze
method more_tokens? (line 29) | def more_tokens?
method next_token (line 33) | def next_token
method rule_matching (line 39) | def rule_matching(string)
method match_at_beginning (line 45) | def match_at_beginning(pattern, string)
method rule_with_longest_match (line 49) | def rule_with_longest_match(rules_with_matches)
method string_after (line 53) | def string_after(match)
FILE: ruby/understanding-computation/04/lib/npda.rb
class NPDA (line 1) | class NPDA < Struct.new(:current_configurations, :accept_states, :rulebook)
method accepting? (line 2) | def accepting?
method read_character (line 6) | def read_character(character)
method read_string (line 10) | def read_string(string)
method current_configurations (line 16) | def current_configurations
FILE: ruby/understanding-computation/04/lib/npda_design.rb
class NPDADesign (line 1) | class NPDADesign < Struct.new(:start_state, :bottom_character, :accept_s...
method accepts? (line 2) | def accepts?(string)
method to_npda (line 6) | def to_npda
FILE: ruby/understanding-computation/04/lib/npda_rulebook.rb
class NPDARulebook (line 1) | class NPDARulebook < Struct.new(:rules)
method next_configurations (line 2) | def next_configurations(configurations, character)
method follow_rules_for (line 6) | def follow_rules_for(configuration, character)
method rules_for (line 10) | def rules_for(configuration, character)
method follow_free_moves (line 14) | def follow_free_moves(configurations)
FILE: ruby/understanding-computation/04/lib/pda_configuration.rb
class PDAConfiguration (line 1) | class PDAConfiguration < Struct.new(:state, :stack)
method stuck (line 4) | def stuck
method stuck? (line 8) | def stuck?
FILE: ruby/understanding-computation/04/lib/pda_rule.rb
class PDARule (line 1) | class PDARule < Struct.new(:state, :character, :next_state,
method applies_to? (line 3) | def applies_to?(configuration, character)
method follow (line 9) | def follow(configuration)
method next_stack (line 13) | def next_stack(configuration)
FILE: ruby/understanding-computation/04/lib/simple_parser.rb
type SimpleParser (line 1) | module SimpleParser
function accepts? (line 38) | def self.accepts?(string)
FILE: ruby/understanding-computation/04/lib/stack.rb
class Stack (line 1) | class Stack < Struct.new(:contents)
method push (line 2) | def push(character)
method pop (line 6) | def pop
method top (line 10) | def top
method inspect (line 14) | def inspect
FILE: scheme/eopl/build/exercise.rb
class Exercise (line 1) | class Exercise
method initialize (line 4) | def initialize(chapter, number)
method next (line 15) | def next
method each (line 23) | def each
method each_with_test (line 31) | def each_with_test
method chapters (line 40) | def chapters(include_appendices = true)
method exercises_in_chapter (line 46) | def exercises_in_chapter(chapter)
method name (line 52) | def name
method file_path (line 56) | def file_path
method test_path (line 60) | def test_path
method exercise_require_path (line 64) | def exercise_require_path
method has_test? (line 68) | def has_test?
method formatted_chapter (line 74) | def formatted_chapter
FILE: scheme/sicp/05/support/51/evaluator.c
type p_type (line 52) | typedef enum p_type p_type;
type symbol_node (line 53) | typedef struct symbol_node symbol_node;
type memory (line 54) | typedef struct pairs memory;
type value (line 55) | typedef struct value value;
type value (line 57) | typedef value (*primitive_function)(value);
type p_type (line 68) | enum p_type {
type value (line 81) | struct value {
type pairs (line 95) | struct pairs {
function error (line 135) | void error(const char *message) {
function errorc (line 140) | void errorc(const char *message, char c) {
function errorv (line 145) | void errorv(const char *message, value val) {
function errort (line 152) | void errort(const char *message, char *token) {
function errors (line 158) | void errors(const char *message, symbol sym) {
type symbol_node (line 175) | struct symbol_node {
function symbol_node (line 180) | symbol_node* allocate_symbol_node(const char *name) {
function symbol (line 191) | symbol intern(const char *name) {
function initialize_symbols (line 226) | void initialize_symbols() {
function null_p (line 262) | bool null_p(value val) { return val.type == p_null; }
function boolean_p (line 263) | bool boolean_p(value val) { return val.type == p_boolean; }
function number_p (line 264) | bool number_p(value val) { return val.type == p_number; }
function symbol_p (line 265) | bool symbol_p(value val) { return val.type == p_symbol; }
function string_p (line 266) | bool string_p(value val) { return val.type == p_string; }
function pair_p (line 267) | bool pair_p(value val) { return val.type == p_pair; }
function procedure_p (line 268) | bool procedure_p(value val) { return val.type == p_procedure; }
function primitive_p (line 269) | bool primitive_p(value val) { return val.type == p_primitive; }
function label_p (line 270) | bool label_p(value val) { return val.type == p_label; }
function broken_heart_p (line 271) | bool broken_heart_p(value val) { return val.type == p_broken_heart; }
function value (line 275) | value null() {
function value (line 281) | value truev() {
function value (line 285) | value falsev() {
function value (line 289) | value booleanv(bool val) {
function value (line 295) | value num(long n) {
function value_to_long (line 299) | long value_to_long(value val) {
function value (line 308) | value sym(const char *s) {
function symbol (line 312) | symbol value_to_sym(value val) {
function value (line 321) | value str(const char *s) {
function value (line 329) | value cons(value car, value cdr) {
function value (line 344) | value car(value pair) {
function value (line 351) | value cdr(value pair) {
function set_car (line 358) | void set_car(value pair, value val) {
function set_cdr (line 366) | void set_cdr(value pair, value val) {
function value (line 376) | value pcons(value car, value cdr) {
function value (line 385) | value pcdr(value proc) {
function value (line 392) | value pcar(value proc) {
function value (line 401) | value primitive(primitive_function function) {
function value (line 407) | value label(void *label) {
function value (line 420) | value broken_heart() {
function wipe_memory (line 432) | void wipe_memory(memory *memory) {
function initialize_memory (line 438) | void initialize_memory() {
function push (line 455) | void push(value v) {
function value (line 462) | value pop() {
function initialize_registers (line 483) | void initialize_registers() {
function value (line 499) | value first(value pair) { return car(pair); }
function value (line 500) | value second(value pair) { return car(cdr(pair)); }
function value (line 501) | value third(value pair) { return car(cdr(cdr(pair))); }
function value (line 502) | value fourth(value pair) { return car(cdr(cdr(cdr(pair)))); }
function length (line 511) | int length(value list) {
function eq (line 522) | bool eq(value v1, value v2) {
function equal (line 526) | bool equal(value v1, value v2) {
function value (line 559) | value empty_environment() {
function value (line 563) | value extend_environment(value vars, value vals, value enclosing) {
function value (line 571) | value lookup_variable(symbol name, value env) {
function define_variable (line 592) | void define_variable(symbol name, value val, value env) {
function set_variable_value (line 601) | void set_variable_value(symbol name, value val, value env) {
function true_p (line 630) | bool true_p(value val) {
function value (line 634) | value make_procedure(value params, value body, value env) {
function value (line 638) | value procedure_parameters(value proc) { return pcar(proc); }
function value (line 639) | value procedure_body(value proc) { return first(pcdr(proc)); }
function value (line 640) | value procedure_environment(value proc) { return second(pcdr(proc)); }
function value (line 642) | value empty_arglist() {
function value (line 646) | value adjoin_arg(value arg, value arglist) {
function value (line 653) | value apply_primitive_procedure(value proc, value args) {
function value (line 669) | value prim_add(value args) {
function value (line 680) | value prim_sub(value args) {
function value (line 695) | value prim_mul(value args) {
function value (line 706) | value prim_equal_sign(value args) {
function value (line 713) | value prim_less_than_sign(value args) {
function value (line 720) | value prim_eq_p(value args) {
function value (line 724) | value prim_equal_p(value args) {
function value (line 728) | value prim_number_p(value args) {
function value (line 732) | value prim_string_p(value args) {
function value (line 736) | value prim_symbol_p(value args) {
function value (line 740) | value prim_pair_p(value args) {
function value (line 744) | value prim_null_p(value args) {
function value (line 748) | value prim_car(value args) {
function value (line 752) | value prim_cdr(value args) {
function value (line 756) | value prim_cons(value args) {
function value (line 760) | value prim_list(value args) {
function value (line 764) | value prim_set_car_bang(value args) {
function value (line 769) | value prim_set_cdr_bang(value args) {
function value (line 774) | value prim_display(value args) {
function value (line 780) | value prim_newline(value args) {
function value (line 786) | value prim_gc_runs(value args) {
function value (line 790) | value prim_stack_max_depth(value args) {
function add_primitive_to_env (line 802) | void add_primitive_to_env(value env, const char *name, primitive_functio...
function initialize_global_environment (line 806) | void initialize_global_environment() {
function gc (line 904) | void gc() {
function relocate (line 927) | void relocate(value val) {
function update (line 945) | void update(value *val) {
function relocate_registers_and_stack (line 957) | void relocate_registers_and_stack() {
function update_registers_and_stack (line 972) | void update_registers_and_stack() {
function update_value_from_old_memory (line 987) | void update_value_from_old_memory(value *val) {
function gc_if_necessary (line 994) | void gc_if_necessary() {
function print_cdr (line 1007) | void print_cdr(value v) {
function print (line 1024) | void print(value v) {
function value (line 1082) | value read(const char *string) {
function advance (line 1090) | char advance() {
function match (line 1100) | void match(char c) {
function whitespace (line 1106) | void whitespace() {
function value (line 1118) | value parse_symbol() {
function value (line 1134) | value parse_number() {
function value (line 1150) | value parse_string() {
function value (line 1170) | value parse_quote() {
function value (line 1178) | value parse_list() {
function value (line 1198) | value parse_sexp() {
function tagged_list_p (line 1220) | bool tagged_list_p(value expr, symbol tag) {
function self_evaluating_p (line 1229) | bool self_evaluating_p(value expr) { return number_p(expr) || string_p(e...
function variable_p (line 1230) | bool variable_p(value expr) { return symbol_p(expr); ...
function quoted_p (line 1231) | bool quoted_p(value expr) { return tagged_list_p(expr, s_quote)...
function begin_p (line 1232) | bool begin_p(value expr) { return tagged_list_p(expr, s_begin)...
function if_p (line 1233) | bool if_p(value expr) { return tagged_list_p(expr, s_if); ...
function definition_p (line 1234) | bool definition_p(value expr) { return tagged_list_p(expr, s_define...
function assignment_p (line 1235) | bool assignment_p(value expr) { return tagged_list_p(expr, s_set_ba...
function lambda_p (line 1236) | bool lambda_p(value expr) { return tagged_list_p(expr, s_lambda...
function application_p (line 1237) | bool application_p(value expr) { return pair_p(expr); ...
function value (line 1239) | value text_of_quotation(value expr) { return car(cdr(expr)); }
function value (line 1241) | value if_predicate(value expr) { return second(expr); }
function value (line 1242) | value if_consequent(value expr) { return third(expr); }
function value (line 1243) | value if_alternative(value expr) { return fourth(expr); }
function value (line 1245) | value operator(value expr) { return car(expr); }
function value (line 1246) | value operands(value expr) { return cdr(expr); }
function no_operands_p (line 1247) | bool no_operands_p(value expr) { return null_p(expr); }
function value (line 1249) | value lambda_parameters(value expr) { return car(cdr(expr)); }
function value (line 1250) | value lambda_body(value expr) { return cdr(cdr(expr)); }
function value (line 1252) | value assignment_variable(value expr) { return second(expr); }
function value (line 1253) | value assignment_value(value expr) { return third(expr); }
function value (line 1255) | value make_lambda(value parameters, value body) {
function value (line 1259) | value definition_variable(value expr) {
function value (line 1266) | value definition_value(value expr) {
function value (line 1274) | value begin_actions(value expr) { return cdr(expr); }
function value (line 1275) | value first_exp(value expr) { return car(expr); }
function value (line 1276) | value rest_exps(value expr) { return cdr(expr); }
function last_exp_p (line 1277) | int last_exp_p(value expr) { return pair_p(expr) && null_p(cdr(expr...
function value (line 1279) | value first_operand(value expr) { return car(expr); }
function value (line 1280) | value rest_operands(value expr) { return cdr(expr); }
function last_operand_p (line 1281) | int last_operand_p(value expr) { return pair_p(expr) && null_p(cdr(expr...
function value (line 1296) | value start() {
function value (line 1473) | value eval(value expression) {
function run_file (line 1490) | void run_file(const char *filename) {
function value (line 1522) | value read_line() {
function repl (line 1529) | void repl() {
function main (line 1551) | int main(int argc, char *argv[]) {
FILE: scheme/sicp/05/support/52/runtime.c
type p_type (line 29) | typedef enum p_type p_type;
type symbol_node (line 30) | typedef struct symbol_node symbol_node;
type memory (line 31) | typedef struct pairs memory;
type value (line 32) | typedef struct value value;
type value (line 34) | typedef value (*primitive_function)(value);
type p_type (line 40) | enum p_type {
type value (line 53) | struct value {
type pairs (line 62) | struct pairs {
function error (line 94) | void error(const char *message) {
function errorc (line 99) | void errorc(const char *message, char c) {
function errorv (line 104) | void errorv(const char *message, value val) {
function errort (line 111) | void errort(const char *message, char *token) {
function errors (line 117) | void errors(const char *message, symbol sym) {
type symbol_node (line 128) | struct symbol_node {
function symbol_node (line 133) | symbol_node* allocate_symbol_node(const char *name) {
function symbol (line 144) | symbol intern(const char *name) {
function initialize_symbols (line 176) | void initialize_symbols() {
function null_p (line 192) | bool null_p(value val) { return val.type == p_null; }
function boolean_p (line 193) | bool boolean_p(value val) { return val.type == p_boolean; }
function number_p (line 194) | bool number_p(value val) { return val.type == p_number; }
function symbol_p (line 195) | bool symbol_p(value val) { return val.type == p_symbol; }
function string_p (line 196) | bool string_p(value val) { return val.type == p_string; }
function pair_p (line 197) | bool pair_p(value val) { return val.type == p_pair; }
function procedure_p (line 198) | bool procedure_p(value val) { return val.type == p_procedure; }
function primitive_p (line 199) | bool primitive_p(value val) { return val.type == p_primitive; }
function label_p (line 200) | bool label_p(value val) { return val.type == p_label; }
function broken_heart_p (line 201) | bool broken_heart_p(value val) { return val.type == p_broken_heart; }
function value (line 205) | value null() {
function value (line 211) | value truev() {
function value (line 215) | value falsev() {
function value (line 219) | value booleanv(bool val) {
function value (line 225) | value num(long n) {
function value_to_long (line 229) | long value_to_long(value val) {
function value (line 238) | value sym(const char *s) {
function symbol (line 242) | symbol value_to_sym(value val) {
function value (line 251) | value str(const char *s) {
function value (line 259) | value cons(value car, value cdr) {
function value (line 274) | value car(value pair) {
function value (line 281) | value cdr(value pair) {
function set_car (line 288) | void set_car(value pair, value val) {
function set_cdr (line 296) | void set_cdr(value pair, value val) {
function value (line 306) | value pcons(value car, value cdr) {
function value (line 315) | value pcdr(value proc) {
function value (line 322) | value pcar(value proc) {
function value (line 331) | value primitive(primitive_function function) {
function value (line 337) | value label(void *label) {
function value (line 350) | value broken_heart() {
function wipe_memory (line 358) | void wipe_memory(memory *memory) {
function initialize_memory (line 364) | void initialize_memory() {
function push (line 379) | void push(value v) {
function value (line 386) | value pop() {
function initialize_registers (line 404) | void initialize_registers() {
function value (line 416) | value first(value pair) { return car(pair); }
function value (line 417) | value second(value pair) { return car(cdr(pair)); }
function value (line 418) | value third(value pair) { return car(cdr(cdr(pair))); }
function value (line 419) | value fourth(value pair) { return car(cdr(cdr(cdr(pair)))); }
function length (line 425) | int length(value list) {
function eq (line 436) | bool eq(value v1, value v2) {
function equal (line 440) | bool equal(value v1, value v2) {
function value (line 463) | value empty_environment() {
function value (line 467) | value extend_environment(value vars, value vals, value enclosing) {
function value (line 475) | value lookup_variable(symbol name, value env) {
function define_variable (line 496) | void define_variable(symbol name, value val, value env) {
function set_variable_value (line 505) | void set_variable_value(symbol name, value val, value env) {
function value (line 532) | value apply_primitive_procedure(value proc, value args) {
function value (line 545) | value prim_add(value args) {
function value (line 556) | value prim_sub(value args) {
function value (line 571) | value prim_mul(value args) {
function value (line 582) | value prim_equal_sign(value args) {
function value (line 589) | value prim_less_than_sign(value args) {
function value (line 596) | value prim_eq_p(value args) {
function value (line 600) | value prim_equal_p(value args) {
function value (line 604) | value prim_number_p(value args) {
function value (line 608) | value prim_string_p(value args) {
function value (line 612) | value prim_symbol_p(value args) {
function value (line 616) | value prim_pair_p(value args) {
function value (line 620) | value prim_null_p(value args) {
function value (line 624) | value prim_car(value args) {
function value (line 628) | value prim_cdr(value args) {
function value (line 632) | value prim_cons(value args) {
function value (line 636) | value prim_list(value args) {
function value (line 640) | value prim_set_car_bang(value args) {
function value (line 645) | value prim_set_cdr_bang(value args) {
function value (line 650) | value prim_display(value args) {
function value (line 656) | value prim_newline(value args) {
function value (line 662) | value prim_gc_if_necessary(value args) {
function value (line 667) | value prim_gc_runs(value args) {
function value (line 671) | value prim_stack_max_depth(value args) {
function value (line 675) | value prim_apply_primitive(value args) {
function value (line 685) | value prim_error(value args) {
function add_primitive_to_env (line 699) | void add_primitive_to_env(value env, const char *name, primitive_functio...
function initialize_global_environment (line 703) | void initialize_global_environment() {
function gc (line 758) | void gc() {
function relocate (line 781) | void relocate(value val) {
function update (line 799) | void update(value *val) {
function relocate_registers_and_stack (line 811) | void relocate_registers_and_stack() {
function update_registers_and_stack (line 824) | void update_registers_and_stack() {
function update_value_from_old_memory (line 837) | void update_value_from_old_memory(value *val) {
function gc_if_necessary (line 844) | void gc_if_necessary() {
function print_cdr (line 855) | void print_cdr(value v) {
function print (line 872) | void print(value v) {
function value (line 922) | value read(const char *string) {
function advance (line 930) | char advance() {
function match (line 940) | void match(char c) {
function whitespace (line 946) | void whitespace() {
function value (line 958) | value parse_symbol() {
function value (line 974) | value parse_number() {
function value (line 990) | value parse_string() {
function value (line 1010) | value parse_quote() {
function value (line 1018) | value parse_list() {
function value (line 1038) | value parse_sexp() {
function run_file (line 1058) | void run_file(const char *filename) {
function value (line 1087) | value read_line() {
function repl (line 1094) | void repl() {
function main (line 1113) | int main(int argc, char *argv[]) {
function primitive_procedure_p (line 1135) | bool primitive_procedure_p(value proc) {
function value (line 1139) | value lookup_variable_value(value name, value env) {
function value (line 1143) | value list(value singleton) {
function value (line 1147) | value make_compiled_procedure(value entry, value env) {
function value (line 1151) | value compiled_procedure_entry(value proc) {
function value (line 1155) | value compiled_procedure_env(value proc) {
function set_variable_value_bang (line 1159) | void set_variable_value_bang(value name, value val, value env) {
function define_variable_bang (line 1163) | void define_variable_bang(value name, value val, value env) {
function true_p (line 1167) | bool true_p(value val) {
function false_p (line 1171) | bool false_p(value val) {
function value (line 1194) | value eval(value expr) {
Condensed preview — 1993 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (4,549K chars).
[
{
"path": ".git-hooks/install-hooks",
"chars": 454,
"preview": "#!/usr/bin/env zsh\n\nemulate -R zsh\n\ncd ${0%/*}\n\nhooks_dir=\"$(git rev-parse --git-dir)/hooks\"\n\nfor hook in *; do\n if ["
},
{
"path": ".git-hooks/prepare-commit-msg",
"chars": 1543,
"preview": "#!/usr/bin/env zsh\nemulate -LR zsh\nsetopt extendedglob\n\nfiles=(\"${(@f)$(git diff --cached --name-only)}\")\n\ncase $files[1"
},
{
"path": ".gitignore",
"chars": 67,
"preview": "java/**/bin/**\njava/*/.classpath\njava/*/.project\njava/*/.settings/\n"
},
{
"path": "README",
"chars": 149,
"preview": "You should probably not care about this project. It contains various code I decided to keep for various reason, none of "
},
{
"path": "Rakefile",
"chars": 166,
"preview": "desc 'Install git hooks'\ntask :hooks do\n Dir['git-hooks/*'].each do |file|\n name = file.split('/').last\n sh \"ln -"
},
{
"path": "advent-of-code/2020/01.1.pl",
"chars": 261,
"preview": "use strict;\nuse v5.32;\n\nopen INPUT, '<', 'inputs/1.1';\n\nmy @numbers;\n\nwhile (<INPUT>) {\n chomp $_;\n push @numbers, $_;"
},
{
"path": "advent-of-code/2020/01.2.pl",
"chars": 315,
"preview": "use strict;\nuse v5.32;\n\nopen INPUT, '<', 'inputs/1.1';\n\nmy @numbers;\n\nwhile (<INPUT>) {\n chomp $_;\n push @numbers, $_;"
},
{
"path": "advent-of-code/2020/02.1.pl",
"chars": 324,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/2' or die;\n\nmy $valid = 0;\n\nwhile (<INPUT>) {\n /^(\\d+)-(\\d+) (\\w): ("
},
{
"path": "advent-of-code/2020/02.2.pl",
"chars": 364,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/2' or die;\n\nmy $valid = 0;\n\nmy $count = 0;\nwhile (<INPUT>) {\n $count"
},
{
"path": "advent-of-code/2020/03.1.pl",
"chars": 376,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/3' or die;\n\nmy $input = [map { chomp; $_ } <INPUT>];\nmy $width = leng"
},
{
"path": "advent-of-code/2020/03.2.pl",
"chars": 768,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( reduce );\n\nopen INPUT, '<', 'inputs/3' or die;\n\nsub collisions {\n my ( $inp"
},
{
"path": "advent-of-code/2020/04.1.pl",
"chars": 401,
"preview": "use v5.32;\nuse warnings;\nuse Set::Scalar;\n\nopen INPUT, '<', 'inputs/4';\n\nmy $required = Set::Scalar->new(qw(byr iyr eyr "
},
{
"path": "advent-of-code/2020/04.2.pl",
"chars": 1018,
"preview": "use v5.32;\nuse warnings;\nuse Set::Scalar;\nuse Data::Dump qw(dump);\n\nopen INPUT, '<', 'inputs/4';\n\nmy $required = Set::Sc"
},
{
"path": "advent-of-code/2020/05.1.pl",
"chars": 440,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw(max);\n\nmy $line = 'BFFFBBFRRR';\n\nopen INPUT, '<', 'inputs/5';\n\nsub seat {\n $"
},
{
"path": "advent-of-code/2020/05.2.pl",
"chars": 540,
"preview": "use v5.32;\nuse warnings;\nuse Array::Utils qw(array_minus);\nuse List::Util qw(min max);\n\nmy $line = 'BFFFBBFRRR';\n\nopen I"
},
{
"path": "advent-of-code/2020/06.1.pl",
"chars": 320,
"preview": "use v5.32;\nuse warnings;\nuse Data::Dump qw( dump );\nuse List::Util qw( reduce );\nuse List::MoreUtils qw( uniq );\n\nopen I"
},
{
"path": "advent-of-code/2020/06.2.pl",
"chars": 405,
"preview": "use v5.32;\nuse warnings;\nuse Data::Dump qw( dump );\nuse List::Util qw( reduce );\nuse List::MoreUtils qw( uniq );\nuse Set"
},
{
"path": "advent-of-code/2020/07.1.pl",
"chars": 767,
"preview": "use v5.32;\nuse warnings;\nuse Data::Dump qw(dump);\n\nmy %bags;\n\nopen INPUT, '<', 'inputs/7' or die;\n\nwhile (<INPUT>) {\n /"
},
{
"path": "advent-of-code/2020/07.2.pl",
"chars": 732,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( reduce );\nuse Data::Dump qw(dump);\n\nmy %bags;\n\nopen INPUT, '<', 'inputs/7' o"
},
{
"path": "advent-of-code/2020/08.1.pl",
"chars": 506,
"preview": "use v5.32;\nuse warnings;\nuse experimental qw( switch );\n\nmy @instructions;\n\nopen INPUT, '<', 'inputs/8';\n\nwhile ( <INPUT"
},
{
"path": "advent-of-code/2020/08.2.pl",
"chars": 1212,
"preview": "use v5.32;\nuse warnings;\nuse experimental qw( switch );\n\nuse Storable qw( dclone );\n\nmy @instructions;\n\nopen INPUT, '<',"
},
{
"path": "advent-of-code/2020/09.1.pl",
"chars": 711,
"preview": "use v5.32;\nuse warnings;\n\nuse Data::Dump qw(dump);\n\nopen INPUT, '<', 'inputs/9';\n\nmy $preamble = 25;\n\nmy $consume = $pre"
},
{
"path": "advent-of-code/2020/09.2.pl",
"chars": 1298,
"preview": "use v5.32;\nuse warnings;\n\nuse List::Util qw( min max );\nuse Data::Dump qw(dump);\n\nopen INPUT, '<', 'inputs/9';\nmy $pream"
},
{
"path": "advent-of-code/2020/10.1.pl",
"chars": 373,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( max );\n\nopen INPUT, '<', 'inputs/10';\n\nmy @numbers = ( 0 );\n\nwhile (<INPUT>)"
},
{
"path": "advent-of-code/2020/10.2.pl",
"chars": 529,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( max reduce );\n\nopen INPUT, '<', 'inputs/10';\n\nmy @numbers;\n\nwhile (<INPUT>) "
},
{
"path": "advent-of-code/2020/11.1.pl",
"chars": 1263,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/11';\n\nmy $plan;\n\nwhile ( <INPUT> ) {\n chomp;\n push @$plan, [ split "
},
{
"path": "advent-of-code/2020/11.2.pl",
"chars": 1839,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/11';\n\nmy $plan;\n\nwhile ( <INPUT> ) {\n chomp;\n push @$plan, [ split "
},
{
"path": "advent-of-code/2020/12.1.pl",
"chars": 863,
"preview": "use v5.32;\nuse warnings;\nuse experimental qw(smartmatch switch);\n\nopen INPUT, '<', 'inputs/12';\n\nmy @pos = ( 0, 0 );\nmy "
},
{
"path": "advent-of-code/2020/12.2.pl",
"chars": 874,
"preview": "use v5.32;\nuse warnings;\nuse experimental qw(smartmatch switch);\n\nopen INPUT, '<', 'inputs/12';\n\nmy @pos = ( 0, 0 );\nmy "
},
{
"path": "advent-of-code/2020/13.1.pl",
"chars": 420,
"preview": "use v5.32;\nuse warnings;\n\nopen INPUT, '<', 'inputs/13';\nmy $contents = do { local $/; <INPUT> };\n\nmy ( $time, $schedule "
},
{
"path": "advent-of-code/2020/13.2.pl",
"chars": 465,
"preview": "use v5.32;\nuse warnings;\n\nuse Math::Utils qw( gcd );\n\nopen INPUT, '<', 'inputs/13';\nmy $contents = do { local $/; <INPUT"
},
{
"path": "advent-of-code/2020/14.1.pl",
"chars": 516,
"preview": "use v5.32;\nuse warnings;\nuse experimental \"switch\";\nuse bigint;\nuse List::Util qw( sum );\n\nopen INPUT, '<', 'inputs/14';"
},
{
"path": "advent-of-code/2020/14.2.pl",
"chars": 966,
"preview": "use v5.32;\nuse warnings;\nuse experimental \"switch\";\nuse bigint;\nuse List::Util qw( sum );\nuse List::MoreUtils qw( uniq z"
},
{
"path": "advent-of-code/2020/15.1.pl",
"chars": 399,
"preview": "use v5.32;\nuse warnings;\n\nmy @numbers = ( 15, 12, 0, 14, 3, 1 );\n\nmy %spoken;\nmy $next = shift @numbers;\nmy $turn = 1;\n\n"
},
{
"path": "advent-of-code/2020/15.2.pl",
"chars": 403,
"preview": "use v5.32;\nuse warnings;\n\nmy @numbers = ( 15, 12, 0, 14, 3, 1 );\n\nmy %spoken;\nmy $next = shift @numbers;\nmy $turn = 1;\n\n"
},
{
"path": "advent-of-code/2020/16.1.pl",
"chars": 749,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( none );\n\nopen INPUT, '<', 'inputs/16';\n\nmy $contents = do { local $/; <INPUT"
},
{
"path": "advent-of-code/2020/16.2.pl",
"chars": 1603,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( none );\nuse Set::Scalar;\n\nopen INPUT, '<', 'inputs/16';\n\nmy $contents = do {"
},
{
"path": "advent-of-code/2020/17.1.pl",
"chars": 1155,
"preview": "use v5.32;\nuse warnings;\nuse Hash::MultiKey;\nuse List::Util qw( sum uniq );\n\nmy %game;\ntie %game, 'Hash::MultiKey';\n\nmy "
},
{
"path": "advent-of-code/2020/17.2.pl",
"chars": 1231,
"preview": "use v5.32;\nuse warnings;\nuse Hash::MultiKey;\nuse List::Util qw( sum uniq );\n\nmy %game;\ntie %game, 'Hash::MultiKey';\n\nmy "
},
{
"path": "advent-of-code/2020/18.1.pl",
"chars": 913,
"preview": "use v5.32;\nuse warnings;\nuse experimental 'switch';\n\nopen INPUT, '<', 'inputs/18';\n\nsub evaluate {\n my $tokens = shift;"
},
{
"path": "advent-of-code/2020/18.2.pl",
"chars": 670,
"preview": "use v5.32;\nuse warnings;\n\nmy $parse = qr{\n (?&MULT) (?{ $_ = $^R->[1] })\n\n (?(DEFINE)\n (?<NUMBER> ( \\d ) (?{ [$^R, "
},
{
"path": "advent-of-code/2020/19.1.pl",
"chars": 858,
"preview": "use v5.32;\nuse warnings;\nuse experimental 'switch';\n\nopen INPUT, '<', 'inputs/19';\nmy $contents = do { local $/; <INPUT>"
},
{
"path": "advent-of-code/2020/19.2.pl",
"chars": 319,
"preview": "use v5.32;\nuse warnings;\n\nopen STDIN, '<', 'inputs/19';\n\n$/ x= 2;\n$_ = <>;\ns/^8: .*$/8: 42 | 42 8/m;\ns/^11: .*$/11: 42 3"
},
{
"path": "advent-of-code/2020/20.1.pl",
"chars": 2745,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( first min max reduce );\n\nopen STDIN, '<', 'inputs/20';\n\nmy @tiles;\n\nsub bin "
},
{
"path": "advent-of-code/2020/20.2.pl",
"chars": 5144,
"preview": "use v5.32;\nuse warnings;\nuse List::Util qw( first min max reduce );\nuse List::MoreUtils qw( all );\nuse Hash::MultiKey;\n\n"
},
{
"path": "advent-of-code/2020/21.1.pl",
"chars": 1079,
"preview": "use v5.32;\nuse warnings;\nuse Set::Scalar;\nuse List::Util qw( uniq );\nuse Array::Utils qw( array_diff );\n\nopen STDIN, '<'"
},
{
"path": "advent-of-code/2020/21.2.pl",
"chars": 1259,
"preview": "use v5.32;\nuse warnings;\nuse Set::Scalar;\nuse List::Util qw( uniq );\nuse Array::Utils qw( array_diff );\n\nopen STDIN, '<'"
},
{
"path": "advent-of-code/2020/22.1.pl",
"chars": 429,
"preview": "use v5.32;\nuse warnings;\nuse List::MoreUtils qw( zip );\n\nopen STDIN, '<', 'inputs/22';\n\n$_ = do { local $/; <> };\nm/^Pla"
},
{
"path": "advent-of-code/2020/22.2.pl",
"chars": 1104,
"preview": "use v5.32;\nuse warnings;\nuse List::MoreUtils qw( zip );\n\nopen STDIN, '<', 'inputs/22';\n\n$_ = do { local $/; <> };\nm/^Pla"
},
{
"path": "advent-of-code/2020/23.1.pl",
"chars": 2096,
"preview": "use v5.32;\nuse warnings;\n\nuse List::Util qw( any );\nuse constant INPUT => '784235916';\n\npackage Ring {\n use List::MoreU"
},
{
"path": "advent-of-code/2020/23.2.pl",
"chars": 1487,
"preview": "use v5.32;\nuse warnings;\n\nuse List::Util qw( any );\nuse constant INPUT => '784235918';\nuse constant LIMIT => 1_000_000;\n"
},
{
"path": "advent-of-code/2020/24.1.pl",
"chars": 704,
"preview": "use v5.32;\nuse warnings;\nuse experimental 'switch';\n\nuse Hash::MultiKey;\n\nopen STDIN, '<', 'inputs/24';\n\nsub coordinates"
},
{
"path": "advent-of-code/2020/24.2.pl",
"chars": 1355,
"preview": "use v5.32;\nuse warnings;\nuse experimental 'switch';\n\nuse List::Util qw( uniq );\nuse Hash::MultiKey;\n\nopen STDIN, '<', 'i"
},
{
"path": "advent-of-code/2020/25.1.pl",
"chars": 523,
"preview": "use v5.32;\nuse warnings;\n\nuse constant MOD => 20201227;\n\nsub transform {\n my ( $loop, $subject ) = @_;\n my $result = 1"
},
{
"path": "advent-of-code/2020/25.2.pl",
"chars": 0,
"preview": ""
},
{
"path": "advent-of-code/2020/inputs/1.1",
"chars": 991,
"preview": "1028\n1987\n1938\n1136\n1503\n1456\n1107\n1535\n1946\n1986\n855\n1587\n1632\n1548\n1384\n1894\n1092\n1876\n1914\n1974\n1662\n1608\n2004\n1464\n1"
},
{
"path": "advent-of-code/2020/inputs/10",
"chars": 332,
"preview": "84\n60\n10\n23\n126\n2\n128\n63\n59\n69\n127\n73\n140\n55\n154\n133\n36\n139\n4\n70\n110\n97\n153\n105\n41\n106\n79\n145\n35\n134\n146\n148\n13\n77\n49\n10"
},
{
"path": "advent-of-code/2020/inputs/11",
"chars": 8460,
"preview": "LLLLLLL.LLLLLLLLLLLL.LL.L.LLLLLLLLLLLLLLLLLL.LLLLL.LLLLLLL.LLLLLLLLL.LLLL.LLLLL.LLLLLLLLLLLLL\nLLLLLLL.LLLLLLLLLLLL.LLL.."
},
{
"path": "advent-of-code/2020/inputs/12",
"chars": 2807,
"preview": "F29\nE5\nL90\nW1\nR90\nE1\nR90\nW5\nF32\nE2\nS3\nR270\nF61\nR180\nR180\nE2\nF13\nR180\nF18\nL180\nF15\nN2\nS2\nR270\nN2\nF81\nW4\nN2\nE1\nN5\nF5\nN3\nR9"
},
{
"path": "advent-of-code/2020/inputs/13",
"chars": 163,
"preview": "1006726\n23,x,x,x,x,x,x,x,x,x,x,x,x,41,x,x,x,x,x,x,x,x,x,647,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,13,19,x,x,x,x,x,x,x,x,x,29"
},
{
"path": "advent-of-code/2020/inputs/14",
"chars": 13797,
"preview": "mask = 11110100010101111011001X0100XX00100X\nmem[17610] = 1035852\nmem[55284] = 229776690\nmem[16166] = 12685380\nmem[8340] "
},
{
"path": "advent-of-code/2020/inputs/16",
"chars": 19185,
"preview": "departure location: 26-724 or 743-964\ndeparture station: 33-845 or 864-954\ndeparture platform: 26-472 or 482-967\ndepartu"
},
{
"path": "advent-of-code/2020/inputs/17",
"chars": 72,
"preview": "#####..#\n#..###.#\n###.....\n.#.#.#..\n##.#..#.\n######..\n.##..###\n###.####\n"
},
{
"path": "advent-of-code/2020/inputs/18",
"chars": 19536,
"preview": "2 * 9 + 5 + ((8 + 6 + 5) * (2 + 3 * 9 + 3) + 5) * (7 + 9 + 7 + 3 * 7) * 5\n7 + (2 + 8 * 8 * 2 + (4 * 3 * 9 + 4 * 4)) + 4 "
},
{
"path": "advent-of-code/2020/inputs/19",
"chars": 16408,
"preview": "2: 12 16 | 41 26\n55: 92 16 | 84 26\n107: 48 26 | 29 16\n91: 16 86 | 26 120\n56: 19 16 | 30 26\n33: 69 16 | 127 26\n65: 112 16"
},
{
"path": "advent-of-code/2020/inputs/2",
"chars": 20510,
"preview": "1-4 m: mrfmmbjxr\n5-16 b: bbbbhbbbbpbxbbbcb\n7-8 x: qxrxmxccxxx\n9-11 k: kkkkkkktmkhk\n8-12 g: sgwvdxzhkvndv\n6-9 v: zvmvvmvv"
},
{
"path": "advent-of-code/2020/inputs/20",
"chars": 17568,
"preview": "Tile 2011:\n.##...#..#\n.#.#.#...#\n.......###\n.....##.#.\n#...#.....\n##...#...#\n#.#.#....#\n##..##....\n.....#.#..\n##.#......"
},
{
"path": "advent-of-code/2020/inputs/21",
"chars": 15037,
"preview": "vzkbf lxrsn mnj bjqfl brqg kcddk nkjc bgblpf xxhp cfb pzqgtb cggl cjhv vplz dlhfnjb jtfmtpd ccmvjbn jgrrd dvjxl tdrxvd v"
},
{
"path": "advent-of-code/2020/inputs/22",
"chars": 162,
"preview": "Player 1:\n6\n25\n8\n24\n30\n46\n42\n32\n27\n48\n5\n2\n14\n28\n37\n17\n9\n22\n40\n33\n3\n50\n47\n19\n41\n\nPlayer 2:\n1\n18\n31\n39\n16\n10\n35\n29\n26\n44\n2"
},
{
"path": "advent-of-code/2020/inputs/24",
"chars": 13628,
"preview": "neswsewswseswseenwseneswseswswswseswse\nnwnenwwnwnwneswnenweswnwnwnwnenwswnese\nwnewwwwwwwwswwwsewnwwswnee\nwseeeeeeesesene"
},
{
"path": "advent-of-code/2020/inputs/3",
"chars": 10336,
"preview": ".#..........#...#...#..#.......\n.###...#.#.##..###..#...#...#..\n#.....#................#...#.#.\n#.....#..###............"
},
{
"path": "advent-of-code/2020/inputs/3.sample",
"chars": 133,
"preview": "..##.......\n#...#...#..\n.#....#..#.\n..#.#...#.#\n.#...##..#.\n..#.##.....\n.#.#.#....#\n.#........#\n#.##...#...\n#...##....#\n"
},
{
"path": "advent-of-code/2020/inputs/4",
"chars": 21916,
"preview": "iyr:2015 cid:189 ecl:oth byr:1947 hcl:#6c4ab1 eyr:2026\nhgt:174cm\npid:526744288\n\npid:688706448 iyr:2017 hgt:162cm cid:174"
},
{
"path": "advent-of-code/2020/inputs/4.sample",
"chars": 282,
"preview": "ecl:gry pid:860033327 eyr:2020 hcl:#fffffd\nbyr:1937 iyr:2017 cid:147 hgt:183cm\n\niyr:2013 ecl:amb cid:350 eyr:2023 pid:02"
},
{
"path": "advent-of-code/2020/inputs/5",
"chars": 9306,
"preview": "FBBFFBBLLL\nFFBFFFBRLL\nFFBBBBFRRL\nFBFBBBBRLL\nBFBBBBFLLR\nFFFBBBBLRR\nBFFFFFBLLL\nBBFFFBFRRL\nFFBFFFFLLR\nBFFFBBBRRL\nFBFBFFFLRL"
},
{
"path": "advent-of-code/2020/inputs/6",
"chars": 18473,
"preview": "bapocnysdr\nlpandcmb\nbplndca\n\nrgi\nci\ni\niv\n\nxdgwtsc\ngtcxswd\nsdcxtwg\n\ng\nj\nk\n\ndrcmwzh\naostudi\n\nqziunh\nhgkaslmyz\n\nfovlpdhurzq"
},
{
"path": "advent-of-code/2020/inputs/7",
"chars": 45129,
"preview": "dim silver bags contain 3 posh fuchsia bags.\nwavy olive bags contain 1 striped olive bag, 1 dull cyan bag.\ndull coral ba"
},
{
"path": "advent-of-code/2020/inputs/8",
"chars": 5164,
"preview": "acc +13\njmp +412\nnop +137\nnop +144\nacc +33\nacc -11\njmp +445\nnop +327\nacc -10\njmp +1\njmp +578\njmp +1\njmp +415\nacc +25\nacc"
},
{
"path": "advent-of-code/2020/inputs/9",
"chars": 9023,
"preview": "30\n20\n2\n19\n18\n15\n49\n50\n23\n39\n16\n31\n41\n36\n22\n35\n40\n38\n33\n8\n13\n43\n48\n24\n42\n69\n44\n10\n29\n60\n21\n54\n18\n26\n28\n34\n37\n39\n23\n30\n31"
},
{
"path": "advent-of-code/2021/.gitignore",
"chars": 19,
"preview": "Cargo.lock\ntarget/\n"
},
{
"path": "advent-of-code/2021/day01/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day01\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day01/src/main.rs",
"chars": 571,
"preview": "use std::fs;\n\nfn main() {\n println!(\"first = {:?}\", first());\n println!(\"second = {:?}\", second());\n}\n\nfn numbers("
},
{
"path": "advent-of-code/2021/day02/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day02\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day02/src/main.rs",
"chars": 1303,
"preview": "use std::fs;\n\nenum Direction {\n Forward(i64),\n Up(i64),\n Down(i64),\n}\n\nuse Direction::*;\n\nfn main() {\n print"
},
{
"path": "advent-of-code/2021/day03/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day03\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day03/src/main.rs",
"chars": 2025,
"preview": "use std::fs;\n\nfn main() {\n println!(\"first = {:?}\", first());\n println!(\"second = {:?}\", second());\n}\n\nfn input() "
},
{
"path": "advent-of-code/2021/day04/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day04\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day04/src/main.rs",
"chars": 2223,
"preview": "use std::fs;\n\nstruct Cell {\n number: i64,\n marked: bool,\n}\n\nstruct Board {\n rows: Vec<Vec<Cell>>,\n score: Op"
},
{
"path": "advent-of-code/2021/day05/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day05\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day05/src/main.rs",
"chars": 2217,
"preview": "use std::collections::HashMap;\nuse std::fs;\n\n#[derive(Debug, PartialEq, Eq, Hash)]\nstruct Point {\n x: i64,\n y: i64"
},
{
"path": "advent-of-code/2021/day06/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day06\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day06/src/main.rs",
"chars": 784,
"preview": "use std::fs::read_to_string;\n\nfn parse_input() -> Vec<usize> {\n let input = read_to_string(\"../inputs/06\").unwrap();\n"
},
{
"path": "advent-of-code/2021/day07/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day07\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day07/src/main.rs",
"chars": 775,
"preview": "use std::fs::read_to_string;\n\nfn parse_input() -> Vec<i64> {\n let input = read_to_string(\"../inputs/07\").unwrap();\n "
},
{
"path": "advent-of-code/2021/day08/Cargo.toml",
"chars": 226,
"preview": "[package]\nname = \"day08\"\nversion = \"0.1.0\"\nauthors = [\"Stefan Kanev <stefan.kanev@gmail.com>\"]\nedition = \"2018\"\n\n# See m"
},
{
"path": "advent-of-code/2021/day08/src/main.rs",
"chars": 2178,
"preview": "use std::fs::read_to_string;\n\n#[derive(Debug)]\nstruct InputLine {\n patterns: Vec<String>,\n output: Vec<String>,\n}\n"
},
{
"path": "advent-of-code/2021/day09/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day09\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day09/src/main.rs",
"chars": 1989,
"preview": "use std::{collections::VecDeque, fs};\n\nfn parse_input() -> Vec<Vec<u8>> {\n let text = fs::read_to_string(\"../inputs/0"
},
{
"path": "advent-of-code/2021/day10/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day10\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day10/src/main.rs",
"chars": 1255,
"preview": "use std::fs;\n\nfn score(input: &str) -> (usize, usize) {\n let mut stack: Vec<char> = vec![];\n\n for char in input.ch"
},
{
"path": "advent-of-code/2021/day11/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day11\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day11/src/main.rs",
"chars": 1586,
"preview": "use std::fs;\n\ntype Board = Vec<Vec<usize>>;\n\nfn advance(board: &mut Board, h: usize, w: usize) -> usize {\n fn increme"
},
{
"path": "advent-of-code/2021/day12/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day12\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day12/src/main.rs",
"chars": 1692,
"preview": "use std::{collections::HashMap, fs};\n\ntype Graph<'a> = HashMap<&'a str, Vec<&'a str>>;\n\nfn is_small(cave: &str) -> bool "
},
{
"path": "advent-of-code/2021/day13/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day13\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day13/src/main.rs",
"chars": 1882,
"preview": "use std::{collections::HashSet, fs};\n\ntype Point = (usize, usize);\ntype Fold = (char, usize);\n\nfn parse_input() -> (Hash"
},
{
"path": "advent-of-code/2021/day14/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day14\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day14/src/main.rs",
"chars": 2182,
"preview": "use std::{collections::HashMap, fs};\n\ntype Pair = (u8, u8);\ntype RuleSet = HashMap<Pair, u8>;\ntype Histogram = HashMap<P"
},
{
"path": "advent-of-code/2021/day15/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day15\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day15/src/main.rs",
"chars": 2036,
"preview": "use std::{\n cmp::Reverse,\n collections::BinaryHeap,\n fs,\n};\n\nfn parse_input() -> Vec<Vec<i64>> {\n fs::read_t"
},
{
"path": "advent-of-code/2021/day16/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day16\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day16/src/main.rs",
"chars": 4260,
"preview": "// This is significantly more complicated than it needs to be, but I wanted to play a bit with Rust\n// and do the follow"
},
{
"path": "advent-of-code/2021/day17/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day17\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day17/src/main.rs",
"chars": 1426,
"preview": "use std::fs;\n\nfn parse_input() -> (i64, i64, i64, i64) {\n let line = fs::read_to_string(\"../inputs/17\").unwrap();\n "
},
{
"path": "advent-of-code/2021/day18/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day18\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day18/src/main.rs",
"chars": 4606,
"preview": "use std::fs;\n\n#[derive(Debug, PartialEq, Clone, Copy)]\nenum Part {\n Open,\n Close,\n Comma,\n Number(u8),\n}\n\nus"
},
{
"path": "advent-of-code/2021/day19/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day19\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day19/src/main.rs",
"chars": 6567,
"preview": "use std::{\n collections::{HashSet, VecDeque},\n fs,\n ops::{Mul, Sub},\n};\n\ntype Number = i16;\n\n#[derive(Debug, Co"
},
{
"path": "advent-of-code/2021/day20/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day20\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day20/src/main.rs",
"chars": 2174,
"preview": "use std::{collections::HashSet, fs};\n\ntype Number = i32;\ntype Point = (Number, Number);\n\nfn parse_input() -> (String, Ha"
},
{
"path": "advent-of-code/2021/day21/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day21\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day21/src/main.rs",
"chars": 2911,
"preview": "use std::{collections::HashMap, fs};\n\n#[derive(Copy, Clone, PartialEq, Eq, Hash)]\nstruct Game {\n positions: [u16; 2],"
},
{
"path": "advent-of-code/2021/day22/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day22\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day22/src/main.rs",
"chars": 3616,
"preview": "use std::fs;\n\ntype Num = i64;\n\n#[derive(Copy, Clone)]\nstruct Interval {\n from: Num,\n to: Num,\n}\n\nimpl Interval {\n "
},
{
"path": "advent-of-code/2021/day23/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day23\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day23/src/main.rs",
"chars": 5567,
"preview": "use std::cmp::Reverse;\nuse std::collections::{BinaryHeap, HashMap};\nuse std::fs;\n\ntype Cost = i32;\ntype Point = (usize, "
},
{
"path": "advent-of-code/2021/day24/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day24\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day24/src/main.rs",
"chars": 1173,
"preview": "use std::fs;\n\ntype Num = i32;\n\nfn main() {\n let digits = [1, 2, 3, 4, 5, 6, 7, 8, 9];\n let fns: Vec<(Num, Num, Num"
},
{
"path": "advent-of-code/2021/day25/Cargo.toml",
"chars": 174,
"preview": "[package]\nname = \"day25\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n# See more keys and their definitions at https://doc.rust-l"
},
{
"path": "advent-of-code/2021/day25/src/main.rs",
"chars": 1249,
"preview": "use std::fs;\n\nfn main() {\n let mut map: Vec<Vec<u8>> = fs::read_to_string(\"../inputs/25\")\n .unwrap()\n ."
},
{
"path": "advent-of-code/2021/inputs/01",
"chars": 9822,
"preview": "103\n106\n107\n110\n121\n132\n147\n148\n144\n141\n147\n149\n156\n152\n155\n156\n157\n145\n144\n145\n147\n153\n155\n175\n170\n173\n171\n205\n208\n216\n"
},
{
"path": "advent-of-code/2021/inputs/02",
"chars": 7744,
"preview": "forward 8\nforward 3\ndown 8\ndown 2\nup 1\nup 4\ndown 9\nforward 3\nforward 4\nforward 5\nforward 1\nforward 1\nup 8\nforward 2\nforw"
},
{
"path": "advent-of-code/2021/inputs/03",
"chars": 13000,
"preview": "110001010111\n011011110010\n110011110011\n101000010111\n011101100100\n111001011100\n011100000101\n011110110011\n001001111111\n111"
},
{
"path": "advent-of-code/2021/inputs/04",
"chars": 7890,
"preview": "99,56,7,15,81,26,75,40,87,59,62,24,58,34,78,86,44,65,18,94,20,17,98,29,57,92,14,32,46,79,85,84,35,68,55,22,41,61,90,11,6"
},
{
"path": "advent-of-code/2021/inputs/05",
"chars": 9253,
"preview": "194,556 -> 739,556\n818,920 -> 818,524\n340,734 -> 774,300\n223,511 -> 146,434\n841,47 -> 122,766\n323,858 -> 859,322\n277,205"
},
{
"path": "advent-of-code/2021/inputs/06",
"chars": 600,
"preview": "5,1,2,1,5,3,1,1,1,1,1,2,5,4,1,1,1,1,2,1,2,1,1,1,1,1,2,1,5,1,1,1,3,1,1,1,3,1,1,3,1,1,4,3,1,1,4,1,1,1,1,2,1,1,1,5,1,1,5,1,"
},
{
"path": "advent-of-code/2021/inputs/07",
"chars": 3890,
"preview": "1101,1,29,67,1102,0,1,65,1008,65,35,66,1005,66,28,1,67,65,20,4,0,1001,65,1,65,1106,0,8,99,35,67,101,99,105,32,110,39,101"
},
{
"path": "advent-of-code/2021/inputs/08",
"chars": 16898,
"preview": "febca cfagb ecbafd efdcbg cbegdfa fg bgafec gfae acgdb gfc | cgf facdeb ecgfdb afcbge\nacbed dcagb cfbega ecgdab be deafc"
},
{
"path": "advent-of-code/2021/inputs/09",
"chars": 10100,
"preview": "9987675345698765453987654321234589999899878923493212345678999998656782467898999899878301234578998787\n9876543234789765322"
},
{
"path": "advent-of-code/2021/inputs/10",
"chars": 9367,
"preview": "[[<[<{[<{{<[{(()[])[[]()]}[((){})<[]{}>]}<<{[]{}}<(){}>><([]<>)>>>[[[<<>>[<><>]][<<>>(<><>)]][{\n((<[(<<(<{<((<()<>>{()()"
},
{
"path": "advent-of-code/2021/inputs/11",
"chars": 110,
"preview": "4836484555\n4663841772\n3512484556\n1481547572\n7741183422\n8683222882\n4215244233\n1544712171\n5725855786\n1717382281\n"
},
{
"path": "advent-of-code/2021/inputs/12",
"chars": 162,
"preview": "BC-gt\ngt-zf\nend-KH\nend-BC\nso-NL\nso-ly\nstart-BC\nNL-zf\nend-LK\nLK-so\nly-KH\nNL-bt\ngt-NL\nstart-zf\nso-zf\nly-BC\nBC-zf\nzf-ly\nly-"
},
{
"path": "advent-of-code/2021/inputs/13",
"chars": 6934,
"preview": "792,394\n1124,850\n1208,850\n721,173\n1057,252\n1119,182\n1017,402\n485,58\n773,880\n1171,197\n661,546\n218,628\n574,693\n673,316\n393"
},
{
"path": "advent-of-code/2021/inputs/14",
"chars": 822,
"preview": "SNVVKOBFKOPBFFFCPBSF\n\nHH -> P\nCH -> P\nHK -> N\nOS -> N\nHV -> S\nVC -> C\nVO -> K\nOC -> C\nFB -> S\nNP -> S\nOK -> H\nOO -> N\nPP"
},
{
"path": "advent-of-code/2021/inputs/15",
"chars": 10100,
"preview": "1124751783612228519483416186391693192764152281421133194141163183224351733212394799536339411529842112\n1299938854391228215"
},
{
"path": "advent-of-code/2021/inputs/16",
"chars": 1353,
"preview": "40541D900AEDC01A88002191FE2F45D1006A2FC2388D278D4653E3910020F2E2F3E24C007ECD7ABA6A200E6E8017F92C934CFA0E5290B569CE0F4BA5"
},
{
"path": "advent-of-code/2021/inputs/17",
"chars": 37,
"preview": "target area: x=153..199, y=-114..-75\n"
},
{
"path": "advent-of-code/2021/inputs/18",
"chars": 3404,
"preview": "[[[[2,5],4],[[1,0],[8,3]]],[[2,[2,4]],[1,[3,3]]]]\n[[[2,2],[[4,3],3]],[[[8,6],3],[3,7]]]\n[[[9,[4,1]],[9,0]],[6,[6,0]]]\n[["
},
{
"path": "advent-of-code/2021/inputs/19",
"chars": 10900,
"preview": "--- scanner 0 ---\n-880,-557,778\n-611,290,670\n598,502,694\n627,-521,631\n-908,-626,915\n-667,517,-416\n653,-608,742\n619,-567,"
},
{
"path": "advent-of-code/2021/inputs/20",
"chars": 10614,
"preview": "##.##.#..###....##..##.#.##...#..#..##.####..##...###.....##.####.##.##.##...####.######..#.###.#.##..###.#..#####...#.#"
},
{
"path": "advent-of-code/2021/inputs/21",
"chars": 60,
"preview": "Player 1 starting position: 1\nPlayer 2 starting position: 2\n"
},
{
"path": "advent-of-code/2021/inputs/22",
"chars": 20806,
"preview": "on x=-38..7,y=-5..47,z=-4..41\non x=-16..35,y=-21..25,z=-48..5\non x=-43..4,y=-32..21,z=-18..27\non x=-16..38,y=-37..9,z=-1"
},
{
"path": "advent-of-code/2021/inputs/23",
"chars": 66,
"preview": "#############\n#...........#\n###B#B#D#D###\n #C#A#A#C#\n #########\n"
},
{
"path": "advent-of-code/2021/inputs/24",
"chars": 2042,
"preview": "inp w\nmul x 0\nadd x z\nmod x 26\ndiv z 1\nadd x 10\neql x w\neql x 0\nmul y 0\nadd y 25\nmul y x\nadd y 1\nmul z y\nmul y 0\nadd y w"
},
{
"path": "advent-of-code/2021/inputs/25",
"chars": 19180,
"preview": "..vv.v>vv.>..>..>.>...v>vv..>.vv>..v>.v...v>vv.>.>....v>..v>.>.vvv>...>>vvvvv..v.v.>>..v>v.v>..>..>>v>>..v>.>v..>>>>>v.."
},
{
"path": "advent-of-code/2022/.gitignore",
"chars": 31,
"preview": "day*/day[0-9][0-9]\nday*/sample\n"
},
{
"path": "advent-of-code/2022/day01/day01.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day01\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day01/src/day01.nim",
"chars": 404,
"preview": "import strutils, sequtils, strformat, algorithm\n\nlet data = readFile(\"../inputs/01\")\n\nproc calories(): seq[int] =\n for "
},
{
"path": "advent-of-code/2022/day02/day02.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day02\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day02/src/day02.nim",
"chars": 333,
"preview": "import strformat\n\nvar partOne = 0\nvar partTwo = 0\n\nfor line in lines(\"../inputs/02\"):\n let first = int(line[0]) - int('"
},
{
"path": "advent-of-code/2022/day03/day03.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day03\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day03/src/day03.nim",
"chars": 512,
"preview": "import sugar, sets, sequtils, strutils, math, strformat\n\nproc score(groups: seq[seq[string]]): int =\n groups\n .map(g"
},
{
"path": "advent-of-code/2022/day04/day04.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day04\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day04/src/day04.nim",
"chars": 428,
"preview": "import sequtils, strutils, strformat\n\nlet inputs = lines(\"../inputs/04\")\n .toSeq\n .mapIt(it.split({',', '-'}).map(pars"
},
{
"path": "advent-of-code/2022/day05/day05.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day05\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day05/src/day05.nim",
"chars": 1157,
"preview": "import strutils, sequtils, algorithm, sugar\n\ntype\n Input = object\n stacks: seq[seq[char]]\n instructions: seq[tupl"
},
{
"path": "advent-of-code/2022/day06/day06.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day06\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day06/src/day06.nim",
"chars": 240,
"preview": "import sets\n\nproc solve(size: int): int =\n let chars = readFile(\"../inputs/06\")\n for i in 0 ..< chars.len - size:\n "
},
{
"path": "advent-of-code/2022/day07/day07.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day07\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day07/src/day07.nim",
"chars": 859,
"preview": "import strutils, tables, sugar, sequtils, math, strformat\n\nvar cwd: seq[string] = @[\"\"]\nvar sizes = {\"/\": 0}.toTable\n\nfo"
},
{
"path": "advent-of-code/2022/day08/day08.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day08\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day08/src/day08.nim",
"chars": 723,
"preview": "import algorithm, sequtils, strformat, sugar\n\nlet grid = lines(\"../inputs/08\").toSeq.map(line => line.toSeq.mapIt(it.int"
},
{
"path": "advent-of-code/2022/day09/day09.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day09\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day09/src/day09.nim",
"chars": 884,
"preview": "import strutils, math, sets, strformat\n\ntype\n Point = tuple[x, y: int]\n\nproc `+`(a, b: Point): Point = (a.x + b.x, a.y "
},
{
"path": "advent-of-code/2022/day10/day10.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day10\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day10/src/day10.nim",
"chars": 522,
"preview": "import strutils, sequtils\n\niterator changes(): int =\n for line in lines(\"../inputs/10\"):\n yield 0\n if line != \"no"
},
{
"path": "advent-of-code/2022/day11/day11.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day11\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day11/src/day11.nim",
"chars": 2349,
"preview": "import strscans, strutils, sequtils, parseutils, sugar, algorithm\n\ntype\n Monkey = object\n index: int\n things: seq"
},
{
"path": "advent-of-code/2022/day12/day12.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day12\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day12/src/day12.nim",
"chars": 1141,
"preview": "import sequtils, strutils, deques\n\nvar map: seq[seq[char]]\nvar start: (int, int)\nvar target: (int, int)\nvar distance: se"
},
{
"path": "advent-of-code/2022/day13/day13.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day13\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day13/src/day13.nim",
"chars": 1079,
"preview": "import json, math, strutils, algorithm, sequtils\n\nproc wrap(node: JsonNode): JsonNode =\n if node.kind == JInt:\n resu"
},
{
"path": "advent-of-code/2022/day14/day14.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day14\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day14/src/day14.nim",
"chars": 1214,
"preview": "import strutils, sequtils, sets, math\n\ntype\n Point = tuple[x, y: int]\n\nproc `-`(a, b: Point): Point = (a.x - b.x, a.y -"
},
{
"path": "advent-of-code/2022/day15/day15.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day15\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day15/src/day15.nim",
"chars": 2306,
"preview": "import re, strutils, sequtils, algorithm, options, math, sugar\n\nconst LIMIT = 4_000_000\n\ntype\n Point = tuple[x, y: int]"
},
{
"path": "advent-of-code/2022/day16/day16.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day16\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day16/src/day16.nim",
"chars": 1672,
"preview": "import re, tables, strutils, sequtils\n\ntype\n Index = range[0..63]\n\nvar indices: Table[string, Index]\nvar rates: array[l"
},
{
"path": "advent-of-code/2022/day17/day17.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day17\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day17/src/day17.nim",
"chars": 2153,
"preview": "import std/enumerate, sets, sequtils, tables\n\ntype\n Point = tuple[x: int, y: int]\n\nlet shapes = [\n @[(0, 0), (1, 0), ("
},
{
"path": "advent-of-code/2022/day18/day18.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day18\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day18/src/day18.nim",
"chars": 1177,
"preview": "import strutils, sequtils, sets, sequtils, sugar, math\n\ntype\n Point = tuple[x, y, z: int]\n\nproc within(p: Point, lower:"
},
{
"path": "advent-of-code/2022/day19/day19.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day19\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day19/src/day19.nim",
"chars": 1642,
"preview": "import strutils, sequtils, sets, math\n\ntype\n Blueprint = seq[int]\n State = array[9, int]\n\nvar blueprints = newSeq[Blue"
},
{
"path": "advent-of-code/2022/day20/day20.nimble",
"chars": 75,
"preview": "srcDir = \"src\"\nbin = @[\"day20\"]\n\nrequires \"nim >= 1.6.10\"\n"
},
{
"path": "advent-of-code/2022/day20/src/day20.nim",
"chars": 890,
"preview": "import strutils, lists\n\nproc properMod(a, b: int): int = (a mod b + b) mod b\n\nproc advance(node: var DoublyLinkedNode[in"
},
{
"path": "advent-of-code/2022/inputs/01",
"chars": 10408,
"preview": "3864\n5112\n3233\n3008\n5052\n3291\n4002\n5402\n2907\n2398\n3014\n3923\n1475\n1997\n2519\n\n9130\n9712\n12437\n3457\n11610\n4598\n\n1698\n1551\n6"
},
{
"path": "advent-of-code/2022/inputs/02",
"chars": 10000,
"preview": "B Y\nA Z\nA Z\nC Z\nB Y\nB Y\nB X\nB Z\nC Z\nB X\nB Y\nA Z\nB Y\nB Z\nB Y\nC Z\nB Z\nB Y\nB Z\nC Y\nB Y\nA Z\nB Y\nB Y\nB Y\nC Y\nA Z\nB Y\nB X\nA Z\n"
},
{
"path": "advent-of-code/2022/inputs/03",
"chars": 10222,
"preview": "PnJJfVPBcfVnnPnBFFcggttrtgCrjDtSjzSS\nllWlLbmmdLLwLbqGdmTmbZfCQtzrMQfrjSzrtSrMqgMt\nsHlZTsWZwGGlZmGTmdlZbhJNRPphVfRvVnRBsR"
},
{
"path": "advent-of-code/2022/inputs/04",
"chars": 11435,
"preview": "71-89,66-70\n24-70,23-55\n19-85,18-86\n50-90,50-95\n55-55,56-72\n3-65,5-66\n98-99,66-99\n14-67,14-14\n4-79,78-79\n13-98,10-98\n27-"
}
]
// ... and 1793 more files (download for full content)
About this extraction
This page contains the full source code of the skanev/playground GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1993 files (4.1 MB), approximately 1.2M tokens, and a symbol index with 2152 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.