Reference List for Fairly Common Syntax Highlighting Styles

2026-01-13

Just a super-quick reference for the standard set of styles avaliable in a lot of Pygments-derived code highlighters.

abap

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

algol

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

algol_nu

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

arduino

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

ashen

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

aura-theme-dark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

aura-theme-dark-soft

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

autumn

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

average

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

base16-snazzy

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

borland

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

bw

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

catppuccin-frappe

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

catppuccin-latte

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

catppuccin-macchiato

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

catppuccin-mocha

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

colorful

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

doom-one

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

doom-one2

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

dracula

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

emacs

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

evergarden

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

friendly

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

fruity

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

github

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

github-dark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

gruvbox

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

gruvbox-light

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

hr_high_contrast

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

hrdark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

igor

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

lovelace

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

manni

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

modus-operandi

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

modus-vivendi

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

monokai

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

monokailight

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

murphy

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

native

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

nord

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

nordic

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

onedark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

onesenterprise

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

paraiso-dark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

paraiso-light

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

pastie

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

perldoc

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

pygments

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

rainbow_dash

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

rose-pine

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

rose-pine-dawn

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

rose-pine-moon

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

RPGLE

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

rrt

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

solarized-dark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

solarized-dark256

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

solarized-light

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

swapoff

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

tango

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

tokyonight-day

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

tokyonight-moon

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

tokyonight-night

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

tokyonight-storm

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

trac

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

vim

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

vs

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

vulcan

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

witchhazel

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

xcode

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file

xcode-dark

-- stack script --resolver lts-20.3 --package containers --package unordered-containers
import Data.List
import Data.Maybe
import Data.Sequence (Seq ((:<|)), (|>), fromList)
import Data.Map (Map, size, empty, update, insertWith)

data Scanner = Scanner {
    queue :: Seq Char,
    count :: Map Char Int
}

scan :: Scanner -> Char -> Scanner
scan (Scanner q c) x =
    let (y, q') = case q of y :<| q' -> (y, q')
        c' = Data.Map.update (\y -> if y == 1 then Nothing else Just (y - 1)) y c
        q'' = q' |> x
        c'' = insertWith (+) x 1 c'
    in Scanner q'' c''

main = do
    file <- readFile "input.txt"

    let n = 14

    let initial = Scanner {
        queue = fromList $ take n file,
        count = foldl (\m c -> insertWith (+) c 1 m) empty $ take n file
    }

    print $ (+ n) $ fromJust
          $ findIndex (\s -> n == (size $ count s))
          $ scanl scan initial
          $ drop n file