[Question]
  [
An *uninteresting number* (which I totally didn't make up only for this challenge) is created like this:
> 
> 1. Take a positive integer N
> 2. Create a new number O by adding the digits of N at the end of N
> 3. The final uninteresting number is O\*N
> 
> 
> 
For example for N=12:
> 
> 1. O = 1212
> 2. O\*N = 1212 \* 12
> 3. Final number is 14544
> 
> 
> 
# Input
A positive integer N (N > 0) or your language's equivalent. You don't have to catch incorrect input.
# Output
The corresponding uninteresting number.
# Test cases
```
  1 -> 11
  2 -> 44
  3 -> 99
 10 -> 10100
174 -> 30306276
```
# Scoring
Shortest Code in Bytes wins.
  
[Answer]
## [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
Ð«*
```
**Explained**
```
Ð    # triplicate input
 «   # conactenate
  *  # multiply
```
[Try it online](http://05ab1e.tryitonline.net/#code=w5DCqyo&input=MTI)
[Answer]
## JavaScript (ES6), 10 bytes
```
_=>(_+_)*_
```
Needs to be called with the argument as a `String`, not a `Number`.
### Usage:
```
(_=>(_+_)*_)('3')
99
```
-3 bytes thanks to [@Quill](https://codegolf.stackexchange.com/users/41519/quill)'s suggestion.
[Answer]
# Java 8, ~~29 26 25~~ 21 Bytes
God bless lambda
```
c->new Long(c+""+c)*c
```
~~c->Long.decode(c+""+c)\*c;~~
[Answer]
## vim, 11
```
C<C-r>=<C-r>"<C-r>"*<C-r>"<cr>
```
crcrcrcrcr...
```
C       change (delete and enter insert mode) until the end of the line
<C-r>=  insert an expression via the special "expression register"
<C-r>"  insert the contents of the default register (what we just C'd)
<C-r>"  ... again
*       multiplied by
<C-r>"  the input (again)
<cr>    insert the result of this expression
```
[Answer]
# Pyth, ~~5~~ 4 bytes
```
*s+`
```
Explanation:
```
    Q    input
   `     representation, basically str(Q)
  +  Q   add Q to its own string form
 s       parse int
*     Q  multiply by input
         print
```
[Test it here](http://pyth.herokuapp.com/?code=%2As%2A2%60&input=12&test_suite=1&test_suite_input=1%0A2%0A3%0A10%0A174&debug=1).
[Answer]
# Emacs, 17 bytes
`(``\*``SPACE``C-SPACE``C-E``M-Y``SPACE``C-Y``C-Y``)``C-J`
### Explanation
* `(``\*``SPACE` adds `(*`  at point (before the number);
* `C-SPACE``C-E``M-Y` Select and copy the number;
* `SPACE` adds a space character at point (after the number);
* `C-Y``C-Y` pastes two times the number at point;
* `)` adds `)` at the end;
* `C-J` interprets the line as a LISP expression and prints its result.
### Exemple
Cursor represented by a pipe (`|`)
* `|174`
* `(``\*``SPACE` `(* |174`
* `C-SPACE``C-E``M-Y` `(* 174|`
* `SPACE` `(* 174 |`
* `C-Y``C-Y` `(* 174 174174|`
* `)` `(* 174 174174)|`
* `C-J`
### Result
```
(* 174 174174)
30306276|
```
[Answer]
# Python 2.7, 21 bytes:
```
lambda f:int(`f`*2)*f
```
Well, this has to be the shortest Python answer I have ever written in the shortest amount of time ever. It's an anonymous lambda function that can be executed by naming it anything you want and then calling it like a normal function wrapped in `print()`. For instance, if your input is `12`, and the function was named `H`, this this would be called like `print(H(12))`.
[Try It Online! (Ideone)](http://ideone.com/DPWJQ8)
Note that this only works for values up and equal to `9223372036854775807` since any higher value and `repr()` puts a `L` at the end of the integer. Therefore, for values greater than `9223372036854775807`, this **24 byte** version would be the one that works:
```
lambda f:int(str(f)*2)*f
```
[Try This Online! (Ideone)](http://ideone.com/OUZGUo)
[Answer]
# C#, 19 23 bytes
```
n=>int.Parse(""+n+n)*n;
```
# Without strings, 47 bytes
```
n=>{int i=1;while(i<=n)i*=10;return(i+1)*n*n;};
```
[Answer]
## Jelly, 4 Bytes
```
;DḌ×
```
[Try it online](http://jelly.tryitonline.net/#code=O0ThuIzDlw&input=&args=MTc0)
## Explanation
```
;DḌ×    Main link. argument : N
 D      Decimal; Yield the digits of N
;       Concatenate N and its digits
  Ḍ     Convert to integer; We get O
   ×    Multiply O and N
```
[Answer]
# J, 7 bytes
```
*,~&.":
```
## Explanation
```
*,~&.":  Input: n
     ":  Format n as a string
 ,~&.    Reflect and join the string to make "nn"
         and parse the string to get a number
*        Multiply that number by n
```
[Answer]
# C, ~~70~~ ~~68~~ ~~54~~ ~~53~~ ~~52~~ 44
```
f(n){return(pow(10,(int)log10(n)+1)*n+n)*n;}
```
Previous version (48 bytes, no math functions), saved 16 bytes thanks to @LeakyNun, 1 byte thanks to @FryAmTheEggman, 4 bytes thanks to @TobySpeight:
```
f(n,d,i){for(i=d=n;d;d/=10)i*=10;return(i+n)*n;}
```
Call `f()` with one argument, the number, and it returns the corresponding uninteresting number.
## Test program
```
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
    while (*++argv) {
        int n = atoi(*argv);
        printf("%d -> %d\n", n, f(n));
    }
    return 0;
}
```
## Test results:
```
$ ./84712 1 2 3 4 10 174
1 -> 11
2 -> 44
3 -> 99
4 -> 176
10 -> 10100
174 -> 30306276
```
[Try it online!](http://ideone.com/Ighcg1)
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 7 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
⊢×#⍎⍕,⍕
```
`⍕` string representation
`⍕,` prepend string representation
`#⍎` make into number (in root namespace)
`⊢×` multiply by original number
[Answer]
## [Retina](https://github.com/m-ender/retina), ~~27~~ 20 bytes
```
^
$_$*: $_
:
$_$*:
:
```
Gets a bit slow for large inputs, because before the last the stage the result is represented in unary.
[Try it online!](http://retina.tryitonline.net/#code=JShHYApeCiRfJCo6ICRfCjoKJF8kKjoKOg&input=MQoyCjMKMTAKMTI) (The first line enables a linefeed-separated test suite.)
### Explanation
I'll use `2` as an example input (because the unary representations get a bit unwieldy for larger inputs).
**Stage 1: Substitution**
```
^
$_$*: $_
```
By matching the beginning of the string with `^` we simply prepend some stuff. `$_` refers to the input string itself and `$*:` means we insert that many colons. So we get:
```
:: 22
```
**Stage 2: Substitution**
```
:
$_$*:
```
Now we match every `:` and again replace it with `$_$*:`. Of course, this time `$_` doesn't evaluate to an integer (but to `:: 22` in our example), but `$*` just looks for the first decimal in the string, so this evaluates to the input concatenated to itself (`O` in the challenge specification). We'll end up with `N*O` colons, followed by `O`:
```
:::::::::::::::::::::::::::::::::::::::::::: 22
```
**Stage 3: Match**
```
:
```
All that's left is counting the `:`s to convert from unary back to decimal, which is exactly what this stage does.
[Answer]
# [CJam](https://sourceforge.net/p/cjam/wiki/Home/), 8 bytes
```
ri_`_+i*
```
[**Try it online!**](http://cjam.tryitonline.net/#code=cmlfYF8raSo&input=MTI)
```
r     e# Read input
i     e# Convert to integer
_     e# Duplicate
`     e# Convert to string
_     e# Duplicate
+     e# Concatenate
i     e# Convert to integer
*     e# Multiply. Implicitly display
```
[Answer]
# Jelly, ~~8~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ŒṘẋ2v×
```
[Try it online!](http://jelly.tryitonline.net/#code=xZLhuZjhuosydsOX&args=MTI)
## Explanation
```
ŒṘẋ2v× - Main link. Left argument: the number to convert
     × - Multiply
    v  - an evaluation of the left argument
ŒṘ     - converted to string
  ẋ    - multiplied by
   2   - two and the left argument
```
[Answer]
# Awk, 13 bytes
```
$0=($0$0)*$0
```
Set the line to 2 of itself multiplied by itself
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
:?c:?*.
```
### Explanation
```
:?c      Concatenate Input to itself
   :?*.  Output is that concatenation times Input
```
[Answer]
# Python, 42 bytes
Pure arithmetic approach, without strings!
```
f=lambda n,m=1:m<=n and f(n,m*10)or-~m*n*n
```
[Ideone it!](http://ideone.com/vtE7wa)
[Answer]
# Matlab / Octave, 20 bytes
```
@(x)eval([x x 42 x])
```
This is an anonymous function that takes the input as a string.
Example use:
```
>> f = @(x)eval([x x 42 x])
f = 
    @(x)eval([x,x,42,x])
>> f('12')
ans =
       14544
```
Or [try it online with ideone](http://ideone.com/AmRGvN).
### Explanation
The code builds a string by concatenating the input string twice, then the character `*` (that has ASCII code 42), then the string again. The concatenated string is then evaluated.
[Answer]
## Lua, 20 Bytes
Takes in a command-line argument, and outputs via STDOUT
```
a=...print((a..a)*a)
```
And ungolfed as @LeakyNun asked in the comment :)
```
a=...       -- alias for the first argument
print(
     (a..a) -- concatenate a with itself, equivalent to a:rep(2)
     *a)    -- multiply the resulting number by a
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 6 bytes
```
tVthU*
```
[**Try it online!**](http://matl.tryitonline.net/#code=dFZ0aFUq&input=MTI)
```
tV     % Input number implicitly. Duplicate and convert to string
th     % Duplicate and concatenate the two equal strings
U      % Convert to number
*      % Multiply
```
[Answer]
## zsh, 13 bytes
```
<<<$[$1$1*$1]
```
Takes input as a command line argument, outputs to STDOUT.
This only works in zsh, but here's **15 bytes in Bash** using `echo` instead of `<<<`:
```
echo $[$1$1*$1]
```
[Answer]
## Perl, 11 bytes
```
$_*=$_ x2
```
+ the `p` and `l` flags.
(run with `perl -ple '$_*=$_ x2'`)
-2 bytes thanks to pipe.
[Answer]
## Excel VBA, 35 Bytes
Sub called with number, msgbox returns answer
```
Sub B(a)
MsgBox (a & a) * a
End Sub
```
**Alternative Excel VBA, 42 Bytes**
Number given in formula, returns answer.
```
Function B(a)
B = (a & a) * a
End Function
```
[Answer]
## Pyke, ~~5~~ 4 bytes
```
`+b*
```
[Try it here!](http://pyke.catbus.co.uk/?code=%60%2Bb%2a&input=12)
```
`    -    str(input)
 +   -   ^+input  (convert to string implicitly)
  b  -  int(^)
   * - ^*input
```
Also 5 bytes with string inputs
```
+bRb*
+]mbB
```
[Answer]
# PHP, ~~25~~ 24 bytes
Short opening tags are useful for surprisingly few golfing challenges, luckily this is one of them.
Unfortunately operator precedence is the opposite of the order you need to do them in so lots of brackets are needed.
```
<?=($a=$argv[1])*"$a$a";
```
edit: I realised that seeing as how I'm using brackets anyway I can effectively skip the concatenation operator by changing the written order of the operations around.
[Answer]
# dc, ~~11~~ 10 bytes
```
ddZAr^1+**
```
I *knew* that eventually I would find a use for the `Z` command!
Operation is fairly simple - count the digits, take 10 raised to that power and add one. This gives a multiplier that concatenates the number with itself. Then just multiply.
I/O uses the stack, as usual for dc.
## Full program
This is what I used for the tests:
```
#!/usr/bin/dc
?
ddZAr^1+**
p
```
The two extra commands give us pipeline I/O.
## Tests
```
$ for i in 1 2 3 10 174; do printf '%d -> ' $i; ./84712.dc <<<$i; done
1 -> 11
2 -> 44
3 -> 99
10 -> 10100
174 -> 30306276
```
Thanks are due to Sir Biden XVII (1 byte).
[Answer]
# Mumps, 11 bytes
```
R I W I_I*I
```
This is one of those rare golf challenges where the idiosyncrasies of Mumps can come in very handy. First, all variables are strings, and all math equations are strictly evaluated left-to-right (as in: not PEMDAS), so 1+2\*4=12 in Mumps instead of =9 the way PEMDAS would. So, (barely) ungolfed:
```
R I ;     Read from stdin to variable I
W I_I*I ; Write out I concatenated with I, then multiplied by I.
```
Word of caution - because the flavour of Mumps that I'm using (InterSystems Ensemble) does not echo the carriage return for stdin, the input and output number will appear concatenated. To rectify that / increase readability, you'd need to add two bytes and add a manual CR/LF, thusly:
```
R I W !,I_I*I
```
However, as I didn't see that requirement in the rules of the challenge, I'm pretty sure that I'm good with the shorter code. If I'm mistaken, please feel free to LART me and I'll modify my answer. :-)
[Answer]
# PowerShell, ~~25~~, 18 bytes
Thank you TessellatingHeckler for reminding me how much PS loves the pipeline.
New 18 bytes:
```
process{$_*"$_$_"}
```
Old 25 bytes:
```
param($a);[int]"$a$a"*$a
```
Explanation:
```
# new
process{$_*"$_$_"}
process{         } # runs code block once for each passed item
        $_*        # multiple the first parameter
           "$_$_"  # concatenate as a string for ease
                   # in this case, the order does the typecasting for us
# old
param($a);[int]"$a$a"*$a
param($a)                 # assigns the first passed parameter to variable $a
         ;                # line terminator
          [int]           # type cast string "$a$a" to int32
               "$a$a"     # convert $a$a to string for easy concatenation
                     *$a  # multiply by $a
```
Testing (save as boring.ps1):
```
# new
12 | .\boring.ps1
14544
174 | .\boring.ps1
30306276
# old
.\boring.ps1 12
14544
.\boring.ps1 174
30306276
```
Definitely not the winning answer, but fun regardless!
[Answer]
## Batch, ~~27~~ ~~20~~ 18 bytes
```
@cmd/cset/a%1%1*%1
```
Edit: Saved 7 bytes thanks to @TessellatingHeckler. Saved a further 2 bytes thanks to @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.
]