title: "DDoouubbllee ssppeeaakk!!"

text:
# Question
Title: "DDoouubbllee ssppeeaakk!!"
Super simple challenge today, or is it?

I feel like we've heard a fair bit about double speak recently, well let's define it in a codable way...

Double speak is when each and every character in a string of text is immediately repeated. For example:

```
"DDoouubbllee  ssppeeaakk!!"

```

---

# The Rules

* Write code which accepts one argument, a string.
* It will modify this string, duplicating every character.
* Then it will return the double speak version of the string.
* It's code golf, try to achieve this in the smallest number of bytes.
* Please include a link to an online interpreter for your code.
* Input strings will only contain characters in the printable ASCII range. Reference: http://www.asciitable.com/mobile/

---

## Leaderboards

Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

```
var QUESTION_ID=188988;
var OVERRIDE_USER=53748;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="<h1>"+q.body.replace(OVERRIDE_REG,"")+"</h1>")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery("<i>"+n.language+"</i>").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
```

```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}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="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <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><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><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>
```

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

```
# Language Name, [Other information] N bytes

```

where `N` is the size of your submission. Other information may include flags set and if you've improved your score (usually a struck out number like `<s>M</s>`). `N` should be the right-most number in this heading, and everything before the first `,` is the name of the language you've used. The language name and the word `bytes` may be links.

For example:

```
# [><>](http://esolangs.org/wiki/Fish), <s>162</s> 121 [bytes](https://esolangs.org/wiki/Fish#Instructions)

```

# Answer
# Malbolge, 20775 and 2334 bytes

Probably I didn't beat anyone with it, but it was incredibly fun to make.

