[Question]
  [
Consider a square block of text, N characters wide by N tall, for some odd integer N greater than 1.
As an example let N = 5 and the text be:
```
MLKJI
NWVUH
OXYTG
PQRSF
ABCDE
```
Notice that this is the alphabet (besides Z) spiraled around counter-clockwise from the lower left corner. It's kind of like a rolled up carpet.
![Spiral Alphabet](https://i.stack.imgur.com/x1I7y.png)
"Unrolling" the text by one quarter turn clockwise so `FGHI` are on the same level as `ABCDE` results in:
```
     PONM
     QXWL
     RYVK
     STUJ
ABCDEFGHI
```
This unrolling can be done 7 more times until the text is a single line:
```
         SRQP
         TYXO
         UVWN
ABCDEFGHIJKLM
             UTS
             VYR
             WXQ
ABCDEFGHIJKLMNOP
                WVU
                XYT
ABCDEFGHIJKLMNOPQRS
                   XW
                   YV
ABCDEFGHIJKLMNOPQRSTU
                     YX
ABCDEFGHIJKLMNOPQRSTUVW
                       Y
ABCDEFGHIJKLMNOPQRSTUVWX
ABCDEFGHIJKLMNOPQRSTUVWXY
```
# Challenge
The challenge is to write a program that is an N×N block of text that outputs the number of times it has "unrolled" by a quarter turn when it is rearranged into the unrolling patterns and run.
There are really two contests here: (hopefully it won't be too messy)
1. Do this with the smallest N. (down to a limit of N = 3)
2. Do this with the largest N. (no limit)
There will not be an accepted answer but the winner in each of these categories will receive at least 50 bounty rep from me. In case of ties the oldest answers win.
# Example
If your code block is
```
MyP
rog
ram
```
running it as is should output 0.
Running
```
   rM
   oy
ramgP
```
should output 1.
Running
```
     or
ramgPyM
```
should output 2.
Running
```
       o
ramgPyMr
```
should output 3.
Finally, running `ramgPyMro` should output 4.
# Details
* The output should be printed to stdout (or the closest alternative) by itself. There is no input.
* You may only use [printable ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) (hex codes 20 to 7E, that includes space) in your code.
* Spaces fill the empty space in the unrolling arrangements. (Unless you're unrolling to the left.)
* Only the arrangements from completely square to completely flat need to have valid output. No other arrangements will be run.
* You may not read your own source.
* You may use comments.
* N = 1 is excluded since in many languages the program `0` would work.
* If desired you may unroll to the left rather than the right. So e.g.
```
MyP
rog
ram
```
becomes
```
Pg
yo
Mrram
```
and so on. No extra spaces are added when rolling this way. The lines just end
(Related: [Write a Rectangular Program that Outputs the Number of Times it was Rotated](https://codegolf.stackexchange.com/questions/33150/write-a-rectangular-program-that-outputs-the-number-of-times-it-was-rotated))
  
[Answer]
### Golfscript, N <- [5,7..]
```
.   .
 . . 
 ..  
.  .#
],9\-
```
Fully unrolled:
```
],9\-#  .   .  .  . . ...
```
Explanation:
* `.` (multiple times) - duplicate the input
* `]` - collect the stack into a single array
* `,` - take its length
* `9\-` - subtract it from 9
* `#` - line comment
Whitespace is a NOP, but any other NOP would have worked just as well.
Fully rolled up, it uses nine copies of the input (contents ignored) as the stack; 9 - 9 = 0; it has not been unrolled.
Each unroll hides one more dot (duplicate) behind the comment, shrinking the stack once, incrementing the output.
Fully unrolled, it uses only the input (contents ignored) as the stack; 9 - 1 = 8; it has been unrolled 8 times.
The same approach works for any N > 4: Change `9` to the appropriate value of 2\*N+1, then extend the pattern of dots (duplicate) using the same spiral pattern that ensures exactly one dot gets unrolled during each unroll.
[Answer]
## GolfScript, N = 4
This one right rolls as original spec.
```
.. . 
...# 
.#.~
],8-
```
Here are the unrolls:
```
    ...
    #..
    ..
],8-~#.
       .#.
       ...
],8-~#. ..
          ..
          .#
],8-~#. ....
            ..
],8-~#. ....#.
              .
],8-~#. ....#..
],8-~#. ....#...
```
[Try it here](http://golfscript.apphb.com/)
[Answer]
# APL, N = 3
```
201
340
5|0
```
Unrolled:
```
   32
   40
5|001
     43
5|00102
       4
5|001023
5|0010234
```
[Try it online.](http://ngn.github.io/apl/web/index.html#code=201%0A340%0A5|0)
It calculates the remainder of that number divided by 5. Only the result of last line is printed.
# APL, N = 2
```
⍬∞
≡0
```
Unrolled:
```
  ⍬
≡0∞
≡0∞⍬
```
[Try it online.](http://ngn.github.io/apl/web/index.html#code=%u236C%u221E%0A%u22610)
`≡` returns the depth (not to be confused with the dimension or length) of an array:
* `0` is not an array. So the depth is 0.
* `0∞` is an array with two items `0` and `∞` (infinity). It has depth 1.
* `0∞⍬` has another item `⍬`, which is an empty array with depth 1. So `0∞⍬` has depth 2.
These two programs also works in the online interpreter. I'm not sure if the later one is syntactically correct.
```
⍬0
≡∞
```
  
```
⍬¯
≡0
```
# APL, for any N >= 4
For N = 4:
```
∞  ∞
 ∞∞
∞ ∞
⍴1↓∞
```
Fully unrolled:
```
⍴1↓∞  ∞  ∞ ∞ ∞∞∞
```
For N = 5:
```
∞   ∞
 ∞ ∞
 ∞∞
∞  ∞
⍴1↓ ∞
```
Fully unrolled:
```
⍴1↓ ∞   ∞   ∞  ∞  ∞ ∞ ∞∞∞
```
`1↓` removes an item in the array. It also returns the empty array if the argument is scalar. `⍴` gets the array length.
]