     def format_table(rows) do
       rows
       |> Enum.map(&format_row/1)
-      |> Enum.join("\n")
     end
 
     defp format_row([]), do: "⋮"

      @doc "Format for column"
      def to_column(v)
    end

    defimpl Column, for: BitString do
      def to_column("―"), do: String.pad_trailing("", Table.column_width(), "―")

    @moduledoc "Prints the scores to STDOUT."

    def print(state) do
      IO.puts("\n\n\n\nHI-SCORE and ACCURACY\n")

      s = score(state.score)
      a = accuracy(state.accuracy)
      print_tables([s, a])

      IO.puts("\n\nHUNTED vs HUNTERS vs MINERS:\n")

      h1 = hunters(state.kills)
      h2 = hunted(state.kills, state.crashes)
      m = miners(state.miner, state.crashes)
      print_tables([h1, h2, m])

      IO.puts("\n\nVENDETTAs (player vs player):\n")

      state.kills
      |> vendettas(Map.keys(state.accuracy))
      |> print_table()

      IO.puts("\n")

      state.kills
      |> player_vs_player(Map.keys(state.accuracy))
      |> print_table()
    end

    @table_width 20

    def print_table(data) do
      data
      |> Hiscore.Table.format_table()
      |> Enum.join("\n")
      |> IO.puts()
    end

    def print_tables(tables) do
      tables
      |> zip()
      |> Enum.map(&pad_and_join_columns/1)
      |> Enum.join("\n")
      |> IO.puts()
    end

    @spec pad_and_join_columns(list()) :: String.t()
    defp pad_and_join_columns(row) do
      row
      |> Enum.map(&pad_column/1)
      |> Enum.join("")
    end

    defp pad_column(nil), do: String.pad_trailing("", @table_width)
    defp pad_column(col), do: String.pad_trailing(col, @table_width)

    defp zip(tables) do
      tables
      |> Enum.map(&Hiscore.Table.format_table/1)
      |> zip([])
    end

    defp zip(tables, results) do
      columns = Enum.map(tables, &List.first/1)

      if Enum.all?(columns, &is_nil/1) do
        results
      else
        zip(Enum.map(tables, &Enum.drop(&1, 1)), Enum.concat(results, [columns]))
      end
    end

    defp accuracy(data) do
      results =