```
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPNdchKIeHFbaD_AWV[><X;9U86R53ON1L.DCH+)EDC&;@#>=<;|98x6wu32s0p(',mk)(i&f|{"ca}`^z][wZXtWUqTRnmPNjcbJJ_dcbEDYB@@?ZSX;VUTS6QPO11F..CHGF)(C<A$?>=<}:98xx/uu,10/po,+$kiih%$#z!b}|{z]xwvXXmUUjonmPOjihafIdcbaD_^]??T<<QVUT76QPONG0..-HGFED=B%@?>=~|438yw5vt21r/o'&+lj(ig%fd"ca}`^z][wZXtWUqpoRQlkjihafIdcbaDBXW\?=YX;9UNMR53O20//DIH+)E>=B%#?"~<}{9zx6wu3tr0/pn,%$jj!&%$ed!~}|{zs\ZZYtsrqponglOjiLgfHdGEaDB^]@[=SRW:8T75Q42N1/K.,HG*E'=<A$"!!6;:{8x0/4us1rp.-,ml)('&%$#z!b}|{zy[qvutsUkTinmlejchKIIH]bE`_^A\[=Y<:VU86RKJO20LK.,HA@E(&BA$">76;|z8yw5vt2sq/pn,mkjj!&%$edy~a|{z][qpuXVUUjonQOkdchKIHH]baD_AWV[><;;PUT7R4JIN1/K.,H+)E(&B%#?"~<}{zz1654ut1*qoon+*#(i&%$e"!~``uzy\ZvonsVTSShmlOjLbafIGFF[`_B@\UTY<:99NSR53OHGL/-I,*F)'C&$@#!=~|:{y765vu21*/pnnm*)(!h%$#d!~}__tyx[vXnmrUSoRPlkNiKa`eHFbECBBW\[>Y;QPU86R53O20L/-I,*F)'&&;@?>!~;:92ywwv3210).o,+*k('g%fd"ca}`^z][wZXtsVqSihmPNjiLgI_^cFD`_B]?UTY<:VUT76QPONGL/--,GFEDC<%@?>!<;:98yw5.-2sq/.o,l$#(ig%fd"!b`|uty\ZYYnsrUpRhglOMiLJfIGcFD`CA]@>==RWVU87RQPONG0..-HGFEDC<A$?>!<;:zz1ww.321rq.-,+*)"'hffe"!~}|{zyrwZutsVqpoQQfkjMhJ`_dGEaDBAAV[Z=;WPOT75Q4211FKJ-+G@?D'%A$">!};|z8yw5vt210qp-,+*)('&}$e"!~}|^tyxwvXnWlqpohmfkNLLK`IdcbE`_^]\?=YRQV97S64P31ML/J,BAF)'CB%@"87<}{9zx6wu3tr0qo-nlkk"'&%fezcaa`{ty\wvuXsrTpSQmPNjiLJf_^cFD`_B@\UTY<:V97S64P31M0.J-+GFE('B;@#!!~;:3z765v321qq(-,m*j"!&ge#db~}`{]srwZXtWUTTinmPkMcbgJHdGEaDB^A?[><X;988MRQP32MLE.,,+FED=B%@?>!}549zxww.32sq/(',mk)(i&f|{"ca}`^z][wZXtWUqTRnQOkNLhgfIHcbaZ_B@@?ZYXWP9TSR5PON00EJI,*F?>C&$##8=<}:z216wu32s0p(',mk)jh&ge#db~a_{^\x[YuXVUUjonmPOjihg`IdcFa`BAAV[Z=;WPOT75Q42N1/K.,HGF)(CBA@?8=~;:9z76v43tr0)(-nl*)j'g}|#db~a_^^sxwZXtmlqTRnQOkNLhKIeHFbEC_^]@?ZYXWVUN7554ONMLKJIBG*EDC&$:9!!6;:9zy6543210/(o,+*)(h~%$#"bxav{tyxwpuXVVUjoRmlkNihJfIGcFD`CA]@>ZY<:VONS64PO2M/EDI,*F)'C&$@#!=~|:98yx/4u21r/.-mm$)(i&f|{"ca}`^z][wZXtWUqTRnQOkjMhJ`_dGEaDB^A?>>SXWV98SL5332MLEJ-HGF)DC%A@#>~65:{y76w4t,+0qo-,m*j"!&ge#"c~`vuz][wZXtWUqTRnQOkNLhgfIHcb[`C^]\[>YXW99N66KPON10KJIB+))(CBA@9>!<;:9z765uu,10q.n&%*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJfIGFF[`_^A@[ZYXQV9TSRQ4ON0L/-,,AFE(C%;:?"~<;|z8105vtss*/.o,l$#(ig%fd"ca}`^z][wZXtWUTTinmlONihgfe^GEED_^]\[ZSX;VUT7RQP22GLK.I+A@E(&%%:?>!};438yw5vtss*/.om+$#(ig%$ec!xw|_]y\ZvYWsVTpSQmPNMMbgfeHGba`_^]V[>YX;VUTSR53OHGL/-,,AFE(C%;:?"~<;|9y105vt2sq/pn,mk)jh&ge#db~a_{zy\[vutsrqpiRmlkjiKafedcE[DY^]\UZSX;VUT7RQ322GLK.I+A@E(&BA$">76;|z8yw5vt2sq/pn,mk)jh&geddy~}|_^s\ZZYtmrUponQlkMihKIe^]bEC_^A\>TSX;988MRQ4O1GFK.,HG*E'=<A$">!};|z8yw5vt2sqpp',+*kj'~%f#"!b}|^z][wvYWslkpSQPPejiLJf_^cFD`_B]?UTY<:VU8S5KJO20L/-I,*F)'CB%#?87<;:{z76/vtts0/.',m*)(i&%$ddy~}`{]srwZXtWUqpSnPfejMKgJHGG\a`C^@VUZ=;W:8T75Q42N1/K.,++@EDC&%@?>7<}{{z7654-t10/p-,l*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJII^cbaDC^]\[T=;;:UTSRQJO2MLK.IHGFE(&B;:?"~<}{98y6v.-2sq/pn,mk)jh&ge#db~a_{^\xwvYXsrqpohmPNNMhgfedc\E`_^A\[=YX;9UNMR53O20L/-I,*F)'C&$@#!=~|:{yxx/432sr/.-,+*#jhhg$#"!~}|uz]xwvYtsUqpSnPfejMKgJHdcFaCYX]@>Z=;WV9T6LKP31M0.J-+GF)D&<;@?>!~;:98765.3trrq.-,+*)('~g$#"c~}|{z][wpotWUqTRnQOkNLhgJeG]\aDB^]@[=SRW:8T75Q42N1/..CHGF)(CBA@?>=<5|98765u-210/o'n%*)(!&}$eccbw|_zyx[vuWsVTSShmlOMibafIGFF[`_B]?UTY<:V97S6433HML/-IBAF)'C&$@#!=~|:{y765vu,1r/.-nl$#(igff{"!b}_uty\ZYYnsrUSohglOMiLJfIGcFD`CA]@>Z=;W:877LQPO21LE.,,+FE>C&A@?"=<|{{276wu3,+0qonn%*)j'g}|#db~a_{^\x[YuXVrUSoRPlOMihgJIdc\aD_^]@[Z<XW:U7MLQ42N1/K.,H+)E(&B%#?"~<}{9zxww.321rq.-,%ljji&%$#z!b}|{^yxwYYnsrUSohglOMiLJfeHcE[Z_B@\?=Y<:V97S64P31M0.J-+**?DCB%$?>=<5:{876w432rr).-n+k#"'hf$#d!awv{^\xwZXtmlqTRnQOkNLhKIeHFbEC_B@\?=YXW:9TSRQPI200/JIHGFE>C&A@#!76||3876wv3210/.',m*)j'&%eez!~a_{tsx[YXXmrqTRngfkNLhgJeG]\aDB^A?[><;;PUTS65PONMLKJC,**)DCBA@?>=6;|987x54t21r/o'&+lj(ig%fd"ca``uzy\wYonsVTpSQmPNjMKgfIGc\[`_^A@[ZYXWVUTMR5PONML.DIHGF(>'<A@9>=6;|98y654tt+0/p-m%$)('hg|eccb}v{^yxwZutVrqToQgfkNLhgJeG]\aDBAAV[Z=X:POT7544INM0.JCBG*(D'%A$">!};|z8yw543ts0).o,+*)j'&%eezbbw|{z]\wvoXVVUponglOjihgJedcEEZ_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{9zx6wutt+0/.on+*)"'h%$#"c~}|^^sxwZuWmlqTRnQOkjMhJ`_dGEaDB^A?[><X;9U86R53ON1L.DCHGF)(CBA@9"~~}:9876/4u210/p-,l*kihh}$#db~wv{^\[[putWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U8655JONM0/JIHGF?D'BA@?"=<;{{2xx/432sr/.-,+*)(!h%$#"!aw|{zy[qZotsrkpinQOONchKfedcFa`B^A?[Z=X:POT7544INM0K-CBG*(D'%A$">!};|z8yw5vtss*/.-nm$)j'&%$e"!a}`^]]rwvYWslkpSQmPNjMKgJHdGEaDB^A?[ZY<;VO8665POHM0KJ-HGFED'%A:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhg`eHFFE`_^]V[>YXW:UTS55JON1L.DCH+)E(&BA$?!76;|z8yw54u2r*).om+lj('h%e{z!b`|{z]\wvutmrUponQOediLJII^cbEC_XW\?=Y<:V97S64P31M0.J-+G*(D'%$$9>=<}|98765.ussr/.-,+*#(i&%$e"!~``u]]rwvuXWrqponmfkNihKfeGcFD`CA]@>==RWV9T6LKP31M0.J-+G*(D'%A$">=<}|9876543,s0/p-,lkk"'&ge#zy~a_{^\x[YutWUqjinQONNchgfIHcba`_^]\UZ=XWVUT6LQPON0F/DIHG@E>C&A@#>=<||387x5u-,1rp.om+lj(ig%fd"ca}`^zy\wYonsVTpSQmPNMMbgfeHG\ECCB]V[>YXW:UT6R53O20//DIH+)E>=B%#?>!<|438yw5vt21rp.'&+lj(ig%fd"ca}`^zyx[ZunsVqpoRmlNjiLJf_^cFD`CA]@>Z=;WV9T6LKP31ML/J,BAF)'CB%@"87<}{zz1654ut10)pnnm*)(!&g$#"cawv{^\xwZuWmlqTRnQONNchgJeG]\aDB^]@[=SRW:8T75Q42N1/K.,H+)((=BA@#"=<;49z765v321qq(-,mk)"!&ge#"c~`vuz][wZXWWlqpSQmfejMKgfIGc\[`CA]@>Z=;W:8T75Q42NML/.IHGF?(&&%@?>=<5:{876w432rr).-n+k#"'hf$ec!~a|^tsx[YuXVUUjonQlNdchKIeHFbEC_B@\?=Y<:99NSRQ43NMLKJCH+))(CBA@?>7~;:9z76v43t1q)(-nl*ki'hf$ec!b`|_]y\ZvYWsVTSShmlkNMhgfedc\ECCB]\[ZYXWPU8SRQ4ONMLK.,HA@E(&BA$?!76;|z8yw5vt2sq/pn,mk)jh&ge#db~}|_^yxwvutslqTRRQlkjihgfe^Gba`C^]?[Z=;WPOT75Q42N1/K.,H+)E(&B%#?"~<}{zz1654ut10/.-,+*#j'&%$#cy~}|{]s\qvunsrkpSQQPejMhgfIdcEa`C^@VUZ=;WV9T6LKP31ML/J,BAF)'C&$@#!=~|:{y7xv4usrr).-,ml#(iggf#zc~}|_zy[wZXtsVTpihmPNjMKgfIdF\[`CA]\?Z<RQV97S64P31M0.--BGFE('B;$""!<;49z765v32r0qonn%*)jh&}|#dbaav{z]xZpotWUqTRnQONNchgJHd]\aDB^A?[><X;9U86RQP32MLEJ-++*EDC<%@?>!<;{9zx6wu3tr0qonn%*)j'g}|#db~}`{]srwZXtsVqSihmPNMMbgfIGc\[CCX]\[>=XWVO8665PONMFK.IHG*ED&B%#?>!<|438yw54u2r*).omll#('hf${z!b`|{^y[qpuXVrUSoRPlOMLLafedGFa`_^W\?ZYX;VU7SR5P2HGL/-I,*F)'C&$@#!=~|:{y7xv4usrr).-,ml)('&%|eccb}|{zyxqvYtsrUSihmPNjMKgfIdF\[`CA]@>Z=;WV9T6LKP31M0.J-+G*(''<A@?"!<;:98705v321rp(',mk)jh&%fd"yx}`^z][wZXtsVTpihmPNjMKgJHdGEaDBAAV[ZY<;VUTSRQPI200/JIHGFEDC<A$?>=~|438yw54u2r*).om+lj(igff{"!b`|uty\ZvYWsVTpSQmPNjMKgfeHGba`_^]\[TY<WVUTS5KPONM/E.CHGF?D=B%@?>!<;{9zx6wu32s0p(',mk)(i&f|{"ca``uzy\wYonsVTpSQPPejiLJf_^cFD`CA]@>Z=;W:8TSR54I200/JCH+FED'BA#?"~<}{98y6v.-2sq/pn,mk)(ig%|{"ca}`^z][wZXtsVqSihmPNMMbgfeHGb[`C^]\?ZY;WV97SLKP31M0.J-+G*(D'%A$">!};|z8ywvv-210qp-,%ljji&%${"c~}|_zy[wvYtVlkpSQmlOjLbafIGcbE`BXW\?=Y<:99NSR5P2HGL/-I,*F)'C&$##8=<;|{876/4u210q.-,ll#('hf${z!b`|{^\xqpuXVrUSonQlNdchKIedGEaZY^A?[><X;9U86R53O20//DIHG*)DCBA:#!!~;:98705v321r/.-mm$)(i&f|{"ca}`^zy\wYonsVTpoRmOediLJII^cbE`BXW\?=YX;V8NMR53O20L/-I,*F)'&&;@?>!~;:98705v321r/.n,mk)jh&ge#"ca}vuz][wZXtsVTpihmPNjMKgJHdGEa`C^@VUZ=;::OTSR54ONMLKJC,**)DCBA@?>7<}:98y65u3tr0qonn%*)j'g}|#db~a_{z]xZpotWUqTRnQOkNLhgJHd]\a`_BA\[ZYXWVOT7RQP3NM/KJ-H*@?D'%A$">!};|z8yw5vt2sq/pn,mkjj!&%$ed!~}|{zyxqZutsrqSinmlkMcLafed]b[`CAA@UZ=XWV9TS544INM0.JCBG*(DC&$@98=~|:{yxx/43tr0)(-nl*ki'hf$ec!b`|{^y[qputsVUjoRmlkNihJII^cbE`BXW\?=<<QVU8S5KJO20LK.I+A@E(&BA$?!76;|z87x5u-,1rp.om+ljii~%$#dc~w`^^]xwpuXsrqTonmOOdihKIe^]bEC_B@\[><XQPU86R5322GLK.,HA@E(&B%#?"~<}{9zx6wutt+0/.on+*#(i&%$e"!a}`^z][wZXtWUqTRnQOkNLhKIedcFE`_^W@>>=XWVUNS6QPO2ML.JI,G)?>&&;@?>!~;:9816w43tr*).omll#('h%e{z!b`|{^y[qpuXVrUSoRPlOMiLJfIGcFD`CA]\[>=XWVUTM6QP3NML..CHG*(D=<A$"!!6;:{y70/4us1rp.om+lj('&gf#"!~}|uz]xwZutVrqToQgfkNLhKIeHFbEC_B@\?=YX;V8NMR53O20L/-IHG*)DCBA@?>7~||{87654321*/p-,+l)('gg|#"ca}vuz][wZXWWlqpSnPfejMKgJHGG\a`C^@VUZ=;WV9T6LKP31MLK.-HGFEDCBA:?"=<;:9y16543s+r).',+*#(i&%$e"!~}|_]yrqvYWsVTSShmlOMibafIGFF[`_B@\UTY<:V97S64P31M0.J-+G*(''<A@?"!6}:9z76vuu,10qo-&%*ki'hf$ec!b`__tyx[vXnmrqpSRmfkNihgJedFbaD_AWV[><XW:U7MLQ4211FKJ-H*@?D'%A$">!};|z8yw5vt2sq/.-nm*)"iggf#"!x}`{z][qpuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20L/-I,*FED'&A@?8=~;:{876vv-21rp.'&+ljii~%$ec!xw|_]yx[vXnmrUSoRPlOMLLafedGFa`_^W@>>=XWVUTMR5PO2ML.JI,G)?>C&$@#!=~|:{y7xv4us1rp.om+ljii~%$#dc~}|{zsx[YYXsrqpongPkjiLgfeGG\a`C^@VUZ=;W:8T75Q4211FKJ-H*@?D'%A$"!!6;:9zy654321*qoon+*)('&%|#d!~}`{zyxwZXtmlqTRnQONNchgJHd]\aDBAAV[Z=;WPOT75QP31MFEJ-+G*(D'%A$">!};|z876wv3210/.-&+l)(i&%eddy~}`^zsrwZXtWUqTRnQONNchgJeG]\a`_BA\[ZYXWVUN7RQPON0FKJIH*@)>CBA:?8=~||{27x543t10/oo&+*k(h~}$ec!~a|^tsx[YuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20LKJ-,AF)DC&$:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhaJedGba`BBW\[><XQPU8655JON1/KDCH+)E(&B%#?"~<;:{z76/4u21r/.n,+l)i!~%fd"ca}`^z][wZXtWUqpSnPfejMKgJHdGEa`_BA\[ZS<::9TSRQJO2MLK.IH*F)'C&$@#!=~|:{y7xv43t1q)(-nl*ki'hf$#d!awv{^\x[YutsVUponmfkNihgJedFbaD_AWV[><;;PUT75QJIN1/..CHG*(D=<A$">=~|:327xv4us1rp.om+lj(ig%$#dc~}|{zs\wvYtsUTTinmPNjcbgJHdGEaDB^A?>>SXW:U7MLQPO21LKJIHG@E(CBA$"87}}4987xw43210/.'nllk('&%$#"!x}`{z][qpuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20L/-I,*FED'&A@?>=<;:38y65432r*/.-,l$k"'&%|#z!b}|_zyxZZotsVTpihmPNMMbgfIGc\[`CA]\?Z<RQV97S64P3100EJIH+*?(&&%@9>!<;|98x65v3s+*/pn,mk)jh&ge#db~a_{^\x[YuXVUUjonmPOjchKIIHcb[D_^]@[Z<XW:8TMLQ42N1/KJ-H*@?D'%A@#>~65:{y7xv4us1rp.om+ljii~%$#dc~}v_]]\wvunsVqpSnmONNchgJHd]\aDB^]@[=SRW:8T75Q42N1/KJ-H*@?D'%A$">=~|:327xvuu,10/po,+*#(iggf#"!~}v{^yx[YonVVkponQPkjihg`eHFFE`_^]\[T=XWV9TS5Q42N1/K.,H+)ED'%A:9>!};|z87x5u-,1rp.om+lj(ig%$e"bxw|_]\\qvutWVqponmleNihKfeGcFDCCX]\?Z<RQV97S64PO20LEDI,*F)'C&$@#!=~|:{yxx/432sr/.-,+*)"'h%$#d!~`|{^y[qpuXVrqToQgfkNLhgJeG]\aDB^A?[><X;9U86R53O20//DIHG*)DCBA@?>=6}:9876v.3210p(o&+*#('~%fddcx}`{z]xwYutWrTjinQOkjMhJ`_dGEa`C^@VUZ=;W:8T75Q42N1/K.,H+)((=BA@#"7<}:9z765uu,10qo-&%*kihh}$#db~wv{^\xwZuWmlqTRnQOkNLKK`edcFE`YB@@?ZYRW:UTS6QP2NM0K-CBG*(DC&A#98=~|{{276wu3,+0qo-nl*ki'hf$ec!b`|_]yxwZYtslqTonQlkjLLafeHcE[Z_^]@?ZYXQ:887RQPOHM0KJI,GF(D'%A$">!};|z8yw54u2r*).om+lj(ig%fdccx}|_z\rqvYWVVkponQPkjihafIdcFDZY^A?>>SXW:U7MLQ42NM0K-CBG*(D'%A$">!};|z8yw5vt2sq/.-nm*)('&}f#"c~}|^^sxwZXtmlqTRQQfkjMKg`_dGEaDB^A?[><XWV98SRQPONGL/--,GFEDCBA:#>=<}:9y7xv4us1rp.om+*k(h~}$ec!b`|_]y\ZvuXVrkjonmPOjihgfed]Fa`C^]\>>SXW:U7MLQPO21LKJIHGFE>C&A@?>=}5:987w/v-210).',m*)(ig}|#db~a_{z][wpotWUqTRQQfkjMKg`_dGEaDB^A?[><X;9U86RQP32G0..-HAF)DC&A@"!!6;:{8x0/4us1rp.-n+k#"'hf$ec!b`|_]y\ZvuXsUkjoRPlOMLLafedGFaZ_B]\?ZYX::OTS64PIHM0.--BGF)'C<;@#!=<}:z216wu3tr0qonn%*)(ih%${dbba|{zsx[vutWrqSonQOkdchKIHH]baD_AWV[><X;988MRQ4O1GFK.,H+)E(&B%#?"~<}{zz1654ut10/(-n+*k('&ff{"!b}_utyxwZYtsrqjSQQPkjihg`eHcbaD_^@??TYX;V8NMR53ON1L.DCH+)E(&BA$?!76;|z87x5u-,1rp.om+lj(ig%$e"bxw|{z]\wvutslqTonmlOjihJJ_GG\a`_BA\[ZYXWVUN7RQPON0FKJIH*@)>CBA:?8=~||{27x5432s0/onn%*)jh&}|#db~}`{]srwZXtWUqTRnQOkNLhKIeHFbEC_B@??TYXW:9NS6QPON1LK-IH+F(>=B%#?"~<;|z8105vt2sq/pn,mk)jh&ge#db~}|_^yr[vutsVqpoQQfNNchgfIHcbaZCAA@[ZYXQV9TSRQ42HGL/-I,*))>CB%@"87<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\[[putsVUponmfkNihgfIdcEaDBAAV[Z=;WPOT75Q42N1/K.,H+)E(&B%#?>=~}:9876/vtts0/.-,+$)j'&ge{z!b`__tyx[vXnmrUSonQlNdchKIeHFbEC_B@\?=Y<:V97S64PON10KJIHGF?D'BA$?>=}}498yw5.-2sqpp',+lj(!~%fd"!b}_uty\ZvYWsVTSShmlkNMhgfedcb[D_^A\[Z<<Q99NSRQ43NMLKJIHG@E(CBA@?!7<;:9y1x/43,10).o,+l)('gg|ddy~}|_^s\ZZYtmrUponQlkjihKIe^]bEC_^A?[TSX;9U86RQ42NGFK.,H+)E(&B%#?"~<}{9zxww.321rq.',mkkj'&}fddc~}|uz]xwvYWmlTTinmlONihg`eHFFE`_^]V?ZYX;VU7S64PO2M/EDI,*F)'&&;@?"=}549zx6wu3tr0qo-nl*kihh}$#"cb}|{zs\wvYtsrTTinmPkMcbgfeHGba`_^W\?ZYX;VU766KPO2M/EDI,*))>CB%#?87<}{9zxww.32sq/(',mk)jh&ge#db~a_{^\xwvYXsrqpongPNNMhgfedcb[`C^]@>TSX;988MRQ4O1GFK.,HG*E'=<A$">!};|z8yw5vt2sq/pn,mk)('hg$#"!~}|uz]xwZutsUUjonQOkdchKIHH]baDB^WV[><XW:U7MLQ42N1/K.,++@EDC&%@?>=<;:92y65432r*/.-,l$k"'&%|#z!b``_ty\wvuXsrqSShmlOMibafIGcbEC_XW\?=YX;V8NMR53O20L/-I,*F)'C&$@#!=~|:98yx/4ussr/(o,+l)('g%$ed!xa__^yxqvYtsrUSihPPejihKJed]bE`_^A\[=Y<:V97SR5P2HGL/-IH+F(>=B%#?>!};438yw5vt2sq/pn,mkjj!&%$ed!~}v_zy\wvuWWlqpSnPfejihKJedcb[`C^]\?=SRW:8T7544INM0.JCBG*(DC&$@98=~|:{y76w4t,+0qo-nl*ki'hfeez!~}`_zyxwvoXVVUponmlkdiLgfeHcbD`_B@\UTY<:VU8S5KJO20L/-I,*F)'C&$@#!=~|:{y765vu210/.-&+l)(i&%$#"ca}vu]]rwvuXWrqponmleNLLKfedcba`_X]@[ZY<WV877LQP3N0FEJ-+G*(D'%A@#>~65:{y7xv43tr0)(-nl*ki'hf$ec!b`|{z]\wvutsrqpinQlkjihJ`edcbDZCX]\[TYRW:UT7RQP22GLK.I+A@EDC&%:#!!~;49z765v32r0/pn,%$)jh&ge#"ca}vuz][wZXtsVqSihmPNjMKgJHdGEDDY^]\?>YRW:UT75KJO20//DIH+F(>=B%#?>!<|438yw5vt2sq/pn,mk)jh&ge#db~}|_^yxqZutWrqpRRglkNLha`eHFEEZ_^A?[TSX;9U86R53O20LKJ-,GFE>C&A@?"=<;{{276wu3,+0qo-,mk)"!&ge#"c~`vuz][wZXtWUqTRnQOkNLhKIeHFba`CB]\[ZS<::9TSRQPIN1LKJ-+A@((=BA@#"=<;:981xvvu210/.-,%*k('&g$#cbbw|{^y[qpuXVrUSoRPlOMiLJfeHcE[Z_B@\[>Y;QPU86RQ4O1GFK.,HGF)(CBA@?>=6;|98y654tt+0/p-m%$)jh&ge#db~a_{^\x[YuXVrqToQgfkNLhKIeHFEEZ_^]@?ZYXWVUTSL5PONML.DIHGF(>'<;@?>=6;|zzy05v321rp(',mk)jh&%fd"yx}`^]]rwvYWslkpSQmPNMMbgfIdF\[`CA]@>Z=;W:8T75QPO21FK.IH+)?>C&$##8=<}:z216wu32s0p(',mk)jh&ge#db~a_{^\x[YuXVrqpSRmfOjiLgfeGG\a`CA]VUZ=;::OTS64PIHM0.J-+G*(D'%A@?"!<;49z765v321qq(-,mk)"!&ge#"ca}vuz][wvYtVlkpSQPPejiLgI_^cFD`CA]@>Z=;W:8T75Q42NML/.IHG@)''&A@?>7<}:98y65u32s0p(',mk)jh&ge#"c~`vuz][wvYWslkpSQmPNjMKgJHdGEDDY^]\?>YXWVOT7RQ4ONM//DIH+F(>=B%#?"~<}{9zx6wu3tr0qo-,m*j"!&ge#db~a_^^sxwvYXsrqpohQOONihgfed]bE`_^A\[=Y<:V97S64P31ML/J,BAF)'C&$@?"=}549zx6wu3tr0/p-m%$)jh&geddy~}|_^yxwvutmrUSSRmlkjihg`IdcbE`_A]@>ZY<:VONS64P31M0.JI,G)?>C&$@#!=~|:{y765vu210/.-,%ljji&%$#"!~}v{^yxwZXnmrUSRRglkNLha`eHFbEC_^A\>TSX;988MRQ42NGFK.,H+)E(&B%#?"~<;:{z76543210).o,+*)(h~%$#"bxav{zyrwpuXsrUponPPeMMbgfeHG\ECCB]V[>YXW:8NMR53O20//DIH+F(>=B%#?"~<}{98y6v.-2sq/.o,l$#(ig%$#dc~w|_zyx[vutsrUSohglOMLLafeHFb[Z_B@\?=YX;9UNMR5322GLK.,HA@E(&B%#?"~<}{9zx6wu321rq.-&m*)jh&%$#"cb}|{ty\wvuXVlkSShmlkNMhgfe^GEED_^]\[TY<WV9TSRQP31MFEJ-+**?DC&A#98=~|:9z7w/.3tr0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpinQOONihgfed]Fa`CAW\[ZY<;VUTSRQJ3110KJIHGFE>C&A@#!76||3876wv3210/.-&+l)('h%$#ccx}|_]yrqvYWsVTpoRmOediLJII^cbE`BXW\?=Y<:99NSR53OHGL/-I,*F)'C&$@#!~~5:98yx543210/.'n+*)('g}$#"!aw`uzyxqvotWrqTonPOOdihKIe^]bEC_B@\?=Y<:V97S64P31M0.J-+GFE('<A$?>=~;:9yy054u2r*).om+ljii~%$ec!xw|_]\\qvuXVrkjoRPOOdihKfH^]bEC_^A\>TSX;9U86R53O20//DIHG*)D=&$$#>=6;|98y65u32s0p(',mk)jh&ge#db~a_{^\x[YuXVrUSRRglkjMLgf_dGbaD_^]??TYX;9UNMR5322GLK.,HA@E(&BA$?!76;|z8yw5vtss*/.-nm*)(!hffe"!~}v{^yxwZutsUUjonQOkdchKIedGEaZY^A?[Z=X:POT75Q42N1/K.,H+)E(&B%#?"~<;:{z7654-2s0/pn,+*)(ih%$#"!xa__^yxwvutmrUponQOedLLafedGFa`_^]\UZ=XWV9TS5Q42NM0.JCBG*(DC&A#98=~|{{276w4t,+0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpongPkjMhgfHH]baD_AWV[ZY<;VUTSRQPOHM0KJIHG)?DCBA#9"7<;49816w432s0/.nn%*)j'g}|#db~a_{z][wpotWUTTinmPNjcbgJHdGEaDB^A?[><X;988MRQP32G0..-HAF)DC&$:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhafIdcFa`_AAV[Z=;WPOT7544INM0.JCBG*(DC&A#98=~|:{y7xvuu,10/po,+$kiih%$#z!b}|{^yxwYYnsrUSohglOMihKIe^]bEC_^A\>TSX;9U86R53O20L/-I,*F)'C&$@?>!~;:927x54us10/.-nm*)('~geed!~}|{ty\wvuXVlkSShmlkNMhgfed]bE`_B]\>ZY<W9ONS64PO2M/EDI,*F)'C&$@#!=~|:{y7xv4us10/po,+*)('~geed!~}|{zyrwZutWUkponmPOjihgfed]bE`_B@VU==RWVU87RQPONMLKD-HGFED&<A@?>~6}498705.3trrq(-n+*)j'&feez!~a|^tsx[YuXVUUjonQlNdchKIedGbDZY^A?[Z=X:POT75Q42N1/K.,HGF)(=B%@?"=<;{{276wu3,+0qonn%*)jh&}|#db~}`{]srwZXtWUqTRnmPkMcbgfeHGb[DBBA\[TY<WVU86LKP31ML/-IBAF)'CB%#?87<}{zz165vt2+*/pn,mk)jh&ge#db~a_^^sxwvYXsrkpSnmPNdchKIHH]baD_AWV[><XW:U7MLQ42N1/K.,H+)E(&B%#?"~<}{987xw432+r/.o,+*jj!&%fd"yx}`^]]rwvYWslkpSQmPNjMKgJHdcbED_^]\UZ=XWV9TSR44INM0.JCBG*(DC&$@98=~|:9z7w/.3tr0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpiRPPOjihgfe^cFa`_B@VU==RWVU87RQPONMLE.,,+FEDCBA@?8=~;:{87w5vt2sq/pn,mk)jh&%f#cyx}`^z][wZXtWUqTRnQOkNLhKIeHFEEZ_^]@?ZYXWVUTSLQ4ONMLK-CHGFE'=&;@?>7<5:{8765v32r0/p-m%$)jh&ge#"c~`vuz][wvuXWlUSSRmfkNihKI_^FF[`_^A@[TY<WVU8SR4P31M0.J-+GF)D&<;@#!=<}:z216wu3tr0qo-nl*)(ih%${d!~a|{]\\qvuXVrkjoRPlOMiLJfIGcFD`CA]@>Z=;W:8TSR54ONMFK.IHG*ED&BA$?!76;|z8ywvv-21rp.'&+lj(ig%$e"bxw|_]y\ZvYWsVTpSQmlkNMhgfe^GEED_^]\[TY<WV9TS5QP3N0FEJ-+G*(D'%A$">!};|z8yw5vt2sqpp',+*kj'&%$#z!b}|_zyxZZotsVTpihmPNMMbgfIGc\[`CA]\?Z<RQV97S64P3100EJIH+*EDCBA@9"=<}:98xx/43t1q)(-,+lk('&%$#"y~a|{z][qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:V97S64P3100EJIH+*EDCBA@?>7~;:987w/4321q)p',+$)(!&g$#"!b}|^z][wvYWslkpSQmPNjMKgJHdGEaDB^A?>>SXWV98SRQJ3110KJIHAF)DCBA$?>=<;|z8105vt2sqpp',+lj(!~%fdccx}|_z\rqvYWsVTpSQmPNjMKgJHdGEDDY^]\?>YXWVOT7RQPO2ML.JI,G)?>C&$@#!=<}{9216wu3tr0qo-nl*ki'hf$ec!~}`_zyxwvoXsrqpSnmlNNcKK`edcFE`_^]\[ZS<::9TSRQPONMFK.IHGF)'=<A$">!}||387x5u-,1rpoo&+*k(h~}$ec!b`|_]y\ZvYWsVTpSQPPejihKJedcba`_^W\?ZYXWV8NSRQP2H1FKJIBG@E(CBA@#>=};|zyy054us1*).om+lj(ig%fd"ca}`^z][wvuXWlUpoRmlkjiLJf_^FF[`_^A@[TY<WVU8SRQPO20LEDI,*F)'CB%@"87<}{9zx6wu3tr0qo-nl*ki'hf$#"cb}|u^\\[vutmrUpoRmlkMihKJedc\aD_^]@>TS;;PUTS65PONMF/--,GFEDC<A$?>=~;:z8yw5vt21r/o'&+lj('h%e{z!b`|{^\xqpuXVrUSoRPlOMiLJII^cbaDC^]\[ZSX;VU8SRQ33HML/J,BAFED'&A@?>=<5|zzy6543210).o,+*k('g%fd"!b}_uty\ZvuXsUkjoRPlOMiLJfeHcE[Z_B@\?=Y<:V97S6433HMLK.-HGFEDCB;@#>=~|438ywvv-21r/o'&+lj('h%e{z!b`|_]y\ZvYWsVTpSQmPNjMKgfeHGba`_^]\[T=XWVUT6LQPON0F/DIHG@E>C&A@#>=<||387xv4-,1rpoo&+*ki'~}$ec!b`|_]y\ZvutWVkpSnmlOjiKJJ_dcFD`YX]@>Z=;WV97SLKP31M0.J-+G*(D'%A$">!}||3876wv3,sqqp-,%*k('h%$#c!~a`{zsx[vutWUkjRRglkjMLgfe^GEED_^]\UZ=XWV9TS544INM0K-CBG*(D'%A$">=~;{327xv4us10qo-&%*ki'hf$ec!b`|_]yxwZYtsrqjoRmlOjihJJ_dcFaCYX]@>Z=;W:8T75Q42N1/K.,HG*E'=<A$">!};|zyy0543ts0/.-,%ljji&%$#"!x}`{zy\wvXtWUqTRnmPkMcbgJHdcFaCYX]@>ZY<W9ONS64P31M0.JI,*F?>CBA$#>=<;:927x54us+*/pnmm$)(i&f|{"ca}|_z\rqvYWsVTpSQmPNjMKgJHdGEaDB^]\?>YXWVUTSL5PO2MLK--BGF)'C<;@#!~~5:9zx6/.3tr0qo-nl*ki'&%fe"!~}|{zyrwZutsrqSinmlkMcLaf_dcb[`C^]@[Z<X;9U86RQ42NGFK.,++@ED'B$:9>!};|z8yw5vt21r/o'&+lj(igff{"!~a`u^yx[YonVVkponQPkjcLJJIdcb[`C^]@[ZY;;PUT75QJINML/.IHG@E(&&%@?>=<5:{87xv.-ss*/.-nm*)('&}$e"!b}|{]]rwvYWslkpSQmPNjiLgI_^cFD`_B]?UTY<:VU86RKJO20LK.I+A@EDC&%@?>=<;4{yyx543210/(-n+*)j'&f$ec!~a|^tsx[YuXVrqToQgfkNLhgJeG]\aDB^A?[><X;988MRQP32MLKJIHG@E(CB%#?>=<;|3z765432+0q.-,m*)i'hf$ecbbw|{^\xqpuXVrqTRngfkNLhgJeG]\aDB^A?[><X;988MRQ42NGFKJI,AF)DCBA$?>=}}4zz1654ut+rppo,%*k('&%f#"baav{z][wpotWUqpSnPfejMKgJHdGEaDB^A?[><X;9U86R5322GLKJ-,G@E(CBA@#>=};:{8x0/4us1rp.-nl*#"'hf$ec!b`|_]y\ZvYWsVTponQPkjcLgfedGba`BBW??TYXW:9TSRQJ3110KJIHG@E(CBA@#!76;|z8ywvv-21r/o'&+ljii~%$e"bxw|_]y\ZvYWsVTpSQmPNjMKJJ_dcbED_^]\[TY<WVUT7RQ3O20//DIH+)E>=B%#?"~<}{9zx6wu3tr0qo-,+lk('&%$#zc~}`^zyxwvYnWrqponmfkNihgJedcEEZ_^A\>TSX;9UT7R4JIN1/KJ-H*@?D'%A@#>~65:{y76w4t,+0qonn%*)j'g}|ddy~}|_ty\wvutWrqpRRgOOdihgJI^GEED_X]@[ZYX;VU766KPO20LEDI,*FE(C%;:?"~<}{9zx6wu3tr0qo-nl*ki'hfeez!~}`_zsx[vutsVqpRnmPkMcbgJHdGEa`CA]VUZ=;W:8T75Q42N1/K.,H+)EDC&%@?8!<;:9z765uu,rr).-,ml)('&}fddc~}|{zsx[vutsVTjinQOkNLKK`edGbDZY^A?>>SXW:U7MLQ42N1/K.,H+)E(&B%#?"~}}4987xw43210).o,+*)j'&f$ecbbw|{^\xqpuXVrUSoRPlOMiLJfIGcFD`_^A@[ZYXWVO8SR53ONMLK.C,GFEDCB;@#>=<}:9y7xv43t1q)(-nlkk"'&ge#zy~a_{^\xwZXtmlqTRnQOkNLhKIeHFbEC_^]@UZ=XWVU8SRQ33H00EJIH+*?(&&%@9>!<;:9z76vuu,10qo-&%*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJfIGFF[`_^A@[TY<WVUT7RQ3ON1L.DCH+)E(&BA$">76;|z8yw5vt2sq/pn,mk)jh&%$ed!~w`{zyx[vutVVkSShmlkNMhgfe^GEED_^]\[TY<WVUT75KJO20L/-,,AFE(C%;:?"~}}498y6v.-2sq/pn,mk)jh&ge#db~a_^^sxwvYXsrqpohmPkjihKfeGcFDCCX]\?=YRQV97S64P31M0.J-+G*(D'%A@?"!<;:9870w43tr0/.-,m$k('&%$#z!b}|{^yxZYYnsrUSohglOMLLafeHcE[Z_B@\?=Y<:V97S64P31M0.J-+GF)D&<;@#!~~5:98y05v3210q.-,ll#ii~%$#dcxa__^yrwZutsrUpoQPPejiLJf_^cFD`_B]?UTY<:V97S64P31M0.J-+G*(D'%A$"!!6;:9zy6/4u210/p-,l*)j'g}|#db~a_{z][wpotWUqTRnQOkNLhKIeHFbEC_^]@?ZYR;VU86RQPON1F/JIHGFE>C&$@#>7<;:9z16w4321r/.n,+l)i!~%fd"ca``uzy\wYonsVTpSQmPNjMKgJHdGEaDBAAV[ZY<;P977LQ4221FK.IHGFE(CBA##8~~5:98yx/4u210qo-,+*)j!h%$#"!~w|_zyx[YonsVTpSQmPNMMbgfIdF\[`CA]@>Z=;W:8TS6Q3IHMLK.C,GFEDCB%^#K=[}GziUUfSt,ON)ooK%kH5XgCBdSRQ=v_^9'[%Y#FlUTR.-P>j<htIHH]o4`l1A?>Zwv*:8TSq5]3!kk/DgHTwd'b%;^L\[Z|49i1Tv4u2rr)(nKl76jE~%BdSbQ`Ouz\[8ZuWs3UC0Rm->jvKt`HG#EE`B1@/z==vutOT&Ro]O[MYKJVyf*c(b%%ML]=Z;X3i1xTRRt+*pp-,%[jYhD%CAARa}+_MLr&Y$5V3DToAmPej*;a`e$]#[Z_B{@[-fwv)UT&qKPmllj/hhBx)(>C&_M^]7Z}Xz8yTf.@Qba/;^,lkk"!WC1BS@-`_uMyK7I5XVV200{mfNj*uK&HHpb[D}B@zy=,+QV9Tr6p]"Nk0|{VBeSRcPa$_9Kn};{zEhgT4u,>*);'nJIkiEW210SRQ=<*;(K&I$tslk}BA@?eMv;(JI$F""mB^|i>>=vW)9'7%$#2NlYX-,HA@)''%%_?8[~;{zzVCT.d,s*N_n,mk6"FDCCTA?>P+{z(xq655s22}S/gfkjLL:fIH#EE!YAjVzgYX:)(s65p]m[MY/hCB+)RcPa$#""=<|43ixwS4Q2P*`p'KJHZ(!WVBec!-P=*ML9J6$GF3q10A-O>=c;(J%HGF!~_^0?.-w+QcUs`p4JmH1//{gyxeRQ

