[Question]
  [
Based on [this](https://codegolf.stackexchange.com/questions/132558/i-double-the-source-you-double-the-output) challenge.
In the rhythm game [osu!](https://osu.ppy.sh/home), the difficulty modifier "Double-time" actually only increases the speed by 50%.
Your task, is to write a program that outputs a positive *even* integer (higher than 0), and when each byte/character (your choice which) in your source code is duplicated, it should output the number multiplied by 1.5.
For example if your source code is `ABC` and that outputs 6, then `AABBCC` should output 9.
Following the original challenge's rules:
## Rules
* You must build a full program.
* The initial source must be at least 1 byte long.
* Both the integers must be in base 10 (outputting them in any other base or with scientific notation is forbidden).
* Your program must not take input (or have an unused, empty input) and must not throw any error (compiler warnings are not considered errors).
* Outputting the integers with trailing / leading spaces is allowed.
* You may not assume a newline between copies of your source.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the fewest bytes **in each language** wins!
* [**Default Loopholes**](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
I imagine this will be far less trivial than the original challenge, but hopefully we'll see some creative and unique answers!
  
[Answer]
# [Pylons](https://github.com/morganthrapp/Pylons-lang), 7 5 4 bytes
Picked a random language on TIO used it
```
46vt
```
Explanation:
[Try it Online!](https://tio.run/##K6jMyc8r/v/fxKys5P9/AA)
```
46    # Stack is [4, 6]
v     # Reverse the stack [6, 4]
t     # take top of stack 4
```
Doubled:
```
4466   # Stack is [4, 4, 6, 6]
vv     # Reverse the stack twice so it's the same [4, 4, 6, 6]
tt     # take top of stack 6 and again which is 6 again
```
Saved 2 bytes thanks to *officialaimm*
Saved 1 bytes thanks to *Veedrac*
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
!‚Äò
```
[Try it online!](https://tio.run/##y0rNyan8/1/xUcOM//8B "Jelly ‚Äì Try It Online")
Explanation:
```
!‚Äò Implicit 0
!  Factorial
 ‚Äò Increment
```
Doubled version:
```
!!‚Äò‚Äò
```
[Try it online!](https://tio.run/##y0rNyan8/19R8VHDDCD6/x8A "Jelly ‚Äì Try It Online")
Explanation:
```
!!‚Äò‚Äò Implicit 0
!    Factorial
 !   Factorial
  ‚Äò  Increment
   ‚Äò Increment
```
[Answer]
# LibreOffice Calc, 8 bytes
```
=A2+3
19
```
Save it as `*.csv` and open it in LibreOffice Calc. You will get 22 in A1.
---
Double them:
```
==AA22++33
1199
```
You will get 33 in A1
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes
```
TnQ
```
[Try it online!](https://tio.run/##y00syfn/PyQv8P9/AA "MATL ‚Äì Try It Online") Or [doubled version](https://tio.run/##y00syfn/PyQkLy8w8P9/AA).
### Explanation
In MATL a scalar value (number, char, logical value) is the same as a 1√ó1 array containing that value.
Normal version:
```
T    % Push true
n    % Number of elements of true: gives 1
Q    % Add 1: gives 2
```
Doubled version:
```
TT   % Push [true, true]
n    % Number of elements of [true, true]: gives 2
n    % Number of elements of 2: gives 1
Q    % Add 1: gives 2
Q    % Add 1: gives 3
```
[Answer]
## vim, 5
```
i1<esc>X<C-a>
```
Without doubling:
```
i1<esc>  insert the literal text "1"
X        delete backwards - a no-op, since there's only one character
<C-a>    increment, giving 2
```
With doubling:
```
ii11<esc>   insert the literal text "i11"
<esc>       escape in normal mode does nothing
XX          since the cursor is on the last character, delete "i1"
<C-a><C-a>  increment twice, giving 3
```
[Answer]
Not sure if this answer is valid. Just post here in case some one may got ideas from here.
# Node.js with -p flag, 7 bytes
By **Alex Varga**:
```
3/3*22
33//33**2222
```
# Node.js with -p flag, 11 bytes
**Old one:**
```
3*2*0/1+22
33**22**00//11++2222
```
Output 22 and 33.
[Answer]
# Python 2 REPL, 11 bytes
```
(3/1)*(2/1)
```
This simply evaluates to 3\*2=6. Duplicated, it is
```
((33//11))**((22//11))
```
which evaluates to 3\*\*2, which is 3 to the power of 2, or 9. 
[Answer]
# APL, 7 bytes
```
‚äÉ‚çï‚åä3√ó‚çü2
```
Prints `2`.
```
‚äÉ‚äÉ‚çï‚çï‚åä‚åä33√ó√ó‚çü‚çü22
```
Prints `3`.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtEx51NT/qnfqop8v48PRHvfONuBDCEBmwJEgeqACsBKTK6P9/AA)
### Waaat?
Single:
```
3√ó‚çü2         ‚Üí 2.079441542  ‚çù  3 * ln 2
‚åä2.079441542 ‚Üí 2            ‚çù  floor
‚äÉ‚çï           ‚Üí '2'          ‚çù  format and take first character
```
Double:
```
‚çü‚çü22          ‚Üí 1.128508398  ‚çù  ln ln 22
√ó1.128508398  ‚Üí 1            ‚çù signum
33√ó1          ‚Üí 33           ‚çù  33 * 1
‚åä‚åä33          ‚Üí 33           ‚çù  floor
‚äÉ‚äÉ‚çï‚çï          ‚Üí '3'          ‚çù  format and take first character
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 3 bytes
```
1u*
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9@wVOv/fwA "Actually ‚Äì Try It Online")
Explanation:
```
1u* Errors are ignored
1   Push 1
 u  Increment
  * Multiply
```
Doubled version:
```
11uu**
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9/QsLRUS@v/fwA "Actually ‚Äì Try It Online")
Explanation:
```
11uu** Errors are ignored
1      Push 1
 1     Push 1
  u    Increment
   u   Increment
    *  Multiply
     * Multiply
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 4 bytes
```
],))
```
[Try it normally!](https://tio.run/##S85KzP3/P1ZHU/P/fwA "CJam ‚Äì Try It Online")
[Try it doubled!](https://tio.run/##S85KzP3/PzZWR0cTCP7/BwA)
### Explanation
Normal:
```
]     e# Wrap the stack in an array: []
 ,    e# Get its length: 0
  ))  e# Increment twice: 2
