Pip,  4  3 bytes

aZa

Try it online!

The operator Z ("zip") takes two iterables and returns a list of pairs of their elements. In this case, we zip the input string with itself. By default, lists are concatenated together before being printed, which produces the desired output.

Swift 6, 40 35 bytes

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

Bespoke, 121 91 bytes

-30 bytes by taking ch to the power of itself, which errors out upon EOF.

doubles,doubles,going by
we defy,we defy
speeding out of mouths to spit
double it,double it

I decided to make this one in the form of a rhyming poem.

C, 156 bytes

#include<stdio.h>
#include<string.h>
void main(int argc,char*argv[]){for(int i=0;i<strlen(argv[1]);i++){printf("%c",argv[1][i]);printf("%c",argv[1][i]);};}

Kakoune, 12 bytes

afaik there is no online interpreter for kakoune

%<a-s>_s.<ret>ypx;yp

sorry, colors in the demo are a bit weird because I've modified a script meant for vim.

not sure why, but if one of the cursors is selecting a newline pasting happens differently so I handle newlines separately

%                    # select whole buffer
 <a-s>               # split selection at line ends
      _              # deselect newlines
       s.<ret>       # spawn a cursor for each character
              yp     # copy and paste with each cursor
                x;   # select newlines on each line
                  yp # copy and paste with each cursor

if it worked as expected we could just do %s.<ret>yp and save a bunch of bytes

Tcl, 50 bytes

lmap c [split {*}$argv ""] {append r $c$c}
puts $r

Try it online!

This is a command line parameter input instead of a function, as in my other answer.

Tcl, 53 bytes

proc D s {lmap c [split $s ""] {append r $c$c}
set r}

Try it online!

Zsh, 28 bytes

for x (${(s::)1})printf $x$x

Try it online!

Much easier than bash!

Javascript (nodejs), 43 bytes

6 Bytes saved due to @Weird Glyphs

process.argv[1].split``.map(a=>a+a).join``

To run, go to https://www.onlinegdb.com/, paste in the program, and input "Double Speak!" for the command line argument section, and hit run!

Malbolge Unshackled, 170 164 bytes

(aBA@?>=<;:9876543210/.-,JH)('&%$#"!~}|{zyKwvutsrqponmlkjihgfedcF!`_^]\[ZYX*tUTSRQPONMLKJIHGF?DCB`@?\=<;:9876543,10/.^,+*)j'&g|#"!~}|{zyxwputsrqponmlkjihafedcF[`_^{

Warning: This code doesn't terminate on EOF, therefore it will throw an "invalid unicode codepoint" error at the end. You can also use it in regular Malbolge, and it will print a garbage value indefinitely.

Try it online!

While browsing the questions with a leaderboard available, I saw that this question was one of the rare ones where a pure Malbolge program got the most upvotes. Nice. The attempt made by Kamila Szewczyk is really impressive, using 20775 bytes. In order to compare this, the cat program made by Matthias Lutter is 9382 bytes long. So this is probably overkill, but it's still reasonable. On the other hand, an alternative program was also provided in the answer, using 2334 bytes if checking EOF is not mandatory. Without that restriction, a cat program is only 62 bytes in Malbolge, so it's clearly possible to improve that score. I'm only going to give a short explanation, since this is using the same strategy used for other looping programs I made, and explaining Malbolge code takes a lot of time, but the short explanation is this:

ji <- Put the data pointer somewhere, and the code pointer
      at the end of the program
ooooooo
ooooooooo
ooooooo
<i <- Printing loop  (happens every 2 cycles)
ooooooooo
oooooo
/ <- Used for jumping ahead (first j in code section)
oo
ooooooooo
ooooooooo
o
ji <- Data pointer resetting loop
oooooo
ooo
/i <- Input reading loop (happens every 4 cycles)
oooo
ooooooooo
ooo
pooo<ooi <- MAIN LOOP: Alternates between j, /, <, j. Only the j are
            properly loaded at the start of the program
ooooooo
oooopoooo/oooo <- Some values for crazyop and in order to go back

joojpoo <- Code section, we need to apply multiple crazyops
ooooooooo  in order to load the correct values into the main loop...
poooooooo
oooooopoo
oojpoooi <- ...and we can now start it!

I'm probably not going to make a version of this that ends on EOF, because the standard cat program in Malbolge Unshackled is... 208KB long...

R, 40 bytes

message(rep(strsplit(x,'')[[1]],each=2))

Here, the input x is implicit, don't know if still counts!

Custom Turing Machine, 80 bytes

Expects the input as \$string$\$.

q0 * _ q1 * ** - >  
q1 * _ q2 * ** > >  
q2 * _ q1 * ** - >  
q2 $ _ q3 _ _ - -

Demo

Try it online

Excel, 43 bytes

=LET(c,MID(A1,SEQUENCE(9^5),1),CONCAT(c&c))

vemf, 2 bytes

‼2

Standalone program that takes a command line argument with text and outputs to stdout. Also a function. Try it online

Uiua, 4 bytes, 2 characters

▽2

Try it on Uiua Pad!

Befalse, 15 bytes

!/,$~?\
 \ ..$/

Try it online!

A straightforward loop using four mirrors. , pushes -1 on EOF, so its bitwise NOT ~ is tested for zero ? to exit the loop.

Uiua, 11 bytes, 5 characters

/⊂≡⊂.

awk — 15 ASCII bytes

awk 'gsub(/./,"&&")_'

fully POSIX-compliant awk code minus the BS of custom codepages

Lazy K, 88 bytes

si`s`k``s`k`s``s`k``s`0001ki``s`0001`001`0001``s`k`si(ss`si`kk)`kk``s`0001k`k``si01``sii

Can be tested here:
https://crypto.stanford.edu/~blynn/lambda/crazyl.html

This uses the Y combinator.

Another 88 byte variant using S S K (λxy. xyx) for the recursion:

ssk``s`0001`001``s`k``s`0001ki``s`0001`001`0001``s`k`si(ss`si`kk)`kk``s`k*s*is`001``si01

(Note that the inner invocation of S S K is done using Iota expression *is.)

Yet another 88 byte variant using S I I (λxy. xxy) for the recursion:

sii``s`k`s``s`k``s`0001ki``s`0001`001`0001``s`k`si(ss`si`kk)`kk``s`0001`001``sii`k``si01

Nibbles, 4 nibbles (2 bytes)

+.@:

Attempt This Online!

Explanation

Two $s are implicit at the end of the program.

+.@:$$
  @     # First line of stdin
 .      # Map to each character:
   :$$  #   Append to itself
+       # Concatenate that list of strings together

YASEPL, 26 25 bytes

=i=1'=l®1`1!m¥i,1~~!+}2,l