```

Try it online!

If the challenge didn't require halting at some point (eg. eof), it becomes pretty trivial, scoring **2334 bytes**:

```
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4u21rp(',mk)jh&%fd"yx}`^z][wZXtWUTTinmPkMcbgJHGG\a`C^@VUZ=;::OTS6Q3IHMLK.-B+FE(CBA##8~~5:98yx5.3t10q.-,+*ki'~}eez!~}`_zyxqvYtsVqpoQQfkjMhJ`_dGEaDBAAV[Z=;WPOT7544INM0K-CBG*(D'%A$">!};|z8yw5vt210qp-,+*#j'&g$#"!~a_{ts[[putsVUponmlkdMhgJedcEEZ_^A\>TSXWV98SRQPONMFK.IHGFE'=BA@?!7~5:9816/4u21r/.-,+lj(!~ff{"!~a`uz]xwvYtsUqTRnQONNchgJHd]\aDBAAV[Z=;WPOT7544INM0.JCBG*(''<A@#!=65:{yxx/43tr0)(-nlkk"'&ge#zy~}|_ty\wvYWmlqTRnmPkMcbgJHdcFaCYX]@>==RWV97SLKP31M0.J-+G*(D'%A$">!}||3876wv-t10/p-,l*)(i~%fddcx}`{zy\wvXtWUqTRnQOkjMhJ`_dGEDDY^]@[=SRW:877LQP3N0FEJ-+**?DC&A#98=~|{{276w4t,+0qonn%*)j'g}|#db~a_^^sxwvYXmrUponQlkMiLJfIGFF[`_B@\UTY<:99NSR53OHGL/-,,AFE(&B;:?"~}}498yw5.-2sq/.-n%l)('&%$e@b>,+^^:87Z5n"!10/QP-kMv(gf%Gc543}|0{[-YXu)t87L5]Ol~jjiz++evbaa`M^!=Z|kWWD05S3?O*)o'JJH)F!~f1TAy>,<^]:xJ6YXmlD0SAQPk+vKaJ%%F5ECCX|zz=xRQ

```

Try it online!

## Explanation

I've been asked to explain how the program works. I'll pick on the second one as it's way easier to explain it than the first one, but the way both of these work is really similar.

Let's start things off with decrypting the code. As someone down in the comments did it before I started working on the explanation, so I really advise you to check it out.

It doesn't make reading the program any easier one would say, but before we jump straight into the code, let's review basics of Malbolge.

The virtual machine is based on trits (**tri**nary digit**s**). Each machine word is ten trits wide, making it range from 0 to 2222222222t (= 59048d). Each memory position holds a machine word; the addresses are one machine word wide too. Both data and code share the same memory space.

There are three registers, each of which holds one machine word, initially 0: the code register C which is a pointer to the instruction that is about to be executed, the data register D used for data manipulation and the accumulator A also used by several instructions to manipulate data.

If the instruction to execute is not in the range 33-126, execution stops (the reference interpreter hangs in this case due to a bug). Otherwise, in order to determine the actual instruction to execute, the value pointed to by the C register is added to the C register itself and the result divided by 94, taking the remainder.

Here is a table of all possible instructions.

| `(C+[C])%94` | Description | Pseudocode | Op |
| --- | --- | --- | --- |
| 4 | Set code pointer to the value pointed to by the current data pointer. | `C = [D]` | i |
| 5 | Output the character in `A`, modulo 256, to standard output. | `PRINT(A%256)` | \< |
| 23 | Input a character from standard input and store it in `A`. | `A = INPUT` | / |
| 39 | Tritwise rotate right. | `A = [D] = ROTATE_RIGHT([D])` | * |
| 40 | Set data pointer to the value pointed to by the current data pointer. | `D = [D]` | j |
| 62 | Tritwise "crazy" opertaion (see table below). | `A = [D] = CRAZY_OP(A, [D])` | p |
| 68 | No operation. | `NOP` | o |
| 81 | Stop execution of the current program. | `STOP` | v |

An image of the table can be found here

Now as the code is more understandable and it's actually possible to tell what is happening there, we can jump to the general idea of what is happening there.

Without any jumps, programming Malbolge is pretty much trivial. When the jumps are used though, there is decrypting task needed to be done before executing this code again. Everytime an instruction is executed, it's getting straight after encrypted, so it doesn't behave this way it did before.

To illustrate the workaround, let's look at normalized Malbolge cat program:

```
jpoo*pjoooop*ojoopoo*ojoooooppjoivvv
o/i<iviv
i<vvvvvvvvvvvvv
oji

```

So as you can see, on the second line we have `/` and `<` instructions dealing with I/O stuff. Utilizing the fact that `C` register is the instruction pointer, we can modify it using `i` instruction effectively creating a branch. Before the branch happens though, we need to decrypt instructions that just a few cycles away read and wrote output to and from TTY, combined with a jump. As there is no real way to store constants effectively, we need to embed many non-related instructions and use their value to compute other constants needed (utilizing the fact that Malbolge doesn't separate program and data)

*Note: Parts of this answer were taken from Esolang wiki Malbolge page licensed under CC0 - link.*

*Possibly, you might want to check my other answer featuring Seed*
> 164 votes

# Answer
# brainfuck, 6 bytes

```
,[..,]

```

Try it online!

For once, a really competitive answer in brainfuck. :-) It just reads from the standard input (`,`), then loops while the character read is not zero (`[`), writing the character read twice (`..`) and finally reading a new character (`,`) before going back to the start of the loop (`]`).

Alternative 6-byte answer:

```
+[,..]

```

Try it online!
> 113 votes

# Answer
# Seed, ~~6013~~ ~~3942~~ ~~3884~~ ~~3865~~ 3848 bytes

```
6 2686150228553910251590139707025615036563204497823963635717768129239771871066022173506550480510882628259267028226290577985584582829987099606110915656117177113555095646841841520224800333754793732176561479800611856258812006670385981709167679328497862503284773114717364645850756926464567857029605682209030697372493435852024478962025612141035167904456425050991742516020282696732660004824569723936406080643638019715421991278634074220365586727498681650073989748857985341022350116695714407041551609933358182688736747622670056818175549484918971558384479903673900409406866275258032866680967195428439907751537922194839977711106739550525066186108781580088916582559490041917035011328862266125578018990106393872489460844458091217404944194309597162769266585917996079831048944050703695352212652362891425728346891039020051565145149143668695374506752075410956647268061596926723805877631732070244839345640289062870487268706837056753112890753688530410829624567367052492603150395779619674714389456447573342335882718419424356991739625084740814435581409670174841935167450868967735568432921607395284483532735870628809137816139721467391760314297120583388009684979379888771619327969950939260709632318979448755571394507744993723267176377451465261335636767345281382139780890626858048062851714445255458413414708836044457819560626602471881203745677166851290194466534044374122781840150694963232713079984019097616802988558052961445185981197848860688635007868494303883280609553158126926303057368716954797175868772233997584782178460308584468311133667562020523260687787209651365697360075036255149184531675013585317549831215044187699501112214237282761452176427542227751840469500783022037518267131004723958694850409020207947539046371030202918430731468837057173037358435898981729128093138565524861044307737736772778645659866179416374742499528142506977571896833797572787168504674372995624869224644028121889021513694674680344413147327217671463636201883832593707987630471763158950694907193475270346642656464131212900528377257996057522592531063490286796434946290829640562975054259249630102041301990094261151488784971084438450904697283402436878185751193256803412549504172175692725366543545573099651580644132336272302990268431569623087644930350666119986012078396755208814027614451748455718916151950218835893255721018309717807161101069849247670957963270760531996609510342178009605381013854568528344071028665101709824510991652144229895556116304356971449229862349660751509158124118556805449346752918775201366378708970673708268140336609704879631200464020207189960217784283188350457711700181561855735903701439931161728546207607766764248018356183768557244013532032616392458312600465372655052565572757979232509950076857757257164261786986456779565081319671440867797151240096925123970490604003172676471092543424462070540303172987644037832692737644573481399927217285232015082118420498058022229538934735831710860610342762500071914715742707928060606416262583307855509796730058097681208691054336064995992598081644175617375019325706441005506100489323794725547244923204524790583484243672718647866979116309868261348266944902049457094368284266044502218232850494065571536043568039093446786891928597439310947971461490128765873399872574753055564655381318395939745692438909430171644009177696549501234738931977436030245682360974103741227416811200635596942701451202333113537361407624672328798572271366897755165037017879673502748767425083758652376018772700583221474572236166246539494675416322678094399996691972837962509574037110004298629947088012862552029152119412750923308070223808629424081676003170951500587426197322368913565250353332410276730344732325753114510178069340400741671217608323179698501977213623893949006870978691284571486316780769512681865771113879654002525802085758553029765815927252866913455193686303619992165147682671351400793392238437682055370542229871989802092530537034276944154276536658348210

```

Try it online!
> 75 votes

# Answer
# Jelly, 1 byte

Full program.

```
ż

```

Try it online!
> 35 votes

# Answer
# Shakespeare Programming Language, ~~139~~ ~~129~~ ~~109~~ 106 bytes

*-3 bytes thanks to Jo King*

```
N.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Page]Ajax:Open mind.Speak thy.Speak thy.Let usAct I.

```

Try it online!

Spews warnings and terminates with an error. Deal with it.
> 32 votes

# Answer
# Haskell, ~~15~~ ~~14~~ 13 bytes

```
(>>=(<$"dd"))

```

Try it online!

or legibly:

```
\xs -> concatMap (\x -> map (const x) ['d','d']) xs

```

Explanation: Lists are a `Monad` in Haskell, and using the bind operator `>>=` is a `concatMap`, executing a function that takes an element and returns a list on each element of the list and then concatenating the resulting lists into one big list.

Now we just have to build a function that, given a value, returns a list of that value twice, which is accomplished by `(<$"dd")`, which can be read as "Take the list `['d','d']` and replace every element with the argument of this function. The `"dd"` could be any expression that results in a list of exactly two elements, but this is the shortest I could come up with.
> 31 votes

# Answer
# Pyramid Scheme, ~~229 218~~ 213 bytes

```
    ^
   /l\
  /oop\
 ^-----^
 -^   ^-
 /[\ /]\
^---^---^
-^ / \  -^
^-/out\ / \
-^-----/set\
 -^   ^-----^
  -^  -    /+\
  / \     ^---^
 /arg\   /1\  -
^-----^  ---
-^    -
 -^
 / \
/arg\
-----^
    /1\
    ---

```

Try it online!

This can definitely be shorter. Input is taken via command line arguments. This equates to basically:

```
str = input()
n = 0
while str[n]:
  print(str[n]*2)
  n += 1

```

With a few caveats, like the printing actually being handled in both the loop condition and the loop body.

Alternative 215 byter:

```
     ^
    /l\
   /oop\
  ^-----^
 /[\    -^
^---^   / \
-^ ^-^ /set\
^- -^-^-----^
-^ / \-    /+\
^-/out\   ^---^
-^-----  /1\  -
 -^      ---
  -^
  / \
 /arg\
^-----^
-^    -
 -^
 / \
/arg\
-----^
    /1\
    ---

```

Try it online!
> 23 votes

# Answer
# 05AB1E, 2 bytes

```
ø˜ or øS  (both 05AB1E versions)
ζ˜ or ζS  (new 05AB1E version only)
€D or €Â  (new 05AB1E version only)
.ι        (new 05AB1E version only)
ºS        (new 05AB1E version only)
·S or xS  (legacy 05AB1E version only)
+S        (legacy 05AB1E version only)

```

Ok, I give up. I'm unable to find a 1-byter to solve this. Loads of 2-byters, though..

Try `ø˜` online or Try `øS` online.
Try `ζ˜` online or Try `ζS` online.
Try `€D` online or Try `€Â` online.
Try  online.
Try `ºS` online.
Try `·S` online or Try `xS` online.
Try `+S` online.

I/O as a list of characters.

**Explanation:**

```
ø    # Zip/transpose the (implicit) input-list with itself
     #  i.e. ["a","b","c"] → [["a","a"],["b","b"],["c","c"]]
 ˜   # Deep flatten it
     # OR
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

```

The only program which works the same in both versions of 05AB1E. :)

```
ζ    # Zip/transpose the (implicit) input-list with the (implicit) input-list
     #  i.e. ["a","b","c"] → [["a","a"],["b","b"],["c","c"]]
 ˜   # Deep flatten it
     # OR
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

```

This version basically works the same as the one above for the new version. In the old version you would need an explicit pair  first, and then you could zip/transpose that. Just `ζ` on a 1D list will be a no-op in the legacy version of 05AB1E.

```
€    # For each character in the (implicit) input-list,
     # keeping all values on the stack into the resulting list:
 D   # Duplicate it
     # OR
 Â   # Bifurcate it (short for duplicate & reverse copy)
     # (which will be output implicitly as result)

```

In the new version of 05AB1E, it keeps all values on the stack into the resulting list when doing a map. Whereas with the legacy version of 05AB1E it would only keep the top value. Which is why these only work in the new version.

```
.ι   # Interleave the (implicit) input-list with the (implicit) input-list
     # (which will be output implicitly as result)

```

This builtin wasn't there yet in the legacy version of 05AB1E.

```
º    # Mirror each value in the (implicit) input-list
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

```

In the legacy version of 05AB1E, the horizontal mirror builtin would be  instead of `º`. However, `∞S` doesn't work in the legacy version, because it would implicitly convert the list to a newline-delimited string before mirroring it completely (Try it here), after which the `S` would also include these newlines.

```
·    # Double each character
     # OR
x    # Double each character (without popping)
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

```

Double is short for `2*`. In the new version of 05AB1E, build in Elixir, this only works on numeric values. The legacy version of 05AB1E was built in Python however, so `2*` works similar and repeats the character.

```
+    # Append all characters in the (implicit) input-list at the same indices
     # with the characters of the (implicit) input-list
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

```

Again, because the legacy version of 05AB1E was built in Python, `"a"+"a"` results in `"aa"`, whereas the `+` cannot be used to append strings in the new version. (PS: There is an append for strings which works in both version, which is `«`, but when giving two list arguments it will concatenate them together instead of merging each string at the same indices like the program above (Try it here).)
> 22 votes

# Answer
## Python, ~~34~~ 25 bytes

```
lambda i:sum(zip(i,i),())

```

Try it online! Another one that returns a string instead of a list of characters:

```
for i in input():print(i,end=i)

```

```
for i in input():               asking for the input, and doing a
                                for loop for every char in the string.
                 print(i,end=i) print the character, and then close
                                the line with the same character.

```

Try it online!
> 18 votes

# Answer
# x86-16 machine code, IBM PC DOS, ~~16~~ ~~10~~ 8 bytes

**Assembled byte `xxd` dump**

```
00000000: b401 cd21 cd29 ebf8                 ...!....

```

**Unassembled listing:**

```
B4 01       MOV  AH, 01H        ; DOS read char from STDIN (AH=01)
CD 21       INT  21H            ; read char into AL (echoes input)
CD 29       INT  29H            ; write char in AL to console again
EB F8       JMP  -8             ; continue looping until break

```

Standalone PC DOS executable. Input from `STDIN`, output to console.

Interactive console input:

Input by pipe:

### Original **16 byte** answer:

**Assembled byte `xxd` dump**

```
00000000: d1ee ad8a c849 acb4 0ecd 10cd 10e2 f7c3  .....I..........

```

**Unassembled listing:**

```
D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H)
AD          LODSW               ; load input length into AL
48          DEC  AX             ; remove leading space from length counter
8A C8       MOV  CL, AL         ; move length to loop counter
        C_LOOP:
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
CD 10       INT  10H            ; write char to console again
E2 F7       LOOP C_LOOP         ; continue looping through chars
C3          RET                 ; exit to DOS

```

Standalone PC DOS executable. Input via command line, output to console.
> 18 votes

# Answer
## Jelly, 1 byte

```
ż

```

Try it online!

Pardon my inexperience, I'm just getting started with Jelly. What I believe is happening is that we've defined a dyadic chain, which treats a single argument as both the left and right arguments. In this case, the chain consists of "zip; interleave x and y", interleaving the input string with itself.

Someone already posted a 1-byte Jelly solution, so I hope it's not bad manners to post mine.
> 17 votes

# Answer
# Jelly, 1 byte

A full program printing the result.

**Try it online!**

### How?

Uses a ~~bug~~ feature...
Jelly's "double" atom,  is implemented with Python's `*` and it vectorises, while Jelly's lists of characters (its only "strings") are implemented as lists of Python strings which are usually just one character long - that is until we realise that in Python `'blah'*2='blahblah'`...

```
Ḥ - Main link: list of characters (as parsed from an argument as a Python string)
  -                       e.g. ['A','b','b','a']
Ḥ - double (vectorises)        ['AA','bb','bb','aa']
  - implicit, smashing print     AAbbbbaa

```
> 16 votes

# Answer
# sed, ~~10~~ 8 bytes

```
s/./&&/g

```

Try it online!

Thanks to @manatwork for -2 bytes.
> 15 votes

# Answer
# JavaScript (Node.js), 22 bytes

Takes input as an array of characters.

```
s=>s.flatMap(c=>[c,c])

```

Try it online!

---

# JavaScript (ES6), 26 bytes

Takes input as a string.

```
s=>s.replace(/./gs,c=>c+c)

```

Try it online!

Alternate version suggested by @PabloLozano:

```
s=>s.replace(/./gs,'$&$&')

```

Try it online!

Doing it the recursive way is also just as long:

```
f=([c,...s])=>c?c+c+f(s):s

```

Try it online!
> 13 votes

# Answer
# PowerShell, ~~29~~ ~~23~~ 21 bytes

<sup>-6 bytes thanks to Andrei Odegov</sup>
<sup>-2 bytes thanks to mazzy</sup>

```
-join($args|%{$_+$_})

```

Try it online!

Takes input via splatting, essentially making it an array of chars
> 12 votes

# Answer
# Haskell, 8 bytes

```
(<*"x2")

```

Try it online!

Any two-character string works in place of `"x2"`.
> 11 votes

# Answer
# APL (dzaima/APL), 2 bytes<sup>SBCS</sup>

Anonymous tacit prefix function.

```
2⌿

```

Try it online!

is "replicate" :-)
> 9 votes

# Answer
# Rust, ~~83~~ ~~46~~ 45 bytes

```
|x:&str|for c in x.chars(){print!("{}{0}",c)}

```

Try it online!

I don't like this, but it's not cheating.

* -1 byte thanks to Maya.
> 9 votes

# Answer
# C (gcc), 40 bytes

```
f(s,t)char*s,*t;{while(*t++=*t++=*s++);}

```

Try it online!

Assumes `t` is a buffer which is large enough to store the output.

Probably not standard-conforming, but it works on TIO.
> 9 votes

# Answer
# Brachylog, 2 bytes

```
jᵐ

```

Try it online!

### Explanation

```
 ᵐ     Map on each char
j      Juxtapose the char to itself

```
> 8 votes

# Answer
# Pyth, 2 bytes

```
.i

```

Try it online!

`.i`nterleaves two copies of the input together. The input is implicit, so a 'full' version of this program would be `.iQQ`, where `Q` is the program's input.
> 8 votes

# Answer
# Perl 5 (`-0777p` `-Mre=/s`), 10 bytes

```
s/./$&$&/g

```

TIO
> 7 votes

# Answer
# Befunge-98 (PyFunge), 6 bytes

```
#@~:,,

```

Try it online!
> 7 votes

# Answer
# Java 8, 27 bytes

```
s->s.replaceAll(".","$0$0")

```

Try it online.

**Old 31 bytes answer before the rules got changed:**

```
s->s.replaceAll("(?s).","$0$0")

```

NOTE: The suggestion of *@EmbodimentOfIgnorance* (`\n|.` instead of `(?s).` has been reverted, since it fails if the input contains `\r`. Thanks for reporting to *@OlivierGrégoire*.

Try it online.

**Explanation:**

```
s->                             // Method with String as both parameter and return-type
  s.replaceAll("(?s).","$0$0")  //  Regex-replace all matches with the replacement
                                //  And return the changed String as result

```

*Regex explanation:*

```
(?s).                           // Match:
(?s)                            //  Enable DOTALL mode so newlines and carriage returns
                                //  are treated as literal
    .                           //  A single character

$0$0                            // Replacement:
$0                              //  All character(s) found in the match
  $0                            //  And again all character(s) found in the match

```
> 7 votes

# Answer
# Haskell, 15 bytes

Here `(:)<*>pure` takes an argument and returns a list containing this argument twice. Then `>>=` maps this function over every entry of a the input list (which is a string in our case) and flattens the result (a list of lists) back to a list.

```
(>>=(:)<*>pure)

```

Try it online!
> 6 votes

# Answer
# , ~~6~~ 3 bytes

-3 bytes thanks to Richard Donovan

```
2#]

```

Try it online!

# K (oK), ~~8~~ 4 bytes

-4 bytes thanks to ngn!

```
{2}#

```

Try it online!
> 6 votes

# Answer
# dotcomma, ~~15~~ 14 bytes

```
[[],][.[[,],]]  code
[[],]           push 0 to the queue
     [.      ]  while next block is non-zero
       [[,],]   pop from the queue and push it twice

```
> 6 votes

# Answer
# makina, 96 bytes

```
v   L>C
v>n0; >n0;
>wv ^
>Ov ^
^i>?g
^IvOC
^ nv
;1<>ppuv
^<<<OOO<
^   >vv
;0nCUv>n1;
   T<<
;1nC

```

It's hard to explain makina code, but basically this goes through each letter of the input and prints it twice.
> 6 votes

# Answer
# JavaScript, 39 bytes

```
alert([...prompt()].map(a=>a+a).join``)
```

May not be the shortest but at least original.

## EDIT

Removed 2 bytes thanks to @emanresu A
> 6 votes

# Answer
# MarioLANG, 23 20 17 bytes

```
>,
"+
.[
.<
!-
#=

```

Try it online!

Unlike brainfuck, MarioLANG returns -1 on EOF, so we must increment the value read before comparing it to zero, and then decrement before printing it. This is probably the shortest answer possible in MarioLANG.
> 5 votes

# Answer
# Scala, 37 bytes

```
def^(s:String)=s.flatMap(x=>Seq(x,x))

```

Try it online!
> 5 votes

# Answer
# Labyrinth, 12 bytes

```
",)@
" (
..:

```

Try it online!

I have just discovered this language so this answer may be notably improved...
> 5 votes

# Answer
# Stax, 2 bytes

```
c\

```

Run and debug it at staxlang.xyz!

Copy. Zip. Implicit print.
> 5 votes

# Answer
# , ~~50~~ 33 bytes

-17 bytes thanks to Giuseppe

```
function(a)gsub('(.)','\\1\\1',a)

```

Try it online!
> 5 votes

# Answer
# Turing Machine But Way Worse, 475 bytes

```
0 0 0 1 1 0 0
1 0 1 1 1 0 0
0 1 0 1 2 0 0
1 1 1 1 a 0 0
0 2 0 1 3 0 0
1 2 1 1 b 0 0
0 3 0 1 4 0 0
1 3 1 1 c 0 0
0 4 0 1 5 0 0
1 4 1 1 d 0 0
0 5 0 1 6 0 0
1 5 1 1 e 0 0
0 6 0 1 7 0 0
1 6 1 1 f 0 0
0 7 0 1 g 0 0
1 7 1 1 g 0 0
0 a 0 1 b 0 0
1 a 1 1 b 0 0
0 b 0 1 c 0 0
1 b 1 1 c 0 0
0 c 0 1 d 0 0
1 c 1 1 d 0 0
0 d 0 1 e 0 0
1 d 1 1 e 0 0
0 e 0 1 f 0 0
1 e 1 1 f 0 0
0 f 0 0 h 1 0
1 f 1 0 h 1 0
0 h 0 1 i 1 0
1 h 1 1 i 1 0
0 i 0 1 0 0 0
1 i 1 1 0 0 0
0 g 0 1 g 0 1
1 g 1 1 g 0 1

```

Trivial modification of this answer

Try it online!
> 5 votes

# Answer
## Retina, 4 bytes

```

$<&

```

Try it online!

Matches the empty string (i.e. the position before/after each character) and inserts the string between this and the previous match (which is always exactly the previous character; except for the first match where it does nothing).
> 5 votes

# Answer
# Labyrinth, 11 bytes

```
,:
"~~."
 @

```

**Try it online!**

### How?

```
, - takes a byte from STDIN and pushes its ordinal onto the stack (0-255)
  -                                    unless EOF which pushes -1
: - duplicates the top of the stack [TOS]
~ - bitwise NOT TOS (-1 becomes 0, n becomes -n-1)
  -   4-neighbours: if TOS=0 go forward to @
  -                 if TOS<0 go left to ~
  -                 if TOS>0 go right to " (never the case)
@ - exits the program, otherwise...
~ - bitwise NOT TOS (undoes the effect of the previous ~)
. - print and discard TOS (mod 256) as an ASCII character
" - no-op
  -   We've hit a wall, turn around!
. - print and discard TOS (mod 256) as an ASCII character
~ - bitwise NOT TOS (stack starts with an infinite supply of 0s, so now TOS=-1)
~ - bitwise NOT TOS (and now TOS=0 again)
  -   4-neighbours, but TOS=0 takes us forward to "
" - no-op
  -   ...and we're back at the starting ,
  -      facing right, with infinite 0s on the stack - just like the start

```
> 5 votes

# Answer
# GolfScript, ~~7~~ ~~6~~ 4 bytes

```
{.}%

```

\[Try it online!\]\[TIO-jyx60w31\]

my first golfscript program! Other people's explanations on here were super helpful for me to refer to so I'll type mine out even though its pretty short

```
{ }        code block
 .         copy the top item of the stack
   %       array map

```

Try it online!
> 5 votes

# Answer
# JavaScript (V8), 28 bytes

```
a=>[...a].map(p=>p+p).join``

```

Try it online!
> 5 votes

# Answer
# Leaf Lang, 86 bytes

Note: The interpreter does not have a stable release. If I introduce a breaking change I will update this post :)

```
import"string.lf"argv reverse splitString 0=0=while:o:o:o:o:o o print o print 0=0=stop

```

Explaination:

```
0                  - push 0 to the top of stack
import "string.lf" - import stdlib's string.lf
argv               - add all of argv in order to the stack
reverse            - reverse string on top of stack (part of string.lf)
splitString        - split a string into chars (part of string.lf)
0 = 0 =            - this checks to see if the top value of the stack is a zero
while              - runs while the top value on the stack is true (1)
:o:o:o:o           - the language has pop as a keyword but :o is 1 char less and can be put side by side.
:o                 - grab the first letter on top of the stack and store in o
o                  - push the value in o on top of the stack
print              - print top value on stack with no newline
o                  - push the value in o on top of the stack
print              - print top value on stack with no newline
0 = 0 =            - check if the next value on the stack is not a zero
stop               - required to end while loop

```

Degolfed:

<pre><code>import "string.lf"

# [0, 'o', 'l', 'l', 'e', 'h']
0 argv reverse splitString

0 = 0 = while pop pop pop pop
    : current_char
    current_char print current_char print
    0 = 0 =
stop
```
</code></pre>
> 5 votes

# Answer
# Whitespace, 33 bytes

```
[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_integer][T T   T   _Retrieve][S N
S _Duplicate_input][T   N
S S _Output_as_character][T N
S S _Output_as_character][N
S N
N
_Jump_to_Label_LOOP]

```

Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.
`[..._some_action]` added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

**Explanation in pseudo-code:**

```
Start LOOP:
  Character c = STDIN as character
  Print c
  Print c
  Go to next iteration of LOOP

```
> 4 votes

# Answer
# Wolfram Language (Mathematica), ~~13~~ 11 bytes

-2 thanks to LegionMammal978

```
#~Riffle~#&

```

Try it online!

Takes and returns an array of characters.
> 4 votes

# Answer
# Perl 6, ~~13~~ 11 bytes

```
{S:g{.}x=2}

```

Try it online!

Anonymous code block that takes a string and returns a string by replacing each character with twice of itself.
> 4 votes

# Answer
# Brain-Flak, 48 bytes

```
([]){{}({}<>)<>([])}{}<>([]){{}(({}<>))<>([])}<>

```

Try it online!

This code has two main sections. The first just reverses the string:

```
([]){{}({}<>)<>([])}{}<>

```

The second is nearly identical, it reverses the string and doubles the characters in place

```
([]){{}(({}<>))<>([])}{}<>

```

The reason we need to reverse things is that we need to touch every element of the strings in order to make the output. Since Brain-Flak uses a stack model touching each character means popping all of the elements and pushing them. Because of the FIFO manner of a stack this means each time this is done you reverse the string. The reversing issue is not present in Brain-Flueue below.

# Brain-Flueue, 28 bytes

```
([]<>){({}[()])<>(({}))<>}<>

```

Try it online!

Since queues are first in last out all we need to do in Brain-Flueue is iterate through the entire string doubling every character in place. However this does make it harder to iterate through the entire stack. In Brain-Flak we could just go until the stack height is zero however with a queue, pushing something puts it on the bottom of the queue essentially losing it. Instead we use the second queue to keep track of the number of operations we need. This makes are main loop look like:

```
([]<>){({}[()])<>...<>}<>

```

With the contents being the meager

```
(({}))

```

---

Just for fun, both of these answers could get a lot shorter if there were no null bytes in the input (ascii value zero)

# Brain-Flak, 26 bytes

```
{({}<>)<>}<>{(({}<>))<>}<>

```

Try it online!

# Brain-Flueue, 14 bytes

```
{(({}<>))<>}<>

```

Try it online!
> 4 votes

# Answer
# Befunge-93, 8 bytes

```
~:1+%:,,

```

Try it online!

For each character in input, outputs `c%(c+1)` as a character twice. This makes the program calculate `-1%0` on EOF (-1), which terminates it.
> 4 votes

# Answer
# Husk, 3 bytes

```
ṁR2

```

Try it online!
> 4 votes

# Answer
# Flobnar, 11 bytes

```
\\@
|~
,e
:

```

Try it online!

This feels golfable.
> 4 votes

# Answer
# !@#$%^&\*()\_+, 12 bytes

```
*^(_^_!@@*^)

```

Try it online! If programs could terminate with an error, `*(!@@*)` works for 7 bytes.

## Explanation

```
*^(_^_!@@*^)
*^                 take input, add 1
  (        )       loop until top of stack is 0
   _^_             subtract 1
      !            duplicate
       @@          output twice
         *^        take input, add 1

```
> 4 votes

# Answer
# C (gcc), ~~62~~ 41 bytes

```
f(char*a){for(;putchar(putchar(*a++)););}

```

Try it online!

This takes in input as the first arg, and outputs a NULL-terminated string to stdout. Not sure if the NULLs are a big deal. If you read the string properly, you'll stop after the first one ;)

Original without using a footer
> 4 votes

# Answer
# C# (Visual C# Interactive Compiler), 26 bytes

```
s=>s.SelectMany(c=>c+""+c)

```

Try it online!
> 4 votes

# Answer
# Pepe, 19 bytes

```
REEerEErReEeReEeree

```

Try it online!

**Explanation:**

```
REEe # Input as str -> (R)
rEE # Create loop labelled 0 -> (r)
  rReEe # Output as char -> (R)
        # r flag: don't pop
  ReEe # Output as char and pop -> (R)
ree # Loop while (R) != 0

```
> 4 votes

# Answer
# Arn, 5 bytes

```
|{|}\

```

Since this is \<6 bytes I can't compress it

# Explained

```
      \ Fold with...
| Concatenation after...
  { Mapping...
    | And concatenating _ and _
  } End map

```

Fold's required input is automatically assumed to be `_` (initialized as STDIN). Type casting automatic, output automatic.
> 4 votes

# Answer
# Vyxal, 1 byte

```
Y

```

Try it Online!

Yet another trivial answer. `Y` interleaves the input string with itself. It’s good that Vyxal can tie with Jelly and beat 05AB1E in matters of triviality.
> 4 votes

# Answer
# Kotlin, ~~48~~ 35 bytes

35 bytes from 48 bytes thanks to @user

```
{it.map{"$it$it"}.joinToString("")}

```

Not much to it, just that `it.map()` returns a `CharArray` so you have to `joinToString()` it.

Kotlin Playground Link(Would've been TIO but TIO has issues with kotlin.)
> 4 votes

# Answer
# Python 3.8, 31 bytes

```
for x in input():print(end=x*2)

```

Try it online!
> 4 votes

# Answer
# Excel, 43 bytes

```
=CONCAT(MID(A1,SEQUENCE(LEN(A1),2,,0.5),1))

```

Link to Spreadsheet
> 4 votes

# Answer
# Binary Pi Calculus, 5 bytes

```
0x37 0xA7 0xB2 0x7B 0x00

```

I don't know if there is an interpreter for BPC. If there is one, I'd appreciate if someone let me know.

### Explanation

```
0x37     0xA7     0xB2     0x7B     0x00
00110111 10100111 10110010 01111011 00000000
0011011110100111101100100111101100000 000
001                                   Run the following on an infinite number of threads:
   1011110                            Read from free channel 0 into bound variable 0
          100     1100                Write bound variable 0...
             11110                    ...to free channel 1
                      100111101100    Do so again
                                  000 End the process

```

BPC technically does not have I/O capabilities. Instead, I use the global names 0 and 1 for STDIN and STDOUT, respectively (these numbers are, incidentally, the file descriptors for STDIN and STDOUT in most 'nix operating systems)
> 4 votes

# Answer
# Rust, 38 bytes

```
|x:&str|x.find(|c|print!("{c}{c}")>())

```

Playground

This takes advantage of Rust's new formatting features (capturing identifers automatically) as well as the fact that `()` implements `Ord` and can be compared to itself. Basically this solution searches the string for a character that matches a predicate, but that predicate outputs the character twice and returns `false`.
> 4 votes

# Answer
# Python, 31 bytes

```
lambda x:''.join(i*2for i in x)

```

This uses the shorthand for a generator comprehension. It will loop through every character in `x` and double it. `sum` won't work for `str`, so I took the advice from the error and used `''.join`.
> 4 votes

# Answer
# Prolog (SWI), 47 bytes

```
\[X|A]-->[X,X],\A.
\[]-->[].
X+Y:-phrase(\X,Y).

```

Try it online!

-8 from Steffan.

Requires the prolog system to use atoms as characters for double quoted strings(Scryer prolog and GNU Prolog do this by default).

```
:- set_prolog_flag(double_quotes, chars).

```

The DCG alone is 34 bytes, which is still shorter than the 35 byte version of Thoozee's answer, which is `d([A|X],[A,A|Y]):-d(X,Y). d([],[]).`
> 4 votes

# Answer
# , 57 bytes

Nothing special, just using the `std.algorithm`'s fold function to add a character twice every iteration. There's probably a more efficient way to do this but this one's pretty concise.

```
import std;auto d(dstring s){return s.fold!"a~b~b"(""d);}

```

Try it online!
> 4 votes

# Answer
# Uiua, 5 chars / 9 bytes

```
♭⍉[.]

```

Try it online!

Uiua is a fusion of the stack-based and array-oriented paradigms. It is read right-to-left.

`[.]` duplicates the top of the stack (the input string) and puts both into an array.

transposes the array so the 2 input strings go top down (every row contains 2 of a char).

deshapes the array, turning it back into a string.
> 4 votes

# Answer
# QuadR, 4 bytes

```
.
&&

```

Try it online!

`.` replace each character

`&&` with itself followed by itself
> 3 votes

# Answer
## Keg, ~~11~~ ~~7~~ ~~6~~ ~~4~~ 3 bytes

```
(⑩,

```

## Explanation

```
(   # Repeat length of stack times:
 ⑩  # Print without popping the top of the stack
  , # Print with popping

```

Try It Online!
> 3 votes

# Answer
# Gema, 5 characters

```
?=?$0

```

Sample run:

```
bash-5.0$ gema '?=?$0' <<< 'Double speak!'
DDoouubbllee  ssppeeaakk!!

```

Try it online!
> 3 votes

# Answer
# T-SQL 2008, 78 bytes

```
DECLARE @ varchar(max)='Double speak!'

,@z int=1WHILE @z<=len(@)SELECT
@=stuff(@,@z,0,substring(@,@z,1)),@z+=2PRINT @

```

**Try it online**
> 3 votes

# Answer
# Standard ML (MLton), 35 bytes

```
String.translate(fn c=>str c^str c)

```

Try it online!

The function `translate` from the `String` library has the following type:

```
translate : (char -> string) -> string -> string

```

Thus, given a function that takes a char `c`, converts it to a singleton string twice with `str c` and concatenates both with `^`, we get the required functionality.
> 3 votes

# Answer
# Oracle SQL, 43 bytes

```
select regexp_replace(x,'(.)','\1\1')from t

```

It works with an assumption that input data is stored in a table t(x), e.g.

```
with t(x) as (select 'Double speak' from dual)

```
> 3 votes

# Answer
# Gaia, 1 byte

```
Z

```

Try it online!

`Z` interleaves two strings (or lists); implicitly takes the input as both arguments.
> 3 votes

# Answer
# Factor, 32 bytes

```
: f ( s -- s ) dup zip "" join ;

```

Try it online!
> 3 votes

# Answer
# jq (`-Rrj`), 12 characters

```
(./"")[]|.+.

```

Sample run:

```
bash-5.0$ jq -Rrj '(./"")[]|.+.' <<< 'D0uB!e'
DD00uuBB!!ee

```

Try it online!
> 3 votes

# Answer
# Shakespeare Programming Language, 238 164 bytes

```
,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Open mind.Let usScene V.Scene V:.Ajax:Be you better than I?If sospeak thy.Speak thy.Open mind.Let usScene V.

```

Try it online!

Boy, golfing in SPL does seem ugly...

* Lots of bytes saved after Veskah pointed me to the SPL golfing tips. :-)
> 3 votes

# Answer
# Red, 43 bytes

```
func[s][t:""foreach c s[t: rejoin[t c c]]t]

```

Try it online!
> 3 votes

# Answer
# Z80Golf, 10 bytes

```
00000000: cd03 8030 0176 ffff 18f6                 ...0.v....

```

Try it online!

Corresponding assembly:

```
start:
    call $8003 ; input
    jr nc, no_halt
    halt
no_halt:
    rst $38 ; nop-slide to $8000 - output
    rst $38
    jr start

```
> 3 votes

# Answer
# Triangularity, 17 bytes

```
..)..
.IMD.
+}""J

```

Try it online!
> 3 votes

# Answer
# Pip, ~~17~~ ~~16~~ ~~13~~ 11 bytes

```
Fi,#aL2Oa@i

```

Try it online!
> 3 votes

# Answer
# Zsh, 29 bytes

```
s=(${(s::)1})
<<<${(j::)s:^s}

```

Try it online!

I **love** parameter expansion flags:

```
s=(${(s::)1})
   ${     1}    # first argument
     (s::)      # split into characters: (s:foo:) splits on the string "foo"
s=(         )   # capture as array $s

<<<${(j::)s:^s}
   ${     s:^s} # zip array s with array s
     (j::)      # join on empty string (opposite of s::)
<<<             # print to stdout

```

---

Honorable mention, which would be 27 bytes... if not for the required 20 extra bytes to `setopt extendedglob`:

```
setopt extendedglob
<<<${1//(#m)?/$MATCH$MATCH}

```

This is basically the same as `sed 's/./&&/g'<<<$1`, but with builtins only.

Try it online!
> 3 votes

# Answer
# Lua, ~~32~~ 31 bytes

```
print(((...):gsub('.','%0%0')))

```

Try it online!

Full program, take input as command line argument. Explanation is fairly trivial:

<pre><code>print(             -- Print result
    (              -- Drop second result (count of replacements, length of string for us)
        (...)      -- Take first cmd argument
        :gsub(     -- Do replacement:
            '.',   -- Take each character
            '%0%0' -- and replace it with itself (whole match) repeated twice
        )

    )
)
```
</code></pre>
> 3 votes

# Answer
# C (gcc), 57 56 bytes

Thanks to ceilingcat and gastropher for the suggestions.

The string is modified in-place, so the buffer holding the string needs to be big enough first.

```
i;f(char*s){for(i=strlen(s)+1;i--;s[i-~i]=s[i*2]=s[i]);}

```

Try it online!

### C version with allocated string, 73 71 bytes

If the string buffer can't be assumed to be big enough (or writable), this version allocates a buffer to return.

```
f(s,t,u)char*s,*t;{for(u=t=malloc(strlen(s)*3);*t++=*s;*t++=*s++);s=u;}

```

Try it online!
> 3 votes

# Answer
## Swift 5, 30 bytes

thanks to @Mr.Xcoder for -14 bytes

`{a in a.flatMap{"\($0)\($0)"}}`

Try it online!
> 3 votes

# Answer
# PHP, ~~37~~ 32 bytes

-2 bytes by removing PHP start tag `<?` and adding it in header per **gwaugh**'s suggestion

-3 bytes thanks to great idea of **gwaugh** and eliminating the need for `!=''` check

```
for(;$l.=$l=$argn[$i++];)echo$l;

```

Try it online!
> 3 votes

# Answer
# JavaScript (V8), 28 bytes

```
s=>[...s].map(n=>n+n).join``

```

Try it online!
> 3 votes

# Answer
# Ook!, 48 bytes

```
Ook.Ook!Ook!Ook?Ook!Ook.Ook!Ook.Ook.Ook!Ook?Ook!

```

This is just a port of my brainfuck answer. Unfortunately there is no support for *Ook!* on TIO, but you can use this online interpreter.
> 3 votes

# Answer
# K (oK), 5 bytes

**Solution:**

```
,/2#'

```

Try it online!

**Explanation:**

```
,/2#' / the solution
  2#' / 2 take (#) each
,/    / flatten

```
> 3 votes

# Answer
# Kotlin, 44 bytes

```
{s:String->s.map{"$it$it"}.joinToString("")}

```

Try it online!
> 3 votes

# Answer
# MathGolf, 1 byte

```
^

```

Try it online!

Same as the Jelly answer, zip works on a character level for strings. Implicitly pops the input twice, and zips it with itself to produce a string. The first idea I had was `m_` (map each character to duplicate), which produces identical output.
> 3 votes

# Answer
# Gaia, ~~4~~ 3 bytes

```
:¦$

```

Basically just maps the duplicate instruction to the input string, then turns the returned list into a string

Edit: turns out there was already a 1 byte answer in Gaia for this question that I missed, so my solution isn't that great

# How it works

```
:   Duplicate
¦   Map to each character of the input string
$   Convert the returned list to a string
Auto outputs stack

```

Try it Online!
> 3 votes

# Answer
# Piet, 20 codels

If you are using npiet, you might want to use the `-q` option to stop the interpreter from printing a prompt for each character.

## Rundown

If STDIN contains no character, Piet's input functions will not lock or throw an error, but simply fail quietly. To know if we reached the end of the string, we therefore push a sentinel 0 to the stack to detect if nothing was read.

In pseudo code:

```
1. Push 1 to stack
2. Perform NOT on top of stack
3. Attempt to read character
4. Duplicate top of stack, twice.
5. Perform NOT on top of stack, twice,
   leaving a 1 if character was read, 0 otherwise.
6. Turn Direction Pointer as many steps as value on top of stack.
7. If we turn, print character, twice, and go to start
8. If we do not turn, get caught in exit block. (Bottom left corner.)

```
> 3 votes

# Answer
# Poetic, ~~46~~ 49 bytes

*+3 bytes to account for inputs that are longer than the tape will allow (unlikely, but possible).*

```
enduring a tragedy,knowing a way i am,troubles me

```

Try it online!

Poetic is an esolang I created in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.

The point of the language is to allow for programs to be written in free-verse poetry. I encourage you all to try it out sometime!
> 3 votes

# Answer
# Forth (gforth), 39 bytes

```
: f bounds ?do i 1 type i 1 type loop ;

```

Try it online!

Beats NieDzejkob's submission by one byte. If we don't care empty strings, we can safely remove the `?` in `?do`, making it 38 bytes.

A function that takes a string in the standard representation (addr, length), and prints the result to the console.

### How it works

gforth documentation about `bounds`

```
: f ( addr len -- )
  bounds ?do        \ Iterate through char addresses..
    i 1 type        \   Print one char at the address
    i 1 type        \   One more time
  loop ;            \ End loop

```
> 3 votes

# Answer
# Backhand, 5 bytes

```
i}o:

```

Try it online!

(note the trailing space) This should be the optimal answer, since all of `io:` are needed, 4 bytes needs at two movement modifiers to avoid getting stuck in two instruction loops, and no three byte permutation works.

### Explanation:

```
i       Input
   :    Dupe
  o     Output
 }      Move back to output
  o     Output
   :    Unnecessary dupe
i       Beginning of loop again

```

Of course, for a suboptimal but ironic answer you could do:

```
vvii::oooo22jj

```

Try it online!

Which doubles up on every character.
> 3 votes

# Answer
# SWI-Prolog, 87 bytes

I did not see any Prolog attempt, so I tried to make one.

```
d([A|X],[A,A|Y]):-d(X,Y). d([],[]). p(X,W):-string_codes(X,Y),d(Y,Z),string_codes(W,Z).
```

The predicate to be called is `p`:

`?- p("Hello world!", X)`

It produces (in **SWI-Prolog** online interpreter):

`X = "HHeelllloo wwoorrlldd!!";`

## Explanation

The code uses two different predicates: the first one (`d`) works with a list and duplicates every element in it.

```
d([A|X], [A,A|Y]) :- d(X, Y).
d([],[]).
```

As most of Prolog's predicates, it uses recursion to implement iteration over elements: the first line is the **recursive step**, while the second is the **base step**. Duplication is obtained by forcing the head of the first argument to be equal to the "2-elements-head" of the second argument.

Unluckily, this is not enough to work with strings: in fact, predicate `p` serves as converter between strings and lists.

```
p(X,W) :- string_codes(X,Y), d(Y,Z), string_codes(W,Z).
```

Due to library names, this second predicate extends the solution by at least 22 unnecessary characters... So, if anyone could suggest me a way to get rid of those, or any general solution improvement, I'd be very grateful ^^

Note that you can still use `d` in a sort of *"raw-mode"*, reducing the solution length to **35 bytes**. However, the input is technically not a string.

`?- d(['H','e','l','l','o',' ','w','o','r','l','d','!'],X)`

Try it online!
> 3 votes

# Answer
# Taxi, <sup>390 342</sup> 335 bytes

```
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.[A]Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan B i.Pickup a passenger going to Cyclone.Go to Zoom Zoom:n 1 l 3 r.Go to Cyclone:w.[C]Pickup a passenger going to Post Office.Switch to plan B i.Switch to plan C.[B]Go to Post Office:s 1 l 2 r 1 l.Switch to plan A.

```

Try it online!

## Explanation/Ungolfed

```
    [Take input string]
Go to Post Office: west 1st left, 1st right, 1st left.
Pickup a passenger going to Chop Suey.

[loop]
    [If string as a passenger, split it]
Go to Chop Suey: north 1st right, 1st left, 4th right, 1st left.
    [At the end of the string, end the program]
Switch to plan end_loop if noone is waiting.
        [any character after end_loop is fine]
    [Duplicate first character left]
Pickup a passenger going to Cyclone.
Go to Zoom Zoom: north 1st left, 3rd right.
Go to Cyclone: west.
    [Pickup character twice]
[two]
Pickup a passenger going to the Post Office.
Switch to plan end_loop if noone is waiting.
Switch to plan two.
    [Prints characters or crashes program, you can't drive that way]
[end_loop]
Go to the Post Office: south 1st left, 2nd right, 1st left.
Switch to plan loop.

```

## Comment

It does not even matter whether we tank at Zoom Zoom or Fueler Up, both are 335 bytes.

By tanking at Fueler Up we pay so much that we don't earn enough and are out of gas for string of length 86 or more. However, even tanking at Zoom Zoom does not allow to drive infinitely, it probably stops at strings of a length around 129, I didn't test or solve this because it's an old answer.

```
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.[A]Go to Fueler Up:n 1 r 1 l.Go to Chop Suey:n 3 r 1 l.Switch to plan B i.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 3 l.[C]Pickup a passenger going to Post Office.Switch to plan B i.Switch to plan C.[B]Go to Post Office:s 1 l 2 r 1 l.Switch to plan A.

```

Try it online! (With a long string)
> 3 votes

# Answer
# QBasic, 58 bytes

```
LINE INPUT s$
FOR i=1TO LEN(s$)*2
?MID$(s$,i/2+.1,1);
NEXT

```

### Explanation

`LINE INPUT` reads all input characters until a newline into `s$`. We loop `i` from 1 up to twice the length of the string and output the `i/2`th character (rounded up) at each iteration. There's a slight hitch, in that QBasic rounds numbers with a fractional part of `.5` up sometimes and down other times; adding a small amount like `.1` is sufficient to round the halves up, while the whole numbers still get rounded back down.
> 3 votes

# Answer
# *Acc!!*, 42 bytes

```
N
Count i while _/32 {
Write _
Write _
N
}

```

Try it online!

Reads one character at a time into the accumulator and outputs the accumulator twice for each character. Loops until it encounters something with an ASCII code less than 32 (newline or EOF).
> 3 votes

# Answer
# naz, ~~34~~ 32 bytes

```
2x1v1x1f0a0x1x2f1r3x1v1e2o2f0x2f

```

Works for any null-terminated input string.

Try it online!

**Explanation** (with `0x` instructions removed)

```
2x1v             # Set variable 1 equal to 0
1x1f0a           # Function 1
                 # Add 0 to the register
1x2f1r3x1v1e2o2f # Function 2
                 # Read a byte of input and goto function 1 if it equals variable 1
                 # Otherwise, output twice and call function 2
2f               # Call function 2

```
> 3 votes

# Answer
# Burlesque, 2 bytes

```
)J

```

Try it online!

```
) # Map (implicitly explode and apply to each character then concatenate)
J # Duplicate