```
Double:
```
]         e# Wrap the stack in an array: []
 ]        e# Wrap the stack in an array: [[]]
  ,       e# Get its length: 1
   ,      e# Get the range from 0 to n-1: [0]
    )     e# Pull out its last element: 0
     )))  e# Increment 3 times: 3
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
X>
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/wu7/fwA "05AB1E ‚Äì Try It Online")
Explanation:
```
X> Only top of stack is printed
X  Push X (default 1)
 > Increment
```
Doubled version:
```
XX>>
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/IsLO7v9/AA "05AB1E ‚Äì Try It Online")
Explanation:
```
XX>> Only top of stack is printed
X    Push X (default 1)
 X   Push X (default 1)
  >  Increment
   > Increment
```
[Answer]
# [Neim](https://github.com/okx-code/Neim), 2 bytes
```
ùêì>
```
[Try it online!](https://tio.run/##y0vNzP3//8PcCZPt/v8HAA "Neim ‚Äì Try It Online")
Explanation:
```
ùêì> Implicit 0
ùêì  Factorial
 > Increment
```
Doubled version:
```
ùêìùêì>>
```
[Try it online!](https://tio.run/##y0vNzP3//8PcCZNB2M7u/38A "Neim ‚Äì Try It Online")
```
ùêìùêì>> Implicit 0
ùêì    Factorial
 ùêì   Factorial
  >  Increment
   > Increment
```
[Answer]
# Pyth, 3 bytes
```
he1
```
[Try it here.](http://pyth.herokuapp.com/?code=he1&debug=0)
Explanation:
```
he1
h   Increment
 e   Last digit
  1   1
```
Doubled version:
```
hhee11
```
[Try it here.](http://pyth.herokuapp.com/?code=hhee11&debug=0)
Explanation:
```
hhee11
h      Increment
 h      Increment
  e      Last digit
   e      Last digit
    11     11
