complete day 1

8 files changed, 5731 insertions, 43 deletions

diff --git a/.hlint.yaml b/.hlint.yaml
new file mode 100644
index 0000000..011dc9d
--- /dev/null
+++ b/.hlint.yaml
@@ -0,0 +1,3288 @@
+- arguments:
+  - "-XConstraintKinds"
+  - "-XDeriveGeneric"
+  - "-XGeneralizedNewtypeDeriving"
+  - "-XLambdaCase"
+  - "-XOverloadedStrings"
+  - "-XRecordWildCards"
+  - "-XScopedTypeVariables"
+  - "-XStandaloneDeriving"
+  - "-XTupleSections"
+  - "-XTypeApplications"
+  - "-XViewPatterns"
+- ignore:
+    name: Use head
+- ignore:
+    name: Use Foldable.forM_
+- hint:
+    lhs: "pure ()"
+    note: "Use 'pass'"
+    rhs: pass
+- hint:
+    lhs: "return ()"
+    note: "Use 'pass'"
+    rhs: pass
+- hint:
+    lhs: "(: [])"
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: "(:| [])"
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Sequence.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Text.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Text.Lazy.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.ByteString.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.ByteString.Lazy.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Map.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Map.Strict.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.HashMap.Strict.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.HashMap.Lazy.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.IntMap.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.IntMap.Strict.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.Set.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.HashSet.singleton
+    note: "Use `one`"
+    rhs: one
+- hint:
+    lhs: Data.IntSet.singleton
+    note: "Use `one`"
+    rhs: one
+- warn:
+    lhs: Control.Exception.evaluate
+    rhs: evaluateWHNF
+- warn:
+    lhs: "Control.Exception.evaluate (force x)"
+    rhs: evaluateNF x
+- warn:
+    lhs: "Control.Exception.evaluate (x `deepseq` ())"
+    rhs: evaluateNF_ x
+- warn:
+    lhs: "void (evaluateWHNF x)"
+    rhs: evaluateWHNF_ x
+- warn:
+    lhs: "void (evaluateNF x)"
+    rhs: evaluateNF_ x
+- hint:
+    lhs: Control.Exception.throw
+    note: "Use 'impureThrow'"
+    rhs: impureThrow
+- warn:
+    lhs: Data.Text.IO.readFile
+    rhs: readFileText
+- warn:
+    lhs: Data.Text.IO.writeFile
+    rhs: writeFileText
+- warn:
+    lhs: Data.Text.IO.appendFile
+    rhs: appendFileText
+- warn:
+    lhs: Data.Text.Lazy.IO.readFile
+    rhs: readFileLText
+- warn:
+    lhs: Data.Text.Lazy.IO.writeFile
+    rhs: writeFileLText
+- warn:
+    lhs: Data.Text.Lazy.IO.appendFile
+    rhs: appendFileLText
+- warn:
+    lhs: Data.ByteString.readFile
+    rhs: readFileBS
+- warn:
+    lhs: Data.ByteString.writeFile
+    rhs: writeFileBS
+- warn:
+    lhs: Data.ByteString.appendFile
+    rhs: appendFileBS
+- warn:
+    lhs: Data.ByteString.Lazy.readFile
+    rhs: readFileLBS
+- warn:
+    lhs: Data.ByteString.Lazy.writeFile
+    rhs: writeFileLBS
+- warn:
+    lhs: Data.ByteString.Lazy.appendFile
+    rhs: appendFileLBS
+- hint:
+    lhs: "foldl' (flip f)"
+    note: "Use 'flipfoldl''"
+    rhs: "flipfoldl' f"
+- warn:
+    lhs: "foldl' (+) 0"
+    rhs: sum
+- warn:
+    lhs: "foldl' (*) 1"
+    rhs: product
+- hint:
+    lhs: "fmap and (sequence s)"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: andM s
+- hint:
+    lhs: "and <$> sequence s"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: andM s
+- hint:
+    lhs: "fmap or (sequence s)"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: orM s
+- hint:
+    lhs: "or <$> sequence s"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: orM s
+- hint:
+    lhs: "fmap and (mapM f s)"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: allM f s
+- hint:
+    lhs: "and <$> mapM f s"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: allM f s
+- hint:
+    lhs: "fmap or (mapM f s)"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: anyM f s
+- hint:
+    lhs: "or <$> mapM f s"
+    note: Applying this hint would mean that some actions that were being executed previously would no longer be executed.
+    rhs: anyM f s
+- warn:
+    lhs: "getAlt (foldMap (Alt . f) xs)"
+    rhs: asumMap xs
+- warn:
+    lhs: "getAlt . foldMap (Alt . f)"
+    rhs: asumMap
+- hint:
+    lhs: "foldr (\\x acc -> f x <|> acc) empty"
+    note: "Use 'asumMap'"
+    rhs: asumMap f
+- hint:
+    lhs: "asum (map f xs)"
+    note: "Use 'asumMap'"
+    rhs: asumMap f xs
+- warn:
+    lhs: "map fst &&& map snd"
+    rhs: unzip
+- hint:
+    lhs: "fmap (fmap f) x"
+    note: "Use '(<<$>>)'"
+    rhs: "f <<$>> x"
+- hint:
+    lhs: "(\\f -> f x) <$> ff"
+    note: Use flap operator
+    rhs: "ff ?? x"
+- hint:
+    lhs: "fmap (\\f -> f x) ff"
+    note: Use flap operator
+    rhs: "ff ?? x"
+- hint:
+    lhs: "fmap ($ x) ff"
+    note: Use flap operator
+    rhs: "ff ?? x"
+- hint:
+    lhs: "($ x) <$> ff"
+    note: Use flap operator
+    rhs: "ff ?? x"
+- warn:
+    lhs: "fmap f (nonEmpty x)"
+    rhs: viaNonEmpty f x
+- warn:
+    lhs: fmap f . nonEmpty
+    rhs: viaNonEmpty f
+- warn:
+    lhs: "f <$> nonEmpty x"
+    rhs: viaNonEmpty f x
+- warn:
+    lhs: partitionEithers . map f
+    rhs: partitionWith f
+- warn:
+    lhs: partitionEithers $ map f x
+    rhs: partitionWith f x
+- warn:
+    lhs: "f >>= guard"
+    rhs: guardM f
+- warn:
+    lhs: guard =<< f
+    rhs: guardM f
+- warn:
+    lhs: forever
+    note: "'forever' is loosely typed and may hide errors"
+    rhs: infinitely
+- warn:
+    lhs: "whenM (not <$> x)"
+    rhs: unlessM x
+- warn:
+    lhs: "unlessM (not <$> x)"
+    rhs: whenM x
+- warn:
+    lhs: "either (const True) (const False)"
+    rhs: isLeft
+- warn:
+    lhs: "either (const False) (const True)"
+    rhs: isRight
+- warn:
+    lhs: "either id (const a)"
+    rhs: fromLeft a
+- warn:
+    lhs: "either (const b) id"
+    rhs: fromRight b
+- warn:
+    lhs: "either Just (const Nothing)"
+    rhs: leftToMaybe
+- warn:
+    lhs: "either (const Nothing) Just"
+    rhs: rightToMaybe
+- warn:
+    lhs: "maybe (Left l) Right"
+    rhs: maybeToRight l
+- warn:
+    lhs: "maybe (Right r) Left"
+    rhs: maybeToLeft r
+- warn:
+    lhs: "case m of Just x -> f x; Nothing -> pure ()"
+    rhs: whenJust m f
+- warn:
+    lhs: "case m of Just x -> f x; Nothing -> return ()"
+    rhs: whenJust m f
+- warn:
+    lhs: "case m of Just x -> f x; Nothing -> pass"
+    rhs: whenJust m f
+- warn:
+    lhs: "case m of Nothing -> pure ()  ; Just x -> f x"
+    rhs: whenJust m f
+- warn:
+    lhs: "case m of Nothing -> return (); Just x -> f x"
+    rhs: whenJust m f
+- warn:
+    lhs: "case m of Nothing -> pass     ; Just x -> f x"
+    rhs: whenJust m f
+- warn:
+    lhs: "maybe (pure ())   f m"
+    rhs: whenJust m f
+- warn:
+    lhs: "maybe (return ()) f m"
+    rhs: whenJust m f
+- warn:
+    lhs: maybe pass        f m
+    rhs: whenJust m f
+- warn:
+    lhs: "m >>= \\a -> whenJust a f"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Just x -> f x; Nothing -> pure ()"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Just x -> f x; Nothing -> return ()"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Just x -> f x; Nothing -> pass"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Nothing -> pure ()  ; Just x -> f x"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Nothing -> return (); Just x -> f x"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= \\case Nothing -> pass     ; Just x -> f x"
+    rhs: whenJustM m f
+- warn:
+    lhs: "maybe (pure ())   f =<< m"
+    rhs: whenJustM m f
+- warn:
+    lhs: "maybe (return ()) f =<< m"
+    rhs: whenJustM m f
+- warn:
+    lhs: maybe pass        f =<< m
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= maybe (pure ())   f"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= maybe (return ()) f"
+    rhs: whenJustM m f
+- warn:
+    lhs: "m >>= maybe pass        f"
+    rhs: whenJustM m f
+- warn:
+    lhs: "case m of Just _ -> pure ()  ; Nothing -> x"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "case m of Just _ -> return (); Nothing -> x"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "case m of Just _ -> pass     ; Nothing -> x"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "case m of Nothing -> x; Just _ -> pure ()"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "case m of Nothing -> x; Just _ -> return ()"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "case m of Nothing -> x; Just _ -> pass"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (\\_ -> pure ()    ) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (\\_ -> return ()  ) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (\\_ -> pass       ) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (const (pure ()  )) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (const (return ())) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "maybe x (const pass) m"
+    rhs: whenNothing_ m x
+- warn:
+    lhs: "m >>= \\a -> whenNothing_ a x"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Just _ -> pure ()  ; Nothing -> x"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Just _ -> return (); Nothing -> x"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Just _ -> pass     ; Nothing -> x"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Nothing -> x; Just _ -> pure ()"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Nothing -> x; Just _ -> return ()"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= \\case Nothing -> x; Just _ -> pass"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (\\_ -> pure ()    ) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (\\_ -> return ()  ) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (\\_ -> pass       ) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (const (pure ()  )) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (const (return ())) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "maybe x (const pass) =<< m"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (\\_ -> pure ())"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (\\_ -> return ())"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (\\_ -> pass)"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (const (pure ())  )"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (const (return ()))"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "m >>= maybe x (const pass)"
+    rhs: whenNothingM_ m x
+- warn:
+    lhs: "whenLeft ()"
+    rhs: whenLeft_
+- warn:
+    lhs: "case m of Left x -> f x; Right _ -> pure ()"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "case m of Left x -> f x; Right _ -> return ()"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "case m of Left x -> f x; Right _ -> pass"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "case m of Right _ -> pure ()  ; Left x -> f x"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "case m of Right _ -> return (); Left x -> f x"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "case m of Right _ -> pass     ; Left x -> f x"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (\\_ -> pure ()    ) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (\\_ -> return ()  ) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (\\_ -> pass       ) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (const (pure ()  )) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (const (return ())) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "either f (const pass) m"
+    rhs: whenLeft_ m f
+- warn:
+    lhs: "m >>= \\a -> whenLeft_ a f"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Left x -> f x; Right _ -> pure ()"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Left x -> f x; Right _ -> return ()"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Left x -> f x; Right _ -> pass"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Right _ -> pure ()  ; Left x -> f x"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Right _ -> return (); Left x -> f x"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= \\case Right _ -> pass     ; Left x -> f x"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (\\_ -> pure ()    ) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (\\_ -> return ()  ) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (\\_ -> pass       ) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (const (pure ()  )) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (const (return ())) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "either f (const pass) =<< m"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (\\_ -> pure ())"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (\\_ -> return ())"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (\\_ -> pass)"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (const (pure ())  )"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (const (return ()))"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "m >>= either f (const pass)"
+    rhs: whenLeftM_ m f
+- warn:
+    lhs: "whenRight ()"
+    rhs: whenRight_
+- warn:
+    lhs: "case m of Right x -> f x; Left _ -> pure ()"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "case m of Right x -> f x; Left _ -> return ()"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "case m of Right x -> f x; Left _ -> pass"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "case m of Left _ -> pure ()  ; Right x -> f x"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "case m of Left _ -> return (); Right x -> f x"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "case m of Left _ -> pass     ; Right x -> f x"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (\\_ -> pure ()    ) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (\\_ -> return ()  ) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (\\_ -> pass       ) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (const (pure ()  )) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (const (return ())) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "either (const pass) f m"
+    rhs: whenRight_ m f
+- warn:
+    lhs: "m >>= \\a -> whenRight_ a f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Right x -> f x; Left _ -> pure ()  "
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Right x -> f x; Left _ -> return ()"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Right x -> f x; Left _ -> pass"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Left _ -> pure ()  ; Right x -> f x"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Left _ -> return (); Right x -> f x"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= \\case Left _ -> pass     ; Right x -> f x"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (\\_ -> pure ()    ) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (\\_ -> return ()  ) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (\\_ -> pass       ) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (const (pure ()  )) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (const (return ())) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "either (const pass) f =<< m"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (\\_ -> pure ())   f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (\\_ -> return ()) f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (\\_ -> pass)      f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (const (pure ())  ) f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (const (return ())) f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "m >>= either (const pass) f"
+    rhs: whenRightM_ m f
+- warn:
+    lhs: "case m of Left x -> f x; Right _ -> pure d  "
+    rhs: whenLeft d m f
+- warn:
+    lhs: "case m of Left x -> f x; Right _ -> return d"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "case m of Right _ -> pure d  ; Left x -> f x"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "case m of Right _ -> return d; Left x -> f x"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "either f (\\_ -> pure d    ) m"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "either f (\\_ -> return d  ) m"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "either f (const (pure d  )) m"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "either f (const (return d)) m"
+    rhs: whenLeft d m f
+- warn:
+    lhs: "m >>= \\a -> whenLeft d a f"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= \\case Left x -> f x; Right _ -> pure d"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= \\case Left x -> f x; Right _ -> return d"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= \\case Right _ -> pure d  ; Left x -> f x"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= \\case Right _ -> return d; Left x -> f x"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "either f (\\_ -> pure d    ) =<< m"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "either f (\\_ -> return d  ) =<< m"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "either f (const (pure d  )) =<< m"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "either f (const (return d)) =<< m"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= either f (\\_ -> pure d)"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= either f (\\_ -> return d)"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= either f (const (pure d))"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "m >>= either f (const (return d))"
+    rhs: whenLeftM d m f
+- warn:
+    lhs: "case m of Right x -> f x; Left _ -> pure d"
+    rhs: whenRight d m f
+- warn:
+    lhs: "case m of Right x -> f x; Left _ -> return d"
+    rhs: whenRight d m f
+- warn:
+    lhs: "case m of Left _ -> pure d  ; Right x -> f x"
+    rhs: whenRight d m f
+- warn:
+    lhs: "case m of Left _ -> return d; Right x -> f x"
+    rhs: whenRight d m f
+- warn:
+    lhs: "either (\\_ -> pure d    ) f m"
+    rhs: whenRight d m f
+- warn:
+    lhs: "either (\\_ -> return d  ) f m"
+    rhs: whenRight d m f
+- warn:
+    lhs: "either (const (pure d  )) f m"
+    rhs: whenRight d m f
+- warn:
+    lhs: "either (const (return d)) f m"
+    rhs: whenRight d m f
+- warn:
+    lhs: "m >>= \\a -> whenRight d a f"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= \\case Right x -> f x; Left _ -> pure d"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= \\case Right x -> f x; Left _ -> return d"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= \\case Left _ -> pure d  ; Right x -> f x"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= \\case Left _ -> return d; Right x -> f x"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "either (\\_ -> pure d    ) f =<< m"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "either (\\_ -> return d  ) f =<< m"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "either (const (pure d  )) f =<< m"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "either (const (return d)) f =<< m"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= either (\\_ -> pure d)   f"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= either (\\_ -> return d) f"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= either (const (pure d)  ) f"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "m >>= either (const (return d)) f"
+    rhs: whenRightM d m f
+- warn:
+    lhs: "case m of [] -> return (); (x:xs) -> f (x :| xs)"
+    rhs: whenNotNull m f
+- warn:
+    lhs: "case m of [] -> pure ()  ; (x:xs) -> f (x :| xs)"
+    rhs: whenNotNull m f
+- warn:
+    lhs: "case m of [] -> pass     ; (x:xs) -> f (x :| xs)"
+    rhs: whenNotNull m f
+- warn:
+    lhs: "case m of (x:xs) -> f (x :| xs); [] -> return ()"
+    rhs: whenNotNull m f
+- warn:
+    lhs: "case m of (x:xs) -> f (x :| xs); [] -> pure ()  "
+    rhs: whenNotNull m f
+- warn:
+    lhs: "case m of (x:xs) -> f (x :| xs); [] -> pass     "
+    rhs: whenNotNull m f
+- warn:
+    lhs: "m >>= \\case [] -> pass     ; (x:xs) -> f (x :| xs)"
+    rhs: whenNotNullM m f
+- warn:
+    lhs: "m >>= \\case [] -> pure ()  ; (x:xs) -> f (x :| xs)"
+    rhs: whenNotNullM m f
+- warn:
+    lhs: "m >>= \\case [] -> return (); (x:xs) -> f (x :| xs)"
+    rhs: whenNotNullM m f
+- warn:
+    lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> pass     "
+    rhs: whenNotNullM m f
+- warn:
+    lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> pure ()  "
+    rhs: whenNotNullM m f
+- warn:
+    lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> return ()"
+    rhs: whenNotNullM m f
+- warn:
+    lhs: mapMaybe leftToMaybe
+    rhs: lefts
+- warn:
+    lhs: mapMaybe rightToMaybe
+    rhs: rights
+- warn:
+    lhs: flip runReaderT
+    rhs: usingReaderT
+- warn:
+    lhs: flip runReader
+    rhs: usingReader
+- warn:
+    lhs: flip runStateT
+    rhs: usingStateT
+- warn:
+    lhs: flip runState
+    rhs: usingState
+- warn:
+    lhs: "fst <$> usingStateT s st"
+    rhs: evaluatingStateT s st
+- warn:
+    lhs: "fst (usingState s st)"
+    rhs: evaluatingState s st
+- warn:
+    lhs: "snd <$> usingStateT s st"
+    rhs: executingStateT s st
+- warn:
+    lhs: "snd (usingState s st)"
+    rhs: executingState s st
+- warn:
+    lhs: "MaybeT (pure m)"
+    rhs: hoistMaybe m
+- warn:
+    lhs: "MaybeT (return m)"
+    rhs: hoistMaybe m
+- warn:
+    lhs: MaybeT . pure
+    rhs: hoistMaybe
+- warn:
+    lhs: MaybeT . return
+    rhs: hoistMaybe
+- warn:
+    lhs: "ExceptT (pure m)"
+    rhs: hoistEither m
+- warn:
+    lhs: "ExceptT (return m)"
+    rhs: hoistEither m
+- warn:
+    lhs: ExceptT . pure
+    rhs: hoistEither
+- warn:
+    lhs: ExceptT . return
+    rhs: hoistEither
+- warn:
+    lhs: fromMaybe mempty
+    rhs: maybeToMonoid
+- warn:
+    lhs: "m ?: mempty"
+    rhs: maybeToMonoid m
+- warn:
+    lhs: "Data.Map.toAscList (Data.Map.fromList x)"
+    rhs: sortWith fst x
+- warn:
+    lhs: "Data.Map.toDescList (Data.Map.fromList x)"
+    rhs: "sortWith (Down . fst) x"
+- warn:
+    lhs: "Data.Set.toList (Data.Set.fromList l)"
+    rhs: sortNub l
+- warn:
+    lhs: "Data.Set.assocs (Data.Set.fromList l)"
+    rhs: sortNub l
+- warn:
+    lhs: "Data.Set.toAscList (Data.Set.fromList l)"
+    rhs: sortNub l
+- warn:
+    lhs: "Data.HashSet.toList (Data.HashSet.fromList l)"
+    rhs: unstableNub l
+- warn:
+    lhs: nub
+    note: "'nub' is O(n^2), 'ordNub' is O(n log n)"
+    rhs: ordNub
+- warn:
+    lhs: "sortBy (comparing f)"
+    note: "If the function you are using for 'comparing' is slow, use 'sortOn' instead of 'sortWith', because 'sortOn' caches applications the function and 'sortWith' doesn't."
+    rhs: sortWith f
+- warn:
+    lhs: sortOn fst
+    note: "'sortWith' will be faster here because it doesn't do caching"
+    rhs: sortWith fst
+- warn:
+    lhs: sortOn snd
+    note: "'sortWith' will be faster here because it doesn't do caching"
+    rhs: sortWith snd
+- warn:
+    lhs: "sortOn (Down . fst)"
+    note: "'sortWith' will be faster here because it doesn't do caching"
+    rhs: "sortWith (Down . fst)"
+- warn:
+    lhs: "sortOn (Down . snd)"
+    note: "'sortWith' will be faster here because it doesn't do caching"
+    rhs: "sortWith (Down . snd)"
+- warn:
+    lhs: Data.Text.IO.putStr
+    rhs: putText
+- warn:
+    lhs: Data.Text.IO.putStrLn
+    rhs: putTextLn
+- warn:
+    lhs: Data.Text.Lazy.IO.putStr
+    rhs: putLText
+- warn:
+    lhs: Data.Text.Lazy.IO.putStrLn
+    rhs: putLTextLn
+- warn:
+    lhs: Data.ByteString.Char8.putStr
+    rhs: putBS
+- warn:
+    lhs: Data.ByteString.Char8.putStrLn
+    rhs: putBSLn
+- warn:
+    lhs: Data.ByteString.Lazy.Char8.putStr
+    rhs: putLBS
+- warn:
+    lhs: Data.ByteString.Lazy.Char8.putStrLn
+    rhs: putLBSLn
+- warn:
+    lhs: Data.Text.Lazy.Text
+    rhs: LText
+- warn:
+    lhs: Data.ByteString.Lazy.ByteString
+    rhs: LByteString
+- warn:
+    lhs: Data.ByteString.UTF8.fromString
+    rhs: encodeUtf8
+- warn:
+    lhs: Data.ByteString.UTF8.toString
+    rhs: decodeUtf8
+- warn:
+    lhs: Data.Text.Encoding.encodeUtf8
+    rhs: encodeUtf8
+- warn:
+    lhs: Data.Text.Encoding.decodeUtf8
+    rhs: decodeUtf8
+- warn:
+    lhs: "Data.ByteString.Lazy.toStrict (encodeUtf8 x)"
+    rhs: encodeUtf8 x
+- warn:
+    lhs: "toStrict (encodeUtf8 x)"
+    rhs: encodeUtf8 x
+- warn:
+    lhs: "decodeUtf8 (Data.ByteString.Lazy.fromStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: "decodeUtf8 (fromStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: Data.ByteString.Lazy.UTF8.fromString
+    rhs: encodeUtf8
+- warn:
+    lhs: Data.ByteString.Lazy.UTF8.toString
+    rhs: decodeUtf8
+- warn:
+    lhs: "Data.ByteString.Lazy.fromStrict (Data.Text.Encoding.encodeUtf8 x)"
+    rhs: encodeUtf8 x
+- warn:
+    lhs: "Data.ByteString.Lazy.fromStrict (encodeUtf8 x)"
+    rhs: encodeUtf8 x
+- warn:
+    lhs: "Data.Text.Encoding.decodeUtf8 (Data.ByteString.Lazy.toStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: "Data.Text.Encoding.decodeUtf8 (toStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: "decodeUtf8 (Data.ByteString.Lazy.toStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: "decodeUtf8 (toStrict x)"
+    rhs: decodeUtf8 x
+- warn:
+    lhs: Data.Text.pack
+    rhs: toText
+- warn:
+    lhs: Data.Text.unpack
+    rhs: toString
+- warn:
+    lhs: Data.Text.Lazy.pack
+    rhs: toLText
+- warn:
+    lhs: Data.Text.Lazy.unpack
+    rhs: toString
+- warn:
+    lhs: Data.Text.Lazy.toStrict
+    rhs: toText
+- warn:
+    lhs: Data.Text.Lazy.fromStrict
+    rhs: toLText
+- warn:
+    lhs: "Data.Text.pack (show x)"
+    rhs: show x
+- warn:
+    lhs: "Data.Text.Lazy.pack (show x)"
+    rhs: show x
+- warn:
+    lhs: Data.ByteString.Lazy.fromStrict
+    rhs: fromStrict
+- warn:
+    lhs: Data.ByteString.Lazy.toStrict
+    rhs: toStrict
+- warn:
+    lhs: Data.Text.Lazy.fromStrict
+    rhs: fromStrict
+- warn:
+    lhs: Data.Text.Lazy.toStrict
+    rhs: toStrict
+- warn:
+    lhs: Control.Applicative.Alternative
+    name: "Use 'Alternative' from Relude"
+    note: "'Alternative' is already exported from Relude"
+    rhs: Alternative
+- warn:
+    lhs: Control.Applicative.empty
+    name: "Use 'empty' from Relude"
+    note: "'empty' is already exported from Relude"
+    rhs: empty
+- warn:
+    lhs: "(Control.Applicative.<|>)"
+    name: "Use '<|>' from Relude"
+    note: "Operator '(<|>)' is already exported from Relude"
+    rhs: "(<|>)"
+- warn:
+    lhs: Control.Applicative.some
+    name: "Use 'some' from Relude"
+    note: "'some' is already exported from Relude"
+    rhs: some
+- warn:
+    lhs: Control.Applicative.many
+    name: "Use 'many' from Relude"
+    note: "'many' is already exported from Relude"
+    rhs: many
+- warn:
+    lhs: Control.Applicative.Const
+    name: "Use 'Const' from Relude"
+    note: "'Const' is already exported from Relude"
+    rhs: Const
+- warn:
+    lhs: Control.Applicative.getConst
+    name: "Use 'getConst' from Relude"
+    note: "'getConst' is already exported from Relude"
+    rhs: getConst
+- warn:
+    lhs: Control.Applicative.ZipList
+    name: "Use 'ZipList' from Relude"
+    note: "'ZipList' is already exported from Relude"
+    rhs: ZipList
+- warn:
+    lhs: Control.Applicative.getZipList
+    name: "Use 'getZipList' from Relude"
+    note: "'getZipList' is already exported from Relude"
+    rhs: getZipList
+- warn:
+    lhs: Control.Applicative.liftA2
+    name: "Use 'liftA2' from Relude"
+    note: "'liftA2' is already exported from Relude"
+    rhs: liftA2
+- warn:
+    lhs: Control.Applicative.liftA3
+    name: "Use 'liftA3' from Relude"
+    note: "'liftA3' is already exported from Relude"
+    rhs: liftA3
+- warn:
+    lhs: Control.Applicative.optional
+    name: "Use 'optional' from Relude"
+    note: "'optional' is already exported from Relude"
+    rhs: optional
+- warn:
+    lhs: "(Control.Applicative.<**>)"
+    name: "Use '<**>' from Relude"
+    note: "Operator '(<**>)' is already exported from Relude"
+    rhs: "(<**>)"
+- warn:
+    lhs: Data.Bits.xor
+    name: "Use 'xor' from Relude"
+    note: "'xor' is already exported from Relude"
+    rhs: xor
+- warn:
+    lhs: Data.Char.chr
+    name: "Use 'chr' from Relude"
+    note: "'chr' is already exported from Relude"
+    rhs: chr
+- warn:
+    lhs: Data.Int.Int8
+    name: "Use 'Int8' from Relude"
+    note: "'Int8' is already exported from Relude"
+    rhs: Int8
+- warn:
+    lhs: Data.Int.Int16
+    name: "Use 'Int16' from Relude"
+    note: "'Int16' is already exported from Relude"
+    rhs: Int16
+- warn:
+    lhs: Data.Int.Int32
+    name: "Use 'Int32' from Relude"
+    note: "'Int32' is already exported from Relude"
+    rhs: Int32
+- warn:
+    lhs: Data.Int.Int64
+    name: "Use 'Int64' from Relude"
+    note: "'Int64' is already exported from Relude"
+    rhs: Int64
+- warn:
+    lhs: Data.Word.Word8
+    name: "Use 'Word8' from Relude"
+    note: "'Word8' is already exported from Relude"
+    rhs: Word8
+- warn:
+    lhs: Data.Word.Word16
+    name: "Use 'Word16' from Relude"
+    note: "'Word16' is already exported from Relude"
+    rhs: Word16
+- warn:
+    lhs: Data.Word.Word32
+    name: "Use 'Word32' from Relude"
+    note: "'Word32' is already exported from Relude"
+    rhs: Word32
+- warn:
+    lhs: Data.Word.Word64
+    name: "Use 'Word64' from Relude"
+    note: "'Word64' is already exported from Relude"
+    rhs: Word64
+- warn:
+    lhs: Data.Word.byteSwap16
+    name: "Use 'byteSwap16' from Relude"
+    note: "'byteSwap16' is already exported from Relude"
+    rhs: byteSwap16
+- warn:
+    lhs: Data.Word.byteSwap32
+    name: "Use 'byteSwap32' from Relude"
+    note: "'byteSwap32' is already exported from Relude"
+    rhs: byteSwap32
+- warn:
+    lhs: Data.Word.byteSwap64
+    name: "Use 'byteSwap64' from Relude"
+    note: "'byteSwap64' is already exported from Relude"
+    rhs: byteSwap64
+- warn:
+    lhs: Numeric.Natural.Natural
+    name: "Use 'Natural' from Relude"
+    note: "'Natural' is already exported from Relude"
+    rhs: Natural
+- warn:
+    lhs: System.IO.IOMode
+    name: "Use 'IOMode' from Relude"
+    note: "'IOMode' is already exported from Relude"
+    rhs: IOMode
+- warn:
+    lhs: System.IO.ReadMode
+    name: "Use 'ReadMode' from Relude"
+    note: "'ReadMode' is already exported from Relude"
+    rhs: ReadMode
+- warn:
+    lhs: System.IO.WriteMode
+    name: "Use 'WriteMode' from Relude"
+    note: "'WriteMode' is already exported from Relude"
+    rhs: WriteMode
+- warn:
+    lhs: System.IO.AppendMode
+    name: "Use 'AppendMode' from Relude"
+    note: "'AppendMode' is already exported from Relude"
+    rhs: AppendMode
+- warn:
+    lhs: System.IO.ReadWriteMode
+    name: "Use 'ReadWriteMode' from Relude"
+    note: "'ReadWriteMode' is already exported from Relude"
+    rhs: ReadWriteMode
+- warn:
+    lhs: Data.Ord.Down
+    name: "Use 'Down' from Relude"
+    note: "'Down' is already exported from Relude"
+    rhs: Down
+- warn:
+    lhs: Data.Ord.comparing
+    name: "Use 'comparing' from Relude"
+    note: "'comparing' is already exported from Relude"
+    rhs: comparing
+- warn:
+    lhs: Data.Coerce.Coercible
+    name: "Use 'Coercible' from Relude"
+    note: "'Coercible' is already exported from Relude"
+    rhs: Coercible
+- warn:
+    lhs: Data.Coerce.coerce
+    name: "Use 'coerce' from Relude"
+    note: "'coerce' is already exported from Relude"
+    rhs: coerce
+- warn:
+    lhs: Data.Kind.Constraint
+    name: "Use 'Constraint' from Relude"
+    note: "'Constraint' is already exported from Relude"
+    rhs: Constraint
+- warn:
+    lhs: Data.Kind.Type
+    name: "Use 'Type' from Relude"
+    note: "'Type' is already exported from Relude"
+    rhs: Type
+- warn:
+    lhs: Data.Typeable.Typeable
+    name: "Use 'Typeable' from Relude"
+    note: "'Typeable' is already exported from Relude"
+    rhs: Typeable
+- warn:
+    lhs: Data.Proxy.Proxy
+    name: "Use 'Proxy' from Relude"
+    note: "'Proxy' is already exported from Relude"
+    rhs: Proxy
+- warn:
+    lhs: Data.Typeable.Typeable
+    name: "Use 'Typeable' from Relude"
+    note: "'Typeable' is already exported from Relude"
+    rhs: Typeable
+- warn:
+    lhs: Data.Void.Void
+    name: "Use 'Void' from Relude"
+    note: "'Void' is already exported from Relude"
+    rhs: Void
+- warn:
+    lhs: Data.Void.absurd
+    name: "Use 'absurd' from Relude"
+    note: "'absurd' is already exported from Relude"
+    rhs: absurd
+- warn:
+    lhs: Data.Void.vacuous
+    name: "Use 'vacuous' from Relude"
+    note: "'vacuous' is already exported from Relude"
+    rhs: vacuous
+- warn:
+    lhs: Data.Base.maxInt
+    name: "Use 'maxInt' from Relude"
+    note: "'maxInt' is already exported from Relude"
+    rhs: maxInt
+- warn:
+    lhs: Data.Base.minInt
+    name: "Use 'minInt' from Relude"
+    note: "'minInt' is already exported from Relude"
+    rhs: minInt
+- warn:
+    lhs: Data.Base.ord
+    name: "Use 'ord' from Relude"
+    note: "'ord' is already exported from Relude"
+    rhs: ord
+- warn:
+    lhs: GHC.Enum.boundedEnumFrom
+    name: "Use 'boundedEnumFrom' from Relude"
+    note: "'boundedEnumFrom' is already exported from Relude"
+    rhs: boundedEnumFrom
+- warn:
+    lhs: GHC.Enum.boundedEnumFromThen
+    name: "Use 'boundedEnumFromThen' from Relude"
+    note: "'boundedEnumFromThen' is already exported from Relude"
+    rhs: boundedEnumFromThen
+- warn:
+    lhs: GHC.Generics.Generic
+    name: "Use 'Generic' from Relude"
+    note: "'Generic' is already exported from Relude"
+    rhs: Generic
+- warn:
+    lhs: GHC.Real.Ratio
+    name: "Use 'Ratio' from Relude"
+    note: "'Ratio' is already exported from Relude"
+    rhs: Ratio
+- warn:
+    lhs: GHC.Real.Rational
+    name: "Use 'Rational' from Relude"
+    note: "'Rational' is already exported from Relude"
+    rhs: Rational
+- warn:
+    lhs: GHC.Real.denominator
+    name: "Use 'denominator' from Relude"
+    note: "'denominator' is already exported from Relude"
+    rhs: denominator
+- warn:
+    lhs: GHC.Real.numerator
+    name: "Use 'numerator' from Relude"
+    note: "'numerator' is already exported from Relude"
+    rhs: numerator
+- warn:
+    lhs: GHC.TypeNats.CmpNat
+    name: "Use 'CmpNat' from Relude"
+    note: "'CmpNat' is already exported from Relude"
+    rhs: CmpNat
+- warn:
+    lhs: GHC.TypeNats.KnownNat
+    name: "Use 'KnownNat' from Relude"
+    note: "'KnownNat' is already exported from Relude"
+    rhs: KnownNat
+- warn:
+    lhs: GHC.TypeNats.Nat
+    name: "Use 'Nat' from Relude"
+    note: "'Nat' is already exported from Relude"
+    rhs: Nat
+- warn:
+    lhs: GHC.TypeNats.SomeNat
+    name: "Use 'SomeNat' from Relude"
+    note: "'SomeNat' is already exported from Relude"
+    rhs: SomeNat
+- warn:
+    lhs: GHC.TypeNats.natVal
+    name: "Use 'natVal' from Relude"
+    note: "'natVal' is already exported from Relude"
+    rhs: natVal
+- warn:
+    lhs: GHC.TypeNats.someNatVal
+    name: "Use 'someNatVal' from Relude"
+    note: "'someNatVal' is already exported from Relude"
+    rhs: someNatVal
+- warn:
+    lhs: GHC.TypeLits.CmpNat
+    name: "Use 'CmpNat' from Relude"
+    note: "'CmpNat' is already exported from Relude"
+    rhs: CmpNat
+- warn:
+    lhs: GHC.TypeLits.KnownNat
+    name: "Use 'KnownNat' from Relude"
+    note: "'KnownNat' is already exported from Relude"
+    rhs: KnownNat
+- warn:
+    lhs: GHC.TypeLits.Nat
+    name: "Use 'Nat' from Relude"
+    note: "'Nat' is already exported from Relude"
+    rhs: Nat
+- warn:
+    lhs: GHC.TypeLits.SomeNat
+    name: "Use 'SomeNat' from Relude"
+    note: "'SomeNat' is already exported from Relude"
+    rhs: SomeNat
+- warn:
+    lhs: GHC.TypeLits.natVal
+    name: "Use 'natVal' from Relude"
+    note: "'natVal' is already exported from Relude"
+    rhs: natVal
+- warn:
+    lhs: GHC.TypeLits.someNatVal
+    name: "Use 'someNatVal' from Relude"
+    note: "'someNatVal' is already exported from Relude"
+    rhs: someNatVal
+- warn:
+    lhs: GHC.ExecutionStack.getStackTrace
+    name: "Use 'getStackTrace' from Relude"
+    note: "'getStackTrace' is already exported from Relude"
+    rhs: getStackTrace
+- warn:
+    lhs: GHC.ExecutionStack.showStackTrace
+    name: "Use 'showStackTrace' from Relude"
+    note: "'showStackTrace' is already exported from Relude"
+    rhs: showStackTrace
+- warn:
+    lhs: GHC.OverloadedLabels.IsLabel
+    name: "Use 'IsLabel' from Relude"
+    note: "'IsLabel' is already exported from Relude"
+    rhs: IsLabel
+- warn:
+    lhs: GHC.OverloadedLabels.fromLabel
+    name: "Use 'fromLabel' from Relude"
+    note: "'fromLabel' is already exported from Relude"
+    rhs: fromLabel
+- warn:
+    lhs: GHC.Stack.CallStack
+    name: "Use 'CallStack' from Relude"
+    note: "'CallStack' is already exported from Relude"
+    rhs: CallStack
+- warn:
+    lhs: GHC.Stack.HasCallStack
+    name: "Use 'HasCallStack' from Relude"
+    note: "'HasCallStack' is already exported from Relude"
+    rhs: HasCallStack
+- warn:
+    lhs: GHC.Stack.callStack
+    name: "Use 'callStack' from Relude"
+    note: "'callStack' is already exported from Relude"
+    rhs: callStack
+- warn:
+    lhs: GHC.Stack.currentCallStack
+    name: "Use 'currentCallStack' from Relude"
+    note: "'currentCallStack' is already exported from Relude"
+    rhs: currentCallStack
+- warn:
+    lhs: GHC.Stack.getCallStack
+    name: "Use 'getCallStack' from Relude"
+    note: "'getCallStack' is already exported from Relude"
+    rhs: getCallStack
+- warn:
+    lhs: GHC.Stack.prettyCallStack
+    name: "Use 'prettyCallStack' from Relude"
+    note: "'prettyCallStack' is already exported from Relude"
+    rhs: prettyCallStack
+- warn:
+    lhs: GHC.Stack.prettySrcLoc
+    name: "Use 'prettySrcLoc' from Relude"
+    note: "'prettySrcLoc' is already exported from Relude"
+    rhs: prettySrcLoc
+- warn:
+    lhs: GHC.Stack.withFrozenCallStack
+    name: "Use 'withFrozenCallStack' from Relude"
+    note: "'withFrozenCallStack' is already exported from Relude"
+    rhs: withFrozenCallStack
+- warn:
+    lhs: Data.Bifoldable.Bifoldable
+    name: "Use 'Bifoldable' from Relude"
+    note: "'Bifoldable' is already exported from Relude"
+    rhs: Bifoldable
+- warn:
+    lhs: Data.Bifoldable.bifold
+    name: "Use 'bifold' from Relude"
+    note: "'bifold' is already exported from Relude"
+    rhs: bifold
+- warn:
+    lhs: Data.Bifoldable.bifoldMap
+    name: "Use 'bifoldMap' from Relude"
+    note: "'bifoldMap' is already exported from Relude"
+    rhs: bifoldMap
+- warn:
+    lhs: Data.Bifoldable.bifoldr
+    name: "Use 'bifoldr' from Relude"
+    note: "'bifoldr' is already exported from Relude"
+    rhs: bifoldr
+- warn:
+    lhs: Data.Bifoldable.bifoldl
+    name: "Use 'bifoldl' from Relude"
+    note: "'bifoldl' is already exported from Relude"
+    rhs: bifoldl
+- warn:
+    lhs: "Data.Bifoldable.bifoldl'"
+    name: "Use 'bifoldl'' from Relude"
+    note: "'bifoldl'' is already exported from Relude"
+    rhs: "bifoldl'"
+- warn:
+    lhs: Data.Bifoldable.bifoldlM
+    name: "Use 'bifoldlM' from Relude"
+    note: "'bifoldlM' is already exported from Relude"
+    rhs: bifoldlM
+- warn:
+    lhs: "Data.Bifoldable.bifoldr'"
+    name: "Use 'bifoldr'' from Relude"
+    note: "'bifoldr'' is already exported from Relude"
+    rhs: "bifoldr'"
+- warn:
+    lhs: Data.Bifoldable.bifoldrM
+    name: "Use 'bifoldrM' from Relude"
+    note: "'bifoldrM' is already exported from Relude"
+    rhs: bifoldrM
+- warn:
+    lhs: Data.Bifoldable.bitraverse_
+    name: "Use 'bitraverse_' from Relude"
+    note: "'bitraverse_' is already exported from Relude"
+    rhs: bitraverse_
+- warn:
+    lhs: Data.Bifoldable.bifor_
+    name: "Use 'bifor_' from Relude"
+    note: "'bifor_' is already exported from Relude"
+    rhs: bifor_
+- warn:
+    lhs: Data.Bifoldable.biasum
+    name: "Use 'biasum' from Relude"
+    note: "'biasum' is already exported from Relude"
+    rhs: biasum
+- warn:
+    lhs: Data.Bifoldable.bisequence_
+    name: "Use 'bisequence_' from Relude"
+    note: "'bisequence_' is already exported from Relude"
+    rhs: bisequence_
+- warn:
+    lhs: Data.Bifoldable.biList
+    name: "Use 'biList' from Relude"
+    note: "'biList' is already exported from Relude"
+    rhs: biList
+- warn:
+    lhs: Data.Bifoldable.binull
+    name: "Use 'binull' from Relude"
+    note: "'binull' is already exported from Relude"
+    rhs: binull
+- warn:
+    lhs: Data.Bifoldable.bilength
+    name: "Use 'bilength' from Relude"
+    note: "'bilength' is already exported from Relude"
+    rhs: bilength
+- warn:
+    lhs: Data.Bifoldable.bielem
+    name: "Use 'bielem' from Relude"
+    note: "'bielem' is already exported from Relude"
+    rhs: bielem
+- warn:
+    lhs: Data.Bifoldable.biand
+    name: "Use 'biand' from Relude"
+    note: "'biand' is already exported from Relude"
+    rhs: biand
+- warn:
+    lhs: Data.Bifoldable.bior
+    name: "Use 'bior' from Relude"
+    note: "'bior' is already exported from Relude"
+    rhs: bior
+- warn:
+    lhs: Data.Bifoldable.biany
+    name: "Use 'biany' from Relude"
+    note: "'biany' is already exported from Relude"
+    rhs: biany
+- warn:
+    lhs: Data.Bifoldable.biall
+    name: "Use 'biall' from Relude"
+    note: "'biall' is already exported from Relude"
+    rhs: biall
+- warn:
+    lhs: Data.Bifoldable.bifind
+    name: "Use 'bifind' from Relude"
+    note: "'bifind' is already exported from Relude"
+    rhs: bifind
+- warn:
+    lhs: Data.Bitraversable.Bitraversable
+    name: "Use 'Bitraversable' from Relude"
+    note: "'Bitraversable' is already exported from Relude"
+    rhs: Bitraversable
+- warn:
+    lhs: Data.Bitraversable.bitraverse
+    name: "Use 'bitraverse' from Relude"
+    note: "'bitraverse' is already exported from Relude"
+    rhs: bitraverse
+- warn:
+    lhs: Data.Bitraversable.bisequence
+    name: "Use 'bisequence' from Relude"
+    note: "'bisequence' is already exported from Relude"
+    rhs: bisequence
+- warn:
+    lhs: Data.Bitraversable.bifor
+    name: "Use 'bifor' from Relude"
+    note: "'bifor' is already exported from Relude"
+    rhs: bifor
+- warn:
+    lhs: Data.Bitraversable.bimapDefault
+    name: "Use 'bimapDefault' from Relude"
+    note: "'bimapDefault' is already exported from Relude"
+    rhs: bimapDefault
+- warn:
+    lhs: Data.Bitraversable.bifoldMapDefault
+    name: "Use 'bifoldMapDefault' from Relude"
+    note: "'bifoldMapDefault' is already exported from Relude"
+    rhs: bifoldMapDefault
+- warn:
+    lhs: Control.Monad.guard
+    name: "Use 'guard' from Relude"
+    note: "'guard' is already exported from Relude"
+    rhs: guard
+- warn:
+    lhs: Control.Monad.unless
+    name: "Use 'unless' from Relude"
+    note: "'unless' is already exported from Relude"
+    rhs: unless
+- warn:
+    lhs: Control.Monad.when
+    name: "Use 'when' from Relude"
+    note: "'when' is already exported from Relude"
+    rhs: when
+- warn:
+    lhs: Data.Bool.bool
+    name: "Use 'bool' from Relude"
+    note: "'bool' is already exported from Relude"
+    rhs: bool
+- warn:
+    lhs: Data.Hashable.Hashable
+    name: "Use 'Hashable' from Relude"
+    note: "'Hashable' is already exported from Relude"
+    rhs: Hashable
+- warn:
+    lhs: Data.Hashable.hashWithSalt
+    name: "Use 'hashWithSalt' from Relude"
+    note: "'hashWithSalt' is already exported from Relude"
+    rhs: hashWithSalt
+- warn:
+    lhs: Data.HashMap.Strict.HashMap
+    name: "Use 'HashMap' from Relude"
+    note: "'HashMap' is already exported from Relude"
+    rhs: HashMap
+- warn:
+    lhs: Data.HashSet.HashSet
+    name: "Use 'HashSet' from Relude"
+    note: "'HashSet' is already exported from Relude"
+    rhs: HashSet
+- warn:
+    lhs: Data.IntMap.Strict.IntMap
+    name: "Use 'IntMap' from Relude"
+    note: "'IntMap' is already exported from Relude"
+    rhs: IntMap
+- warn:
+    lhs: Data.IntSet.IntSet
+    name: "Use 'IntSet' from Relude"
+    note: "'IntSet' is already exported from Relude"
+    rhs: IntSet
+- warn:
+    lhs: Data.Map.Strict.Map
+    name: "Use 'Map' from Relude"
+    note: "'Map' is already exported from Relude"
+    rhs: Map
+- warn:
+    lhs: Data.Sequence.Sequence
+    name: "Use 'Sequence' from Relude"
+    note: "'Sequence' is already exported from Relude"
+    rhs: Sequence
+- warn:
+    lhs: Data.Set.Set
+    name: "Use 'Set' from Relude"
+    note: "'Set' is already exported from Relude"
+    rhs: Set
+- warn:
+    lhs: Data.Tuple.swap
+    name: "Use 'swap' from Relude"
+    note: "'swap' is already exported from Relude"
+    rhs: swap
+- warn:
+    lhs: Data.Vector.Vector
+    name: "Use 'Vector' from Relude"
+    note: "'Vector' is already exported from Relude"
+    rhs: Vector
+- warn:
+    lhs: GHC.Exts.IsList
+    name: "Use 'IsList' from Relude"
+    note: "'IsList' is already exported from Relude"
+    rhs: IsList
+- warn:
+    lhs: GHC.Exts.fromList
+    name: "Use 'fromList' from Relude"
+    note: "'fromList' is already exported from Relude"
+    rhs: fromList
+- warn:
+    lhs: GHC.Exts.fromListN
+    name: "Use 'fromListN' from Relude"
+    note: "'fromListN' is already exported from Relude"
+    rhs: fromListN
+- warn:
+    lhs: Debug.Trace.trace
+    name: "Use 'trace' from Relude"
+    note: "'trace' is already exported from Relude"
+    rhs: trace
+- warn:
+    lhs: Debug.Trace.traceShow
+    name: "Use 'traceShow' from Relude"
+    note: "'traceShow' is already exported from Relude"
+    rhs: traceShow
+- warn:
+    lhs: Debug.Trace.traceShowId
+    name: "Use 'traceShowId' from Relude"
+    note: "'traceShowId' is already exported from Relude"
+    rhs: traceShowId
+- warn:
+    lhs: Debug.Trace.traceShowM
+    name: "Use 'traceShowM' from Relude"
+    note: "'traceShowM' is already exported from Relude"
+    rhs: traceShowM
+- warn:
+    lhs: Debug.Trace.traceM
+    name: "Use 'traceM' from Relude"
+    note: "'traceM' is already exported from Relude"
+    rhs: traceM
+- warn:
+    lhs: Debug.Trace.traceId
+    name: "Use 'traceId' from Relude"
+    note: "'traceId' is already exported from Relude"
+    rhs: traceId
+- warn:
+    lhs: Control.DeepSeq.NFData
+    name: "Use 'NFData' from Relude"
+    note: "'NFData' is already exported from Relude"
+    rhs: NFData
+- warn:
+    lhs: Control.DeepSeq.rnf
+    name: "Use 'rnf' from Relude"
+    note: "'rnf' is already exported from Relude"
+    rhs: rnf
+- warn:
+    lhs: Control.DeepSeq.deepseq
+    name: "Use 'deepseq' from Relude"
+    note: "'deepseq' is already exported from Relude"
+    rhs: deepseq
+- warn:
+    lhs: Control.DeepSeq.force
+    name: "Use 'force' from Relude"
+    note: "'force' is already exported from Relude"
+    rhs: force
+- warn:
+    lhs: "(Control.DeepSeq.$!!)"
+    name: "Use '$!!' from Relude"
+    note: "Operator '($!!)' is already exported from Relude"
+    rhs: "($!!)"
+- warn:
+    lhs: Control.Exception.Exception
+    name: "Use 'Exception' from Relude"
+    note: "'Exception' is already exported from Relude"
+    rhs: Exception
+- warn:
+    lhs: Control.Exception.SomeException
+    name: "Use 'SomeException' from Relude"
+    note: "'SomeException' is already exported from Relude"
+    rhs: SomeException
+- warn:
+    lhs: Control.Exception.toException
+    name: "Use 'toException' from Relude"
+    note: "'toException' is already exported from Relude"
+    rhs: toException
+- warn:
+    lhs: Control.Exception.fromException
+    name: "Use 'fromException' from Relude"
+    note: "'fromException' is already exported from Relude"
+    rhs: fromException
+- warn:
+    lhs: Control.Exception.displayException
+    name: "Use 'displayException' from Relude"
+    note: "'displayException' is already exported from Relude"
+    rhs: displayException
+- warn:
+    lhs: Data.Foldable.asum
+    name: "Use 'asum' from Relude"
+    note: "'asum' is already exported from Relude"
+    rhs: asum
+- warn:
+    lhs: Data.Foldable.find
+    name: "Use 'find' from Relude"
+    note: "'find' is already exported from Relude"
+    rhs: find
+- warn:
+    lhs: Data.Foldable.find
+    name: "Use 'find' from Relude"
+    note: "'find' is already exported from Relude"
+    rhs: find
+- warn:
+    lhs: Data.Foldable.fold
+    name: "Use 'fold' from Relude"
+    note: "'fold' is already exported from Relude"
+    rhs: fold
+- warn:
+    lhs: "Data.Foldable.foldl'"
+    name: "Use 'foldl'' from Relude"
+    note: "'foldl'' is already exported from Relude"
+    rhs: "foldl'"
+- warn:
+    lhs: Data.Foldable.forM_
+    name: "Use 'forM_' from Relude"
+    note: "'forM_' is already exported from Relude"
+    rhs: forM_
+- warn:
+    lhs: Data.Foldable.for_
+    name: "Use 'for_' from Relude"
+    note: "'for_' is already exported from Relude"
+    rhs: for_
+- warn:
+    lhs: Data.Foldable.sequenceA_
+    name: "Use 'sequenceA_' from Relude"
+    note: "'sequenceA_' is already exported from Relude"
+    rhs: sequenceA_
+- warn:
+    lhs: Data.Foldable.toList
+    name: "Use 'toList' from Relude"
+    note: "'toList' is already exported from Relude"
+    rhs: toList
+- warn:
+    lhs: Data.Foldable.traverse_
+    name: "Use 'traverse_' from Relude"
+    note: "'traverse_' is already exported from Relude"
+    rhs: traverse_
+- warn:
+    lhs: Data.Traversable.forM
+    name: "Use 'forM' from Relude"
+    note: "'forM' is already exported from Relude"
+    rhs: forM
+- warn:
+    lhs: Data.Traversable.mapAccumL
+    name: "Use 'mapAccumL' from Relude"
+    note: "'mapAccumL' is already exported from Relude"
+    rhs: mapAccumL
+- warn:
+    lhs: Data.Traversable.mapAccumR
+    name: "Use 'mapAccumR' from Relude"
+    note: "'mapAccumR' is already exported from Relude"
+    rhs: mapAccumR
+- warn:
+    lhs: "(Control.Arrow.&&&)"
+    name: "Use '&&&' from Relude"
+    note: "Operator '(&&&)' is already exported from Relude"
+    rhs: "(&&&)"
+- warn:
+    lhs: "(Control.Category.>>>)"
+    name: "Use '>>>' from Relude"
+    note: "Operator '(>>>)' is already exported from Relude"
+    rhs: "(>>>)"
+- warn:
+    lhs: "(Control.Category.<<<)"
+    name: "Use '<<<' from Relude"
+    note: "Operator '(<<<)' is already exported from Relude"
+    rhs: "(<<<)"
+- warn:
+    lhs: Data.Function.fix
+    name: "Use 'fix' from Relude"
+    note: "'fix' is already exported from Relude"
+    rhs: fix
+- warn:
+    lhs: Data.Function.on
+    name: "Use 'on' from Relude"
+    note: "'on' is already exported from Relude"
+    rhs: 'on'
+- warn:
+    lhs: Data.Bifunctor.Bifunctor
+    name: "Use 'Bifunctor' from Relude"
+    note: "'Bifunctor' is already exported from Relude"
+    rhs: Bifunctor
+- warn:
+    lhs: Data.Bifunctor.bimap
+    name: "Use 'bimap' from Relude"
+    note: "'bimap' is already exported from Relude"
+    rhs: bimap
+- warn:
+    lhs: Data.Bifunctor.first
+    name: "Use 'first' from Relude"
+    note: "'first' is already exported from Relude"
+    rhs: first
+- warn:
+    lhs: Data.Bifunctor.second
+    name: "Use 'second' from Relude"
+    note: "'second' is already exported from Relude"
+    rhs: second
+- warn:
+    lhs: Data.Functor.void
+    name: "Use 'void' from Relude"
+    note: "'void' is already exported from Relude"
+    rhs: void
+- warn:
+    lhs: "(Data.Functor.$>)"
+    name: "Use '$>' from Relude"
+    note: "Operator '($>)' is already exported from Relude"
+    rhs: "($>)"
+- warn:
+    lhs: "(Data.Functor.<&>)"
+    name: "Use '<&>' from Relude"
+    note: "Operator '(<&>)' is already exported from Relude"
+    rhs: "(<&>)"
+- warn:
+    lhs: Data.Functor.Compose.Compose
+    name: "Use 'Compose' from Relude"
+    note: "'Compose' is already exported from Relude"
+    rhs: Compose
+- warn:
+    lhs: Data.Functor.Compose.getCompose
+    name: "Use 'getCompose' from Relude"
+    note: "'getCompose' is already exported from Relude"
+    rhs: getCompose
+- warn:
+    lhs: Data.Functor.Identity.Identity
+    name: "Use 'Identity' from Relude"
+    note: "'Identity' is already exported from Relude"
+    rhs: Identity
+- warn:
+    lhs: Data.Functor.Identity.runIdentity
+    name: "Use 'runIdentity' from Relude"
+    note: "'runIdentity' is already exported from Relude"
+    rhs: runIdentity
+- warn:
+    lhs: Control.Concurrent.MVar.MVar
+    name: "Use 'MVar' from Relude"
+    note: "'MVar' is already exported from Relude"
+    rhs: MVar
+- warn:
+    lhs: Control.Concurrent.MVar.newEmptyMVar
+    name: "Use 'newEmptyMVar' from Relude"
+    note: "'newEmptyMVar' is already exported from Relude"
+    rhs: newEmptyMVar
+- warn:
+    lhs: Control.Concurrent.MVar.newMVar
+    name: "Use 'newMVar' from Relude"
+    note: "'newMVar' is already exported from Relude"
+    rhs: newMVar
+- warn:
+    lhs: Control.Concurrent.MVar.putMVar
+    name: "Use 'putMVar' from Relude"
+    note: "'putMVar' is already exported from Relude"
+    rhs: putMVar
+- warn:
+    lhs: Control.Concurrent.MVar.readMVar
+    name: "Use 'readMVar' from Relude"
+    note: "'readMVar' is already exported from Relude"
+    rhs: readMVar
+- warn:
+    lhs: Control.Concurrent.MVar.swapMVar
+    name: "Use 'swapMVar' from Relude"
+    note: "'swapMVar' is already exported from Relude"
+    rhs: swapMVar
+- warn:
+    lhs: Control.Concurrent.MVar.takeMVar
+    name: "Use 'takeMVar' from Relude"
+    note: "'takeMVar' is already exported from Relude"
+    rhs: takeMVar
+- warn:
+    lhs: Control.Concurrent.MVar.tryPutMVar
+    name: "Use 'tryPutMVar' from Relude"
+    note: "'tryPutMVar' is already exported from Relude"
+    rhs: tryPutMVar
+- warn:
+    lhs: Control.Concurrent.MVar.tryReadMVar
+    name: "Use 'tryReadMVar' from Relude"
+    note: "'tryReadMVar' is already exported from Relude"
+    rhs: tryReadMVar
+- warn:
+    lhs: Control.Concurrent.MVar.tryTakeMVar
+    name: "Use 'tryTakeMVar' from Relude"
+    note: "'tryTakeMVar' is already exported from Relude"
+    rhs: tryTakeMVar
+- warn:
+    lhs: Control.Monad.STM.STM
+    name: "Use 'STM' from Relude"
+    note: "'STM' is already exported from Relude"
+    rhs: STM
+- warn:
+    lhs: Control.Monad.STM.atomically
+    name: "Use 'atomically' from Relude"
+    note: "'atomically' is already exported from Relude"
+    rhs: atomically
+- warn:
+    lhs: Control.Monad.STM.throwSTM
+    name: "Use 'throwSTM' from Relude"
+    note: "'throwSTM' is already exported from Relude"
+    rhs: throwSTM
+- warn:
+    lhs: Control.Monad.STM.catchSTM
+    name: "Use 'catchSTM' from Relude"
+    note: "'catchSTM' is already exported from Relude"
+    rhs: catchSTM
+- warn:
+    lhs: Control.Concurrent.STM.TVar.TVar
+    name: "Use 'TVar' from Relude"
+    note: "'TVar' is already exported from Relude"
+    rhs: TVar
+- warn:
+    lhs: Control.Concurrent.STM.TVar.newTVarIO
+    name: "Use 'newTVarIO' from Relude"
+    note: "'newTVarIO' is already exported from Relude"
+    rhs: newTVarIO
+- warn:
+    lhs: Control.Concurrent.STM.TVar.readTVarIO
+    name: "Use 'readTVarIO' from Relude"
+    note: "'readTVarIO' is already exported from Relude"
+    rhs: readTVarIO
+- warn:
+    lhs: "Control.Concurrent.STM.TVar.modifyTVar'"
+    name: "Use 'modifyTVar'' from Relude"
+    note: "'modifyTVar'' is already exported from Relude"
+    rhs: "modifyTVar'"
+- warn:
+    lhs: Control.Concurrent.STM.TVar.newTVar
+    name: "Use 'newTVar' from Relude"
+    note: "'newTVar' is already exported from Relude"
+    rhs: newTVar
+- warn:
+    lhs: Control.Concurrent.STM.TVar.readTVar
+    name: "Use 'readTVar' from Relude"
+    note: "'readTVar' is already exported from Relude"
+    rhs: readTVar
+- warn:
+    lhs: Control.Concurrent.STM.TVar.writeTVar
+    name: "Use 'writeTVar' from Relude"
+    note: "'writeTVar' is already exported from Relude"
+    rhs: writeTVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.TMVar
+    name: "Use 'TMVar' from Relude"
+    note: "'TMVar' is already exported from Relude"
+    rhs: TMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.newTMVar
+    name: "Use 'newTMVar' from Relude"
+    note: "'newTMVar' is already exported from Relude"
+    rhs: newTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.newEmptyTMVar
+    name: "Use 'newEmptyTMVar' from Relude"
+    note: "'newEmptyTMVar' is already exported from Relude"
+    rhs: newEmptyTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.newTMVarIO
+    name: "Use 'newTMVarIO' from Relude"
+    note: "'newTMVarIO' is already exported from Relude"
+    rhs: newTMVarIO
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.newEmptyTMVarIO
+    name: "Use 'newEmptyTMVarIO' from Relude"
+    note: "'newEmptyTMVarIO' is already exported from Relude"
+    rhs: newEmptyTMVarIO
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.takeTMVar
+    name: "Use 'takeTMVar' from Relude"
+    note: "'takeTMVar' is already exported from Relude"
+    rhs: takeTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.putTMVar
+    name: "Use 'putTMVar' from Relude"
+    note: "'putTMVar' is already exported from Relude"
+    rhs: putTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.readTMVar
+    name: "Use 'readTMVar' from Relude"
+    note: "'readTMVar' is already exported from Relude"
+    rhs: readTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.tryReadTMVar
+    name: "Use 'tryReadTMVar' from Relude"
+    note: "'tryReadTMVar' is already exported from Relude"
+    rhs: tryReadTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.swapTMVar
+    name: "Use 'swapTMVar' from Relude"
+    note: "'swapTMVar' is already exported from Relude"
+    rhs: swapTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.tryTakeTMVar
+    name: "Use 'tryTakeTMVar' from Relude"
+    note: "'tryTakeTMVar' is already exported from Relude"
+    rhs: tryTakeTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.tryPutTMVar
+    name: "Use 'tryPutTMVar' from Relude"
+    note: "'tryPutTMVar' is already exported from Relude"
+    rhs: tryPutTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.isEmptyTMVar
+    name: "Use 'isEmptyTMVar' from Relude"
+    note: "'isEmptyTMVar' is already exported from Relude"
+    rhs: isEmptyTMVar
+- warn:
+    lhs: Control.Concurrent.STM.TMVar.mkWeakTMVar
+    name: "Use 'mkWeakTMVar' from Relude"
+    note: "'mkWeakTMVar' is already exported from Relude"
+    rhs: mkWeakTMVar
+- warn:
+    lhs: Data.IORef.IORef
+    name: "Use 'IORef' from Relude"
+    note: "'IORef' is already exported from Relude"
+    rhs: IORef
+- warn:
+    lhs: Data.IORef.atomicModifyIORef
+    name: "Use 'atomicModifyIORef' from Relude"
+    note: "'atomicModifyIORef' is already exported from Relude"
+    rhs: atomicModifyIORef
+- warn:
+    lhs: "Data.IORef.atomicModifyIORef'"
+    name: "Use 'atomicModifyIORef'' from Relude"
+    note: "'atomicModifyIORef'' is already exported from Relude"
+    rhs: "atomicModifyIORef'"
+- warn:
+    lhs: Data.IORef.atomicWriteIORef
+    name: "Use 'atomicWriteIORef' from Relude"
+    note: "'atomicWriteIORef' is already exported from Relude"
+    rhs: atomicWriteIORef
+- warn:
+    lhs: Data.IORef.modifyIORef
+    name: "Use 'modifyIORef' from Relude"
+    note: "'modifyIORef' is already exported from Relude"
+    rhs: modifyIORef
+- warn:
+    lhs: "Data.IORef.modifyIORef'"
+    name: "Use 'modifyIORef'' from Relude"
+    note: "'modifyIORef'' is already exported from Relude"
+    rhs: "modifyIORef'"
+- warn:
+    lhs: Data.IORef.newIORef
+    name: "Use 'newIORef' from Relude"
+    note: "'newIORef' is already exported from Relude"
+    rhs: newIORef
+- warn:
+    lhs: Data.IORef.readIORef
+    name: "Use 'readIORef' from Relude"
+    note: "'readIORef' is already exported from Relude"
+    rhs: readIORef
+- warn:
+    lhs: Data.IORef.writeIORef
+    name: "Use 'writeIORef' from Relude"
+    note: "'writeIORef' is already exported from Relude"
+    rhs: writeIORef
+- warn:
+    lhs: "atomicModifyIORef ref (\\a -> (f a, ()))"
+    rhs: atomicModifyIORef_ ref f
+- warn:
+    lhs: "atomicModifyIORef ref $ \\a -> (f a, ())"
+    rhs: atomicModifyIORef_ ref f
+- warn:
+    lhs: "atomicModifyIORef' ref $ \\a -> (f a, ())"
+    rhs: "atomicModifyIORef'_ ref f"
+- warn:
+    lhs: "atomicModifyIORef' ref (\\a -> (f a, ()))"
+    rhs: "atomicModifyIORef'_ ref f"
+- warn:
+    lhs: Data.Text.IO.getLine
+    name: "Use 'getLine' from Relude"
+    note: "'getLine' is already exported from Relude"
+    rhs: getLine
+- warn:
+    lhs: System.IO.hFlush
+    name: "Use 'hFlush' from Relude"
+    note: "'hFlush' is already exported from Relude"
+    rhs: hFlush
+- warn:
+    lhs: System.IO.hIsEOF
+    name: "Use 'hIsEOF' from Relude"
+    note: "'hIsEOF' is already exported from Relude"
+    rhs: hIsEOF
+- warn:
+    lhs: System.IO.hSetBuffering
+    name: "Use 'hSetBuffering' from Relude"
+    note: "'hSetBuffering' is already exported from Relude"
+    rhs: hSetBuffering
+- warn:
+    lhs: System.IO.hGetBuffering
+    name: "Use 'hGetBuffering' from Relude"
+    note: "'hGetBuffering' is already exported from Relude"
+    rhs: hGetBuffering
+- warn:
+    lhs: System.IO.Handle
+    name: "Use 'Handle' from Relude"
+    note: "'Handle' is already exported from Relude"
+    rhs: Handle
+- warn:
+    lhs: System.IO.stdin
+    name: "Use 'stdin' from Relude"
+    note: "'stdin' is already exported from Relude"
+    rhs: stdin
+- warn:
+    lhs: System.IO.stdout
+    name: "Use 'stdout' from Relude"
+    note: "'stdout' is already exported from Relude"
+    rhs: stdout
+- warn:
+    lhs: System.IO.stderr
+    name: "Use 'stderr' from Relude"
+    note: "'stderr' is already exported from Relude"
+    rhs: stderr
+- warn:
+    lhs: System.IO.withFile
+    name: "Use 'withFile' from Relude"
+    note: "'withFile' is already exported from Relude"
+    rhs: withFile
+- warn:
+    lhs: System.IO.BufferMode
+    name: "Use 'BufferMode' from Relude"
+    note: "'BufferMode' is already exported from Relude"
+    rhs: BufferMode
+- warn:
+    lhs: System.Environment.getArgs
+    name: "Use 'getArgs' from Relude"
+    note: "'getArgs' is already exported from Relude"
+    rhs: getArgs
+- warn:
+    lhs: System.Environment.lookupEnv
+    name: "Use 'lookupEnv' from Relude"
+    note: "'lookupEnv' is already exported from Relude"
+    rhs: lookupEnv
+- warn:
+    lhs: Data.List.genericDrop
+    name: "Use 'genericDrop' from Relude"
+    note: "'genericDrop' is already exported from Relude"
+    rhs: genericDrop
+- warn:
+    lhs: Data.List.genericLength
+    name: "Use 'genericLength' from Relude"
+    note: "'genericLength' is already exported from Relude"
+    rhs: genericLength
+- warn:
+    lhs: Data.List.genericReplicate
+    name: "Use 'genericReplicate' from Relude"
+    note: "'genericReplicate' is already exported from Relude"
+    rhs: genericReplicate
+- warn:
+    lhs: Data.List.genericSplitAt
+    name: "Use 'genericSplitAt' from Relude"
+    note: "'genericSplitAt' is already exported from Relude"
+    rhs: genericSplitAt
+- warn:
+    lhs: Data.List.genericTake
+    name: "Use 'genericTake' from Relude"
+    note: "'genericTake' is already exported from Relude"
+    rhs: genericTake
+- warn:
+    lhs: Data.List.group
+    name: "Use 'group' from Relude"
+    note: "'group' is already exported from Relude"
+    rhs: group
+- warn:
+    lhs: Data.List.inits
+    name: "Use 'inits' from Relude"
+    note: "'inits' is already exported from Relude"
+    rhs: inits
+- warn:
+    lhs: Data.List.intercalate
+    name: "Use 'intercalate' from Relude"
+    note: "'intercalate' is already exported from Relude"
+    rhs: intercalate
+- warn:
+    lhs: Data.List.intersperse
+    name: "Use 'intersperse' from Relude"
+    note: "'intersperse' is already exported from Relude"
+    rhs: intersperse
+- warn:
+    lhs: Data.List.isPrefixOf
+    name: "Use 'isPrefixOf' from Relude"
+    note: "'isPrefixOf' is already exported from Relude"
+    rhs: isPrefixOf
+- warn:
+    lhs: Data.List.permutations
+    name: "Use 'permutations' from Relude"
+    note: "'permutations' is already exported from Relude"
+    rhs: permutations
+- warn:
+    lhs: "Data.List.scanl'"
+    name: "Use 'scanl'' from Relude"
+    note: "'scanl'' is already exported from Relude"
+    rhs: "scanl'"
+- warn:
+    lhs: Data.List.sort
+    name: "Use 'sort' from Relude"
+    note: "'sort' is already exported from Relude"
+    rhs: sort
+- warn:
+    lhs: Data.List.sortBy
+    name: "Use 'sortBy' from Relude"
+    note: "'sortBy' is already exported from Relude"
+    rhs: sortBy
+- warn:
+    lhs: Data.List.sortOn
+    name: "Use 'sortOn' from Relude"
+    note: "'sortOn' is already exported from Relude"
+    rhs: sortOn
+- warn:
+    lhs: Data.List.subsequences
+    name: "Use 'subsequences' from Relude"
+    note: "'subsequences' is already exported from Relude"
+    rhs: subsequences
+- warn:
+    lhs: Data.List.tails
+    name: "Use 'tails' from Relude"
+    note: "'tails' is already exported from Relude"
+    rhs: tails
+- warn:
+    lhs: Data.List.transpose
+    name: "Use 'transpose' from Relude"
+    note: "'transpose' is already exported from Relude"
+    rhs: transpose
+- warn:
+    lhs: Data.List.uncons
+    name: "Use 'uncons' from Relude"
+    note: "'uncons' is already exported from Relude"
+    rhs: uncons
+- warn:
+    lhs: Data.List.unfoldr
+    name: "Use 'unfoldr' from Relude"
+    note: "'unfoldr' is already exported from Relude"
+    rhs: unfoldr
+- warn:
+    lhs: Data.List.NonEmpty.NonEmpty
+    name: "Use 'NonEmpty' from Relude"
+    note: "'NonEmpty' is already exported from Relude"
+    rhs: NonEmpty
+- warn:
+    lhs: "(Data.List.NonEmpty.:|)"
+    name: "Use ':|' from Relude"
+    note: "Operator '(:|)' is already exported from Relude"
+    rhs: "(:|)"
+- warn:
+    lhs: Data.List.NonEmpty.nonEmpty
+    name: "Use 'nonEmpty' from Relude"
+    note: "'nonEmpty' is already exported from Relude"
+    rhs: nonEmpty
+- warn:
+    lhs: Data.List.NonEmpty.head
+    name: "Use 'head' from Relude"
+    note: "'head' is already exported from Relude"
+    rhs: head
+- warn:
+    lhs: Data.List.NonEmpty.init
+    name: "Use 'init' from Relude"
+    note: "'init' is already exported from Relude"
+    rhs: init
+- warn:
+    lhs: Data.List.NonEmpty.last
+    name: "Use 'last' from Relude"
+    note: "'last' is already exported from Relude"
+    rhs: last
+- warn:
+    lhs: Data.List.NonEmpty.tail
+    name: "Use 'tail' from Relude"
+    note: "'tail' is already exported from Relude"
+    rhs: tail
+- warn:
+    lhs: GHC.Exts.sortWith
+    name: "Use 'sortWith' from Relude"
+    note: "'sortWith' is already exported from Relude"
+    rhs: sortWith
+- warn:
+    lhs: Control.Monad.Except.ExceptT
+    name: "Use 'ExceptT' from Relude"
+    note: "'ExceptT' is already exported from Relude"
+    rhs: ExceptT
+- warn:
+    lhs: Control.Monad.Except.runExceptT
+    name: "Use 'runExceptT' from Relude"
+    note: "'runExceptT' is already exported from Relude"
+    rhs: runExceptT
+- warn:
+    lhs: Control.Monad.Reader.MonadReader
+    name: "Use 'MonadReader' from Relude"
+    note: "'MonadReader' is already exported from Relude"
+    rhs: MonadReader
+- warn:
+    lhs: Control.Monad.Reader.Reader
+    name: "Use 'Reader' from Relude"
+    note: "'Reader' is already exported from Relude"
+    rhs: Reader
+- warn:
+    lhs: Control.Monad.Reader.ReaderT
+    name: "Use 'ReaderT' from Relude"
+    note: "'ReaderT' is already exported from Relude"
+    rhs: ReaderT
+- warn:
+    lhs: Control.Monad.Reader.runReaderT
+    name: "Use 'runReaderT' from Relude"
+    note: "'runReaderT' is already exported from Relude"
+    rhs: runReaderT
+- warn:
+    lhs: Control.Monad.Reader.ask
+    name: "Use 'ask' from Relude"
+    note: "'ask' is already exported from Relude"
+    rhs: ask
+- warn:
+    lhs: Control.Monad.Reader.asks
+    name: "Use 'asks' from Relude"
+    note: "'asks' is already exported from Relude"
+    rhs: asks
+- warn:
+    lhs: Control.Monad.Reader.local
+    name: "Use 'local' from Relude"
+    note: "'local' is already exported from Relude"
+    rhs: local
+- warn:
+    lhs: Control.Monad.Reader.reader
+    name: "Use 'reader' from Relude"
+    note: "'reader' is already exported from Relude"
+    rhs: reader
+- warn:
+    lhs: Control.Monad.Reader.runReader
+    name: "Use 'runReader' from Relude"
+    note: "'runReader' is already exported from Relude"
+    rhs: runReader
+- warn:
+    lhs: Control.Monad.Reader.withReader
+    name: "Use 'withReader' from Relude"
+    note: "'withReader' is already exported from Relude"
+    rhs: withReader
+- warn:
+    lhs: Control.Monad.Reader.withReaderT
+    name: "Use 'withReaderT' from Relude"
+    note: "'withReaderT' is already exported from Relude"
+    rhs: withReaderT
+- warn:
+    lhs: Control.Monad.State.Strict.MonadState
+    name: "Use 'MonadState' from Relude"
+    note: "'MonadState' is already exported from Relude"
+    rhs: MonadState
+- warn:
+    lhs: Control.Monad.State.Strict.State
+    name: "Use 'State' from Relude"
+    note: "'State' is already exported from Relude"
+    rhs: State
+- warn:
+    lhs: Control.Monad.State.Strict.StateT
+    name: "Use 'StateT' from Relude"
+    note: "'StateT' is already exported from Relude"
+    rhs: StateT
+- warn:
+    lhs: Control.Monad.State.Strict.runStateT
+    name: "Use 'runStateT' from Relude"
+    note: "'runStateT' is already exported from Relude"
+    rhs: runStateT
+- warn:
+    lhs: Control.Monad.State.Strict.evalState
+    name: "Use 'evalState' from Relude"
+    note: "'evalState' is already exported from Relude"
+    rhs: evalState
+- warn:
+    lhs: Control.Monad.State.Strict.evalStateT
+    name: "Use 'evalStateT' from Relude"
+    note: "'evalStateT' is already exported from Relude"
+    rhs: evalStateT
+- warn:
+    lhs: Control.Monad.State.Strict.execState
+    name: "Use 'execState' from Relude"
+    note: "'execState' is already exported from Relude"
+    rhs: execState
+- warn:
+    lhs: Control.Monad.State.Strict.execStateT
+    name: "Use 'execStateT' from Relude"
+    note: "'execStateT' is already exported from Relude"
+    rhs: execStateT
+- warn:
+    lhs: Control.Monad.State.Strict.get
+    name: "Use 'get' from Relude"
+    note: "'get' is already exported from Relude"
+    rhs: get
+- warn:
+    lhs: Control.Monad.State.Strict.gets
+    name: "Use 'gets' from Relude"
+    note: "'gets' is already exported from Relude"
+    rhs: gets
+- warn:
+    lhs: Control.Monad.State.Strict.modify
+    name: "Use 'modify' from Relude"
+    note: "'modify' is already exported from Relude"
+    rhs: modify
+- warn:
+    lhs: "Control.Monad.State.Strict.modify'"
+    name: "Use 'modify'' from Relude"
+    note: "'modify'' is already exported from Relude"
+    rhs: "modify'"
+- warn:
+    lhs: Control.Monad.State.Strict.put
+    name: "Use 'put' from Relude"
+    note: "'put' is already exported from Relude"
+    rhs: put
+- warn:
+    lhs: Control.Monad.State.Strict.runState
+    name: "Use 'runState' from Relude"
+    note: "'runState' is already exported from Relude"
+    rhs: runState
+- warn:
+    lhs: Control.Monad.State.Strict.state
+    name: "Use 'state' from Relude"
+    note: "'state' is already exported from Relude"
+    rhs: state
+- warn:
+    lhs: Control.Monad.State.Strict.withState
+    name: "Use 'withState' from Relude"
+    note: "'withState' is already exported from Relude"
+    rhs: withState
+- warn:
+    lhs: Control.Monad.Trans.MonadIO
+    name: "Use 'MonadIO' from Relude"
+    note: "'MonadIO' is already exported from Relude"
+    rhs: MonadIO
+- warn:
+    lhs: Control.Monad.Trans.MonadTrans
+    name: "Use 'MonadTrans' from Relude"
+    note: "'MonadTrans' is already exported from Relude"
+    rhs: MonadTrans
+- warn:
+    lhs: Control.Monad.Trans.lift
+    name: "Use 'lift' from Relude"
+    note: "'lift' is already exported from Relude"
+    rhs: lift
+- warn:
+    lhs: Control.Monad.Trans.liftIO
+    name: "Use 'liftIO' from Relude"
+    note: "'liftIO' is already exported from Relude"
+    rhs: liftIO
+- warn:
+    lhs: Control.Monad.Trans.Identity.IdentityT
+    name: "Use 'IdentityT' from Relude"
+    note: "'IdentityT' is already exported from Relude"
+    rhs: IdentityT
+- warn:
+    lhs: Control.Monad.Trans.Identity.runIdentityT
+    name: "Use 'runIdentityT' from Relude"
+    note: "'runIdentityT' is already exported from Relude"
+    rhs: runIdentityT
+- warn:
+    lhs: Control.Monad.Trans.Maybe.MaybeT
+    name: "Use 'MaybeT' from Relude"
+    note: "'MaybeT' is already exported from Relude"
+    rhs: MaybeT
+- warn:
+    lhs: Control.Monad.Trans.Maybe.maybeToExceptT
+    name: "Use 'maybeToExceptT' from Relude"
+    note: "'maybeToExceptT' is already exported from Relude"
+    rhs: maybeToExceptT
+- warn:
+    lhs: Control.Monad.Trans.Maybe.exceptToMaybeT
+    name: "Use 'exceptToMaybeT' from Relude"
+    note: "'exceptToMaybeT' is already exported from Relude"
+    rhs: exceptToMaybeT
+- warn:
+    lhs: Control.Monad.MonadPlus
+    name: "Use 'MonadPlus' from Relude"
+    note: "'MonadPlus' is already exported from Relude"
+    rhs: MonadPlus
+- warn:
+    lhs: Control.Monad.mzero
+    name: "Use 'mzero' from Relude"
+    note: "'mzero' is already exported from Relude"
+    rhs: mzero
+- warn:
+    lhs: Control.Monad.mplus
+    name: "Use 'mplus' from Relude"
+    note: "'mplus' is already exported from Relude"
+    rhs: mplus
+- warn:
+    lhs: Control.Monad.filterM
+    name: "Use 'filterM' from Relude"
+    note: "'filterM' is already exported from Relude"
+    rhs: filterM
+- warn:
+    lhs: Control.Monad.forever
+    name: "Use 'forever' from Relude"
+    note: "'forever' is already exported from Relude"
+    rhs: forever
+- warn:
+    lhs: Control.Monad.join
+    name: "Use 'join' from Relude"
+    note: "'join' is already exported from Relude"
+    rhs: join
+- warn:
+    lhs: Control.Monad.mapAndUnzipM
+    name: "Use 'mapAndUnzipM' from Relude"
+    note: "'mapAndUnzipM' is already exported from Relude"
+    rhs: mapAndUnzipM
+- warn:
+    lhs: Control.Monad.mfilter
+    name: "Use 'mfilter' from Relude"
+    note: "'mfilter' is already exported from Relude"
+    rhs: mfilter
+- warn:
+    lhs: Control.Monad.replicateM
+    name: "Use 'replicateM' from Relude"
+    note: "'replicateM' is already exported from Relude"
+    rhs: replicateM
+- warn:
+    lhs: Control.Monad.replicateM_
+    name: "Use 'replicateM_' from Relude"
+    note: "'replicateM_' is already exported from Relude"
+    rhs: replicateM_
+- warn:
+    lhs: Control.Monad.zipWithM
+    name: "Use 'zipWithM' from Relude"
+    note: "'zipWithM' is already exported from Relude"
+    rhs: zipWithM
+- warn:
+    lhs: Control.Monad.zipWithM_
+    name: "Use 'zipWithM_' from Relude"
+    note: "'zipWithM_' is already exported from Relude"
+    rhs: zipWithM_
+- warn:
+    lhs: "(Control.Monad.<$!>)"
+    name: "Use '<$!>' from Relude"
+    note: "Operator '(<$!>)' is already exported from Relude"
+    rhs: "(<$!>)"
+- warn:
+    lhs: "(Control.Monad.<=<)"
+    name: "Use '<=<' from Relude"
+    note: "Operator '(<=<)' is already exported from Relude"
+    rhs: "(<=<)"
+- warn:
+    lhs: "(Control.Monad.=<<)"
+    name: "Use '=<<' from Relude"
+    note: "Operator '(=<<)' is already exported from Relude"
+    rhs: "(=<<)"
+- warn:
+    lhs: "(Control.Monad.>=>)"
+    name: "Use '>=>' from Relude"
+    note: "Operator '(>=>)' is already exported from Relude"
+    rhs: "(>=>)"
+- warn:
+    lhs: Control.Monad.Fail.MonadFail
+    name: "Use 'MonadFail' from Relude"
+    note: "'MonadFail' is already exported from Relude"
+    rhs: MonadFail
+- warn:
+    lhs: Data.Maybe.catMaybes
+    name: "Use 'catMaybes' from Relude"
+    note: "'catMaybes' is already exported from Relude"
+    rhs: catMaybes
+- warn:
+    lhs: Data.Maybe.fromMaybe
+    name: "Use 'fromMaybe' from Relude"
+    note: "'fromMaybe' is already exported from Relude"
+    rhs: fromMaybe
+- warn:
+    lhs: Data.Maybe.isJust
+    name: "Use 'isJust' from Relude"
+    note: "'isJust' is already exported from Relude"
+    rhs: isJust
+- warn:
+    lhs: Data.Maybe.isNothing
+    name: "Use 'isNothing' from Relude"
+    note: "'isNothing' is already exported from Relude"
+    rhs: isNothing
+- warn:
+    lhs: Data.Maybe.listToMaybe
+    name: "Use 'listToMaybe' from Relude"
+    note: "'listToMaybe' is already exported from Relude"
+    rhs: listToMaybe
+- warn:
+    lhs: Data.Maybe.mapMaybe
+    name: "Use 'mapMaybe' from Relude"
+    note: "'mapMaybe' is already exported from Relude"
+    rhs: mapMaybe
+- warn:
+    lhs: Data.Maybe.maybeToList
+    name: "Use 'maybeToList' from Relude"
+    note: "'maybeToList' is already exported from Relude"
+    rhs: maybeToList
+- warn:
+    lhs: Data.Either.isLeft
+    name: "Use 'isLeft' from Relude"
+    note: "'isLeft' is already exported from Relude"
+    rhs: isLeft
+- warn:
+    lhs: Data.Either.isRight
+    name: "Use 'isRight' from Relude"
+    note: "'isRight' is already exported from Relude"
+    rhs: isRight
+- warn:
+    lhs: Data.Either.lefts
+    name: "Use 'lefts' from Relude"
+    note: "'lefts' is already exported from Relude"
+    rhs: lefts
+- warn:
+    lhs: Data.Either.partitionEithers
+    name: "Use 'partitionEithers' from Relude"
+    note: "'partitionEithers' is already exported from Relude"
+    rhs: partitionEithers
+- warn:
+    lhs: Data.Either.rights
+    name: "Use 'rights' from Relude"
+    note: "'rights' is already exported from Relude"
+    rhs: rights
+- warn:
+    lhs: Data.Monoid.All
+    name: "Use 'All' from Relude"
+    note: "'All' is already exported from Relude"
+    rhs: All
+- warn:
+    lhs: Data.Monoid.getAll
+    name: "Use 'getAll' from Relude"
+    note: "'getAll' is already exported from Relude"
+    rhs: getAll
+- warn:
+    lhs: Data.Monoid.Alt
+    name: "Use 'Alt' from Relude"
+    note: "'Alt' is already exported from Relude"
+    rhs: Alt
+- warn:
+    lhs: Data.Monoid.getAlt
+    name: "Use 'getAlt' from Relude"
+    note: "'getAlt' is already exported from Relude"
+    rhs: getAlt
+- warn:
+    lhs: Data.Monoid.Any
+    name: "Use 'Any' from Relude"
+    note: "'Any' is already exported from Relude"
+    rhs: Any
+- warn:
+    lhs: Data.Monoid.getAny
+    name: "Use 'getAny' from Relude"
+    note: "'getAny' is already exported from Relude"
+    rhs: getAny
+- warn:
+    lhs: Data.Monoid.Ap
+    name: "Use 'Ap' from Relude"
+    note: "'Ap' is already exported from Relude"
+    rhs: Ap
+- warn:
+    lhs: Data.Monoid.getAp
+    name: "Use 'getAp' from Relude"
+    note: "'getAp' is already exported from Relude"
+    rhs: getAp
+- warn:
+    lhs: Data.Monoid.Dual
+    name: "Use 'Dual' from Relude"
+    note: "'Dual' is already exported from Relude"
+    rhs: Dual
+- warn:
+    lhs: Data.Monoid.getDual
+    name: "Use 'getDual' from Relude"
+    note: "'getDual' is already exported from Relude"
+    rhs: getDual
+- warn:
+    lhs: Data.Monoid.Endo
+    name: "Use 'Endo' from Relude"
+    note: "'Endo' is already exported from Relude"
+    rhs: Endo
+- warn:
+    lhs: Data.Monoid.appEndo
+    name: "Use 'appEndo' from Relude"
+    note: "'appEndo' is already exported from Relude"
+    rhs: appEndo
+- warn:
+    lhs: Data.Monoid.First
+    name: "Use 'First' from Relude"
+    note: "'First' is already exported from Relude"
+    rhs: First
+- warn:
+    lhs: Data.Monoid.getFirst
+    name: "Use 'getFirst' from Relude"
+    note: "'getFirst' is already exported from Relude"
+    rhs: getFirst
+- warn:
+    lhs: Data.Monoid.Last
+    name: "Use 'Last' from Relude"
+    note: "'Last' is already exported from Relude"
+    rhs: Last
+- warn:
+    lhs: Data.Monoid.getLast
+    name: "Use 'getLast' from Relude"
+    note: "'getLast' is already exported from Relude"
+    rhs: getLast
+- warn:
+    lhs: Data.Monoid.Product
+    name: "Use 'Product' from Relude"
+    note: "'Product' is already exported from Relude"
+    rhs: Product
+- warn:
+    lhs: Data.Monoid.getProduct
+    name: "Use 'getProduct' from Relude"
+    note: "'getProduct' is already exported from Relude"
+    rhs: getProduct
+- warn:
+    lhs: Data.Monoid.Sum
+    name: "Use 'Sum' from Relude"
+    note: "'Sum' is already exported from Relude"
+    rhs: Sum
+- warn:
+    lhs: Data.Monoid.getSum
+    name: "Use 'getSum' from Relude"
+    note: "'getSum' is already exported from Relude"
+    rhs: getSum
+- warn:
+    lhs: Data.Semigroup.Semigroup
+    name: "Use 'Semigroup' from Relude"
+    note: "'Semigroup' is already exported from Relude"
+    rhs: Semigroup
+- warn:
+    lhs: Data.Semigroup.sconcat
+    name: "Use 'sconcat' from Relude"
+    note: "'sconcat' is already exported from Relude"
+    rhs: sconcat
+- warn:
+    lhs: Data.Semigroup.stimes
+    name: "Use 'stimes' from Relude"
+    note: "'stimes' is already exported from Relude"
+    rhs: stimes
+- warn:
+    lhs: "(Data.Semigroup.<>)"
+    name: "Use '<>' from Relude"
+    note: "Operator '(<>)' is already exported from Relude"
+    rhs: "(<>)"
+- warn:
+    lhs: Data.Semigroup.WrappedMonoid
+    name: "Use 'WrappedMonoid' from Relude"
+    note: "'WrappedMonoid' is already exported from Relude"
+    rhs: WrappedMonoid
+- warn:
+    lhs: Data.Semigroup.cycle1
+    name: "Use 'cycle1' from Relude"
+    note: "'cycle1' is already exported from Relude"
+    rhs: cycle1
+- warn:
+    lhs: Data.Semigroup.mtimesDefault
+    name: "Use 'mtimesDefault' from Relude"
+    note: "'mtimesDefault' is already exported from Relude"
+    rhs: mtimesDefault
+- warn:
+    lhs: Data.Semigroup.stimesIdempotent
+    name: "Use 'stimesIdempotent' from Relude"
+    note: "'stimesIdempotent' is already exported from Relude"
+    rhs: stimesIdempotent
+- warn:
+    lhs: Data.Semigroup.stimesIdempotentMonoid
+    name: "Use 'stimesIdempotentMonoid' from Relude"
+    note: "'stimesIdempotentMonoid' is already exported from Relude"
+    rhs: stimesIdempotentMonoid
+- warn:
+    lhs: Data.Semigroup.stimesMonoid
+    name: "Use 'stimesMonoid' from Relude"
+    note: "'stimesMonoid' is already exported from Relude"
+    rhs: stimesMonoid
+- warn:
+    lhs: Data.ByteString.ByteString
+    name: "Use 'ByteString' from Relude"
+    note: "'ByteString' is already exported from Relude"
+    rhs: ByteString
+- warn:
+    lhs: Data.ByteString.Short.ShortByteString
+    name: "Use 'ShortByteString' from Relude"
+    note: "'ShortByteString' is already exported from Relude"
+    rhs: ShortByteString
+- warn:
+    lhs: Data.ByteString.Short.toShort
+    name: "Use 'toShort' from Relude"
+    note: "'toShort' is already exported from Relude"
+    rhs: toShort
+- warn:
+    lhs: Data.ByteString.Short.fromShort
+    name: "Use 'fromShort' from Relude"
+    note: "'fromShort' is already exported from Relude"
+    rhs: fromShort
+- warn:
+    lhs: Data.String.IsString
+    name: "Use 'IsString' from Relude"
+    note: "'IsString' is already exported from Relude"
+    rhs: IsString
+- warn:
+    lhs: Data.String.fromString
+    name: "Use 'fromString' from Relude"
+    note: "'fromString' is already exported from Relude"
+    rhs: fromString
+- warn:
+    lhs: Data.Text.Text
+    name: "Use 'Text' from Relude"
+    note: "'Text' is already exported from Relude"
+    rhs: Text
+- warn:
+    lhs: Data.Text.lines
+    name: "Use 'lines' from Relude"
+    note: "'lines' is already exported from Relude"
+    rhs: lines
+- warn:
+    lhs: Data.Text.unlines
+    name: "Use 'unlines' from Relude"
+    note: "'unlines' is already exported from Relude"
+    rhs: unlines
+- warn:
+    lhs: Data.Text.words
+    name: "Use 'words' from Relude"
+    note: "'words' is already exported from Relude"
+    rhs: words
+- warn:
+    lhs: Data.Text.unwords
+    name: "Use 'unwords' from Relude"
+    note: "'unwords' is already exported from Relude"
+    rhs: unwords
+- warn:
+    lhs: "Data.Text.Encoding.decodeUtf8'"
+    name: "Use 'decodeUtf8'' from Relude"
+    note: "'decodeUtf8'' is already exported from Relude"
+    rhs: "decodeUtf8'"
+- warn:
+    lhs: Data.Text.Encoding.decodeUtf8With
+    name: "Use 'decodeUtf8With' from Relude"
+    note: "'decodeUtf8With' is already exported from Relude"
+    rhs: decodeUtf8With
+- warn:
+    lhs: Data.Text.Encoding.Error.OnDecodeError
+    name: "Use 'OnDecodeError' from Relude"
+    note: "'OnDecodeError' is already exported from Relude"
+    rhs: OnDecodeError
+- warn:
+    lhs: Data.Text.Encoding.Error.OnError
+    name: "Use 'OnError' from Relude"
+    note: "'OnError' is already exported from Relude"
+    rhs: OnError
+- warn:
+    lhs: Data.Text.Encoding.Error.UnicodeException
+    name: "Use 'UnicodeException' from Relude"
+    note: "'UnicodeException' is already exported from Relude"
+    rhs: UnicodeException
+- warn:
+    lhs: Data.Text.Encoding.Error.lenientDecode
+    name: "Use 'lenientDecode' from Relude"
+    note: "'lenientDecode' is already exported from Relude"
+    rhs: lenientDecode
+- warn:
+    lhs: Data.Text.Encoding.Error.strictDecode
+    name: "Use 'strictDecode' from Relude"
+    note: "'strictDecode' is already exported from Relude"
+    rhs: strictDecode
+- warn:
+    lhs: Text.Read.Read
+    name: "Use 'Read' from Relude"
+    note: "'Read' is already exported from Relude"
+    rhs: Read
+- warn:
+    lhs: Text.Read.readMaybe
+    name: "Use 'readMaybe' from Relude"
+    note: "'readMaybe' is already exported from Relude"
+    rhs: readMaybe
+- warn:
+    lhs: "(liftIO (newEmptyMVar ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newEmptyMVar' from Relude, it's already lifted"
+    rhs: newEmptyMVar
+- warn:
+    lhs: "(liftIO (newMVar x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newMVar' from Relude, it's already lifted"
+    rhs: newMVar
+- warn:
+    lhs: "(liftIO (putMVar x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putMVar' from Relude, it's already lifted"
+    rhs: putMVar
+- warn:
+    lhs: "(liftIO (readMVar x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readMVar' from Relude, it's already lifted"
+    rhs: readMVar
+- warn:
+    lhs: "(liftIO (swapMVar x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'swapMVar' from Relude, it's already lifted"
+    rhs: swapMVar
+- warn:
+    lhs: "(liftIO (takeMVar x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'takeMVar' from Relude, it's already lifted"
+    rhs: takeMVar
+- warn:
+    lhs: "(liftIO (tryPutMVar x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'tryPutMVar' from Relude, it's already lifted"
+    rhs: tryPutMVar
+- warn:
+    lhs: "(liftIO (tryReadMVar x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'tryReadMVar' from Relude, it's already lifted"
+    rhs: tryReadMVar
+- warn:
+    lhs: "(liftIO (tryTakeMVar x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'tryTakeMVar' from Relude, it's already lifted"
+    rhs: tryTakeMVar
+- warn:
+    lhs: "(liftIO (atomically x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'atomically' from Relude, it's already lifted"
+    rhs: atomically
+- warn:
+    lhs: "(liftIO (newTVarIO x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newTVarIO' from Relude, it's already lifted"
+    rhs: newTVarIO
+- warn:
+    lhs: "(liftIO (readTVarIO x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readTVarIO' from Relude, it's already lifted"
+    rhs: readTVarIO
+- warn:
+    lhs: "(liftIO (newTMVarIO x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newTMVarIO' from Relude, it's already lifted"
+    rhs: newTMVarIO
+- warn:
+    lhs: "(liftIO (newEmptyTMVarIO ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newEmptyTMVarIO' from Relude, it's already lifted"
+    rhs: newEmptyTMVarIO
+- warn:
+    lhs: "(liftIO (exitWith x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'exitWith' from Relude, it's already lifted"
+    rhs: exitWith
+- warn:
+    lhs: "(liftIO (exitFailure ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'exitFailure' from Relude, it's already lifted"
+    rhs: exitFailure
+- warn:
+    lhs: "(liftIO (exitSuccess ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'exitSuccess' from Relude, it's already lifted"
+    rhs: exitSuccess
+- warn:
+    lhs: "(liftIO (die x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'die' from Relude, it's already lifted"
+    rhs: die
+- warn:
+    lhs: "(liftIO (readFile x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readFile' from Relude, it's already lifted"
+    rhs: readFile
+- warn:
+    lhs: "(liftIO (writeFile x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeFile' from Relude, it's already lifted"
+    rhs: writeFile
+- warn:
+    lhs: "(liftIO (appendFile x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'appendFile' from Relude, it's already lifted"
+    rhs: appendFile
+- warn:
+    lhs: "(liftIO (readFileText x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readFileText' from Relude, it's already lifted"
+    rhs: readFileText
+- warn:
+    lhs: "(liftIO (writeFileText x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeFileText' from Relude, it's already lifted"
+    rhs: writeFileText
+- warn:
+    lhs: "(liftIO (appendFileText x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'appendFileText' from Relude, it's already lifted"
+    rhs: appendFileText
+- warn:
+    lhs: "(liftIO (readFileLText x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readFileLText' from Relude, it's already lifted"
+    rhs: readFileLText
+- warn:
+    lhs: "(liftIO (writeFileLText x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeFileLText' from Relude, it's already lifted"
+    rhs: writeFileLText
+- warn:
+    lhs: "(liftIO (appendFileLText x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'appendFileLText' from Relude, it's already lifted"
+    rhs: appendFileLText
+- warn:
+    lhs: "(liftIO (readFileBS x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readFileBS' from Relude, it's already lifted"
+    rhs: readFileBS
+- warn:
+    lhs: "(liftIO (writeFileBS x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeFileBS' from Relude, it's already lifted"
+    rhs: writeFileBS
+- warn:
+    lhs: "(liftIO (appendFileBS x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'appendFileBS' from Relude, it's already lifted"
+    rhs: appendFileBS
+- warn:
+    lhs: "(liftIO (readFileLBS x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readFileLBS' from Relude, it's already lifted"
+    rhs: readFileLBS
+- warn:
+    lhs: "(liftIO (writeFileLBS x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeFileLBS' from Relude, it's already lifted"
+    rhs: writeFileLBS
+- warn:
+    lhs: "(liftIO (appendFileLBS x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'appendFileLBS' from Relude, it's already lifted"
+    rhs: appendFileLBS
+- warn:
+    lhs: "(liftIO (newIORef x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'newIORef' from Relude, it's already lifted"
+    rhs: newIORef
+- warn:
+    lhs: "(liftIO (readIORef x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'readIORef' from Relude, it's already lifted"
+    rhs: readIORef
+- warn:
+    lhs: "(liftIO (writeIORef x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'writeIORef' from Relude, it's already lifted"
+    rhs: writeIORef
+- warn:
+    lhs: "(liftIO (modifyIORef x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'modifyIORef' from Relude, it's already lifted"
+    rhs: modifyIORef
+- warn:
+    lhs: "(liftIO (modifyIORef' x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'modifyIORef'' from Relude, it's already lifted"
+    rhs: "modifyIORef'"
+- warn:
+    lhs: "(liftIO (atomicModifyIORef x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'atomicModifyIORef' from Relude, it's already lifted"
+    rhs: atomicModifyIORef
+- warn:
+    lhs: "(liftIO (atomicModifyIORef' x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'atomicModifyIORef'' from Relude, it's already lifted"
+    rhs: "atomicModifyIORef'"
+- warn:
+    lhs: "(liftIO (atomicWriteIORef x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'atomicWriteIORef' from Relude, it's already lifted"
+    rhs: atomicWriteIORef
+- warn:
+    lhs: "(liftIO (getLine ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'getLine' from Relude, it's already lifted"
+    rhs: getLine
+- warn:
+    lhs: "(liftIO (print x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'print' from Relude, it's already lifted"
+    rhs: print
+- warn:
+    lhs: "(liftIO (putStr x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putStr' from Relude, it's already lifted"
+    rhs: putStr
+- warn:
+    lhs: "(liftIO (putStrLn x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putStrLn' from Relude, it's already lifted"
+    rhs: putStrLn
+- warn:
+    lhs: "(liftIO (putText x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putText' from Relude, it's already lifted"
+    rhs: putText
+- warn:
+    lhs: "(liftIO (putTextLn x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putTextLn' from Relude, it's already lifted"
+    rhs: putTextLn
+- warn:
+    lhs: "(liftIO (putLText x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putLText' from Relude, it's already lifted"
+    rhs: putLText
+- warn:
+    lhs: "(liftIO (putLTextLn x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putLTextLn' from Relude, it's already lifted"
+    rhs: putLTextLn
+- warn:
+    lhs: "(liftIO (putBS x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putBS' from Relude, it's already lifted"
+    rhs: putBS
+- warn:
+    lhs: "(liftIO (putBSLn x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putBSLn' from Relude, it's already lifted"
+    rhs: putBSLn
+- warn:
+    lhs: "(liftIO (putLBS x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putLBS' from Relude, it's already lifted"
+    rhs: putLBS
+- warn:
+    lhs: "(liftIO (putLBSLn x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'putLBSLn' from Relude, it's already lifted"
+    rhs: putLBSLn
+- warn:
+    lhs: "(liftIO (hFlush x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'hFlush' from Relude, it's already lifted"
+    rhs: hFlush
+- warn:
+    lhs: "(liftIO (hIsEOF x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'hIsEOF' from Relude, it's already lifted"
+    rhs: hIsEOF
+- warn:
+    lhs: "(liftIO (hSetBuffering x y))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'hSetBuffering' from Relude, it's already lifted"
+    rhs: hSetBuffering
+- warn:
+    lhs: "(liftIO (hGetBuffering x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'hGetBuffering' from Relude, it's already lifted"
+    rhs: hGetBuffering
+- warn:
+    lhs: "(liftIO (getArgs ))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'getArgs' from Relude, it's already lifted"
+    rhs: getArgs
+- warn:
+    lhs: "(liftIO (lookupEnv x))"
+    name: "'liftIO' is not needed"
+    note: "If you import 'lookupEnv' from Relude, it's already lifted"
+    rhs: lookupEnv
+- hint:
+    lhs: "fmap (bimap f g)"
+    note: "Use `bimapF` from `Relude.Extra.Bifunctor`"
+    rhs: bimapF f g
+- hint:
+    lhs: "bimap f g <$> x"
+    note: "Use `bimapF` from `Relude.Extra.Bifunctor`"
+    rhs: bimapF f g x
+- hint:
+    lhs: "fmap (first f)"
+    note: "Use `firstF` from `Relude.Extra.Bifunctor`"
+    rhs: firstF f
+- hint:
+    lhs: fmap . first
+    note: "Use `firstF` from `Relude.Extra.Bifunctor`"
+    rhs: firstF
+- hint:
+    lhs: "fmap (second f)"
+    note: "Use `secondF` from `Relude.Extra.Bifunctor`"
+    rhs: secondF f
+- hint:
+    lhs: fmap . second
+    note: "Use `secondF` from `Relude.Extra.Bifunctor`"
+    rhs: secondF
+- hint:
+    lhs: "[minBound .. maxBound]"
+    note: "Use `universe` from `Relude.Extra.Enum`"
+    rhs: universe
+- hint:
+    lhs: succ
+    note: "`succ` from `Prelude` is a pure function but it may throw exception. Consider using `next` from `Relude.Extra.Enum` instead."
+    rhs: next
+- hint:
+    lhs: pred
+    note: "`pred` from `Prelude` is a pure function but it may throw exception. Consider using `prev` from `Relude.Extra.Enum` instead."
+    rhs: prev
+- hint:
+    lhs: toEnum
+    note: "`toEnum` from `Prelude` is a pure function but it may throw exception. Consider using `safeToEnum` from `Relude.Extra.Enum` instead."
+    rhs: safeToEnum
+- hint:
+    lhs: sum xs / length xs
+    note: "Use `average` from `Relude.Extra.Foldable`"
+    rhs: average xs
+- hint:
+    lhs: "\\a -> (a, a)"
+    note: "Use `dup` from `Relude.Extra.Tuple`"
+    rhs: dup
+- hint:
+    lhs: "\\a -> (f a, a)"
+    note: "Use `toFst` from `Relude.Extra.Tuple`"
+    rhs: toFst f
+- hint:
+    lhs: "\\a -> (a, f a)"
+    note: "Use `toSnd` from `Relude.Extra.Tuple`"
+    rhs: toSnd f
+- hint:
+    lhs: fmap . toFst
+    note: "Use `fmapToFst` from `Relude.Extra.Tuple`"
+    rhs: fmapToFst
+- hint:
+    lhs: "fmap (toFst f)"
+    note: "Use `fmapToFst` from `Relude.Extra.Tuple`"
+    rhs: fmapToFst f
+- hint:
+    lhs: fmap . toSnd
+    note: "Use `fmapToSnd` from `Relude.Extra.Tuple`"
+    rhs: fmapToSnd
+- hint:
+    lhs: "fmap (toSnd f)"
+    note: "Use `fmapToSnd` from `Relude.Extra.Tuple`"
+    rhs: fmapToSnd f
+- hint:
+    lhs: map . toFst
+    note: "Use `fmapToFst` from `Relude.Extra.Tuple`"
+    rhs: fmapToFst
+- hint:
+    lhs: "map (toFst f)"
+    note: "Use `fmapToFst` from `Relude.Extra.Tuple`"
+    rhs: fmapToFst f
+- hint:
+    lhs: map . toSnd
+    note: "Use `fmapToSnd` from `Relude.Extra.Tuple`"
+    rhs: fmapToSnd
+- hint:
+    lhs: "map (toSnd f)"
+    note: "Use `fmapToSnd` from `Relude.Extra.Tuple`"
+    rhs: fmapToSnd f
+- hint:
+    lhs: "fmap (,a) (f a)"
+    note: "Use `traverseToFst` from `Relude.Extra.Tuple`"
+    rhs: traverseToFst f a
+- hint:
+    lhs: "fmap (flip (,) a) (f a)"
+    note: "Use `traverseToFst` from `Relude.Extra.Tuple`"
+    rhs: traverseToFst f a
+- hint:
+    lhs: "(,a) <$> f a"
+    note: "Use `traverseToFst` from `Relude.Extra.Tuple`"
+    rhs: traverseToFst f a
+- hint:
+    lhs: "flip (,) a <$> f a"
+    note: "Use `traverseToFst` from `Relude.Extra.Tuple`"
+    rhs: traverseToFst f a
+- hint:
+    lhs: "fmap (a,) (f a)"
+    note: "Use `traverseToSnd` from `Relude.Extra.Tuple`"
+    rhs: traverseToSnd f a
+- hint:
+    lhs: "fmap ((,) a) (f a)"
+    note: "Use `traverseToSnd` from `Relude.Extra.Tuple`"
+    rhs: traverseToSnd f a
+- hint:
+    lhs: "(a,) <$> f a"
+    note: "Use `traverseToSnd` from `Relude.Extra.Tuple`"
+    rhs: traverseToSnd f a
+- hint:
+    lhs: "(,) a <$> f a"
+    note: "Use `traverseToSnd` from `Relude.Extra.Tuple`"
+    rhs: traverseToSnd f a
diff --git a/cabal.project b/cabal.project
index 7d1590d..5676cb5 100644
--- a/cabal.project
+++ b/cabal.project
@@ -1,3 +1,2 @@
 -- Local packages
 packages: day01
-          day02
diff --git a/day01/app/Main.hs b/day01/app/Main.hs
index 65ae4a0..4525289 100644
--- a/day01/app/Main.hs
+++ b/day01/app/Main.hs
@@ -1,4 +1,153 @@
-module Main where
+{-
+--- Day 1: Calorie Counting ---
+
+Santa's reindeer typically eat regular reindeer food, but they need a lot of magical energy to
+deliver presents on Christmas.  For that, their favourite snack is a special type of star fruit
+that only grows deep in the jungle.  The Elves have brought you on their annual expedition to
+the grove where the fruit grows.
+
+To supply enough magical energy, the expedition needs to retrieve a minimum of fifty stars by
+December 25th.  Although the Elves assure you that the grove has plenty of fruit, you decide to
+grab any fruit you see along the way, just in case.
+
+Collect stars by solving puzzles.  Two puzzles will be made available on each day in the Advent
+calendar; the second puzzle is unlocked when you complete the first.  Each puzzle grants one
+star.  Good luck!
+
+The jungle must be too overgrown and difficult to navigate in vehicles or access from the air;
+the Elves' expedition traditionally goes on foot.  As your boats approach land, the Elves begin
+taking inventory of their supplies.  One important consideration is food - in particular, the
+number of Calories each Elf is carrying (your puzzle input).
+
+The Elves take turns writing down the number of Calories contained by the various meals,
+snacks, rations, etc. that they've brought with them, one item per line.  Each Elf separates
+their own inventory from the previous Elf's inventory (if any) by a blank line.
+
+For example, suppose the Elves finish writing their items' Calories and end up with the
+following list:
+
+```
+1000
+2000
+3000
+
+4000
+
+5000
+6000
+
+7000
+8000
+9000
+
+10000
+```
+
+This list represents the Calories of the food carried by five Elves:
+
+    The first Elf is carrying food with 1000, 2000, and 3000 Calories, a total of 6000 Calories.
+    The second Elf is carrying one food item with 4000 Calories.
+    The third Elf is carrying food with 5000 and 6000 Calories, a total of 11000 Calories.
+    The fourth Elf is carrying food with 7000, 8000, and 9000 Calories, a total of 24000 Calories.
+    The fifth Elf is carrying one food item with 10000 Calories.
+
+In case the Elves get hungry and need extra snacks, they need to know which Elf to ask: they'd
+like to know how many Calories are being carried by the Elf carrying the most Calories.  In the
+example above, this is 24000 (carried by the fourth Elf).
+
+Find the Elf carrying the most Calories.  How many total Calories is that Elf carrying?
+
+--- Part Two ---
+
+By the time you calculate the answer to the Elves' question, they've already realized that the
+Elf carrying the most Calories of food might eventually run out of snacks.
+
+To avoid this unacceptable situation, the Elves would instead like to know the total Calories
+carried by the top three Elves carrying the most Calories.  That way, even if one of those Elves
+runs out of snacks, they still have two backups.
+
+In the example above, the top three Elves are the fourth Elf (with 24000 Calories), then the
+third Elf (with 11000 Calories), then the fifth Elf (with 10000 Calories).  The sum of the
+Calories carried by these three elves is 45000.
+
+Find the top three Elves carrying the most Calories.  How many Calories are those Elves carrying
+in total?
+-}
+{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
+
+{-# HLINT ignore "Use readFileLBS" #-}
+module Main (main) where
+
+import Data.ByteString.Lazy (ByteString, readFile)
+import Data.Char (digitToInt)
+import Options.Applicative (Parser, ParserInfo, argument, execParser, fullDesc, help, helper, info, metavar, str)
+import Relude (Either (Left, Right), FilePath, IO, Int, Integer, String, Text, Type, concat, const, fmap, foldl', fst, map, max, pass, print, readFileText, return, reverse, show, snd, sort, sum, take, zip, ($), ($!), (*), (+), (.), (<), (<$>), (<*), (<*>), (<>), (<|>), (>), (>>), (>>=))
+import Relude.Print (putTextLn)
+import Relude.String.Conversion (toString)
+import Text.Parsec (ParseError, parse, (<?>))
+import Text.Parsec.ByteString.Lazy (GenParser)
+import Text.Parsec.Char (digit, string)
+import Text.Parsec.Combinator (eof, many1)
+import Text.Parsec.Prim (parsecMap, try)
+
+type Opts :: Type
+newtype Opts = Opts {_filename :: Text}
+
+options :: Parser Opts
+options = Opts <$> filename
+  where
+    filename :: Parser Text
+    filename = argument str $ metavar "filename" <> help "Input file"
+
+opts :: ParserInfo Opts
+opts = info (helper <*> options) fullDesc
+
+parseInput :: FilePath -> ByteString -> Either ParseError [[Int]]
+parseInput = parse parser
+
+parser :: GenParser t st [[Int]]
+parser = many1 block <* eof
+
+block :: GenParser t st [Int]
+block = many1 (int <* eol) <* (eol <|> eof)
+
+int :: GenParser t st Int
+int = foldl' (\a i -> a * 10 + digitToInt i) 0 <$> many1 digit
+
+eol :: GenParser t st ()
+eol =
+  parsecMap
+    (const ())
+    ( try (string "\n\r")
+        <|> try (string "\r\n")
+        <|> string "\n"
+        <|> string "\r"
+        <?> "end of line"
+    )
+
+-- imax :: (Int, Int) -> (Int, Int) -> (Int, Int)
+-- imax (aidx, asum) (idx, _sum) =
+--   if _sum > asum
+--     then (idx, _sum)
+--     else (aidx, asum)
+--
+-- run :: [[Int]] -> Int
+-- run = snd . foldl' imax (0, 0) . zip [1 ..] . map sum
+
+runPart1 :: [[Int]] -> Int
+runPart1 = foldl' max 0 . map sum
+
+runPart2 :: [[Int]] -> Int
+runPart2= sum . take 3 . reverse . sort . map sum
 
 main :: IO ()
-main = putStrLn "Hello, Haskell!"
+main = do
+  fileName <- toString . _filename <$> execParser opts
+  rawInput <- readFile fileName
+  case parseInput fileName rawInput of
+    Left e -> do
+      putTextLn "Error parsing input:"
+      print e
+    Right r -> do
+      print $ runPart1 r
+      print $ runPart2 r
diff --git a/day01/day01.cabal b/day01/day01.cabal
index 9cdc96d..28684dc 100644
--- a/day01/day01.cabal
+++ b/day01/day01.cabal
@@ -1,22 +1,34 @@
-cabal-version:      2.4
-name:               day01
-version:            0.1.0.0
+cabal-version: 2.4
+name:          day01
+version:       0.1.0.0
 synopsis:
 
 -- A URL where users can report bugs.
 -- bug-reports:
-license:            NONE
-author:             Shivesh Mandalia
-maintainer:         mail@shivesh.org
+license:
+author:        Shivesh Mandalia
+maintainer:    mail@shivesh.org
 
 executable day01
-    main-is:          Main.hs
+  main-is:            Main.hs
 
-    -- Modules included in this executable, other than Main.
-    -- other-modules:
+  -- Modules included in this executable, other than Main.
+  -- other-modules:
 
-    -- LANGUAGE extensions used by modules in this package.
-    -- other-extensions:
-    build-depends:    base ^>=4.16.4.0
-    hs-source-dirs:   app
-    default-language: Haskell2010
+  -- LANGUAGE extensions used by modules in this package.
+  default-extensions:
+    NoImplicitPrelude
+    OverloadedStrings
+    StandaloneKindSignatures
+
+  build-depends:
+    , base                  ^>=4.16.4.0
+    , optparse-applicative  >=0.17.0.0
+    , parsec                >=3.1.16.1
+    , relude                ^>=1.1.0.0
+
+  hs-source-dirs:     app
+  default-language:   Haskell2010
+  ghc-options:
+    -Weverything -Wno-unused-packages -Wno-missing-safe-haskell-mode
+    -Wno-safe
diff --git a/day01/examples/input.txt b/day01/examples/input.txt
new file mode 100644
index 0000000..bf3b409
--- /dev/null
+++ b/day01/examples/input.txt
@@ -0,0 +1,2252 @@
+7569
+1357
+10134
+4696
+4423
+8869
+3562
+6597
+
+4038
+9038
+1352
+8005
+4811
+6281
+3961
+4023
+
+7234
+3510
+7728
+1569
+4583
+7495
+3941
+6015
+6531
+2637
+
+18211
+19347
+16113
+7314
+
+3359
+7199
+4527
+5384
+1752
+2422
+6301
+1923
+5957
+3000
+6835
+1986
+
+9837
+5600
+11944
+9188
+2356
+7054
+7549
+
+19258
+32524
+
+15237
+10665
+11603
+3047
+6430
+
+3218
+3421
+5897
+4950
+6920
+3118
+5140
+2364
+4650
+3216
+5223
+2402
+6073
+
+16733
+10846
+10699
+5704
+
+16364
+7679
+5249
+
+69625
+
+2432
+3304
+1846
+11421
+9850
+7406
+
+11788
+10569
+9105
+13946
+5825
+5780
+
+5701
+3011
+4082
+3895
+9127
+8124
+7818
+1398
+5443
+
+9172
+11176
+4400
+4126
+3226
+6516
+
+4784
+3620
+1087
+2533
+6306
+6601
+2539
+2634
+8533
+
+1765
+4859
+7129
+5595
+2936
+3340
+7565
+7752
+3834
+5943
+6931
+
+3516
+1217
+5776
+2286
+2197
+3014
+4302
+2294
+5915
+1744
+1007
+2695
+
+5728
+8002
+4340
+1468
+2743
+8017
+6742
+5924
+1490
+4792
+
+32995
+20012
+
+57974
+
+12603
+10225
+6899
+9986
+1811
+
+3991
+3427
+1641
+1997
+4577
+5141
+6317
+3869
+2086
+2394
+5451
+4061
+3912
+3968
+
+13322
+7684
+17919
+14291
+
+8875
+11474
+10009
+2836
+2999
+13462
+
+3708
+7178
+2303
+6047
+3002
+4253
+2620
+6321
+6538
+1672
+5623
+4445
+
+7594
+9506
+11613
+4382
+11164
+11772
+
+4143
+4863
+6876
+5387
+3223
+4621
+5344
+6356
+6151
+2687
+5774
+3570
+5506
+
+14826
+18705
+22216
+
+2109
+10543
+9216
+2103
+4909
+11592
+11574
+
+7076
+7210
+13392
+9010
+11206
+2430
+
+5524
+5266
+3474
+5772
+4389
+2866
+5281
+3445
+5062
+5624
+1289
+5082
+4932
+3702
+4462
+
+8903
+15889
+12929
+15606
+12521
+
+3958
+2105
+6631
+5906
+5366
+5698
+6452
+7522
+5595
+7892
+2611
+
+11540
+15585
+10410
+11433
+15924
+
+13538
+7274
+25109
+
+2027
+8353
+4550
+3143
+5959
+1361
+8119
+4990
+6639
+5914
+
+4288
+3407
+4919
+5857
+1737
+1100
+2123
+4001
+6954
+3470
+4972
+
+63284
+
+22745
+25713
+6948
+
+2671
+5918
+2996
+5049
+5552
+2862
+4148
+2699
+1267
+3203
+4101
+1669
+3841
+1645
+
+12339
+13808
+5765
+9380
+5878
+11724
+
+6944
+2942
+4488
+3205
+3266
+4343
+5902
+2415
+6376
+3563
+4262
+4253
+
+24318
+8839
+
+13143
+3079
+8421
+16182
+4310
+
+3940
+1588
+4554
+7978
+3061
+5421
+1413
+3283
+3457
+2084
+4425
+
+6041
+16098
+8298
+
+6346
+3091
+4566
+2749
+2025
+4206
+4649
+1535
+5881
+6502
+2848
+2816
+3764
+2020
+
+7370
+4174
+6795
+1962
+7711
+4206
+6495
+5526
+4480
+2180
+
+12796
+3793
+13517
+12324
+1675
+12092
+
+3519
+2768
+4696
+4921
+5713
+10465
+10032
+6721
+
+8037
+6647
+6670
+3163
+6700
+2015
+4590
+2144
+2485
+3831
+3996
+
+7363
+2114
+3645
+4102
+6663
+3757
+3043
+1488
+1566
+3300
+
+20413
+24591
+24088
+
+7261
+16967
+3491
+
+14354
+11988
+5752
+1080
+
+4160
+5598
+5430
+1042
+6909
+7422
+5222
+4580
+7077
+6009
+4473
+3132
+
+38094
+
+3052
+1814
+5217
+2138
+6224
+2081
+6237
+3829
+6332
+6364
+1612
+3923
+4533
+2415
+
+1732
+1869
+5762
+4834
+3595
+3105
+4997
+3525
+6270
+5260
+4952
+5466
+3703
+3859
+
+3781
+4919
+5489
+4348
+2027
+1542
+2328
+4875
+4317
+2274
+5421
+1528
+3963
+4940
+
+1085
+1745
+5093
+7798
+3642
+7681
+5792
+3291
+7482
+5889
+5784
+
+10489
+6344
+10829
+7847
+10808
+11986
+1223
+
+15486
+12689
+6161
+13613
+15818
+
+2208
+3272
+6446
+4202
+5845
+4708
+6976
+7997
+2047
+
+2882
+7606
+6394
+4353
+6458
+4477
+6710
+8184
+1986
+3996
+
+4096
+5903
+5149
+2970
+5896
+3044
+3801
+2703
+2063
+3652
+6083
+1325
+1921
+
+7255
+6622
+4108
+3272
+8626
+6466
+5211
+
+3189
+18089
+3687
+14113
+
+3376
+1179
+6295
+4694
+5730
+4580
+4831
+4738
+6097
+2199
+5472
+5424
+2997
+
+3656
+5742
+4953
+6405
+7948
+3400
+2571
+1898
+3720
+1919
+7725
+
+8235
+7985
+6168
+2276
+1521
+8539
+2794
+6916
+3589
+7893
+
+5274
+2480
+1861
+2970
+7096
+5896
+5236
+6596
+4901
+3928
+4092
+2193
+
+5578
+6132
+1902
+4091
+7470
+2037
+3949
+6953
+5154
+6307
+4244
+
+1454
+3537
+6539
+8978
+1877
+1454
+3516
+2550
+6548
+
+8176
+10883
+1159
+5666
+10115
+
+1909
+2160
+4754
+1500
+6248
+6766
+3776
+1757
+7563
+6897
+5468
+
+5776
+1295
+14577
+
+1467
+1628
+4841
+2712
+5274
+5645
+5030
+2980
+2148
+2494
+1391
+3978
+4273
+
+5892
+5325
+6605
+4615
+5939
+1734
+4169
+2864
+6916
+3003
+5691
+6886
+
+3207
+1313
+6940
+5545
+1307
+2515
+5310
+2719
+5037
+2852
+4270
+5482
+2629
+
+3113
+3184
+3103
+3874
+2053
+4348
+2034
+5610
+5564
+1245
+2760
+4184
+4388
+4924
+5294
+
+30280
+20633
+
+7281
+4704
+7154
+4633
+4685
+6490
+2221
+4097
+2155
+5782
+2259
+2187
+
+3375
+
+2564
+2306
+7714
+1233
+6833
+1254
+
+3714
+2329
+1168
+6477
+5418
+4491
+7480
+6478
+6092
+3240
+5209
+
+4555
+7903
+4052
+6201
+7707
+2317
+6661
+2402
+2158
+
+3752
+6799
+1474
+9554
+3071
+2588
+7440
+5000
+8195
+
+3945
+8862
+9254
+1049
+6590
+9350
+9632
+6202
+2607
+
+5825
+8152
+1095
+1176
+5725
+8096
+7452
+2804
+
+4902
+4036
+4145
+2369
+4783
+5874
+6162
+2016
+5293
+3958
+7302
+1201
+
+3421
+3339
+4445
+9464
+4824
+9299
+7335
+
+6879
+12322
+7258
+2357
+6743
+
+6630
+4201
+5648
+7472
+3316
+6413
+3651
+5112
+3704
+4059
+6615
+2342
+
+7681
+4263
+1806
+2522
+6200
+1800
+1684
+4629
+5588
+7604
+5150
+
+32417
+
+11824
+4356
+6128
+13448
+
+8280
+9281
+3856
+4534
+8755
+8085
+9197
+
+6955
+7042
+6791
+2400
+6051
+5380
+4118
+4139
+5099
+1114
+3525
+3402
+
+13183
+9082
+12948
+13297
+7114
+9971
+
+63036
+
+9084
+9962
+14352
+12961
+
+3679
+5437
+2514
+2561
+6014
+2091
+2512
+2685
+2395
+3386
+3456
+5414
+1796
+3727
+
+1846
+6054
+9570
+10656
+6468
+12149
+
+4785
+7420
+8022
+6261
+5671
+2126
+6538
+6793
+4723
+5504
+2839
+
+1152
+3372
+10954
+6464
+2765
+
+3398
+4853
+5512
+2553
+8012
+2860
+4092
+5288
+4618
+4616
+3996
+
+1918
+1632
+3795
+3530
+5571
+6305
+5669
+5444
+4991
+2367
+4511
+3484
+3936
+5420
+
+10711
+
+7735
+4055
+8903
+10180
+3356
+5725
+5101
+
+31657
+
+12997
+15132
+13791
+15184
+
+13021
+2125
+7652
+4939
+14287
+
+4244
+8543
+3071
+8029
+6778
+2814
+5218
+6955
+5265
+7921
+
+46784
+
+3526
+3133
+10593
+4638
+9539
+1227
+4904
+5965
+
+7848
+
+3178
+1014
+3628
+7149
+1430
+1663
+2236
+4653
+5188
+2240
+
+6429
+5092
+2605
+1027
+1822
+7407
+2638
+4967
+4244
+3371
+4413
+4861
+
+2470
+9469
+2051
+7278
+9351
+10480
+2860
+4206
+
+9007
+3043
+1424
+9081
+2827
+2652
+5879
+6789
+7120
+
+37743
+
+6312
+5845
+3742
+5544
+3759
+3562
+7319
+2738
+2626
+1534
+2820
+6553
+
+9864
+2966
+6757
+5962
+7093
+1905
+
+4948
+9976
+7084
+8037
+7204
+11131
+
+9115
+
+5691
+3512
+4281
+5631
+2820
+3271
+6239
+2636
+7654
+7050
+3363
+
+7004
+4165
+3989
+6436
+2973
+2194
+4570
+2609
+5751
+6194
+7048
+6261
+
+5831
+1130
+7172
+12886
+8062
+13840
+
+1823
+9111
+6212
+4168
+7883
+10579
+8924
+2743
+
+7852
+5075
+5924
+7389
+3248
+9369
+1453
+9882
+
+21170
+15061
+
+10447
+5517
+10469
+13881
+13602
+
+2267
+6183
+1055
+6806
+4409
+5327
+1873
+2598
+3547
+6547
+5317
+5075
+5351
+
+2380
+3511
+8386
+7944
+8501
+1220
+6635
+9384
+6583
+
+1650
+3461
+5357
+2618
+6668
+6831
+2428
+1581
+6028
+1982
+6315
+3992
+4223
+
+4231
+7521
+7927
+7876
+5052
+5488
+3247
+2191
+1723
+5970
+
+5328
+3471
+5900
+1596
+1013
+3057
+2245
+2850
+3026
+4661
+6302
+5058
+6246
+
+1090
+18730
+17742
+16057
+
+5408
+4499
+2145
+2659
+6971
+7444
+6004
+1196
+3617
+4493
+1812
+3386
+
+1379
+7387
+14347
+12050
+1633
+
+1614
+7776
+11559
+10026
+7185
+
+10478
+1228
+9847
+12113
+12639
+
+2392
+7476
+3785
+6363
+5557
+2393
+1509
+8462
+7233
+6604
+
+1525
+9057
+3723
+12048
+8403
+1434
+7829
+
+11321
+1931
+11036
+5443
+7082
+7616
+10227
+
+5535
+4730
+6475
+4748
+2431
+3575
+3469
+6250
+3313
+5085
+3851
+1218
+3918
+1990
+
+30221
+23041
+
+2861
+5908
+4268
+1877
+1016
+4468
+4593
+1281
+3582
+1108
+2850
+
+3786
+3112
+2359
+4122
+6426
+6756
+2602
+3666
+2640
+3074
+3129
+4290
+6741
+
+11824
+6880
+9944
+1970
+3533
+
+3108
+5050
+
+1122
+3124
+6005
+3098
+4970
+4113
+4703
+5529
+3149
+6373
+5106
+3294
+
+11319
+25294
+15963
+
+1807
+5908
+6709
+5818
+4504
+10170
+6378
+
+5606
+13402
+10945
+6909
+11245
+12279
+
+1666
+6313
+7546
+5273
+4450
+4582
+6319
+7687
+2229
+7612
+2849
+
+5483
+4903
+4321
+3371
+1117
+6806
+6352
+2281
+2598
+6433
+6849
+4444
+4318
+
+7274
+1350
+6505
+6123
+1327
+3259
+2046
+4395
+2081
+3429
+6128
+
+10392
+3224
+8237
+1788
+5544
+11058
+
+13668
+12456
+4385
+13156
+13073
+10019
+
+8544
+1540
+1472
+5529
+4076
+1141
+6039
+5256
+5524
+5986
+
+3721
+5171
+4997
+5498
+6807
+1778
+5120
+2830
+2733
+
+1629
+6387
+4685
+1162
+6393
+1118
+1628
+6786
+5507
+5745
+1914
+2043
+4954
+
+11968
+5263
+6691
+11191
+10725
+2462
+7162
+
+1911
+5528
+8016
+5798
+2448
+7299
+3742
+2756
+1710
+5342
+
+1612
+5217
+2630
+4768
+5942
+2414
+6278
+2422
+3603
+5110
+4823
+3115
+3616
+3872
+
+20562
+
+21492
+
+6167
+22813
+6117
+
+1746
+1883
+5639
+2251
+4456
+1289
+2850
+5350
+6211
+1971
+1628
+4259
+5732
+1522
+
+2427
+19825
+15898
+9510
+
+10822
+
+5729
+8357
+1089
+6622
+3631
+
+9226
+4811
+4979
+4748
+4686
+10536
+8734
+10183
+
+6483
+1553
+6871
+2817
+1964
+4610
+4267
+3258
+6700
+4836
+6902
+1354
+4994
+
+5293
+1858
+1504
+2783
+6933
+6112
+3433
+5478
+4998
+5578
+4112
+4924
+5567
+
+6550
+5932
+6154
+1424
+6667
+7476
+1573
+5597
+3271
+3732
+6926
+5812
+
+9452
+4356
+6277
+3167
+3323
+6475
+2026
+8759
+6115
+
+14299
+
+63447
+
+2635
+5931
+6323
+8330
+3177
+7588
+4316
+3837
+7060
+3915
+
+48633
+
+4750
+2846
+4007
+5026
+6205
+2760
+3031
+2748
+5059
+4779
+2110
+2238
+5475
+
+5832
+3148
+3556
+1924
+5265
+5802
+3515
+1606
+1437
+1210
+2961
+2408
+2580
+5539
+1380
+
+66449
+
+2996
+3761
+4582
+5321
+1600
+5507
+1384
+3288
+2201
+3423
+4042
+1109
+5464
+3278
+5813
+
+8499
+6999
+5484
+2524
+6885
+5701
+5513
+4086
+7943
+4973
+
+1159
+7531
+1852
+15286
+
+4539
+8693
+1014
+1828
+8482
+8082
+5404
+3261
+8635
+6019
+
+3048
+6786
+5651
+1378
+2938
+3365
+5968
+3120
+3338
+6905
+2580
+6653
+3288
+
+11131
+7146
+18154
+
+3907
+4060
+5426
+3596
+5290
+1701
+5058
+5641
+5510
+3599
+4874
+4125
+4174
+4347
+1031
+
+16519
+
+2653
+3214
+8189
+6240
+2010
+9114
+2936
+5757
+
+27107
+
+4099
+1252
+4620
+5294
+6455
+1170
+5050
+4196
+2488
+4760
+7425
+
+4275
+9064
+19197
+2605
+
+4278
+8197
+3238
+3410
+5384
+2670
+5818
+4744
+7541
+6172
+
+13214
+2791
+8165
+8198
+9405
+4916
+
+15390
+7196
+
+8611
+7289
+4196
+1729
+6994
+6587
+5544
+1110
+5397
+2882
+
+2351
+4784
+3193
+6033
+2193
+1767
+5487
+3421
+1503
+3221
+2610
+5334
+3596
+5869
+2536
+
+21247
+12819
+5427
+
+10652
+4957
+2236
+9504
+9850
+11495
+8799
+
+1295
+1117
+4578
+2757
+8310
+7539
+1563
+7445
+9248
+
+1154
+7145
+2494
+1170
+5617
+7106
+1500
+7359
+7355
+7312
+6374
+6591
+
+8635
+4722
+2581
+1321
+4876
+8887
+2091
+5882
+3667
+
+2555
+2895
+5862
+4002
+1331
+2902
+4189
+5844
+4167
+3075
+3559
+3807
+4633
+2562
+2182
+
+7326
+7752
+9975
+9509
+10360
+9290
+4799
+7985
+
+2025
+3129
+10778
+4050
+15824
+
+8875
+12920
+13121
+8778
+4115
+2725
+
+2640
+7696
+9232
+4533
+3279
+3792
+3060
+
+1928
+1954
+7144
+4484
+2340
+7079
+4401
+2149
+4172
+2331
+7733
+
+10089
+1850
+10613
+10002
+7258
+10227
+1377
+4110
+
+1993
+5191
+1557
+6222
+5479
+4984
+6453
+5099
+4422
+4870
+6401
+2377
+1590
+2023
+
+11578
+12357
+5959
+6164
+2562
+
+6504
+3906
+2703
+5974
+3143
+1620
+4910
+2133
+3240
+5300
+2309
+3464
+1256
+
+10982
+7910
+7625
+11675
+10215
+1163
+9569
+
+2915
+3767
+3745
+3972
+1852
+7935
+7429
+5175
+6558
+1430
+1602
+
+3817
+3327
+1928
+4831
+3908
+2935
+1922
+4557
+2762
+4731
+4974
+3861
+2073
+3692
+4205
+
+7336
+2964
+15357
+13398
+7906
+
+3525
+4721
+4014
+3612
+2369
+2023
+2847
+4074
+1129
+2179
+3614
+4281
+3818
+5191
+5381
+
+61042
+
+3819
+4305
+6299
+2583
+1370
+1380
+3654
+2856
+2461
+1332
+1901
+2910
+
+6827
+13660
+16816
+2018
+
+3748
+7348
+8889
+8319
+2671
+7852
+5415
+3932
+8902
+
+3614
+4741
+5864
+5082
+4251
+5216
+6408
+6951
+1828
+1279
+5092
+5998
+1599
+
+2630
+3617
+4473
+5203
+4772
+7763
+3033
+7055
+7533
+3649
+
+2201
+1324
+5999
+5250
+3899
+4327
+7485
+5573
+5759
+6442
+2955
+
+4682
+4459
+6026
+6998
+1943
+4534
+4555
+5575
+5046
+7549
+
+18939
+6157
+4911
+
+3975
+4193
+4442
+4336
+1650
+4874
+4756
+6106
+2389
+2783
+3412
+3343
+3794
+1072
+3170
+
+9191
+9214
+7209
+6637
+9086
+9123
+8213
+9269
+4298
+
+6182
+7624
+3395
+5847
+1575
+6110
+2981
+5999
+5480
+5971
+3642
+
+11213
+13891
+3627
+7688
+11077
+2119
+
+20695
+17278
+14874
+
+6613
+1752
+7179
+7575
+5803
+2655
+5733
+1441
+6247
+3254
+
+3667
+1157
+3324
+1195
+5982
+3444
+5185
+4061
+4297
+4364
+3399
+
+8517
+6424
+4847
+3985
+13460
+2559
+
+4043
+2124
+3622
+5129
+4750
+3882
+6512
+2024
+2053
+4534
+5507
+3312
+5172
+
+9086
+7581
+2686
+12674
+6833
+4967
+
+2401
+12176
+6352
+4439
+8153
+
+8222
+9993
+4988
+10170
+9853
+7487
+10533
+1892
+
+2527
+4255
+4377
+4312
+2549
+2005
+4011
+4803
+5879
+6038
+2382
+3758
+1079
+1875
+2549
+
+3962
+4758
+5211
+5023
+11911
+8809
+1896
+
+6166
+12840
+7486
+9772
+
+3481
+4655
+6998
+2009
+8754
+7585
+8723
+7766
+9118
+
+3997
+6810
+6988
+9613
+7982
+8594
+1229
+7588
+3507
diff --git a/day01/examples/test.txt b/day01/examples/test.txt
new file mode 100644
index 0000000..2094f91
--- /dev/null
+++ b/day01/examples/test.txt
@@ -0,0 +1,14 @@
+1000
+2000
+3000
+
+4000
+
+5000
+6000
+
+7000
+8000
+9000
+
+10000
diff --git a/day02/app/Main.hs b/day02/app/Main.hs
deleted file mode 100644
index 65ae4a0..0000000
--- a/day02/app/Main.hs
+++ /dev/null
@@ -1,4 +0,0 @@
-module Main where
-
-main :: IO ()
-main = putStrLn "Hello, Haskell!"
diff --git a/day02/day02.cabal b/day02/day02.cabal
deleted file mode 100644
index 5e52206..0000000
--- a/day02/day02.cabal
+++ /dev/null
@@ -1,22 +0,0 @@
-cabal-version:      2.4
-name:               day02
-version:            0.1.0.0
-synopsis:
-
--- A URL where users can report bugs.
--- bug-reports:
-license:            NONE
-author:             Shivesh Mandalia
-maintainer:         mail@shivesh.org
-
-executable day01
-    main-is:          Main.hs
-
-    -- Modules included in this executable, other than Main.
-    -- other-modules:
-
-    -- LANGUAGE extensions used by modules in this package.
-    -- other-extensions:
-    build-depends:    base ^>=4.16.4.0
-    hs-source-dirs:   app
-    default-language: Haskell2010