```
> 3 votes

# Answer
# Fortran (GFortran), ~~71~~ 65 bytes

```
character(99)a
read*,a
print*,(a(i:i),a(i:i),i=1,len_trim(a))
end

```

Try it online!

Saved 6 bytes thanks to @roblogic pointing out that if the input is quoted it can be read as list-directed.

If we don't care about extra whitespace:

# Fortran (GFortran), 56 bytes

```
character(99)a
read*,a
print*,(a(i:i),a(i:i),i=1,99)
end

```

Try it online!
> 3 votes

# Answer
# Brainetry, 85 bytes

Golfed version inspired in the program that comes after:

```
a b c d e f
a b c d e f g h
a b c d e f g
a b c d e f g
a b c d e f
a b c d e f g h i

```

To try this online, head over to this link, copy&paste the code in the `btry/replit.btry` file and hit the green "Run" button.

Golfed from this program:

```
This is almost a cat program.
This is a double speak Brainetry cat program:
For every single character of input gotten
I am supposed to output two characters.
Doing this in Brainetry is easy.
Can I get a more difficult challenge, please ?

```
> 3 votes

# Answer
# MAWP, 8 bytes

```
|0~[!;;]

```

Clones each character, pops from stack twice.

Try it!
> 3 votes

# Answer
# Python 3, ~~36~~ 35 bytes

```
print(''.join(x*2for x in input()))