```
[Answer]
# Ruby REPL, 8 bytes
```
";3#";22
```
The REPL only prints the last value evaluated: `22`.
Doubled:
```
"";;33##"";;22
```
This time `33` is the last value evaluated. The string is discarded once again, and a `#` starts a comment.
[Answer]
# [Zsh](https://www.zsh.org/), 14 bytes
```
<:|echo 22
3
:
```
[Try it online!](https://tio.run/##ZY6xDoIwEIb3e4pLrRZW3CrppK6@gAu0hZJoS1qICeqz10ICi7f9d1/@@6ZgosDgJZYlssvtymLJP1oah0UBR@Ax7QCmYGYIYIdq7B@drAaNvXetr54cGudRYmeRvrPAeU5oViY6J98TKgeYpvedHRpk@8CQUEklQSHScawfWoFyVs/dwbjX/4O5Wel6bGHxEocCKbvb88qpzYRByguwNi/mW4D4Aw "Zsh ‚Äì Try It Online")
Getting a full program in a non-golfing language to print anything with source code duplicated like this is a challenge. Zsh is very useful for this, because files and heredocs are implicitly passed to `cat`. Let's take a look at the first line in both cases:
```
<:|echo 22            # Give the file : on stdin to cat. cat pipes to 'echo 22', which ignores stdin
<<::||eecchhoo  2222  # Start heredoc on following lines with EOF string '::', pass to cat.
                      # Since cat exits 0, 'eecchhoo 2222' is not executed
```
So long as `3` is not a program, the first program will only print `22`.
The second program will print `33` surrounded by extra newlines (due to the duplication).
---
If `3` is a function/program/alias, then this **18 byte** solution will still work!
```
<:|echo 22\\c\
3
:
```
[Try it online!](https://tio.run/##ZY6xDoIwEIb3e4pLrRZW3CphUldfoAu0hZIgJS3EBPXZayGBxdv@uy//fbM3oUDvJOY5stvjzkLOP1oai1kmhBRwBh7iHmD2ZgEBDqimoWtlOWocnG1c@eRQW4cS2x7pO/Gcp4QmeaRT8r2gsoBxBtf2Y43s6BkSKqkkWBTxOFWdVqBsr5dub@zr/8HSrHQ1NbC6FacMKRP9dePUbsIg5hXYmlfzPUD4AQ "Zsh ‚Äì Try It Online")
The last `\` is line continuation, so the newline is discarded, effectively making the echo statement
`echo '22\c3'`. The `\c` causes echo to stop printing after `22` (which also happens to suppress the newline).
[Answer]
# [R](https://www.r-project.org/), ~~11~~ 6 bytes
```
1+7*!0
```
[Try it online!](https://tio.run/##K/r/31DbXEvR4L@hoba2ubmWliKQDQA "R ‚Äì Try It Online")
`!` is negation, and `**` is exponentiation (an alias for `^`). Numerics get converted to booleans: `0` to `FALSE`, all others to `TRUE`. Booleans get converted to integers: `FALSE` to `0`, `TRUE` to `1`, so `!0==1`, `!1==0`, `!!00==0` and `!!11==1`.
The single version thus computes \$1+7\times 1=8\$, and the double version computes \$11+77^0=12\$.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 6 bytes
```
O.1)W@
```
Prints `2`.
```
  O
. 1 ) W
  @
```
Pushes `1`, `)` increments, `W` jumps left to `O` which outputs `2`, and `@` finishes the program.
Doubled up, it's obviously `OO..11))WW@@`, which on a cube is:
```
    O O
    . .
1 1 ) ) W W @ @
. . . . . . . .
    . .
    . .
