[Question]
  [
# Challenge description
On some channels on a popular streaming site [twitch.tv](https://www.twitch.tv) a common message people tend to spam in chats to bait people into spamming "LUL" is
```
One more LUL and I'm out
```
[LUL](http://files.gamebanana.com/img/ico/sprays/57822c19e1ad1.png) is a popular emote used to express that something funny happened on stream.
Soon dank memes showed their potential and a parody of the copy-pasta ensued:
```
One more "One more LUL and I'm out" and I'm out
```
Which is the same message nested in itself. Given a non-negative integer `N`, output the LUL-pasta nested `N` times in itself following the pattern below.
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply, the shortest code in bytes wins.
# Sample input / output
```
0: One more LUL and I'm out
1: One more "One more LUL and I'm out" and I'm out
2: One more "One more "One more LUL and I'm out" and I'm out" and I'm out
...
7: One more "One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
```
# Notes
* Leading/trailing newlines are allowed
* Capitalization must be preserved
* Your code may be a full program or a function
* Instead of printing, you may return a string or its equivalent in your language of choice
* You may index from `1` instead of `0`
  
[Answer]
# [Python 2](https://docs.python.org/2/), 56 bytes
```
lambda x:('"One more '*x+'LUL'+' and I\'m out"'*x)[1:-1]
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQYaWhruSfl6qQm1@UqqCuVaGt7hPqo66trpCYl6LgGaOeq5BfWqIElNCMNrTSNYz9X1CUmVeikKaRmVdQWqKhqfnfGAA "Python 2 – TIO Nexus")  
It is 1-indexed
[Answer]
# JavaScript, ~~57~~ ~~56~~ ~~54~~ 52 bytes
```
f=q=>`One more ${q?`"${f(q-1)}"`:"LUL"} and I'm out`
```
Test Snippet:
```
f=q=>`One more ${q?`"${f(q-1)}"`:"LUL"} and I'm out`
```
```
<input type=number min=0 oninput=o.textContent=f(+this.value)>
<p id=o>
```
For some reason the snack snippet is being buggy when the input is `0`, but this works otherwise. Call it like `f(4)`.
### Explanation
```
f=q=>                      //declares a function f with argument q
`One more ... and I'm out` //hardcoded string
 ${q?`"${f(q-1)}"`:"LUL"}  // does recursion based on q
                           // if q is true, ie not 0, recurse
                           // else return "LUL"
```
[Answer]
# Befunge, 91 bytes
```
&:00p10p>"tuo m'I dna "1v
09p00-1<^g09p01-1_v#:g0<<vg
>>00g:#^_$>:#,_@  >$"LUL">" erom enO"
```
[Try it online!](http://befunge.tryitonline.net/#code=JjowMHAxMHA+InR1byBtJ0kgZG5hICIxdgowOXAwMC0xPF5nMDlwMDEtMV92IzpnMDw8dmcKPj4wMGc6I15fJD46IyxfQCAgPiQiTFVMIj4iIGVyb20gZW5PIg&input=Nw)
This is a breakdown of the source code with the various component parts highlighted.
![Source code with execution paths highlighted](https://i.stack.imgur.com/ABz0G.png)
![*](https://i.stack.imgur.com/jmV4j.png) We start by reading the repeat count *N*, and storing two duplicates of it in memory.  
![*](https://i.stack.imgur.com/z4eIY.png) We then countdown the first *N*, pushing multiple copies of " and I'm out" onto the stack in reverse. Each additional copy is separated from the one before with a quote. The quote is generated with the sequence `90g` (basically reading a copy from the first line of the source), since that's the shortest way to do so.  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~30~~ 29 bytes
```
…LULIF“"One€£ ÿ€ƒ I'm€Ä"“}}¦¨
```
[Try it online!](https://tio.run/nexus/05ab1e#@/@oYZlPqI@n26OGOUr@eamPmtYcWqxweD@QPjZJwVM9F8g43KIElK2tPbTs0Ir//40B "05AB1E – TIO Nexus")
Different string-types doesn't seem to mix well, so for some reason I need to end the loop twice.
[Answer]
# C++, 118 + 16 = 134 bytes
```
auto L(int x){std::string k="One more LUL and I'm out",r=k;for(int i=0;i++<x;)r.replace(i*10-1,3,'"'+k+'"');return r;}
```
`#include<string>` - +16
replaces "LUL" to the whole string N times.
Anyone has better golfs?
[Try it online!](https://tio.run/nexus/cpp-gcc#TY/BboMwDIbveQqLHYDBaKveGuBeKdJOPEBG3M4DnCokUqeqz84CO2wXy/5kf/q9vBD3YzAI9ewd8bUVf4RsZKinVujgLaiM2MM9f8zenE6/6zA0yTsjTNYhqE6BZgPndAIbfFK6ZpAX67Y7avaSiqK@y9xVDm@j7jGj18P@7VAeyzRJi6GINZcOfXAMTj5ht/OfCJfAvSfLYtVMmjjLxUPAOnVKCtji9MTQtv9BTAB1HVN3Kl@bjSKbUUbvN84laPiw2xNfdsAqCg2iqcRzWY4/)
Massive thanks to **Kritixi Lithos** and **hvd**, for, uh, Massive help.
[Answer]
# Javascript (ES6), 68 Bytes
```
f=(x,y="LUL")=>~x?f(--x,`"One more ${y} and I'm out"`):y.slice(1,-1)
```
Call like `f(n)`.
You can also call it like `f(n, "LUL")` and replace LUL with any word you wish.
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~39~~ 37 bytes
Two bytes with the help of @KritixiLithos for coming up with the substitution method
```
iOne more LUL and I'm outÀñÓLUL/"."
```
[Try it online!](https://tio.run/nexus/v#@5/pn5eqkJtflKrgE@qjkJiXouCpnquQX1oifbjh8MbDk4Gi@kpCekr///83AwA "V – TIO Nexus")
Hexdump:
```
00000000: 694f 6e65 206d 6f72 6520 4c55 4c20 616e  iOne more LUL an
00000010: 6420 4927 6d20 6f75 741b c0f1 d34c 554c  d I'm out....LUL
00000020: 2f22 122e 22                             /".."
```
[Answer]
# Java, 79 77 bytes
Golfed:
```
String f(int l){return"One more "+(l<1?"LUL":'"'+f(l-1)+'"')+" and I'm out";}
```
Ungolfed, with test:
```
public class OneMoreLulAndImOut {
  public static void main(String[] args) {
    OneMoreLulAndImOut obj = new OneMoreLulAndImOut();
    for (int i = 0; i < 8; ++i) {
      System.out.println(Integer.toString(i) + ": " + obj.f(i));
    }
  }
  String f(int l) {
    return "One more " + (l < 1 ? "LUL" : '"' + f(l - 1) + '"') + " and I'm out";
  }    
}
```
Program output:
```
0: One more LUL and I'm out
1: One more "One more LUL and I'm out" and I'm out
2: One more "One more "One more LUL and I'm out" and I'm out" and I'm out
3: One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out
4: One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
5: One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
6: One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
7: One more "One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
```
[Answer]
# Python, 79 bytes
I just wanted to do a recursive solution, even though it's longer than other answers.
```
x='"One more %s and I\'m out"'
f=lambda n,s=x:n and f(n-1,s%x)or(s%"LUL")[1:-1]
```
[**Try it online**](https://tio.run/nexus/python2#@19hq67kn5eqkJtflKqgWqyQmJei4BmjnquQX1qipM6VZpuTmJuUkqiQp1NsW2GVB5ZP08jTNdQpVq3QzC/SKFZV8gn1UdKMNrTSNYz9X1CUmVcCVGGgyQVjGiKYRgimueZ/AA)
[Answer]
## C#, 125 bytes
```
n=>{string f="One more {0} and I'm out",s=f;for(int i=0;i++<n;)s=string.Format(s,$"\"{f}\"");return string.Format(s,"LUL");};
```
[Answer]
# C, 140 111 bytes
My first attempt at a golfing question..
Golfed:
```
#define F printf(
#define P 1&&putchar(34)
int a=0;void q(n){a=a?a:n,n?n>0?F"One more "),n-P:n?n+P,F" and I'm out"):0:F"LUL"),n+a?q(n-1):0;}
```
I have come to realise is the wrong output since q(0) just gives LUL.
The next attempt:
```
#define o(Q) O(Q,n?34:0);
#define O printf
void q(int n){o("One more %c")n?q(n-1):O("LUL"),o("%c and I’m out")}
```
Example program (tested with GCC on OSX):
```
#define o(Q) O(Q,n?34:0);
#define O printf
void q(int n) {o("One more %c")n?q(n-1):O("LUL"),o("%c and I’m out")}
int main() {
    q(0),putchar('\n');
    q(1),putchar('\n');
    q(2),putchar('\n');
    q(3),putchar('\n');
    return 0;
}
```
Gives output
```
One more LUL and I’m out
One more "One more LUL and I’m out" and I’m out
One more "One more "One more LUL and I’m out" and I’m out" and I’m out
One more "One more "One more "One more LUL and I’m out" and I’m out" and I’m out" and I’m out
```
[Answer]
# Mathematica, ~~69~~ 68 bytes
*Thanks to Martin Ender for saving 1 hard-to-find byte!*
```
""<>Nest[{q="\"",{"One more ",#," and I'm out"},q}&,"LUL",#+1][[2]]&
```
Unnamed function taking a nonnegative integer argument and returning a string. `Nest` applies a function repeatedly to an initial argument; in this case, the function is to surround its argument by the appropriate words and quotation marks. We start from `"LUL"` and iterate `N+1` times; that results in unwanted quotation marks enclosing the entire phrase, but `[[2]]` keeps only the stuff between them. At the end, `""<>` turns the resulting heavily nested list into a single string.
Previous submission:
```
""<>Nest[{o,q="\"",#,q,a}&,{o="One more ","LUL",a=" and I'm out"},#]&
```
[Answer]
## C#, ~~119~~ ~~85~~ 71 bytes
```
string m(int n)=>$"One more {(n<1?"LUL":$"\"{m(--n)}\"")} and I'm out";
```
*Saved 14 bytes thanks to @Luc*
[Answer]
## [Retina](https://github.com/m-ender/retina), 51 bytes
```
.+
$*00LUL1$&$*
0
"One more 
1
 and I'm out"
^"|"$
```
[Try it online!](https://tio.run/nexus/retina#U9VwT/ivp82lomVg4BPqY6iipqLFZcCl5J@XqpCbX5SqwGXIpZCYl6LgqZ6rkF9aosQVp1SjpML1/78BUMaIy5jLhMsUAA "Retina – TIO Nexus")
[Answer]
## R, 97 bytes
```
function(n){s="One more LUL and I'm out";while(n){s=sub("LUL",paste0('"',s,'"'),s);n=n-1};cat(s)}
```
Ungolfed:
```
function(n) {
  s = "One more LUL and I'm out";
  while(n) {
    s = sub("LUL", paste0('"', s, '"'), s);
    n = n - 1
  };
  cat(s)
}
```
[Answer]
## R, 100 97 92 bytes
*"One more recursive function and I'm out"*
```
f=function(n)paste("One more",`if`(n<1,"LUL",paste0('"',f(n-1),'"')),"and I'm out");cat(f(scan()))
```
Edit: Turns out that a non-recursive approach is slightly shorter:
```
x="One more ";y=" and I'm out";cat(x,rep(c('"',x),n<-scan()),"LUL",rep(c(y,'"'),n),y,sep="")
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 39 bytes
*Thank you @ETHproductions for helping.*
```
`"O Ú `p°U +"LUL"+` d I'm t"`pU)s1J
```
[Try it here!](http://ethproductions.github.io/japt/?v=1.4.3&code=YCJPmiDakCBgcLBVICsiTFVMIitgIIRkIEknbSCMdCJgcFUpczFK&input=Nw==)
[Answer]
# Ruby, 51 bytes
One-indexed. [Try it online](https://repl.it/FOl9)
```
->n{['One more ']*n*?"+'LUL'+[" and I'm out"]*n*?"}
```
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), ~~72~~ 67 bytes
```
"$('"One more '*($c=1+"$args"))LUL$(' and I''m out"'*$c)".Trim('"')
```
[Try it online!](https://tio.run/nexus/powershell#@6@koqGu5J@XqpCbX5SqoK6loZJsa6itpJJYlF6spKnpE@oDVKCQmJei4KmunquQX1qipK6lkqyppBdSlJkL1Kuu@f//fyMA "PowerShell – TIO Nexus")
[Answer]
## Lua, 101 bytes
```
i,f,g='"One more ',' and I\'m out"',io.read()+1 print((i:rep(g).."LUL"..f:rep(g)):sub(2,g*24-(g-2)))
```
Obvious string attempt. Repeats `"One more` and `and I'm out"` exactly input + 1 times, with a `LUL` inbetween, then removes first and last quote.
[Answer]
# Haskell, 51 bytes
Indexes from 1.
```
f 0="LUL";f n="One more \""++f(n-1)++"\" and I'm out"
```
[Answer]
# Ruby, 70 bytes
```
def l x,t="LUL";x.times{t='"One more %s and I\'m out"'%t};t[1..~1];end
```
Simply loops for the amount it's given, surrounding the last string via a format string each time.
Index starts at one.
[Answer]
# Stacked, 54 bytes
```
('"One more ' ' and I''m out"')*'LUL'join'^.|.$'εrepl
```
[Try it here!](https://conorobrien-foxx.github.io/stacked/stacked.html) Example usage of "function":
```
1
('"One more ' ' and I''m out"')*'LUL'join'^.|.$'εrepl
out
```
---
One for 56 bytes:
```
@n'One more LUL and I''m out':@o['LUL' '"'o'"'+ +repl]n*
```
[Answer]
# Python 3, 68 Bytes
`def f(a):return('"One more '*a+'LUL'+(' and I%sm out"'%"'")*a)[1:-1]`
[Answer]
# CJam, ~~51~~ 49 bytes
```
" and I'm out\"""\"One more "li1+_@*"LUL"+1>@@*W<
```
[Try it online](https://tio.run/nexus/cjam#@6@kkJiXouCpnquQX1oSo6SkFKPkn5eqkJtflKqglJNpqB3voKXkE@qjpG1o5@CgFW7z/78hAA)
### Ungolfed:
```
" and I'm out\""   "\"One more " // Push two strings to the stack
     l i 1 +                     // Read a number and add 1
     _ @                         // Copy number and rise '"One more ' to the top
     *                           // Multiply '"One more ' by a number
     "LUL" +                     // Add "LUL"
     1>                          // Chop the first quote
     @@                          // Push the result down
     *                           // Multiply ' and I\'m out"' by a number
     W<                          // Chop the last quote
```
[Answer]
## Groovy, 54 bytes
```
{x->('"One more '*x+'LUL'+' and I\'m out\"'*x)[1..-2]}
```
Pretty straightforward, same as the python answer but 2 bytes shorter. It is also 1-indexed.
[Try it Online!](https://tio.run/#5e255)
[Answer]
## Mathematica, ~~65~~ 63 Bytes
```
Nest["\"One more "<>#<>" and I'm out\""&,"LUL",#]~StringTrim~_&
```
Two bytes off by noticing the challenge allows 1-indexing.
[Answer]
# PHP
Hello, i found so far two ways for doing this.
The replacement way 1-indexed **(121 bytes)**.
```
function f($x){$v='One more LUL and i\'m out';$t=$v;for($i=1;$i<=$x;$t=str_replace('LUL','"'.$t.'"',$v),$i++);return $t;}
```
The recursive way **(86 bytes)**.
```
function r($n){$v=($n==0)?'LUL':'"'.r($n-1).'"';return'One more '.$v.' and i\'m out';}
```
[Answer]
# C++, 80 + 16 = 96 bytes
```
std::string L(int c){return"One more "+(c?'"'+L(--c)+'"':"LUL")+" and I'm out";}
```
`#include<string>` - +16
Ungolfed:
```
std::string LUL(int count) {
    return "One more " + (count? ('"' + LUL(--count) + '"') : "LUL") + " and I'm out";
}
```
Calls itself recursively and uses string addition. Pretty straight forward. I mean what else can I say? Even the ungolfed version is essentially a one liner.
[Try it online!](http://cpp.sh/4mcgj)
[Answer]
# [Cheddar](http://cheddar.vihan.org/), 71 bytes
```
i->('One more "'*i).slice(0,-1)+'LUL '+('and I\'m out" '*i).slice(0,-2)
```
[Try it online!](https://tio.run/nexus/cheddar#K0ssUkiz/Z@pa6eh7p@XqpCbX5SqoKSulampV5yTmZyqYaCja6ipre4T6qOgrq2hnpiXouAZo56rkF9aoqSAqs5I839BUWZeiUaahqmm5n8A "Cheddar – TIO Nexus")
]