```

Try it online!

Edit 1: Saved a byte
> 3 votes

# Answer
# Labyrinth, <sup>~~9~~</sup> 8 bytes

```
 ,
.:@
:

```

Try it online!

Wins over Jonathan Allan's answer.

### How it works

```
,    Start at the first meaningful instruction; push a char from stdin
:    Duplicate; on EOF, top is -1 so turn left and exit (@)
     otherwise, top is positive (printable ASCII) so turn right
.:.  Pop-print as char, dup, pop-print as char. Top is still the input char
:    Duplicate; turn to (,) since top is nonzero
,    This is a dead end so it runs again from the start, until EOF

```
> 3 votes

# Answer
# Scala, 21 bytes

```
_./:("")(_+"".+(_)*2)

```

Try it online!
> 3 votes

# Answer
# BRASCA, 6 bytes

~~As of writing, there's no online interpreter yet.~~
EDIT: There is now.

```
,[:oo]

```

Try it online!

## Explanation

```
<implicit input>      - Push STDIN to the stack
,                     - Reverse stack
 [   ]                - While non-zero:
  :oo                 -     Output the current character twice

```
> 3 votes

# Answer
# Python 3, 43 bytes

```
def d(s,o=""):
	for c in s:o+=c+c
	return o

```

Try it online!
> 3 votes

# Answer
# Julia 1.0, <sup>~~20~~</sup> 18 bytes

```
!s=join([s...].^2)