```
It pushes `1` twice, `)` increments twice, `W` jumps left again, which puts it at the right-hand `O` heading north, which outputs `3`, and then the next command is `@` which terminates the program.
[Try it online!](https://tio.run/##Sy5Nyqz4/99fz1Az3OH/fwA "Cubix ‚Äì Try It Online")
[Doubled online!](https://tio.run/##Sy5Nyqz4/9/fX0/P0FBTMzzcweH/fwA "Cubix ‚Äì Try It Online")
[Answer]
# [Klein](https://github.com/Wheatwizard/Klein), ~~8~~ 6 bytes
```
/3+@4\
```
[Single](https://tio.run/##y85Jzcz7/1/fWNvBJOb///8GBoYA "Klein ‚Äì Try It Online"), [Double](https://tio.run/##y85Jzcz7/19f39hYW9vBwcQkJub///8GBoYA "Klein ‚Äì Try It Online")
## Explanation
For the single the program follows a pretty straightforward path. The first mirror deflects it into the second which deflects it through the `4` to the end of the program.
The double is a little more complex. Here it is:
```
//33++@@44\\
```
The first two mirrors work the same, however there is a new mirror due to the doubling which deflects the ip back to the beginning, it is caught by the duplicate of the first mirror and deflected towards the end. All that is run is the `33++` which evaluates to 6.
[Answer]
# TI-Basic, 3 bytes
Single:
```
int(‚àö(8
```
The last expression is implicitly returned/printed in TI-Basic, so this prints `2`
Doubled:
```
int(int(‚àö(‚àö(88
```
Returns/prints 3
TI-Basic is a [tokenized language](http://tibasicdev.wikidot.com/one-byte-tokens); `int(`, `‚àö(`, and `8` are each one byte in memory.
[Answer]
# ><>, ~~19~~ 8 Bytes
```
32b*!{n;
```
Prints `22`  
[Try it online!](https://tio.run/##S8sszvj/39goSUuxOs/6/38A "><> ‚Äì Try It Online")
Explanation:
```
32b   push literals onto the stack: [3,2,11]
*     multiply the top two values: [3,22]
!     skip the next instruction
{     (skipped)
n     pop and print the top value from the stack (22)
;     end execution
```
### Doubled:
```
3322bb**!!{{nn;;
```
Prints `33`  
[Try it online!](https://tio.run/##S8sszvj/39jYyCgpSUtLUbG6Oi/P2vr/fwA "><> ‚Äì Try It Online")
Explanation:
```
3322bb push literals onto the stack: [3,3,2,2,11,11]
**     multiply top values (twice): [3,3,2,242]
!      skip next instruction
!      (skipped)
{{     rotate the stack to the left (twice): [2,242,3,3]
nn     pop and print the top two values from the stack (33)
;      end execution
```
Old Version:  
~~Normal:~~
```
11+!vn;
    n
    ;
```
Prints `2`  
[Try it online!](https://tio.run/##S8sszvj/39BQW7Esz5pLAQjywKT1//8A)
Explanation:
```
1    push 1 on the stack: [1]
 1    push 1 on the stack: [1,1]
  +    add top two values of the stack: [2]
   !    skip the next instruction
    v    (skipped)
     n    print the top value of the stack (2)
      ;    end execution
```
Doubled:
```
1111++!!vvnn;;
        nn
        ;;
```
Prints `3`  
[Try it online!](https://tio.run/##S8sszvj/3xAItLUVFcvK8vKsrbkUoCAvD860tv7/HwA)
Explanation:
```
1111    push four 1's on the stack: [1,1,1,1]
    +    add top two values of the stack: [1,1,2]
     +    add top two values of the stack: [1,3]
      !    skip the next instruction
       !    (skipped)
        v    change direction of execution (down)
         n    print the top value of the stack (3)
          ;    end execution
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 14 bytes
```
'|d 3#';say 22
```
[Try it online!](https://tio.run/##K0gtyjH7/1@9JkXBWFndujixUsHI6P9/AA "Perl 6 ‚Äì Try It Online") [Try it doubled!](https://tio.run/##K0gtyjH7/19dvaYmJUVBwdhYWVld3dq6uDgxsbJSQcEICP7/BwA)
This uses the conveniently named debug function `dd` to output the doubled program to STDERR. To separate the logic we encase the doubled program in quotes, which then cancel each other out when doubled, along with a comment character `#` to comment out the now invalid normal program.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
¬°‚Ä∫
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C2%A1%E2%80%BA&inputs=&header=&footer=)
Port of the Jelly answer.
```
   # (implicit zero)
¬°  # Factorial
 ‚Ä∫ # Incremented
```
Doubled ([Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C2%A1%C2%A1%E2%80%BA%E2%80%BA&inputs=&header=&footer=)):
```
¬°    # 0 factorial = 1
 ¬°   # 1 factorial = 1
  ‚Ä∫‚Ä∫ # Incremented twice = 3
```
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
√∞L‚Ä∫
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C3%B0L%E2%80%BA&inputs=&header=&footer=)
```
√∞   # Space character
 L  # Length
  ‚Ä∫ # Incremented
```
Doubled ([Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C3%B0%C3%B0LL%E2%80%BA%E2%80%BA&inputs=&header=&footer=))
```
√∞√∞     # Space character (one's a nop)
  LL   # Length twice (one's a nop)
    ‚Ä∫‚Ä∫ # Incremented twice
```
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 6 bytes
```
))$$!@
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/19TU0VF0eH/fwA "Hexagony ‚Äì Try It Online") ([Try it doubled!](https://tio.run/##y0itSEzPz6v8/18TCFSAQFHRweH/fwA "Hexagony ‚Äì Try It Online"))
## Explanation
```
  ) )
 $ $ !
  @ .
```
This program does nothing too weird; it just executes each line in order:
* `))`: Increment twice (memory cell = `2`).
* `$$`: Jump the jump; basically a no-op.
* `!`: Print memory cell (`2`)
* `@`: Stop.
---
```
   ) ) )
  ) $ $ $
 $ ! ! @ @
  . . . .
   . . .
```
Only the first and third lines are executed, due to Hexagony's control flow:
* `)))`: Increment 3 times (memory cell = `3`).
* `)$$$`: This line is skipped.
* `$!`: Jump over the first `!`, so the memory cell isn't printed twice.
* `!`: Print `3`.
* `@`: Stop.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 2 bytes
```
‚ñ¨)
```
[Try it online!](https://tio.run/##y00syUjPz0n7///RtDWa//8DAA "MathGolf ‚Äì Try It Online") [Try it doubled](https://tio.run/##y00syUjPz0n7///RtDVApKn5/z8A "MathGolf ‚Äì Try It Online")
Similar to other answers in that the first instruction produces a `1` even when doubled and the second increments it. In this case, I've used reverse exponentiation (`0**0 = 0**0**0 = 1`) but it also could have been any of the `!¬£‚â§¬∞` instruction and perhaps even more that I missed.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 3 bytes
```
UJ^
```
[Run and debug it](https://staxlang.xyz/#c=UJ%5E&i=&a=1&m=2)
[Run and debug the doubled one](https://staxlang.xyz/#c=UUJJ%5E%5E&i=&a=1&m=2)
`U` pushes -1. `J` squares. `^` increments.
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 12 bytes
```
iis(ooh)iiio
```
[Try it online!](https://tio.run/##S0lNTEnLLM7Q/f8/M7NYIz8/QzMzMzP//38A "Deadfish~ ‚Äì Try It Online")
[Try it doubled!](https://tio.run/##S0lNTEnLLM7Q/f8/EwiKizU08oEgI0NTMxMM8vP//wcA "Deadfish~ ‚Äì Try It Online")
## Explanation
```
iis(ooh)iiio
```
Set the accumulator to `2`, square it, print twice to get `44`, stop.
```
iiiiss((oooohh))iiiiiioo
```
Set the accumulator to 4 and square it twice to get 256.  
Since Deadfish~ doesn't like the number 256, it sets the accumulator to 0 instead.  
The `(...)` part of the code is ignored if the accumulator is 0, and then the rest of the code prints `66`.
[Answer]
# [Perl 5](https://www.perl.org/) + `-M5.10.0 -MData::Dump+(dd)`, 17 bytes
```
q{\};d 3#};say 22
```
[Try it online!](https://tio.run/##K0gtyjH9/7@wOqbWOkXBWLnWujixUsHI6P//f/kFJZn5ecX/dX1N9QwN9AyADJfEkkQrK5fS3AJtjZQUTQA "Perl 5 ‚Äì Try It Online")
## Doubled
```
qq{{\\}};;dd  33##}};;ssaayy  2222
```
[Try it online!](https://tio.run/##K0gtyjH9/7@wsLo6Jqa21to6JUVBwdhYWRnELi5OTKysVFAwAoL////lF5Rk5ucV/9f1NdUzNNAzADJcEksSraxcSnMLtDVSUjQB "Perl 5 ‚Äì Try It Online")
## Explanation
I was hopeful to find a way to trigger a `print` without using an external, but I couldn't come up with anything so I settled on `dd`.
The trick here was to leverage Perl's flexibly delimited strings to encase the doubled code without causing a syntax error. Using `{...}` (or any other pairs like`()`, `[]`, `<>`) means in the original code the end char can be escaped with a single `\` which when doubled is just a backslash. Using `q` is easiest as `qq` is just as valid.
```
q{\};d 3#};say 22
```
Here we have a short string containing `};d 3#`, then we just `say 22` which outputs 22.
```
qq{{\\}};;dd  33##}};;ssaayy  2222
```
Here we have a string containing a single `\` and then we `dd`ump out 33 and the rest of the program is commented out.
---
Now that I look through the other answers I see that [@JoKing's answer](https://codegolf.stackexchange.com/a/191483/9365) would work as-is with my command line arguments too...
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 2 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Another "factorial+1" solution.
```
√ä√Ñ
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ysQ)
```
√ä√ä√Ñ√Ñ
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ysrExA)
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 1 byte
I think we all know this is a worthless answer. Gotta show Octave some love.
```
0
```
[Try it online!](https://tio.run/##y08uSSxL/f/f4P9/AA "Octave ‚Äì Try It Online")
]