Consider a binary string `S` of length `n`.  Indexing from `1`, we can compute the [Hamming distances][1] between `S[1..i+1]` and `S[n-i..n]` for all `i` in order from `0` to `n-1`.    The Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different. For example,

    S = 01010

gives 

    [0, 2, 0, 4, 0].

This is because `0` matches `0`, `01` has Hamming distance two to `10`, `010` matches `010`, `0101` has Hamming distance four to `1010`  and finally `01010` matches itself.

We are only interested in outputs where the Hamming distance is at most 1, however. So in this task we will report a `Y` if  the Hamming distance is at most one and an `N` otherwise.  So in our example above we would get

    [Y, N, Y, N, Y]

Define `f(n)` to be the number of distinct arrays of `Y`s and `N`s one gets when iterating over all `2^n` different possible bit strings `S` of length `n`.

## Task

For increasing `n` starting at `1`, your code should output `f(n)`.

## Example answers

For `n = 1..24`, the correct answers are:

    1, 1, 2, 4, 6, 8, 14, 18, 27, 36, 52, 65, 93, 113, 150, 188, 241, 279, 377, 427, 540, 632, 768, 870

## Scoring

Your code should iterate up from `n = 1` giving the answer for each `n` in turn. I will time the entire run, killing it after two  minutes.  

Your score is the highest `n` you get to in that time.

In the case of a tie, the first answer wins.

## Where will my code be tested?

I will run your code on my (slightly old) Windows 7 laptop under cygwin.  As a result, please give any assistance you can to help make this easy.



## Leading entries per language

 - **n = 22** in **Pari/gp** by  alephalpha.
 - **n = 21** in **Mathematica** by  alephalpha. (Self reported)
 - **n = 19** in **Mathematica** by  Jenny_mathy. (Self reported)

  [1]: https://en.wikipedia.org/wiki/Hamming_distance