explanation

=i=1'=l®1`1!m¥i,1~~!+}2,l       packed
=i                              increment variable
  =1'                           var1 = input string
     =l®1                       L = length of input string (var1)
         `1        ! }2,l       while I < L ...
           !m¥i,1                  get character from input string at index I
                 ~~                write it twice
                    +              add 1 to I and check loop.   

YASEPL, 17 bytes

(this one exits with an error)

=i=1'!m¥i,1~~!+?6

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"

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

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.

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:

$> 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
```

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.

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

><>, 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

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.

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

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.

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!

D, 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!

Arturo, 30 bytes

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

Try it

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]

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!

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.

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.

str, 2 bytes

do

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

Try it online!

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 𝟤+𝟦𝑘.

Knight (v2.0-alpha), 22 bytes

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

Try it online!

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!

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

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!

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:

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
```

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.

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)

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

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([],[]).

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

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.

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.

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.

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

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

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

Python 3, 32 bytes

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

Try it online!

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!

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.

Python 3, 44 43 41 37 25 24 Bytes

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

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.

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.

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!

Curry (PAKCS), 16 bytes

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

Try it online!

very similar to haskell.

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.

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

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.

dotcomma, 15 14 bytes

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

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
]]]

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.

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
$$=>$$ $$

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)

Q, 7 bytes:

(,/)2#'

Explanation

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

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!

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

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

Vyxal, 4 2 bytes

2•

Try it Online!

Removed implicit input and output. Thanks @emanresu A

Doesn't beat Y but works nonetheless.

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!

Python, 67 bytes

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

Julia 1.0, ²⁰ 18 bytes

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

Try it online!

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.

Excel, 43 bytes

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

Link to Spreadsheet

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) 

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

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 }

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
  }
}

Python 3.8, 31 bytes

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

Try it online!

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!

Hexagony, 11 bytes

,)</;(/@>;~

Try it online!

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

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

<>^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)

Taxi, ^{390 342} 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)

[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.

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!

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... 

Numberwang, 6 bytes

248337

Try it online!

Factor + sequences.repeating, 12 bytes

[ 2 repeat ]

Try it online!

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`|`@|.)

Duocentehexaquinquagesimal, 3 bytes

6÷V

Try it online!

Haskell, 18 bytes

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

Try it online!

Labyrinth, ⁹ 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

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.)

Python 3, 43 bytes

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

Try it online!

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 ) )

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

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 (trinary digits). 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.

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

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

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!

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.

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!

Scala, 21 bytes

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

Try it online!

Canvas, 3 bytes

２１＊

Try it here!

Python 3, 36 35 bytes

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

Try it online!

Edit 1: Saved a byte

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

Pip, 4 bytes

aWVa

Try it online!

A pip answer without loops.

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.

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.

MAWP, 8 bytes

|0~[!;;]

Clones each character, pops from stack twice.

Try it!

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;

JavaScript (V8), 28 bytes

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

Try it online!

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.

FEU, 12 bytes

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

Try it online!

Just a single regex substitution.

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 ?

PHP, 37 bytes

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

Try it online!

Elixir, 26 bytes

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

Try it online!

Pip, 17 16 13 11 bytes

Fi,#aL2Oa@i

Try it online!

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!

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.

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.

Burlesque, 2 bytes

)J

Try it online!

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

W 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.

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).

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/2th 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.

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!

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.

Pyth, 5 bytes

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

Try it online!

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.

@, 8 bytes

¤ōōč

Explanation

¤    Forever
   č Read a character
 ōō  Output twice

GolfScript, 9 bytes

Great if this hasn't been posted yet.

[{.}/]''+

Try it online!

Binary Lambda Calculus, 10 bytes

8446 0016 c25b 3fdf 9ade

This program was on this page and was known as a ``stuttering'' program.

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!

Bash, 45 bytes

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

Try it online!

[awk], 24 bytes

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

Try it online!

[sed], 13 bytes

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

Try it online!

Wolfram Language (Mathematica), 13 11 bytes

-2 thanks to LegionMammal978

#~Riffle~#&

Try it online!

Takes and returns an array of characters.

R, 61 bytes

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

Try it online!

Clojure, 25 bytes

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

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!

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.

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

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!

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.

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.

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

MathGolf, 2 bytes

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

_^

Explanation

_  Duplicate the implicit input
 ^ Zip

Try it online!

Seed, 6013 3942 3884 3865 3848 bytes

6 2686150228553910251590139707025615036563204497823963635717768129239771871066022173506550480510882628259267028226290577985584582829987099606110915656117177113555095646841841520224800333754793732176561479800611856258812006670385981709167679328497862503284773114717364645850756926464567857029605682209030697372493435852024478962025612141035167904456425050991742516020282696732660004824569723936406080643638019715421991278634074220365586727498681650073989748857985341022350116695714407041551609933358182688736747622670056818175549484918971558384479903673900409406866275258032866680967195428439907751537922194839977711106739550525066186108781580088916582559490041917035011328862266125578018990106393872489460844458091217404944194309597162769266585917996079831048944050703695352212652362891425728346891039020051565145149143668695374506752075410956647268061596926723805877631732070244839345640289062870487268706837056753112890753688530410829624567367052492603150395779619674714389456447573342335882718419424356991739625084740814435581409670174841935167450868967735568432921607395284483532735870628809137816139721467391760314297120583388009684979379888771619327969950939260709632318979448755571394507744993723267176377451465261335636767345281382139780890626858048062851714445255458413414708836044457819560626602471881203745677166851290194466534044374122781840150694963232713079984019097616802988558052961445185981197848860688635007868494303883280609553158126926303057368716954797175868772233997584782178460308584468311133667562020523260687787209651365697360075036255149184531675013585317549831215044187699501112214237282761452176427542227751840469500783022037518267131004723958694850409020207947539046371030202918430731468837057173037358435898981729128093138565524861044307737736772778645659866179416374742499528142506977571896833797572787168504674372995624869224644028121889021513694674680344413147327217671463636201883832593707987630471763158950694907193475270346642656464131212900528377257996057522592531063490286796434946290829640562975054259249630102041301990094261151488784971084438450904697283402436878185751193256803412549504172175692725366543545573099651580644132336272302990268431569623087644930350666119986012078396755208814027614451748455718916151950218835893255721018309717807161101069849247670957963270760531996609510342178009605381013854568528344071028665101709824510991652144229895556116304356971449229862349660751509158124118556805449346752918775201366378708970673708268140336609704879631200464020207189960217784283188350457711700181561855735903701439931161728546207607766764248018356183768557244013532032616392458312600465372655052565572757979232509950076857757257164261786986456779565081319671440867797151240096925123970490604003172676471092543424462070540303172987644037832692737644573481399927217285232015082118420498058022229538934735831710860610342762500071914715742707928060606416262583307855509796730058097681208691054336064995992598081644175617375019325706441005506100489323794725547244923204524790583484243672718647866979116309868261348266944902049457094368284266044502218232850494065571536043568039093446786891928597439310947971461490128765873399872574753055564655381318395939745692438909430171644009177696549501234738931977436030245682360974103741227416811200635596942701451202333113537361407624672328798572271366897755165037017879673502748767425083758652376018772700583221474572236166246539494675416322678094399996691972837962509574037110004298629947088012862552029152119412750923308070223808629424081676003170951500587426197322368913565250353332410276730344732325753114510178069340400741671217608323179698501977213623893949006870978691284571486316780769512681865771113879654002525802085758553029765815927252866913455193686303619992165147682671351400793392238437682055370542229871989802092530537034276944154276536658348210

Try it online!

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.

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!

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!

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.)

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!!"

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!

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

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!

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

J, 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!

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!

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.

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

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.

Lua, 32 31 bytes

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

Try it online!

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

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
        )

    )
)
```

