[Question]
  [
Write a single line program two or more characters long that contains no [line terminators](https://en.wikipedia.org/wiki/Newline#Unicode) and takes no input. For example, your program might be:
```
MyProgram
```
When your program is arranged into the shapes a clock's hands make at 12, 3, 6, and 9 o'clock, it needs to output the corresponding hour number. No other times need be supported.
Specifically:
* When your program is arranged like clock hands at 12 o'clock (üïõ)
```
m
a
r
g
o
r
P
y
M
```
running it should output `12`.
* When your program is arranged like clock hands at 3 o'clock (üïí)
```
m
a
r
g
o
r
P
y
MyProgram
```
running it should output `3`.
* When your program is arranged like clock hands at 6 o'clock (üïï)
```
m
a
r
g
o
r
P
y
M
y
P
r
o
g
r
a
m
```
running it should output `6`.
* When your program is arranged like clock hands at 9 o'clock (üïò)
```
........m
........a
........r
........g
........o
........r
........P
........y
margorPyM
```
running it should output `9`.
# Notes
* The first character in your program is always placed at the center of the clock. (Note how there is only one `M` in the 6 o'clock example.)
* Any one non-newline character may be used to indent the program for the 9 o'clock arrangement. In the examples `.` is used, but space or `/` or `#` would be just as valid.
* For the 3 o'clock arrangement, no characters should be in the empty upper right region. (i.e. keep it empty, don't fill it with spaces.)
* The initial program arrangement (`MyProgram` as is) does not need to do anything. Only the 12, 3, 6, and 9 o'clock arrangements need to have correct, well-defined output.
* Code that only works as a function or REPL command is not allowed. Each of the four arrangements should be ready to run as full programs as is.
**The shortest program in bytes wins.** e.g. `MyProgram` has a length of 9 bytes.
  
[Answer]
# GolfScript, ~~11~~ 10 bytes
```
21;;3#9];6
```
Uses `#` as padding character.
## 12 o'clock
```
6
;
]
9
#
3
;
;
1
2
```
[Try it online!](http://golfscript.tryitonline.net/#code=Ngo7Cl0KOQojCjMKOwo7CjEKMg&input=)
### How it works.
* `6` is pushed on the stack, `;` discards it.
* `]` wraps the stack in an array (does not affect output).
* `9` and `3` are pushed on the stack, `;` and `;` discard them.
* Finally, `1` and `2` are pushed on the stack, and implicitly printed without separation.
## 3 o'clock
```
6
;
]
9
#
3
;
;
1
21;;3#9];6
```
[Try it online!](http://golfscript.tryitonline.net/#code=Ngo7Cl0KOQojCjMKOwo7CjEKMjE7OzMjOV07Ng&input=)
### How it works
* `6` is pushed on the stack, `;` discards it.
* `]` wraps the stack in an array (does not affect output).
* `9` and `3` are pushed on the stack, `;` and `;` discard them.
* `1` and `21` are pushed on the stack, `;;` discards them.
* `3` is pushed on the stack.
* `#` begins a comment until the end of the line.
## 6 o'clock
```
6
;
]
9
#
3
;
;
1
2
1
;
;
3
#
9
]
;
6
```
[Try it online!](http://golfscript.tryitonline.net/#code=Ngo7Cl0KOQojCjMKOwo7CjEKMgoxCjsKOwozCiMKOQpdCjsKNg&input=)
### How it works
* `6` is pushed on the stack, `;` discards it.
* `]` wraps the stack in an array (does not affect output).
* `9` and `3` are pushed on the stack, `;` and `;` discard them.
* `1`, `2` and `1` are pushed on the stack.
* `;` and `;` discard the last `1` and `2`.
* `3` and `9` are pushed on the stack.
* `]` and `;` wrap the stack in an array and discard it, clearing the stack.
* `6` is pushed on the stack.
## 9 o'clock
```
#########6
#########;
#########]
#########9
##########
#########3
#########;
#########;
#########1
6;]9#3;;12
```
[Try it online!](http://golfscript.tryitonline.net/#code=IyMjIyMjIyMjNgojIyMjIyMjIyM7CiMjIyMjIyMjI10KIyMjIyMjIyMjOQojIyMjIyMjIyMjCiMjIyMjIyMjIzMKIyMjIyMjIyMjOwojIyMjIyMjIyM7CiMjIyMjIyMjIzEKNjtdOSMzOzsxMg&input=)
### How it works
* All lines but the last are comments.
* `6` is pushed on the stack, `;` discards it.
* `]` wraps the stack in an array (does not affect output).
* `9` is pushed on the stack.
* `#` begins a comment until the end of the line.
[Answer]
## [><>](http://esolangs.org/wiki/Fish), 20 bytes
```
X   n-+g+aa0g+9a2c!v
```
There's unprintables in there, namely:
* After the `X` is `\x06\t`
* After the `c` is `\x03`
The same part of source code is run each time, using `g` on two parts of the source code to determine what to subtract from 12.
```
v                         Make IP move downwards
 !\x03                    Jump over the \x03
      c                   Push 12
       2a9+g              Get the char at position (2, 19), i.e. the \t for
                          3 o'clock, the \x03 for 9 o'clock, 0 otherwise
            0aa+g         Get the char at position (0, 20), i.e. first char on
                          the line after the X, \x06 for 6 o'clock
                 +        Add
                  -       Subtract from the 12
                   n      Output as number
                    \t    Unrecognised instruction - errors out
```
[12 o'clock](http://fish.tryitonline.net/#code=dgohCgMKYwoyCmEKOQorCmcKMAphCmEKKwpnCisKLQpuCgkKBgpY&input=) | [3 o'clock](http://fish.tryitonline.net/#code=dgohCgMKYwoyCmEKOQorCmcKMAphCmEKKwpnCisKLQpuCgkKBgpYBgluLStnK2FhMGcrOWEyYwMhdg&input=) | [6 o'clock](http://fish.tryitonline.net/#code=dgohCgMKYwoyCmEKOQorCmcKMAphCmEKKwpnCisKLQpuCgkKBgpYCgYKCQpuCi0KKwpnCisKYQphCjAKZworCjkKYQoyCmMKAwohCnY&input=) | [9 o'clock](http://fish.tryitonline.net/#code=ICAgICAgICAgICAgICAgICAgIHYKICAgICAgICAgICAgICAgICAgICEKICAgICAgICAgICAgICAgICAgIAMKICAgICAgICAgICAgICAgICAgIGMKICAgICAgICAgICAgICAgICAgIDIKICAgICAgICAgICAgICAgICAgIGEKICAgICAgICAgICAgICAgICAgIDkKICAgICAgICAgICAgICAgICAgICsKICAgICAgICAgICAgICAgICAgIGcKICAgICAgICAgICAgICAgICAgIDAKICAgICAgICAgICAgICAgICAgIGEKICAgICAgICAgICAgICAgICAgIGEKICAgICAgICAgICAgICAgICAgICsKICAgICAgICAgICAgICAgICAgIGcKICAgICAgICAgICAgICAgICAgICsKICAgICAgICAgICAgICAgICAgIC0KICAgICAgICAgICAgICAgICAgIG4KICAgICAgICAgICAgICAgICAgIAkKICAgICAgICAgICAgICAgICAgIAYKdiEDYzJhOStnMGFhK2crLW4JBlg&input=) (looks misaligned due to the tab)
[Answer]
## [ROOP](http://esolangs.org/wiki/ROOP), 54 bytes
```
OW    3#H V  1#1  H#6  WO#H V>V1#OW V>V9#OW   2#OW   1
```
Uses `<` as padding character.
[12 o'clock](https://tio.run/##K8rPL/j/35BLAQzDufy5lLmMUHiWXGFcdkAM4xvC@R5Anj9QFKTWDMj2ALMMwWpALJgaY6h5YBP@/wcA) | [3 o'clock](https://tio.run/##VYw9CsAwCIV3T/HAE5hAIUtmt2zJMVJ6f7DGNoUq8n748JrzNBNC7KBGTOmXCnWqfjvLl9VT83axh3sNJ8Est5n8/osPAz6ZFR0QFkD5AEZbTe3CDrgWDjA9ImY3) | [6 o'clock](https://tio.run/##K8rPL/j/35BLAQzDufy5lLmMUHiWXGFcdkAM4xvC@R5Anj9QFKTWDMj2ALMMwWpALJgaY6h5EBPC4TxjqJ4wNH0gPWZILoCoAdlpCLcRwrdEcoEC0N3IPMP//wE) | [9 o'clock](https://tio.run/##7ZYxCsAgDEX3nuJDThAFQSjObm56DEvvD7a2W8cMKYpZPkgewv9GPWs9WtslxZsIwwhYkWFJhpEMMyuAfwPwMizLsKC628y58crtW1E1gKR6uHRvLqfqZBzBEh5hunUtmXm67cT/EvGzyABKIvOKzyF35a6RUgEcRYDp7usrFk9jaxc)
## 12 o'clock
The `1` and the `2` that are near the top fall for 3 cycles. When they reach the `W` operator, the operator places the number in `O`, which represents the output.
The `1` in this part
```
1
V
H
```
fell for 2 cycles, the `V` operator moves it below and at the next cycle activates the `H` operator that ends the program.
## 3 o'clock
`O` are also objects that move and fall. Since the code now has a line with more than one character, all other lines are filled with empty spaces. All `O` moves to the right and fall, causing the `W` operators to have no place to send the `1` and `2`.
The only `O` that does not move is the one that is trapped in the center. The `3` above falls for 4 cycles to the `W`.
Then the numbers that fall are filling the 4 spaces between the `W` and`3`. When it is filled, another number can pass over all of them and reach the `H` operator that ends the program.
## 6 o'clock
```
1
H
#
6
W
O
```
Very similar to the 12, the `6` falls to the `W` and the `1` to the `H`. This occurs in 2 cycles, ending the program before the 12 case occurs.
## 9 o'clock
```
<9
<V
<>
<V
< 
<W
<O
<#
<1
<V
<>
<V
< 
<H
```
(I show a single column of `<` because the others do nothing).
The `V` picks up the `9` and moves it to the pipe below, which deflects the object to the left. The pipe `<` moves the object down and the next one to the right. The `V` operator put the `9` in the space below and then it is sent to the output.
The `1` makes equal movements and reaches the `H`, which ends the program. As the pipes move objects in the same cycle, all this takes a single cycle.
]