[Question]
  [
Your task, if you wish to accept it, is to write a program that outputs a positive integer (higher than 0). The tricky part is that if I duplicate your source code, the output must be double the original integer.
# Rules
* You must build a **full program**. That is, your output has to be printed to STDOUT.
* 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).
* 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 shortest (original) code *in each language* wins!
* **[Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)** apply.
### Example
Let's say your source code is `ABC` and its corresponding output is `4`. If I write `ABCABC` instead and run it, the output must be `8`.
# Leaderboard
This uses uses [@manatwork's layout](https://codegolf.meta.stackexchange.com/questions/5139/leaderboard-snippet/7742#7742).
```
/* Configuration */
var QUESTION_ID = 132558; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8349457; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    if (! /<a/.test(lang)) lang = '<i>' + lang + '</i>';
    lang = jQuery(lang).text().toLowerCase();
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link, uniq: lang};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.uniq > b.uniq) return 1;
    if (a.uniq < b.uniq) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=617d0685f6f3">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 33 bytes
```
print len(open(__file__).read())#
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EISc1TyO/AEjEx6dl5qTGx2vqFaUmpmhoair//w8A "Python 2 – Try It Online")
[Try it doubled](https://tio.run/##K6gsycjPM/r/v6AoM69EISc1TyO/AEjEx6dl5qTGx2vqFaUmpmhoaioTVPD/PwA "Python 2 – Try It Online")
# [Python 3](https://docs.python.org/3/), 28 bytes
```
print(len(*open(__file__)))#
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EIyc1T0MrvwBIxsenZeakxsdramoq//8PAA "Python 3 – Try It Online")
[Try it doubled](https://tio.run/##K6gsycjPM/7/v6AoM69EIyc1T0MrvwBIxsenZeakxsdramoq45P7/x8A "Python 3 – Try It Online")
## Explanation
This opens up the source code using `open(__file__)` and gets its length using `len` the `#` prevents any additional code from being read. When the source is doubled so is the length.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
‘
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw4z//wE "Jelly – Try It Online")
or [Try it double!](https://tio.run/##y0rNyan8//9Rwwwg@v8fAA "Jelly – Try It Online")
I have no idea how this works, but apparently it does. 
[Answer]
# Google Sheets, 5 Bytes
Anonymous worksheet formula that takes no input and outputs into the cell which holds the formula
```
=4/(2
```
As a single formula this evaluates to a call stack that looks a little something like
```
=4/(2
=4/(2)
=4/2
=2
2
```
However when this worksheet formula is doubled this call stack evaluates down to
```
=4/(2=4/(2
=4/(2=4/(2)
=4/(2=4/(2))
=4/(2=2)
=4/(True)
=4/True
=4/1
=4
4
```
Of course, an implication of using this method is that once this is repeated more than once, at the third and all following iterations of the problem, the call stack will reach `=4/(2=4)` and thus evaluate down to `=4/0` and throw a `#DIV/0!` error
[Answer]
## C (gcc), 37 bytes
```
i;main(){putchar(i+49);}/*
i=1;//*///
```
The file does not contain a trailing newline.
Doubled version, for syntax highlighting:
```
i;main(){putchar(i+49);}/*
i=1;//*///i;main(){putchar(i+49);}/*
i=1;//*///
```
TIO links: [single](https://tio.run/##S9ZNT07@/z/TOjcxM09Ds7qgtCQ5I7FII1PbxFLTulZfiyvT1tBaX19LX1///38A), [double](https://tio.run/##S9ZNT07@/z/TOjcxM09Ds7qgtCQ5I7FII1PbxFLTulZfiyvT1tBaX19LX1@fKEX//wMA).
[Answer]
# [Python 2](https://docs.python.org/2/), 21 bytes
```
+1
if id:id=0;print 1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/X9uQKzNNITPFKjPF1sC6oCgzr0TB8P9/AA "Python 2 – Try It Online")
**Doubled:**
```
+1
if id:id=0;print 1+1
if id:id=0;print 1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/X9uQKzNNITPFKjPF1sC6oCgzr0TBEKvg//8A "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
**Original**
```
XO
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/wv//fwA "05AB1E – Try It Online")
**Doubled**
```
XOXO
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/wj/C//9/AA "05AB1E – Try It Online")
**Explanation**
**X** pushes **1** to the stack.  
**O** sums the stack.
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 7 bytes
```
/)!@.).
```
Prints 1 regularly then 2 doubled.
[Try it online!](https://tio.run/##y0itSEzPz6v8/19fU9FBT1Pv/38A "Hexagony – Try It Online") or
[Try it doubled online!](https://tio.run/##y0itSEzPz6v8/19fU9FBT1MPSv3/DwA "Hexagony – Try It Online")
### Expanded versions:
Regular:
```
 / )
! @ .
 ) .
```
Doubled:
```
  / ) !
 @ . ) .
/ ) ! @ .
 ) . . .
  . . .
```
The regular program follows the path: `/)!.@` which increments a memory edge (all are initialised to zero) then prints its numeric value. The doubled program follows: `/.)/)!@` which increments the edge twice before printing, instead.
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 1 byte
```
+
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/9f@/9/AA "Braingolf – Try It Online")
Now we're talkin'!
Outputs `20`, or `40` when source is doubled.
## Explanation
`+` is of course the "sum", "add" or "plus" operator, in Braingolf, however it has dyadic, monadic and niladic functions.
When there are at least 2 items on the stack, it's dyadic, and will sum the top 2 items of the stack.
When there is only 1 item on the stack, it's monadic, and will double the item.
When there are no items on the stack, it's niladic, and pushes 20!
Why does it push 20? Well because an empty Braingolf program simply prints a newline, and the ASCII value of a newline is 10, so I figured I'd make niladic `+` push 20 so it's like it's actually being monadic on the implicit newline (even though it isn't at all)
Therefore:
```
+   No input
+   Niladic sum, Push 20
    Implicit output
```
And when doubled up:
```
++  No input
+   Niladic sum, Push 20
 +  Monadic sum, Double top of stack
    Implicit output
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~26~~ 18 bytes
```
main=print$0
 +1--
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oCgzr0TFgEtB21BX9/9/AA "Haskell – Try It Online")
**Doubled:**
```
main=print$0
 +1--main=print$0
 +1--
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oCgzr0TFgEtB21BXF1Pk/38A "Haskell – Try It Online")
I found this version while answering the [tripple version of the challenge](https://codegolf.stackexchange.com/a/157961/56433).
---
### 26 byte version without comment abuse:
```
main|n<-1,nmain<-2=print n
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM68mz0bXUCcPxLTRNbItKMrMK1HI@/8fAA "Haskell – Try It Online") Prints `1`.
In the pattern guard the identifier `n` is set to `1` and `nmain` to `2`, then `print n` prints `1`.
### Double program:
```
main|n<-1,nmain<-2=print nmain|n<-1,nmain<-2=print n
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM68mz0bXUCcPxLTRNbItKMrMK1HIwy3z/z8A "Haskell – Try It Online") Prints `2`.
In the first pattern guard again `n` is set to `1` and `nmain` to `2`, however the print statement has become `print nmain`, so `2` is printed. Because identifier declarations in a pattern guard evaluate to true, the second pattern guard can never be reached.
[Answer]
# Mathematica, 5 bytes
```
(1+1)
```
outputs 2
and (1+1)(1+1) outputs 4
and of course (as many of you asked)
# Mathematica, 3 bytes
```
(2)
```
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 6 bytes
```
({}())
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fo7pWQ1Pz/38A "Brain-Flak (BrainHack) – Try It Online")
## Explanation
What this does should be pretty clear. `{}` grabs a value from the stack, which implicitly zero to begin with, `()` adds one to it and `(...)` pushes the value. On the second run since there is already a 1 on the stack this just adds another 1 to it to make two. In fact if you copy the code `n` times it will always output `n`.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~7~~ 6 bytes
-1 byte thanks to [Teal pelican](https://codegolf.stackexchange.com/users/62009/teal-pelican)
```
\ln;
0
```
[Try it online!](https://tio.run/##S8sszvj/PyYnz5rL4P9/AA)  
[Try it doubled!](https://tio.run/##S8sszvj/PyYnz5rLAEL@/w8A)
# Explanation
I used a `0` but I could have also used `1`-`9`, `a`-`f` because they all push a single value onto the stack.
## Not doubled:
```
\ redirects execution down
0 pushes zero onto stack; STACK: [0]
  (IP wraps around the bottom)
\ redirects execution right
l pushes stack length (1) onto stack; STACK: [0, 1]
n pops off the top value (1) and prints it; STACK: [0]
; end of execution
```
## Doubled:
```
\ redirects execution down
0 pushes zero onto stack; STACK: [0]
0 pushes zero onto stack; STACK: [0, 0]
  (IP wraps around the bottom)
\ redirects execution right
l pushes stack length (2) onto stack; STACK: [0, 0, 2]
n pops off the top value (2) and prints it; STACK: [0, 0]
; end of execution
```
[Answer]
# Python REPL, 2 bytes
*Also works in Pip, Dyalog APL, JavaScript REPL, J, and R*
```
+1
```
~~*I'm making a TIO right now*~~ I couldn't get python repl to work on TIO
[Answer]
## JavaScript, 38 bytes
```
setTimeout('alert(i)',i=1)/*
i++//*///
```
---
```
setTimeout('alert(i)',i=1)/*
i++//*///setTimeout('alert(i)',i=1)/*
i++//*///
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 3 bytes
```
1
```
[Try it online!](https://tio.run/##K0otycxL/P@fy5Dr/38A "Retina – Try It Online")
Prints `2`. Doubling it prints `4`.
The `1` can be replaced with pretty much anything else.
### Explanation
```
1
```
Replaces the empty input with `1`.
```
```
Counts the number of empty matches in `1` which is two (one before the `1` and one after it).
If we double the program, we get an additional stage like the first one. This time it inserts a `1` before and after the initial one, giving `111`. When we now count the number of matches of the empty regex we get four of them.
[Answer]
# Java8, ~~135~~ ~~118~~ 110 bytes
**Single**, prints 8
```
interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///
```
**Doubled**, prints 16
```
interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///interface T{static void main(String[]a){System.out.print(Byte.SIZE);}}/*
class Byte{static int SIZE=16;}/**///
```
---
**Previews answer, 118 bytes**
**Single**, prints 1
```
interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///
```
**Doubled**, prints 2
```
interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///interface T{static void main(String[]a){System.out.print(T.class.getResource("B.class")==null?1:2);}}/*
enum B{}/**///
```
**How this works**
The java-compiler creates a single file for every class in the source file.
Therefore i can simply check if a resource with the name B.class exists.
---
**Orginal Answer, 135 bytes**
**Single**, prints 1
```
interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///
```
**Doubled**, prints 2
```
interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///interface T{static void main(String[]a){int i=1;try{Class.forName("B");i=2;}catch(Exception e){}System.out.print(i);}}/*
enum B{}/**///
```
[Answer]
# [Python 2](https://docs.python.org/2/), 32 bytes
```
print open(__file__,"a").tell()#
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EIb8gNU8jPj4tMyc1Pl5HKVFJU68kNSdHQ1P5/38A)
[Double source code](https://tio.run/##K6gsycjPM/r/v6AoM69EIb8gNU8jPj4tMyc1Pl5HKVFJU68kNSdHQ1OZkPz//wA)
## Explanation
This opens the source code file in append mode
```
open(__file__,"a")
```
We then find the current position in the file, this will be at the end of the file due to opening in append mode
```
open(__file__,"a").tell()
```
We print this length
```
print open(__file__,"a").tell()
```
And add a comment, so that doubling the source code does not execute more code
```
print open(__file__,"a").tell()#
```
[Answer]
# [Neim](https://github.com/okx-code/Neim), 1 byte
```
>
```
Simply increments the top of the stack.
The stack can be imagined as an infinite amount of zeroes to start off, so this increments zero to get one, and doubled, increments it again to get two.
[Try it online!](https://tio.run/##y0vNzP3/3@7/fwA "Neim – Try It Online")
An alternative solution:
```
ᛖ
```
Adds 2, instead of 1.
[Answer]
# Excel VBA, 12 Bytes
Anonymous VBE immediate window function that takes input from and outputs to range `[A1]`. The default value of the range `[A1]` is `""` (empty string) and after one execution the following sets this to `1` and increments by `1` with all subsequent executions.
```
[A1]=[A1+1]:
```
## Input / Output
**Single Version** 
```
[A1]=[A1+1]:
?[A1]    ''# display the value of [A1] to the VBE immediate window
 1
```
**Doubled Version**
```
[A1]=[A1+1]:[A1]=[A1+1]:
?[A1]    ''# display the value of [A1] to the VBE immediate window
 2
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 byte
```
Ä
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=xA==&input=)  
[Try it doubled!](http://ethproductions.github.io/japt/?v=1.4.5&code=xMQ=&input=)  
[Repeats even longer, too!](http://ethproductions.github.io/japt/?v=1.4.5&code=xMTE&input=)
Rather simple. Japt transpiles to JS, and `Ä` transpiles to `+ 1`, so `ÄÄ` transpiles to `+ 1 + 1`, and so on.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 3 bytes
```
|1"
```
[Try it online!](https://tio.run/##yygtzv7/v8ZQ6f9/AA "Husk – Try It Online")
An original idea, for what I have seen in other answers.
### Explanation
`|` in Husk is an "or" operator which returns its second argument if it is thruthy, otherwise the first argument. When applied to arguments of different types it firstly transform all of them into numbers: the transformation for strings (and lists in general) is done by computing their length.
In the original program we apply `|` to 1 and an empty string, which gets converted to 0: the result is 1.
In the doubled program we apply `|` to 1 and the string "|1", which gets converted to 2: the result is 2.
[Answer]
# [SHENZHEN I/O](https://i.stack.imgur.com/nixdi.jpg) Assembly, ~~35~~ 19 bytes, 3¥
-16 bytes, thanks @l4m2!
```
@add 7
@mov acc x1
```
[![enter image description here](https://i.stack.imgur.com/nixdi.jpg)](https://i.stack.imgur.com/nixdi.jpg)
[Answer]
# CJam, 3 bytes
```
5],
```
[Try it Online](http://cjam.aditsu.net/#code=5%5D%2C)
Encapsulate 5 in array. Return length of array. When you duplicate code, the previously returned length, 1, is already on the stack, so you get an array of [1,5], which returns length 2.
[Answer]
# Ruby, 16 bytes
```
+1
p&&exit
p=p 1
```
[Try it online!](https://tio.run/##KypNqvz/X9uQq0BNLbUis4SrwLZAwfD/fwA "Ruby – Try It Online")
### Doubled:
```
+1
p&&exit
p=p 1+1
p&&exit
p=p 1
```
[Try it online!Try it online!](https://tio.run/##KypNqvz/X9uQq0BNLbUis4SrwLZAwRCd//8/AA "Ruby – Try It OnlineRuby – Try It Online")
[Answer]
# Braingolf, 1 byte
```
+
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/9f@/9/AA)
[Try it doubled!](https://tio.run/##SypKzMxLz89J@/9fW/v/fwA)
I don't know how this works, most important it does!
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), 5 bytes
```
90g.@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/39IgXc/h/38A "Befunge-98 (FBBI) – Try It Online")
`g` gets the character value at coordinate (9, 0) in Funge-Space; `.` prints it as an integer, and `@` halts the program. In the un-doubled version, (9, 0) is out of bounds of the program, and Funge-Space outside the program is initialized to the default value of a space, so we print 32. In the doubled version, (9, 0) is the `@` character, so we print 64.
[Answer]
## [Wumpus](https://github.com/m-ender/wumpus), 4 bytes
```
" O@
```
[Try it online!](https://tio.run/##Ky/NLSgt/v9fScHf4f9/AA "Wumpus – Try It Online")
```
" O@" O@
```
[Try it online!](https://tio.run/##Ky/NLSgt/v9fScHfAYT//wcA "Wumpus – Try It Online")
The normal code prints `32` and the doubled one prints `64`.
### Explanation
`"` works like it does in many other Fungeoids: it toggles string mode, where each individual character code is pushed to the stack, instead of executing the command. However, in contrast to most other Fungeoids, Wumpus's playfield doesn't wrap around, so the IP will instead reflect off the end and bounce back and forth through the code.
So for the single program, the following code is actually executed:
```
" O@O " O@
```
The string pushes `32, 79, 64, 79, 32`. Then the space does nothing, the `O` prints `32`, and the `@` terminates the program.
For the doubled program, the string is instead terminated before the IP bounces back, so the code is only traversed once:
```
" O@" O@
```
This time, the string pushes `32, 79, 64`, the `O` prints the `64` and the `@` terminates the program.
This appears to be the only 4-byte solution.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 1 [byte](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
I
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/comp/index.html?code=SQ__), or [try the duplicated version](https://dzaima.github.io/SOGLOnline/comp/index.html?code=SUk_)  
`I` is the increase command, and as no input is provided, it increases 0 (and then in the duplicated program, 1 to 2)
[Answer]
# [,,,](https://github.com/totallyhuman/commata), 2 [bytes](https://github.com/totallyhuman/commata/wiki/Code-page)
```
1∑
```
## Explanation
```
1∑
1   push 1
 ∑  pop everything and push the sum of the stack
```
[Answer]
## JavaScript (ES6), 63 bytes
Prints either `1` or `2` through an alert dialog.
### Original
```
clearTimeout((t=this).x),t.x=setTimeout(`alert(${t.n=-~t.n})`);
```
### Doubled
```
clearTimeout((t=this).x),t.x=setTimeout(`alert(${t.n=-~t.n})`);clearTimeout((t=this).x),t.x=setTimeout(`alert(${t.n=-~t.n})`);
```
]