```

Try it online!
> 3 votes

# Answer
# Dis, 3 bytes.

```
}{{

```

Try it online!

## How it works

```
} ( a=getchar;if a==EOF a=59048;)
 { ( if a==59048 exit; else putchar a%256; )
   { ( again)
( then keep program counter+=1 until 59048 where each cell from i=3 to 59048 is NOP;
   then pc=0 if pc is 59048)

```
> 3 votes

# Answer
# TI-Basic, ~~52~~ ~~37~~ 39 bytes

```
For(I,1,2length(Ans),2
sub(Ans,1,I)+sub(Ans,I,1-I+length(Ans
End
Ans

```

Input is taken in `Ans`. Output is stored in `Ans` and displayed.
> 3 votes

# Answer
# Vyxal, 4 2 bytes

```
2•

```

Try it Online!

Removed implicit input and output. Thanks @emanresu A

Doesn't beat `Y` but works nonetheless.
> 3 votes

# Answer
# , 7 bytes:

```
(,/)2#'

```

## Explanation

```
      '          // Each operator
    2#           // Take two
(,/)             // Join over (aka raze)

```
> 3 votes

# Answer
# Lexurgy, 28 bytes

The "canonical" way of duplicating characters (gemination in linguistics terms) in Lexurgy: capture a character and an empty string, and replace both with itself. The `$$` matches the space literal between words on a newline-separated input.

```
a:
[]$1 *=>$1 $1
$$=>$$ $$

```
> 3 votes

# Answer
# Javascript(Node.js), ~~64~~ ~~57~~ 55 bytes

*-7 bytes thanks to Radvylf Programs*
*-2 bytes thanks to pxeger*
This is my first code golf answer, so I know this could be improved.

```
s=>{eval("e='';for(var i in s){e+=s.at(i).repeat(2)};e")}

```

Attempt this online
> 3 votes

# Answer
## C (clang), 43 chars

The function **f** is double speaking its string input.

```
f(char*a){*a&&f(a+!!putchar(putchar(*a)));}

```

Edit : saved 1 char by reusing the putchar output to eliminate a division, by ceilingcat.
> 3 votes

# Answer
# Wolfram Language (Mathematica), ~~44 33~~ 25 bytes

-11 bytes
-8 bytes

```
{#,#}&/@Characters@#<>""&

```

Mathematica is probably not the best choice for this given its verbose function names, but here's what I managed! The code works by first splitting its input into a list of characters, then it maps an anonymous function over it which replaces each character by a list of two copies. It then combines this list of lists of strings into the final string using `<>""` which is an alias for `StringJoin`, which ignores all list structure.

Try it online!
> 3 votes

# Answer
# Curry (PAKCS), 16 bytes

```
(>>=(\x->[x,x]))

```

Try it online!

very similar to haskell.
> 3 votes

# Answer
# Rust, 114 bytes

```
fn main(){let mut b=format!("");std::io::stdin().read_line(&mut b).unwrap();for l in b.chars(){print!("{}{0}",l)}}

```

Rust is not a great golfing language given its focus on explicitness, but here's an answer anyway!

Normally one allocates a string using `String::new()`, but `format!("")` is two bytes shorter. I also use that the print macro can accept the index of the variable to print, so I avoid writing `print!("{}{}",l,l)`, saving one byte.

Try it online!
> 3 votes

# Answer
# Python 3, 32 bytes

```
lambda s:''.join(c+c for c in s)

```

Try it online!
> 3 votes

# Answer
# CellTail, ~~128~~ ~~94~~ 90 bytes

```
N,k&N..,N:1,k,[k];(k,b),N,N:1,k,b;(k,b),c&N..,1|N:1,k,b+[c];(_,a&N..,1)|(1,a&N..,_):1,a,1;

```

Since both the input and output need to be plain characters it was a bit tricky to prevent spiraling into a endless duplication loop. This version uses `1` as a marker to indicate it's neighbors don't need to split themselves further.

Try the online demo
> 3 votes

# Answer
# yup, ~~9~~ 7 bytes

```
*{:@@*}

```

Try it online.

**Explanation:**

```
*        # Push the first input-character
 {    }  # Loop as long as the top of the stack is NOT 0 (without popping):
         # (the initial `*` is to start the loop)
  :      #  Duplicate the character so there are two on the stack
   @@    #  Pop both, and print them as characters
     *   #  Push the next input-character for the next iteration
         #  (which will push 0 if there are no more input(-character)s left)

```
> 3 votes

# Answer
# Arturo, 30 bytes

```
$[s][join map split s'c->c++c]

```

Try it
> 3 votes

# Answer
# Retina 0.8.2, 6 bytes

```
.
$&$&

```

Try it online! Not guaranteed to work with unprintable characters. Previous 8-byte version worked with newlines:

```
s`.
$&$&

```

Try it online!
> 2 votes

# Answer
# VDM-SL, 28 bytes

```
f(a)==conc[[x,x]|x in seq a]

```

Distributed enumeration of the sequence containing sequences of length 2 of repeated elements of a.
> 2 votes

# Answer
## Perl 6, 33 bytes

```
(@*ARGS[0].comb Xx 2).join.say

```

Comb splits our string into an array. The X meta operator applies the operator to it's right in a cross product fashion. So with the string "Double" it's doing ("D"x2, "o"x2, etc). Then we join the result and say it to print (with a newline).
> 2 votes

# Answer
# Japt `-m`, 1 byte

```
²

```

Try it online
> 2 votes

# Answer
# Japt, 2 bytes

Oliver beat me to the straightforward, 1 byte solution.

```
íU

```

Try it

Interleaves the input with itself.
> 2 votes

# Answer
# Bash, ~~58~~ 39 bytes

Using only shell builtins, no fancy parsers like `sed`.

**58 bytes:** Try it online

~~`a="$*";for((i=0;i<${#a};i++)){ x=${a:i:1};echo -n "$x$x";}`~~

**47 bytes:** (via *primo*)

```
for((;i<${#1};)){ x=${1:i++:1};echo -n "$x$x";}

```

**39 bytes:** (by *manatwork*). Try it online

```
while read -N1 c;do echo -n "$c$c";done

```
> 2 votes

# Answer
# C# (Visual C# Interactive Compiler) with Regex-flag, 24 bytes

: `/u:System.Text.RegularExpressions.Regex` (flag is not in the header, so it won't mess up the leader-board)

Port of my Java 8 answer, so look there for an explanation.

```
s=>Replace(s,".","$0$0")

```

Try it online.
> 2 votes

# Answer
# Forth (gforth), 40 bytes

```
: x 0 ?do dup c@ dup emit emit 1+ loop ;

```

Try it online!

A byte can be saved by removing the `?`, but that will break the handling of zero-length input.
> 2 votes

# Answer
# CJam, 3 bytes

```
q:_

```

Try it online!
> 2 votes

# Answer
# J, 2 bytes

```
2#

```

The verb "#", or "copy", copies its right argument the number of times specified by the left argument where the left argument is greater than or equal to zero and is either a single number or a vector of numbers of the same length as the first axis of the right argument. So, we can copy things "zero" times to remove them:

```
   1 0 1 0 # 1 2 3 4

```

returns 1 3.

Try it online: https://tio.run/##y/r//39qcka@gpGyukt@aVJOqkJxQWpitqI6138A
> 2 votes

# Answer
# \>\<\>, 9 bytes

```
i::0(?;oo

```

Try it online! I'm reasonably confident that this is optimal (barring solutions which terminate through errors; `i:oo` would be such a solution.)

## Explanation

```
i::0(?;oo
i             takes one character of input      [c]
 ::           duplicates it twices              [c, c, c]
   0(?        if it's less than 0 (no input)    [c, c]
      ;       terminate
       oo     output twice                      []
              implicitly wrap to the beginning

```
> 2 votes

# Answer
# Minkolang v.0.15, 7 bytes

```
od?.dOO

```

Try it here!

## Explanation

```
od?.dOO
o            take one character of input
 d           duplicate top of stack
  ?.         terminate if its 0
    dOO      duplicate and output twice

```
> 2 votes

# Answer
# 8086/8088 machine code, 9 bytes

I couldn't resist.

```
ac       lodsb        Read DS:[SI] into AL, then increment SI.
aa       stosb        Write AL into ES:[DI], then increment DI.
3c 00    cmp al, 0    Is AL = 0?
74 03    je +5        If so, jump to the end of this loop.
aa       stosb        Write AL into ES:[DI], then increment DI.
eb f7    jmp -7       Jump to the beginning of this loop.

```

Assumptions:

* The input string is a null-terminated string of bytes located at DS:SI.
* There is an output string buffer located at ES:DI.
* The output string buffer is large enough to hold the resulting string.
* It's not necessary to tell the calling code the location of the output string buffer. If it is, add 2 bytes: `57` (push di) at the beginning and `5f` (pop di) at the end. This assumes that the stack has 2 bytes free.
* This code will be placed inline, so it's unnecessary to use an instruction to return. If this is false, add 1 byte: `c3` (ret) at the end (after the `5f`, if applicable).
> 2 votes

# Answer
# Kotlin, 47 bytes

```
{(0..it.length-1).fold(""){s,c->s+it[c]+it[c]}}

```

Try it online!
> 2 votes

# Answer
# Starry, 14 bytes

```
` , + + + . .'

```

Try it online!
> 2 votes

# Answer
# 33, 8 bytes

```
P[ktppP]

```

Try it online! Or not. How do you get a language on TIO?

The input string has to be null-terminated.

Explanation:

```
P     P  | Get input character
 [     ] | While it isn't a null character:
  kt     | - Put it in the string register
    pp   | - Print it twice

```
> 2 votes

# Answer
# Java (OpenJDK 8), ~~88~~ 87 bytes

```
g->{String d ="";for(int i=0;i<g.length();){d+=""+g.charAt(i)+g.charAt(i++);}return d;}

```

Try it online!

Ungolfed:

```
g->{
    String d ="";
    for (int i=0;i<g.length();) {
        d+=""g.charAt(i)+g.charAt(i++);
    }
return d;
};

```

I'm sure there's way to shorten it, at least it was my first attempt in PPCG.

<sub>-1 for @manatwork</sub>
> 2 votes

# Answer
# x86 machine code, 6 bytes

```
f:
  AC       LODSB
  AA       STOSB
  AA       STOSB
  E2 FB    LOOP  f
  C3       RET

```

Takes address of input string in SI, length of input string in CX, address of output string in DI. Should work in 16, 32 and 64-bit mode.

Try it online!
> 2 votes

# Answer
**Bash, 72 bytes**

```
s=$1;e(){ echo -n "${s:$i:1}";};for ((i=0;i<${#s};i++));do e;e;done;echo

```

If you don't have a bash terminal somewhere, this should work.
> 2 votes

# Answer
# PHP, 59 bytes

-1 bytes by @manatwork

```
function($g){foreach(str_split($g)as$v)$e.=$v.$v;return$e;}

```

Try it online!

## Full program , 44 bytes

```
foreach(str_split(readline())as$v)echo$v.$v;

```

Try it online!
> 2 votes

# Answer
# Fortran (GFortran), 100 bytes

Another demonstration of fortran's concise and elegant string handling capabilities... not!!

Summary: declare S as a 99 character string. read S in string format `'(A)'`. iterate over the trimmed string length. print the `i`'th character a couple of times without a newline (TIL).

Try it Online!

```
character(99)S;read(*,'(A)')S;do i=1,len_trim(S)
write(*,'(A)',advance="no")S(i:i)//S(i:i);enddo;end

```
> 2 votes

# Answer
# Twig, 66 bytes

This is just a simple "split, loop, output twice".
Splitting by `0` on a string is similar to splitting by `''` (empty string).

```
{%macro a(s)%}{%for c in s|split(0)%}{{c~c}}{%endfor%}{%endmacro%}

```

You can try it on https://twigfiddle.com/ldxe0c.
> 2 votes

# Answer
# Matlab \>= r2015a, 16 bytes

```
@(x)repelem(x,2)

```

*Credits to* **Giuseppe**

**Note**: *I haven't found an online interpreter for MATLAB; this answer correctly works with MATLAB r2015a.*

# Matlab \<= r2014b, 23 bytes

```
@(x)char(kron(x,[1,1]))

```

**Note**: *I haven't found an online interpreter for MATLAB; this answer correctly works with MATLAB r2014b.*
> 2 votes

# Answer
# Octave, ~~32~~ 25 bytes

```
@(x)char(kron(x+0,[1,1]))

```

Try it online!

*-7 bytes thanks to* Giuseppe
> 2 votes

# Answer
# Agda, 110 Bytes

Sorry, no online interpreter available because this is more of a proof checker.

So this was quite annoying since I tried not to use the standard library and thus had to explicitly define lists. Chars also don't exist by now, but the function is polymorphic, so it would work in this case.

```
data L(A : Set): Set where
 N : L A
 C : A → L A → L A
d :{A : _}→ L A → L A
d N = N
d(C x y) = C x(C x(d y))

```
> 2 votes

# Answer
# Cubix, 9 bytes

```
oU;?Av/@o

```

Try it online!

Mapped onto a cube

```
    o U
    ; ?
A v / @ o . . .
. . . . . . . .
    . .
    . .

```

Watch it run

* `A` Put all the input onto the stack
* `v` Redirect around the cube and start of the print loop
* `o?` Output the character for the stack value and test value
* `@` If test is negative (EOI), halt
* `Uo;/` If test is positive, u-turn to the left, output character again, pop from stack and reflect onto the start of the print loop.
> 2 votes

# Answer
# K (ngn/k), 5 bytes

```
,/2#'

```

Try it online!

---

the above is an expression that will take (`#`) 2 copies of each (`'`) letter and return a list where each element is a 2-char list, e.g.

```
("DD";"oo";"uu";"bb";"ll";"ee";"  ";"ss";"pp";"ee";"aa";"kk";"!!")

```

`,/` is "join over", and flattens the list. we read the expression as "join over 2 take each *string*". with the string passed right-side we get:

```
  ,/2#'"Double speak!"
"DDoouubbllee  ssppeeaakk!!"

```
> 2 votes

# Answer
# AsciiDots, ~~27~~ 21 bytes

```
.>#a?**>$_a#
 \---/\/

```

Note that this halts in an error, which is allowed.

-6 bytes by getting rid of whitespace and not using warps.

Try it online!
> 2 votes

# Answer
# Kipple (cipple), 28 bytes

```
(i>ac<0>b(a-1b+1c+1a?)b>o<c)

```

It's actually suprisingly difficult to duplicate stack items in Kipple

# Expanation

```
(i>ac<0>b(a-1b+1c+1a?)b>o<c) Full program

(i                         ) Loops until the input stack is empty
 i>a                         Push the top item of the input stack to stack A
    c<a>b                    Push 0's to stack B and C
         (a-1b+1c+1a?)       A loop that basically pushes the top of stack A to stack B and C
                      b>o<c  Push the top of stack B and stack C to the output stack

```

Try it online!
> 2 votes

# Answer
# MathGolf, 2 bytes

I hope this isn't a duplicate. (Great, it isn't.)

```
_^

```

## Explanation

```
_  Duplicate the implicit input
 ^ Zip

```

Try it online!
> 2 votes

# Answer
# Hexadecimal Stacking Pseudo-Assembly Language, 60 bytes

```
000000100000420000400000420000400000030000040000140000010000

```

Try it online!

```
000000 Label start:
100000 read character
420000 load it into register
400000 push it on the stack another time
420000 load it into register
400000 push it on the stack another time
030000 ignore next command if top of stack is non-zero
040000 end program
140000 print string
010000 go to start

```
> 2 votes

# Answer
# Python 3, 31 bytes

```
for t in input():print(t,end=t)

```

a simple program of python

```
for t in input():

```

asking for the input, and doing a for loop for every char in the string.

```
print(t,end=t)

```

print the character, and then close the line with the same character.
> 2 votes

# Answer
## `j`, ~~5~~ 2 bytes

```
+M

```

If you want to specify your input, you need to split your input into a list of individual characters before you do your job. (If that disobeys the rules, I will implement a flag that does this job for the writer. (Flags don't count in bytecount.))

Say your input is `abcdef`. Find imps.py and change those variables:

```
read = [["a","b","c","d","e","f"]]

prog = '+M'

```

## Explanation

Lots of implicit stuff here. Expanded program:

```
aaa+M

The + requires 2 inputs and M only provides a single input. Therefore two 'a''s are prepended.

The M only has 1 input required left, so a single 'a' is prepended.

```

```
a     % The Implicit input
    M % Map every item of this input with...
 aa   % This every item with this every item...
   +  % Concatenated together

% Implicit Output
j % Join the output without a separator

```

# Wren, 24 bytes

```
Fn.new{|s|s.map{|n|n+n}}

```

Try it online!

For every item in the list, return every item concatenated with itself.
> 2 votes

# Answer
# , 61 bytes

```
function(x){paste0(rep(strsplit(x,"")[[1]],e=2),collapse="")}

```

Try it online!
> 2 votes

# Answer
# Bash, 45 bytes

```
while IFS= read -n1 c;do printf %s"$c$c";done

```

Try it online!
> 2 votes

# Answer
# MIT-Scheme 10.\*, 52 bytes

```
(lambda(x)(string-map(lambda(y)(make-string 2 y))x))

```

MIT-Scheme 10.\* apparently has the new `string-map` which simplifies my earlier approach listed below. The only difference is that `make-string` is used to convert the character argument into a string and duplicate it.

### 74 bytes

This is the older solution for MIT-Scheme 9.\* before `string-map` was introduced.

```
(lambda(x)(list->string(append-map(lambda(k)(list k k))(string->list x))))

```

This is an anonymous lambda that takes the input as a string, converts it to a list so that it can be mapped (I don't know of another way to do the same), replicating each character and joining it together in one list, after which it is converted back into a string.
> 2 votes

# Answer
# GolfScript, 4 bytes

```
{.}%

```

Try it online!

Takes an input, which it treats as a list of characters, and maps `.` (push top item of stack to stack) over them.
> 2 votes

# Answer
# Pip, 4 bytes

```
aWVa

```

Try it online!

The operator `WV` ("weave") takes two iterables and interleaves their elements. In this case, weaving the input string with itself produces the desired output.
> 2 votes

# Answer
# **Forth, (GForth) 55 bytes**

```
: d pad 80 accept 0 do pad i + c@ dup emit emit loop ;

```

Usage: d \[enter\]

This text will be doubled. \[enter\]

Online Forth interpreter

'accept' takes a line of up to 80 chars into pad, then the do loop fetches chars from the pad, duplicates them and emits them to the terminal.
> 2 votes

# Answer
# Rexx (Regina), 41 bytes

I just realized the rules specifically state "It will modify this string, duplicating every character." Since the newline is part of the string, I will now leave it in the string and duplicate it, thus reducing my code size to 42 bytes (according to ls -l, TIO says 41).

```
b=''
DO 80
a=CHARIN()
b=b||a||a
END
SAY b

```

Try it online!

Old 60 byte version which strips newlines (or CRs depending on your OS.)

```
b=''
DO 80
a=CHARIN()
b=b||a||a
END
SAY LEFT(b,LENGTH(b)-2)

```

Alternate last line (same number of bytes):

```
SAY STRIP(b,,X2C('0a'))

```

Do 80 iterations, read a char into var a, concatenate two a's onto the end of b during each loop, output the string minus the two newlines or CRs (need to modify for AmigaOS/AROS because it uses CR-LF for line terminators.)

62 byte original version:

```
DO 80
a=CHARIN()
x=CHAROUT(,a)CHAROUT(,a)
END

```

Read up to 80 chars from stdin into string var a, write 'a' to stdout twice for each char read in.
> 2 votes

# Answer
# Elixir, 26 bytes

```
"#{for<<c<-s>>,do: [c,c]}"

```

Try it online!
> 2 votes

# Answer
# PHP, 37 bytes

```
while($c=$s[$i++])$a.=$c.$c;return$a;

```

Try it online!
> 2 votes

# Answer
# FEU, 12 bytes

```
s/(.)/\1\1/g

```

Try it online!

Just a single regex substitution.
> 2 votes

# Answer
## Kite, ~~111~~ ~~94~~ 79 bytes

Really surprised that nobody has used Kite before on CGCC... it's a really easy to learn language.

```
method d(a)[(a|split("")<-method(a)[a+a;])<|method(a,b)[a|str*a|bool|int+b;];];

```

Test suite:

```
method d(a)[(a|split("")<-method(a)[a+a;])<|method(a,b)[a|str*a|bool|int+b;];];

(d("abc"))|print;

(d("Double speak"))|print;

```
> 2 votes

# Answer
# Marbelous, 26 bytes

```
..@0
..00
..]]\/
../\
@0../\..

```

Marbelous is a language based on marble machines

* `@n` (`n` from `0` to `Z`) is a portal which teleport the marble to another portal with the same value
* `00`-`FF` initiate a marble with this value
* `]]` read one byte of input into a parsing marble
* `\/` is a trash can
* `/\` create a duplicate passing marble to it's left and right
* `..` is a noop
* marbles going out of the machine from the bottom are implicitly outputed

interpretor
> 2 votes

# Answer
# Rockstar, ~~82~~ ~~73~~ ~~66~~ 57 bytes

```
listen to S
cut S
O's ""
while S
let O be+roll S*2

say O

```

Try it here (Code will need to be pasted in)

```
listen to S     :Read input string into variable S
cut S           :Split into an array
O's ""          :Initialise O as an empty string
while S         :While S is not empty
let O be+       :  Append to O
  roll S        :    Pop the first element from S
  *2            :    Duplicate
                :End while loop
say O           :Output O

```
> 2 votes

# Answer
# dotcomma, 48 bytes

```
[[],][.[[[,],],]][.[,]][,[,[,.[[[,][,]][,.].]]]]
```

```
<script src="https://combinatronics.com/Radvylf/dotcomma/master/interpreter.js"></script><script src="https://code.jquery.com/jquery-3.5.1.min.js"></script><script>$(document).ready(function () {$("#btnInterpret").click(function () {$("#txtResult").text(interpret($("#txtCode").val(), $("#txtInput").val(), $("#lstOutputAs").children("option:selected").val()));});});</script><style>.textBox {background-color: white;border: 1px solid black;font-family: Courier New, Courier, monospace;width: 100%;}</style>Code: <textarea id="txtCode" type="text" class="textBox" style="height: 200px">[[],][.[[[,],],]][.[,]][,[,[,.[[[,][,]][,.].]]]]</textarea><br />Input: <textarea id="txtInput" type="text" class="textBox">Double speak!</textarea><br /><input id="btnInterpret" type="button" value="Run" />Output as: <select id="lstOutputAs"><option value="true">String</option><option value="">Number array</option></select><br />Result:<br /><div id="txtResult" class="textBox" style="overflow-wrap: break-word"></div>
```

**Code:**

```
[[],]                   insert end marker (0)
[.[                     while characters left
  [[,],],               copy each character 3 times
]]
[.[,]]                  go to first 0
[,[,[,                  delete copies of 0 and first character
  .[[[,][,]][,.].]      delete every third character until we reach 0 again
]]]

```
> 2 votes

# Answer
# Python 3, ~~67~~ 64 bytes

```
t=input()
for i in map(lambda x:x[0]+x[1],zip(t,t)):print(end=i)

```

Try it online!
> 2 votes

# Answer
# Whispers v1, 38 bytes

```
> Input
>> L+L
>> Each 2 1
>> Output 3

```

Try it online!

**Squeezed pseudo code**:

```
>> Output ( Input.map( c -> c + c ) )

```

**Explanation**:

As usual in Whispers, the last line is executed first by default:

```
>> Output 3

```

This line outputs the result of line 3:

```
>> Each 2 1

```

Here we expect line 2 to be a function and line 1 to be an array. It returns the array specified in line 1, whose elements were modified by the function in line 2. Let's look at this array first:

```
> Input

```

Takes the first line of the input. So we get an array of characters.

Now line 2:

```
>> L+L

```

`L` is an argument from the `Each` statement in line 3. Since we are working with strings, `L` is returned concatenated with itself.

So the squashed pseudo-code is:

```
>> Output ( Input.map( c -> c + c ) )

```
> 2 votes

# Answer
# Haskell, 18 bytes

```
f s=s>>= \c->[c,c]

```

Try it online!
> 2 votes

# Answer
# Factor \+ `sequences.repeating`, 12 bytes

```
[ 2 repeat ]

```

Try it online!
> 2 votes

# Answer
# Numberwang, 6 bytes

```
248337

```

Try it online!
> 2 votes

# Answer
# \[MashedPotatoes\], 315 bytes

```
synchronized(0.0f){WHILEstd::ignore=`uniq-c`s/nullptr//gWENDgoto++i;(formatt"case__dict__of{_->OUTPUT=void(0)}def$ARGV(--help)usestrictqw/*read-eval*/;endgoto<>;gotoObject;defstd::ignore(--help)guardnullptrend(formatt"procFS{STDERR}{SETLOCAL()import$ARGV;}std::cout<<--help<<std::endl;goto0.0f;goto++i;")goto<>;")}

```

This is not short, by any means. But I've wanted to try and use MashedPotatoes for something, since the language is so odd. So it might be possible to shorten the code, but it's the sort of language where I'm relieved if I get something to work. :)

It's not available on TIO, so here's a link to the Esolang entry for the language. https://esolangs.org/wiki/MashedPotatoes There's a link the GitHub entry with the code on the page.

And there's one caveat about the interpreter... I submitted a PR to the repo to make it possible to handle EOF when reading character input, and this code relies on that enhancement. The maintainer merged it today (meaning 4/17/2021) so if you may need to refresh your copy if you pulled it previously.

I think a brief explanation of some language quirks are probably necessary first... There are 3 registers `^A, ^C, ^E`, three stacks `0, 1, 2`, two triggers `A, B`, and three labels `0, 1, 2` available.

The constants `STDERR, $[, ~uniq -c~` (where I've used `~` to replace backticks since I cannot figure out how to make backticks work inside backticks) references registers `^A, ^C, ^E` respectively the first time they appear in the code. Then they change to the next register the next time they are used. Meaning `STDERR` evaluates to the value of `^A` the first time it appears in the code, to `^C` the second time, etc...

Trigger `A` is referenced by the constants `use strict qw/LABEL/;, SETLOCAL LABEL, import LABEL;, CFLAGS=LABEL, \emph{LABEL}, ~cat LABEL~` (again `~` used in place of a backtick here) cyclically. Meaning the first occurence of trigger `A` in the code will be `use strict qw/LABEL/;`, the second time will be `SETLOCAL LABEL`, etc... And `LABEL` is replaced the target label.

Similarly trigger `^B` is references by the constants `s/LABEL//g, OUTPUT = LABEL, guard LABEL, lambda: LABEL, """LABEL"""`, also in the same cyclical manner.

Label 0 is referenced by the symbols `0.0f, ++i, <>, Object` cycically.

The cyclical reference names for label 1 are `std::ignore, nullptr, __dict__, void(0)`.

And the label 2 references are `$ARGV, *read-eval*, FS, ()`.

A better description can be found on the Esolangs page for the language.

And next, the code...

```
synchronized (0.0f) {

```

This just assign the label 0, the value 1 since the `(` is on line 1 of the code.

```
  WHILE std::ignore = `uniq -c` s/nullptr//g WEND

```

Increments the value of register `^E`.

```
  goto ++i;

```

Shifts the values of the registers, effectively `^A -> ^E -> ^C -> ^A`

```
  (format t "

```

Loops while `^C` is greater then 0

```
    case __dict__  of { _ -> OUTPUT = void(0) }

```

Reads one character from STDIN into `^A`

```
    def $ARGV(--help) use strict qw/*read-eval*/; end

```

Pushes the value of `^A` to stack 0, since `---help` evaluates to 0

```
    goto <>;
    goto Object;

```

Shift the registers twice.

```
    def std::ignore(--help) guard nullptr end

```

Pop the value of stack 0 into `^A`, the result of the the last 4 actions is effectively `^C = ^A`

```
    (format t "

```

Loop as long as `^C` \> 0, effectively `if not EOF { ... }` since EOF is codepoint 0.

```
      proc FS {STDERR} {

```

Code block for output operations

```
        SETLOCAL ()

```

Print the value of `^A`, mapping the codepoint to a character

```
        import $ARGV;

```

Repeats the same, meaning print `^A` a second time

```
      }

```

End of output code block

```
      std::cout << --help << std::endl;

```

Set `^A` to zero.

```
      goto 0.0f;
      goto ++i;

```

Shift the registers twice, effectively sets `^C` to 0 to cause the loop to exit

```
    ")

```

End of the print loop, which will never run more then once since we explicitly set `^C` to 0 to prevent that.

```
    goto <>;

```

Shift the registers, sets `^C` to the last codepoint read from STDIN, will be 0 on EOF.

```
  ")

```

End of the outermost `(format` loop, will decrement `^C` and compare against 0, so if the read got any character the loop will repeat.

```
}

```

End of `synchronize` code block.
> 2 votes

# Answer
# Hexagony, 11 bytes

```
,)</;(/@>;~

```

Try it online!

Just some simple control flow on this one, could def be improved.
> 2 votes

# Answer
# A0A0, 165 150 142 bytes

```
A0A0
A0C3G1G1A0
A0I1A6V0P0G6C6A0
A0A1G-3G-3A0
G-3

A0A0
C3G1G1A0C3G1G1A0

A0A1G-3G-3A0
G-3
A0A0
C3G1G1A0C3G1G1A0
G-10A0G-10A0
A0A1G-3G-3A0
G-3

```

The program consists of three loops right after one another. The first loop does the following:

```
I1A6V0P0G6C6
I1           ; take character input, store in V0
  A6         ; append this line to the line six below
    V0       ; operand, holds input
      P0     ; prints input
        G6   ; jumps to six lines below
          C6 ; removes all instructions on the six lines below

```

We duplicate the operand and print instructions a little lower, so we can print it twice. We then jump to there and the last `C6` is to get rid of any other instructions that we didn't need afterwards.

The second loop is empty and is constructed from the first loop. The loop is also partially executed so we can enter the loop at the same place each time. This loop will print the character a second time. Because there is a nice `G6` instruction inside the copied instructions that will also be executed, we use that as a way to escape from the infinite loop. This is because six lines below is yet another loop.

```
G-10G1G1
G-10     ; jumps 10 lines up, back to the first loop
    G1   ; no-op
      G1 ; no-op

```

This is a simple infinite loop (also partially executed) that takes us back to the first loop. It's padded with no-ops, since the loops needs at least three instructions. Because the first loop contains a `C6`, any redundant instructions in the second loop will be removed once we get back to the first loop.

Edit: Optimized by 15 bytes. I misunderstood the default loop template I make use of in the code. I was under the impression that the amount of G1 and G-3 instructions on line 2 and 4 of the loop resp. needed to match the amount of instructions inside the loop. This is not the case, you only need two of them (although more also work, as long as each line has an equal amount of them). This change removes these extra instructions.

Edit 2: Optimized by 8 bytes. Because of edit one, it turns out that there's actually no minimum of three instructions in the loop. This allows us to drop four instructions (not two, since the loop at the bottom is partially evaluated), totalling eight bytes.
> 2 votes

# Answer
# MineFriff, 4 bytes

```
:oo~

```

Try it online!

No, I totally didn't forget to add input to MineFriff. You have to supply the string to double speak in the header, which can be generated using this Vyxal snippet.

## Explained

```
:oo~
:    { duplicate the top of the stack }
 oo  { print it twice }
   ~ { back to the start of the line }

```
> 2 votes

# Answer
# Zephyr, 89 bytes

```
input s
set i to 1
set o to""
while""<s[i...i]
set o to(o+s[i])+s[i]
inc i
repeat
print o

```

Try it online!

### Explanation

Oh. My. Goodness.

I spent 20 minutes convinced this challenge wasn't possible in Zephyr. All the language design choices that I made 11 years ago came back to bite me:

* There is no way to get the length of a string (not a design choice, I just didn't implement anything).
* The `print` statement adds a trailing newline by default. Suppressing the trailing newline with `...` adds a space instead.
* The concatenation operator `|` *also* puts a space between the two values.

But a couple of things went right:

* String slicing exists, and doesn't throw an error if the indices are out of bounds.
* You can concatenate any value to a string using the `+` operator. In hindsight, I'm not sure why I thought this was a good feature, but there it is.

And so:

```
input string
set index to 1    # Zephyr uses 1-based indices
set output to ""
# Loop until index is out of bounds, at which point the string slice returns empty string
while "" < string[index...index]
    set output to (output + string[index]) + string[index]
    inc index
repeat
print output

```
> 2 votes

# Answer
# Python, 67 bytes

```
from itertools import*
print(*chain(*[i*2for i in input()]),sep="")

```
> 2 votes

# Answer
# Minim, 73 Bytes (44 w/o Output)

Program is run as follows:

```
C:\Users\chris> minim -a "Double speak!" -f golf.min

```

**Arrays** of values, and subsequently **strings**, cannot be returned or passed around to statements, and the interpreter uses only index 0 for a *'return/exit value'*. Therefore I've opted to just **print** the modified string to the console.

```
[0]=L*2+1.[1:]=A.[[0]]=[[0]--/2]._^![0].C=1.[0]=2.$<[[0]++]._^![[0]].C=5.

```

With whitespace and comments:

```
;;; Insert string into memory and modify it

[0] = L * 2 + 1.         ; Set index 0 to twice the length of the program arguments plus 1
[1 :] = A.               ; Insert program arguments at index 1
    [[0]] = [[0]-- / 2]. ; Set index of index 0 to half of memory at index of index 0, and decrement index 0
    _^ ![0].             ; Skip the next statement if index 0 is 0
C = 1.                   ; Set program counter to 1

;;; Output modified string (no string/array return)

[0] = 2.        ; Set index 0 to 2.
    $< [[0]++]. ; Print index of index 0 as Unicode, and increment index 0
    _^ ![[0]].  ; Skip the next statement if index of index 0 is 0
C = 5.          ; Set program counter to 5

```

Without *printing* it, the program goes down to *just* **44 bytes**.

```
[0]=L*2+1.[1:]=A.[[0]]=[[0]--/2]._^![0].C=1.

```

The modified string is now just in memory.

GitHub Repository
> 2 votes

# Answer
# CLC-INTERCAL, 85 bytes.

```
DO;1<-#1DOCOMEFROM#2DOWRITEIN;1(1)DO:1<-;1SUB#1DDOCOMEFROM':1~:1'~#1(2)DOREADOUT;1+;1

```

Copy and paste to try it online!

## With comments, though I don't know its necessity

```
DONOTE length of array
DO;1<-#1
DOCOMEFROM#2
DONOTE perform getchar() for a time to store to ;1SUB#1
DOWRITEIN;1
DONOTE EOF: zero; otherwise: at least 65536
(1)DO:1<-;1SUB#1
DONOTE die here
D
DONOTE ':1~:1'~#1: zero if EOF one otherwise
DOCOMEFROM':1~:1'~#1
DONOTE putchar() twice
(2)DOREADOUT;1+;1

```
> 2 votes

# Answer
# Python 3, ~~31~~ 24 bytes

*-7 bytes by returning a list of characters instead of a string*

```
lambda s:[c*2for c in s]

```

Returns a list of characters instead of a string.

Try it online!
> 2 votes

# Answer
# Mascarpone, 12 bytes

```
[,:..:!]v*:!

```

Try it online!

Pretty simple.

```
[      ]v*    Push the following as an operation to the stack.
 ,:..         Input a character and output it twice.
     :!   :!  Duplicate the operation and run it so that it loops.

```
> 2 votes

# Answer
# Python 3, 44 43 41 37 25 24 Bytes

I have refactored it a ton and came to this answer:

`print(*[x*2 for x in input()],sep="")`

Try it online!

then from there I got to `lambda i:[x*2 for x in i]`

The TIO doesn't work properly due to it being a function but here it is anyways: The TIO now works thanks to des54321 for their advice:

Try it online!

Here's my other implementation of this challenge with greatly appreciated help from the comments:

`print("".join(map(lambda x:x*2,input())))`

Try it online!

---

End result as of 26/05/2022 thanks to everybody's changes `lambda i:[x*2for x in i]`

Try it online!

## Description

It works by separating the script using pythons map function to grab every character in the inputted string then multiplying them by 2 and joining them back together after it is converted to a map using an empty string then joining every element to it.

Thanks to pxeger for suggesting to remove unnecessary spaces, to Wheat Wizard ♦ for suggesting to remove the quotes from the input, to des54321's advice of using f=\ in the header to fix TIO with lambda functions and Nobody's help detecting the unnecessary space in the lambda.
> 2 votes

# Answer
# K (ngn/k), 11 bytes

```
{,/{x,x}'x}

```

Try it online!

Quick.

Explanation:

```
{,/{x,x}'x}       Main program.
        'x        For each character in the string...
   {x,x}          Duplicate the character twice
 ,/               Then join each duplicated character together

```
> 2 votes

# Answer
# GeoGebra, 40 bytes

```
s="a
InputBox(s
Sum(Zip(S+S,S,Split(s,{"

```

Input goes in the Input Box.

Just found out about GeoGebra's parentheses/quotation marks/(other stuff I'm missing) auto-complete when pasting in code, really cool.

Try It On GeoGebra!
> 2 votes

# Answer
# Alice, ~~12~~ 9 bytes

```
/O./
@IZ\

```

Try it online!

## Explanation Flattened

```
/        Switch to Ordinal mode
 I       Reads a string from the input
  .      Duplicates it
   \/    Does a U turn and switch line
     Z   Zip the two strings
      O  Print it
       @ Bye

```
> 2 votes

# Answer
# MUMPS, 36 bytes

```
a(s) f %=1:1:$l(s) w $e(s,%),$e(s,%)

```

Try it online!

Explanation:

* `a(s)` labels this line as a subroutine `a` with one parameter `s`.
* `$l` is short for `$length` and returns the length of a string.
* `f` is short for `for`. `f %=1:1:$l(s)` loops from 1 to `$l(s)` in steps of 1 with the variable `%` storing the current value.
* `$e` is short for `$extract`. `$e(s,%)` gets the character of `s` at position `%` (one-indexed).
* `w` is short for `write` and prints the expression that follows it.
> 2 votes

# Answer
# Fig, \\$\log\_{256}(96)\approx\\$ 0.823 bytes

```
Y

```

See the README to see how to run this

Polyglots with Vyxal and does the exact same thing: interleaving the input with itself.
> 2 votes

# Answer
# Raku, 21 bytes

```
{[~] [Z~] .comb xx 2}

```

Try it online!

```
{                   }  : anonymous code block
          .comb        : yields chars of input string
                xx 2   : repeat list of chars
     [  ]              : reduction metaoperator
      Z~               : Z operator and concat operator
                       : Z is a metaoperator here that zips using ~
 [~]                   : concat zipped list of repeated chars

```
> 2 votes

# Answer
# Rattle, 12 bytes

```
|I=@P[gbb>]`

```

Try it Online!

# Explanation

```
|              take string as input
 I             split string into characters and store in consecutive memory slots
  =@           set top of stack to the value of the pointer (i.e. length of string)
    P          set pointer to 0
     [....]`   repeat n times where n is the top of the stack
      g        get character in storage at pointer
       bb      add character to print buffer twice
         >     shift pointer right
               [print buffer output implicitly]

```
> 2 votes

# Answer
# C (gcc), 57 bytes (code) + 11 bytes (flags) + N bytes (argv\[1\])

Note: the flag in question is `-Dx=s[1][i]` this code compiles with GCC and Clang

I also had a solution with shorter source code, but including the flags there are more bytes.

```
main(i,s)char**s;{for(i=0;x^'\0';i++)printf("%c%c",x,x);}

```

tricks used:
I was able to skip adding `int i, char**s` by adding the `char**s` after main is declared, saving 2 bytes. I was also able to set `i=0` in the for loop to save a single byte. Using the flag `-Dx=s[1][i]` saved me 7 bytes.

Try it online!
> 2 votes

# Answer
# Piet \+ ascii-piet, 18 bytes (3×6=18 codels)

Technically, we can create a trivial 5 codel (4 ops + 4 no-ops) answer that will never terminate. This non-trivial no-error implementation is a lot more interesting.

Codel size 1:

```
rfnf Tk??k?Ttilj t

```

Try visual Piet online! or Try npiet online!

This improves the answer by @gastropner with 2 codels. Instead of a 5×4 image, this uses a 3×6 image. If you count the number of bytes using ascii-piet, you will find that the previous answer was 18 bytes as well and this is not an improvement but an alternative.

We use the fact that invalid instructions get ignored and got lucky that the whole program is a cycle, just like the previous answer. The main loop is a total of 10 operations, which is an improvement of 1 compared to the previous answer. This improvement was possible by moving the termination point to the right instead of bottom left. In order, the operations are:

```
1.  Output the top value on the stack as character,
2.  Pop the top value from the stack (0 for all but the first loop),
3.  Push 1 to the stack,
4.  Use a `not` operation to turn it into 0,
5.  Push the input character to the stack,
6.  Duplicate the input character
      (OR 0 in case there was no input character),
7.  Duplicate it again,
8.  Use a `not` operation to turn the top value into
      a 0 if there was a (non-null) character and
      a 1 if there wasn't,
9.  Exit the loop if the top value from the stack is 1,
10. Output the top value on the stack as character.

```

I don't think it's possible to remove popping 0 from the stack, because you need the 0 on the stack which requires steps 3 and 4. If you remove step 2, your program could technically become 9 steps total at the expense of an ever growing stack, however, loops must always use an even number of codels. With 9 operations you would thus need a 2 codel block to make up for the odd number. If you could get the program to work in 8 steps, that's probably the minimum as I believe you will necessarily need 8 operations: `INC DUP DUP NOT OUTC OUTC DP+/CC+ PUSH`. Using the same `DUP` and `OUTC` commands will be very difficult with so little space, but I think that would be the only option for reducing the size. Lastly, I do think you need the ninth `NOT` to contrast the sentinel with the input character, because you cannot check for the difference between a successful command and an ignored command without having a different truth value for both.

Note that this also fixes a small bug in the previous answer. The problem with that code is that the Codel Chooser switches between left and right for each iteration. This means that half the time, no 1 is added to the stack and then the previous value on the stack is used in the `NOT` operation. Then if it reaches the `DP+` operation with a 1 (a quarter of the time) **and** this is the end of the string it will act as if this is the input character and print two `<SOH>` characters. This bug only occurs for strings of length +.
> 2 votes

# Answer
# str, 2 bytes

```
do

```

`d` = duplicate, `o` = output. Runs characterwise by default.

Try it online!
> 2 votes

# Answer
# Python 3, ~~39~~ 38 bytes

```
lambda s:(j:=''.join)(map(j,zip(s,s)))

```

Try it online!

Explanation:

```
lambda s:                              # a function which takes a string and...
                            zip(s,s)   # zips it with itself,
                      map(j,        )  # joins each tuple,
         (j:=''.join)(               ) # and joins each string together.

```
> 2 votes

# Answer
# JavaScript (Node.js), 27 bytes

Unsurprisingly not the best JS answer.
Takes array of characters as input since it seems valid for some answers. Output is a string.

```
s=>s.map(b=>a+=b+b,a="")&&a

```

Try it online!
> 2 votes

# Answer
# \>\<\>, 4 bytes

```
i:oo

```

Try it online!

Terminates with an error.

#### Explanation

```
i    # Input one character from STDIN
 :   # Duplicate it
  oo # Output twice
     # This keeps looping until there is no more input to read

```
> 2 votes

# Answer
# Uiua, 4 bytes

```
♭⍉⊟.

```

Try it

Starting with the string "Abc":

couple the string with a duplicate `.` of itself:

```
[ "Abc"
  "Abc" ]

```

transpose this.

```
[ "AA"
  "bb"
  "cc" ]

```

deshape (flatten) this, yielding the final string:

```
"AAbbcc"

```
> 2 votes

# Answer
# Ruby, 16 bytes

```
gsub /./m,'\0\0'

```

Requires `-p`.

Try it online!

Alternatively:

```
gsub(/./m){$&*2}

```

Try it online!
> 1 votes

# Answer
## Python 2, 31 bytes

Realised I was beaten to it already.

```
lambda s:''.join(c*2for c in s)

```
> 1 votes

# Answer
# SNOBOL4 (CSNOBOL4), 69 bytes

```
	I =INPUT
S	I LEN(1) . X REM . I	:F(O)
	O =O X X	:(S)
O	OUTPUT =O
END

```

Try it online!

Prints with a single trailing newline.
> 1 votes

# Answer
# kavod, 16 bytes

```
*>1+8?99.1-#<#0.

```

Try it online!

I picked up a random tarpit and decided this would be a nice challenge to solve

Explanation:

```
*     Take a byte of input and push to stack
>     Push to the register stack without popping from normal stack
1+    Add one to the input
8?    Go to the eighth character in the program if the top of the stack is nonzero (not EOF)
99.   Go to the 99th character in the program (terminating the program). This will be skipped over if input is not EOF
1-    Decrement TOS
#     Print with popping
<#    Get input back from register stack and print it
0.    Go back to the start of the program.

```
> 1 votes

# Answer
# Charcoal, 5 bytes

```
⭆Ｓ⁺ιι

```

Try it online! Link is to verbose version of code. Explanation:

```
 Ｓ      Input string
⭆       Map over characters and join
   ι    Current character
  ⁺     Plus
    ι   Current character
        Implicitly print

```
> 1 votes

# Answer
# PHP, 74 bytes

```
function doubleSpeaker ($s) {
    return preg_replace('/(.)/', '$1$1', $s);
}

```

Try it online!
> 1 votes

# Answer
## 3var, 10 bytes

```
k'>|[PP'>]

```

Try it online！
> 1 votes

# Answer
# C (clang), 60 50 bytes

```
gets(s);while(s[(int)i])putchar(s[(int)(i+=0.5)]);

```

Try it online!

Saved 10 bytes Thanks to Peter Cordes
> 1 votes

# Answer
# , 21 bytes

```
3.6000180070050050094

```

Try it online!

**Explanation**

```
3.          Start the program
6 00 01     Set memory cell 00 to 1 (BF +)
8 00        Start a loop while memory cell 00 is non-zero
7 00        Feed input to memory cell 00 (BF ,)
5 00 5 00   Print input 2 times ("a" -> "aa")
9           Jump to the corresponding 8

```
> 1 votes

# Answer
# SimpleTemplate, 23 bytes

This answer is for a language I wrote, which was supposed to be for templates but hasn't seen many updates.

This is the basic "split, loop, output twice", but without the splitting.

```
{@eachargv.0}{@echo_,_}

```

And now, ungolfed:

```
{@each argv.0 as char}
    {@echo char, char}
{@/}

```

And an explanation:

* `{@each argv.0 as char}`
Loops over each value in `argv.0`, which is the first argument given when calling the `render()` method.
Due to this, you can pass an array of characters or a simple string, and it will loop through it.
The `as char` is optional and the default variable name is `_`.
**Whitespace is optional**
* `{@echo char, char}`
Outputs `char`. Twice.
**Whitespace is optional**
* `{@/}`
Closes the scope of the `{@each ... }`.
**This is optional**, as the language was written to keep track of how many scopes were open and automatically closes all at the end.

Pretty simple, right?

You can try it on: http://sandbox.onlinephpfunctions.com/code/d008a116a051df131edf02533182c5305cf8e834
When trying, you can go to line 906 and change the variable between `$golfed` and `$ungolfed` to try both versions.
> 1 votes

# Answer
# Forget, ~~61~~ 55 bytes

I created this language when I was bored one day. I released it the same day as this challenge was posted. I can guarantee this was not designed specifically for this challenge.

```
in;cleanse;out;out;pop;hasin;in;cleanse;out;out;pop;end

```

-6 bytes by terminating on EOF
~~There's no TIO (yet). The interpreter is available here~~ There's a TIO now
**Explanation:**
`in` \- reads a character from standard input and pushes a pointer to the stack
`cleanse` \- unpoisons the pointer on top of the stack
`out` \- prints the value stored at the address on top of the stack as a character
`out` \- see above
`pop` \- removes the value from the stack to avoid memory leaks
`hasin` \- while characters are available on standard input...
(the body of the loop is the same as before it)
`end` marks the end of the loop
The only way this program can error is if the interpreter forgets the value stored at the address on the stack and the program attempts to use it.
> 1 votes

# Answer
# Aceto: 5 bytes

```
,dppO

```

Doesn't work on TIO, because it hangs indefinitely. Buffering might prevent you from seeing the result, run with -F to immediately flush all output.
> 1 votes

# Answer
# Brain-Flak, 26 bytes

```
{(({}<>))<>}<>{({}<>)<>}<>

```

Pretty simple, and my first Brain-Flak answer :D

(Note: this requires the `-a` and `-ac` flags for ascii I/O)

# How it works

```
{  Begins a loop that will run for every character of input
(({}<>))   Pops the top element of the stack and pushes two copies of it to the second stack
<>  Go back to the first stack
}   End loop
<>   Go to the second stack
{({}<>)<>}   Reverse the second stack and puts it onto the first
<>  Go to the first stack do it outputs it

```

Try it Online!
> 1 votes

# Answer
# Q'Nial7, 28 bytes

```
d is OP N{link cols mix N N}

```

result:

```
     d 'Double Speak!'
DDoouubbllee  SSppeeaakk!!

```

Explanation, using detailed picture mode:

```
     set "decor                 %turn on decoration of atoms and empty arrays,
                                %gives a picture that distinguishes all atoms
"decor
     set "diagram
"diagram                        %set default display mode to diagram,
                                %give full boxed picture of results
     N:='Double Speak!'         %define string N
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
     mix N N                    %nesting restructuring: create table of items
                                %from list of items, the list being N N
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
     cols mix N N               %nesting restructuring: list of columns
                                %of the table
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
||`D|`D|||`o|`o|||`u|`u|||`b|`b|||`l|`l|||`e|`e|||` |` |||`S|`S|||`p|`p|||`e|`e|
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------

+-------+-------+-------+
|+--+--+|+--+--+|+--+--+|
||`a|`a|||`k|`k|||`!|`!||
|+--+--+|+--+--+|+--+--+|
+-------+-------+-------+
     link cols mix N N          %construction op: items of the first item of N
                                %are followed by the items of the second item of N, etc.
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`D|`o|`o|`u|`u|`b|`b|`l|`l|`e|`e|` |` |`S|`S|`p|`p|`e|`e|`a|`a|`k|`k|`!|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

```
> 1 votes

# Answer
# Go, 110 bytes

```
func main(){for j:=0;j<len(os.Args[1]);j++{fmt.Printf("%c%c",os.Args[1][j],os.Args[1][j])};fmt.Printf("\n");}

```

Try It on Jdoodle!
> 1 votes

# Answer
# C#, 104 bytes

```
public class P{public static void Main(string[]a){foreach(char c in a[0])System.Console.Write(c+""+c);}}

```

Try Online
> 1 votes

# Answer
# Clojure, 25 bytes

```
(fn[s](apply str(map #(str % %)s)))

```
> 1 votes

# Answer
# \[awk\], 24 bytes

```
awk '$0=gensub(/./,"&&","g")' <<< "Double speak"

```

Try it online!
> 1 votes

# Answer
# \[sed\], 13 bytes

```
sed 's/\(.\)/&&/g'  <<< "Double speak"

```

Try it online!
> 1 votes

# Answer
## Binary Lambda Calculus, 10 bytes

```
8446 0016 c25b 3fdf 9ade

```

This program was on this page and was known as a \`\`stuttering'' program.
> 1 votes

# Answer
# GolfScript, 9 bytes

Great if this hasn't been posted yet.

```
[{.}/]''+

```

Try it online!
> 1 votes

# Answer
# , 8 bytes

```
¤ōōč

```

## Explanation

```
¤    Forever
   č Read a character
 ōō  Output twice

```
> 1 votes

# Answer
# Pyth, 5 bytes

```
sm*2d
s      Concatenate
  *2d  lambda d: d*2
 m     Mapped over
     Q Input (implicit

```

Try it online!
> 1 votes

# Answer
# Add++, `-i` 8 bytes

```
L,dzbFBJ

```

Try it online!

This creates a lambda (`L`) that:

* duplicates the input string (`d`)
* zips the two strings together (`z`)
* flattens that list (`bF`)
* and joins it together (`BJ`)

Finally, the `-i` flag auto executes the lambda.
> 1 votes

# Answer
# Pip, 4 bytes

```
aWVa

```

Try it online!

A pip answer without loops.
> 1 votes

# Answer
# Canvas, 3 bytes

```
２１＊

```

Try it here!
> 1 votes

# Answer
# Lua, 31 bytes

```
print(((...):gsub(".","%1%1")))

```

Try it online!

### Explanation

`...` is the multi-return formatted version of the `arg` table. We encase it in parentheses here so that it only returns one value (the first).

`gsub()` is the global substitution function, it takes a pattern and returns a string with every instance of it replaced according to the second parameter.

`"."` is a pattern matching any single character.

`"%1%1"` is a pattern which is used as the second parameter to gsub. `%1` means the first case, which is the whole match in this instance, so it repeated the entire match twice.
> 1 votes

# Answer
# Python 3, 31 bytes

```
lambda s:"".join(c*2for c in s)

```

-4 bytes thank you to Redwolf Programs for suggesting lambda method.

Try it online!
> 1 votes

# Answer
# VBScript, 88 bytes

```
s=wscript.arguments(0):k=""
for i=0 to len(s)-1
n=mid(s,i+1,1)
k=k&n&n&" "
next
msgbox k

```

First argument as the string
> 1 votes

# Answer
# Duocentehexaquinquagesimal, 3 bytes

```
6÷V

```

Try it online!
> 1 votes

# Answer
# Unlambda, 11 bytes

```
``ci`c`|`@|

```

Try it online!

On its own, ``|`@|` is an identity function with a side effect of reading a char from the input and printing it twice. ``ci` is a call-with-cc trickery that ends up applying its argument to itself, hence ``c`|`@|` is the same with the above-mentioned side effect; all in all, this will set up a loop.

(The solution is memory inefficient, as each iteration will create a new continuation, hence the space used will be linear or quadratic in the length of the input, depending on the implementation. This can be fixed at the expense of adding two more characters: ```ci`d`c`|`@|`.)
> 1 votes

# Answer
# Ly, 7 bytes

```
ir[:oo]

```

Try it online!

Oddly enough, this turned out to be similar to the Brainfuck answer someone else posted...

```
i        - reads in a line, adds each character to the stack as a codepoint
 r       - reverse the stack
  [   ]  - a "loop while stack not empty" construct
   :     - duplicate the top of the stack
    o    - pop the top of the stack and print codepoint as char
      o  - again...

```
> 1 votes

# Answer
# V (vim), 5 bytes

```
òylpl

```

Try it online!

```
òylpl
ò       " loop until error
 yl     " yank character under cursor
   p    " paste it
    l   " move right

```

Alt:

### V (vim), 5 bytes

```
òälll

```

Try it online!

`ä{motion}` is a synonym for `y{motion}P` which is *almost* what we want but pastes backwards rather than forwards, so we need another `l` here, tying the vim-ier first solution.

Equivalent vim version:

### Vim, 11 bytes

```
qqylpl@qq@q

```

Try it online!
> 1 votes

# Answer
## \<\>^v, 29 bytes

```
.—""?§0 27 0«0 82!=0_~~?(___|

```

#### Explanation

```
.—""?§0 27 0«0 82!=0_~~?(___|

.                             Input string, push to stack
 —                            (not a minus) Reverse the string
  ""                          Push empty string to stack
    ?                         Swap top two elements
     §                        Split top of stack (now the user input) with second element of stack (`""`)
      0                       Push 0
        27                    Push 27
           0                  Push 0
            «                 Goto ; redirects program to the `|`
                            | Reverses instruction pointer direction, now going left
                           _  Pop stack
                          _   Pop stack (again)
                         _    For the third time, pop the stack
                        )     Decrement top of stack
                       ?      Swap top two elements
                      ~       Print top of stack without newline
                     ~        Print top of stack without newline (again, for the double character)
                    _         Pop stack
                   0          Push 0
                  =           Execute next instruction only if top two elements of the stack are equal
                 !            Exit, executed only if the top two elements of the stack are equal
               82             Push 28 (pointer is going left, so literal 82 -> value 28
             0                Push 0
            «                 Goto _
                          _   (Loop goes on, go back to the first "Pop stack")

```

It first reverses the string, then splits it into characters. Then it goes into a loop reverse-iterating the characters and printing them twice, popping them at the same time, each time decrementing the "characters left" counter which is at the top of the stack, and exits when "characters left" is 0.

Mostly inspired by this other answer I made

run online (`>`  is the prompt, cannot remove it)
> 1 votes

# Answer
# SM83, 8 bytes

Input string pointer in `de`, output string pointer in `hl`

```
1A 13 23 B7 C8 23 18 F8

```

```
dbl:
    ld a,(de)               // 1A       read
    inc de                  // 13       and increment
    ld (hl+),a              // 23       write and increment
    or a                    // B7       cheap test for zero
    ret z                   // C8       return if zero
    ld (hl+),a              // 23       write and increment again
    jr dbl                  // 18 F8    loop

```
> 1 votes

# Answer
# Pxem, filename: 17 bytes.

`\001` is such a byte of binary.

```
.w.o.o.i.c.c\001.+.a

```

## How it works

Since this program is simple, here is verbose explaination.

```
XX.z
# while stack is empty or popped value is not zero; do
# NOTE stack is initially empty
.a.wXX.z
  # if not empty; then pop to output its character; fi
  # if not empty; then pop to output its character; fi
  .a.o.oXX.z
  # getchar and push its codepoint value
  # NOTE EOF is -1
  .a.iXX.z
  # if not empty; then duplicate; fi
  # if not empty; then duplicate; fi
  .a.c.cXX.z
  # push one
  # if stack has two or more items; then pop twice and push their sum; fi
  .a\001.+XX.z
# done
# NOTE reaching to end of filename implicitily terminates the program
.a.a

```

Try it online!
> 1 votes

# Answer
## Arduino, 113 bytes

```
#define S Serial
int c;void setup(){S.begin(300);}void loop(){if(S.available()){S.write(c=S.read());S.write(c);}}

```

Pretty simple. If there are unread characters from the serial input, write them twice.

Explanation:

```
#define S Serial /* This abbreviation is worth it if it's used more than twice */

int c;

void setup() {
  S.begin(300); // begin serial communications
}

void loop() {
  if (S.available()) { // if there are bytes to be read
    S.write(
      c = S.read() // read, store, and write it
    );
    S.write(c); // write the stored value
  }
}

```
> 1 votes

# Answer
# Z80, 10 bytes

Input in port `ii`, output in port `oo`.

```
DB ii D3 oo B7 C8 D3 oo
18 F6

```

Disassembly:

```
f:
    in a,(ii)
    out (oo),a
    or a
    ret z
    out (oo),a
    jr f

```
> 1 votes

# Answer
# Python, 31 bytes

```
lambda s:"".join(i*2for i in s)

```

Gives out an actual string instead of a list of characters.

Try it online!
> 1 votes

# Answer
# Knight (v2.0-alpha), 22 bytes

```
;=sP W;O+*[s 2'\'=s]sN

```

Try it online!
> 1 votes

# Answer
# Raku, 16 bytes

```
{[~] .comb Xx 2}

```

Try it online!

Since the task expressly asked for a function, we're counting the curly braces that turn this expression into one; without them, it will just operate on the current topic `$_`, so depending on the surrounding code you don't necessarily need them.

`~` is the string concatenation operator. Wrapping `[`...`]` around it changes it from an infix operator to a prefix function, so everything after it will be joined together into one big string at the end.

`.method` with no explicit invocant calls the method on the current topic, which here is the unnamed argument to the function. The `.comb` method splits a string into a sequence of characters (really one-character strings).

`str x num` repeats the string the given number of times.

`X<operator>` performs an outer join of its operands and applies the given operator to each pair of items in the result. In this case the right operand is the scalar 2, which just gets paired up with each element in the sequence on the left. So `l Xx 2` could also be written, albeit with more bytes, as `l »x»2` or `l.map: *x 2`.

All of the whitespace in the solution is required, unfortunately.
> 1 votes

# Answer
# Scratch, 122 bytes

```
define(s
set[i v]to(1
set[r v]to(
repeat(length of(s
set[r v]to(join(r)(join(letter(i)of(s))(letter(i)of(s
change[i v]by(1

```

Outputs by modifying a global variable, `r`, which is automatically displayed (Consensus).

Try it on Scratch
> 1 votes

# Answer
# Thunno `J`, \\$ 3 \log\_{256}(96) \approx \\$ 2.47 bytes

```
e2*

```

Attempt This Online!

`e` is map, and `2*` doubles. The `J` flag joins the resulting list.

Note: `eZI` and `.ZI` would also work for the same bytecount.
> 1 votes

# Answer
# Thunno 2, 1 byte

```
I

```

Attempt This Online! Interleave the (implicit) input string with itself.

**Alternatives with `J` flag:**

* `Z`: Zip the (implicit) input string with itself, and join.
* `€D`: Duplicate each character in the (implicit) input string in place, and join.
> 1 votes

# Answer
## X86\_64/Linux Machine Code,  27  25 Bytes

Try it online!

**Usage:**

```
$> gcc -Wl,-Tbss=0x80000000 -s -static -nostartfiles -nodefaultlibs -nostdlib -Wl,--build-id=none to-double-speak.S -o to-double-speak
$> echo -n "<input>" | ./to-double-speak

```

Program reads input from stdin (it is sensitive to the exact byte count of input, i.e stray spaces/new lines will change result).

**Output is printed to `STDOUT`**

**Notes:**

* -4 more bytes without `EXIT_CLEANLY` defined (it will segfault to exit). This makes the minimum size **21 Bytes**.
* The 25-byte size assumes the above compile command which sets the BSS address at an ideal value. With generic compile commands (no linker inputs), its 27-bytes.

**Program:**

```
/* Uncomment below if BSS was setup at 2^20. */
/* #define IDEAL_BSS.  */

/* Comment out to save 4 bytes (with segfault to exit).  */
#define EXIT_CLEANLY
    .global _start
    .text
_start:
    /* Incoming registers are zero.  */
    decl    %edx
#ifdef IDEAL_BSS
    btsl    %edx, %esi
#else
    movl    $G_mem, %esi
#endif
    /* eax == 0 == SYS_read.  */
    /* edi == 0 == STDIN.  */
    syscall
    /* Store length in ebp.  */
    xchgl   %eax, %ebp
    negl    %edx
loop:
    /* Setup SYS_write.  */
    movb    $1, %al
    /* SYS_write == 1 == STDOUT.  */
    movl    %eax, %edi
    syscall
    /* Assuming no IO error, we will have successfully written 1
       byte so return (eax) will be 1 again ready for second
       syscall.  */
    syscall
    /* Increment esi.  */
    lodsb
    /* Loop through all bytes.  */
    decl    %ebp
    jnz loop
#ifdef EXIT_CLEANLY
    movb    $60, %al
    syscall
#endif
    .section .bss
G_mem:  .space(4096 * 8)

```

**Example/Tests:**

<pre><code>$> for x in "This is double speak" "Hello World" "AaBbCcDdEeFf"; do echo -n "${x} -> "; echo ${x} | ./to-double-speak; done
This is double speak -> TThhiiss  iiss  ddoouubbllee  ssppeeaakk

Hello World -> HHeelllloo  WWoorrlldd

AaBbCcDdEeFf -> AAaaBBbbCCccDDddEEeeFFff
```
</code></pre>
> 1 votes

# Answer
# Swift 5.9, 40 bytes

```
let f={String(($0+"").flatMap{[$0,$0]})}

```
> 0 votes

---
Tags: code-golf, string
---