Octave, 32 25 bytes

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

Try it online!

-7 bytes thanks to Giuseppe

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.

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.

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|`!|`!| 
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 

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

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!

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!

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.

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.

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!

Kotlin, 44 bytes

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

Try it online!

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))

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.

K (oK), 5 bytes

Solution:

,/2#'

Try it online!

Explanation:

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

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.

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!

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.

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

4, 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       

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.

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!

JavaScript (V8), 28 bytes

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

Try it online!

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!

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.

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).

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!

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.

_{-1 for @manatwork}

Swift 5, 30 bytes

thanks to @Mr.Xcoder for -14 bytes

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

Try it online!

Jelly, 1 byte

Full program.

ż

Try it online!

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

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).)

Starry, 14 bytes

` , + + + . .'

Try it online!

3var, 10 bytes

k'>|[PP'>]

Try it online！

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

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

Try it online!

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

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

Kotlin, 47 bytes

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

Try it online!

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!

PHP, 74 bytes

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

Try it online!

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!

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

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.

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).

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

!@#$%^&*()_+, 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

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

><>, 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

Flobnar, 11 bytes

\\@
|~
,e
:

Try it online!

This feels golfable.

Husk, 3 bytes

ṁR2

Try it online!

CJam, 3 bytes

q:_

Try it online!

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!

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

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).

PowerShell, 29 23 21 bytes

^{-6 bytes thanks to Andrei Odegov
-2 bytes thanks to mazzy}

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

Try it online!

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

Haskell, 8 bytes

(<*"x2")

Try it online!

Any two-character string works in place of "x2".

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.

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.

R, 50 33 bytes

-17 bytes thanks to Giuseppe

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

Try it online!

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

Triangularity, 17 bytes

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

Try it online!

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. :-)

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.

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.

Stax, 2 bytes

c\

Run and debug it at staxlang.xyz!

Copy. Zip. Implicit print.

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

Red, 43 bytes

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

Try it online!

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!

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.

jq (-Rrj), 12 characters

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

Sample run:

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

Try it online!

sed, 10 8 bytes

s/./&&/g

Try it online!

Thanks to @manatwork for -2 bytes.

Factor, 32 bytes

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

Try it online!

Labyrinth, 12 bytes

",)@
" (
..:

Try it online!

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

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.

Japt, 2 bytes

Oliver beat me to the straightforward, 1 byte solution.

íU

Try it

Interleaves the input with itself.

Gaia, 1 byte

Z

Try it online!

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

Scala, 37 bytes

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

Try it online!

Japt -m, 1 byte

²

Try it online

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)

Ruby, 16 bytes

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

Requires -p.

Try it online!

Alternatively:

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

Try it online!

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.

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

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!

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.

Python 2, 31 bytes

Realised I was beaten to it already.

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

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

Befunge-98 (PyFunge), 6 bytes

#@~:,,

Try it online!

Gema, 5 characters

?=?$0

Sample run:

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

Try it online!

Pyth, 2 bytes

.i

Try it online!

.interleaves 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.

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

s/./$&$&/g

TIO

QuadR, 4 bytes

.
&&

Try it online!

. replace each character

&& with itself followed by itself

Brachylog, 2 bytes

jᵐ

Try it online!

Explanation

 ᵐ     Map on each char
j      Juxtapose the char to itself

APL (dzaima/APL), 2 bytes^SBCS

Anonymous tacit prefix function.

2⌿

Try it online!

⌿ is "replicate" :-)