[Question]
  [
As I'm applying for some jobs whose job advert doesn't state the salary, I imagined a particularly evil interviewer that would give the candidate the possibility to decide their own salary ...by "golfing" it!
So it goes simply like that:
> 
> Without using numbers, write a code that outputs the annual salary you'd like to be offered.
> 
> 
> 
However, being able to write concise code is a cornerstone of this company. So they have implemented a very tight seniority ladder where
> 
> employers that write code that is *b* bytes long can earn a maximum of ($1'000'000) ¬∑ *b*-0.75.
> 
> 
> 
we are looking at (these are the integer parts, just for display reasons):
```
   1 byte  ‚Üí $1'000'000       15 bytes ‚Üí $131'199
   2 bytes ‚Üí   $594'603       20 bytes ‚Üí $105'737
   3 bytes ‚Üí   $438'691       30 bytes ‚Üí  $78'011
   4 bytes ‚Üí   $353'553       40 bytes ‚Üí  $62'871
  10 bytes ‚Üí   $177'827       50 bytes ‚Üí  $53'182
```
### The challenge
Write a program or function that takes no input and outputs a text containing a dollar sign (`$`, U+0024) and a decimal representation of a number (integer or real).
* Your code cannot contain the characters `0123456789`.
In the output:
* There may optionally be a single space between the dollar sign and the number.
* Trailing and leading white spaces and new lines are acceptable, but any other output is forbidden.
* The number must be expressed as a decimal number using only the characters `0123456789.`. This excludes the use of scientific notation.
* Any number of decimal places are allowed.
**An entry is valid if** the value it outputs is not greater than ($1'000'000) ¬∑ *b*-0.75, where *b* is the byte length of the source code.
### Example output (the quotes should not be output)
```
"$ 428000"            good if code is not longer than 3 bytes
"$321023.32"          good if code is not longer than 4 bytes
"  $ 22155.0"         good if code is not longer than 160 bytes
"$ 92367.15 \n"       good if code is not longer than 23 bytes
"300000 $"            bad
" lorem $ 550612.89"  bad
"¬£109824"             bad
"$ -273256.21"        bad
"$2.448E5"            bad
```
### The score
The value you output is your score! (Highest salary wins, of course.)
---
## Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, $X (Y bytes)
```
where `X` is your salary and `Y` is the size of your submission. (The `Y bytes` can be anywhere in your answer.) If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>$111111.111... (18 bytes)</s> <s>$111999 (17 bytes)</s> $123456 (16 bytes)
```
You can also make the language name a link, which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), $126,126 (13 bytes)
```
```
var QUESTION_ID=171168,OVERRIDE_USER=77736;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body.replace(/<(s|strike)>.*?<\/\1>/g,"");s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a1=r.match(SCORE_REG),a2=r.match(LANG_REG),a3=r.match(BYTES_REG);a1&&a2&&e.push({user:getAuthorName(s),size:a3?+a3[1]:0,score:+a1[1].replace(/[^\d.]/g,""),lang:a2[1],rawlang:(/<a/.test(a2[1])?jQuery(a2[1]).text():a2[1]).toLowerCase(),link:s.share_link})}),e.sort(function(e,s){var r=e.score,a=s.score;return a-r});var s={},r=1,a=null,n=1;e.forEach(function(e){e.score!=a&&(n=r),a=e.score,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.lang).replace("{{SCORE}}","$"+e.score.toFixed(2)).replace("{{SIZE}}",e.size||"?").replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);s[e.rawlang]=s[e.rawlang]||e});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var r=e.rawlang,a=s.rawlang;return r>a?1:r<a?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SCORE}}","$"+o.score.toFixed(2)).replace("{{SIZE}}",o.size||"?").replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var LANG_REG=/<h\d>\s*((?:[^\n,](?!\s*\(?\d+\s*bytes))*[^\s,:-])/,BYTES_REG=/(\d+)\s*(?:<a[^>]+>|<\/a>)?\s*bytes/i,SCORE_REG=/\$\s*([\d',]+\.?\d*)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:520px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td><td>Size</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SCORE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SCORE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
---
Edit: (rounded) maximum allowed score per byte count, for a quicker reference - [text here](https://tio.run/##HcFBCoAgEADAryySsIqKi0jRob8EZe1FQ7z0@g2aed5xt5pESuvAwBX6Xq8TyVEmsz6d60Cl0wHebzBpWgLFojSyo/izbC36GOZsjBH5AA):
[![enter image description here](https://i.stack.imgur.com/HpQNN.png)](https://i.stack.imgur.com/HpQNN.png)
  
[Answer]
# bash, $127127
```
x;echo \$$?$?
```
[Try it online!](https://tio.run/##S0oszvj/v8I6NTkjXyFGRcVexf7/fwA)
Since the `x` command doesn't exist, it errors and sets the exit code to `127`.
Then, the code outputs a dollar sign followed by `$?` twice. The `$?` variable stores the exit code of the previous command, so this outputs `$127127` in **13 bytes**.
[Answer]
# Java 8, $131,199.00 (15 bytes)
```
v->"$"+'e'*'‘ì'
```
[Try it online.](https://tio.run/##LY1BCsIwEEX3PcVQhKRKe4GiN7AbwY24GNMoqem0NJOASE/h1bxPTLGbD/Pn8V@HAcuufUZl0Tk4oqF3BmCI9XRHpaFZToATT4YeoOR5MC2Eok7tnKVwjGwUNECwhxjKQ77Jd0KLrfh@RKwXZPQ3m5CVDMtAnzzyv3m5Ahar5OVY99XguRrTiy1JqpQkb22xGuf4Aw)
**Explanation:**
```
v->            // Method with empty unused parameter and String return-type
  "$"+         //  Return a dollar sign, concatted with:
      'e'*'‘ì'  //  131199 (101 * 1299)
```
\$131,199.00 < 131,199.31\$
I used [a program to generate](https://tio.run/##XZBba4NAEIXf/RXDkuJa0bINFIJNIL28NU@hpVBL2aqJk3oJOgqh@NvtbmLU9GV3Z77DOTO7k7V0duFP2waJLEtYScx@DYB99Z1gACVJUledYwipQnxNBWbbj0@QlpYBBLEsQJYB4qN@zcEE0xtIWiWEDweKxvSIw1xFRECy2EakiJgKMZuF3himmCnydCzc1fL962358vp8kmzygmNGgHNxe@cBLqZCnY7TzdV7BLGy6FJuAL1LWstEYaW5AnFGuOG6fa/jezfohlHE61vjvbne18IB/l/9JAjis6IxhnN9KClK3bwid68@mJKMs9pZ@GziM9tkdh9kM1PXF96q55NPfMJs3guvLySWzSxm6eTGaNr2Dw) a printable ASCII character in the range `[32, 126]` which, when dividing `131199`, would have the lowest amount of decimal values. Since `101` can divide `131199` evenly, resulting in `1299`, I'm only 31 cents short of my maximum possible salary based on my byte-count of 15.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), (5 bytes) $294204.018...
```
'$PB#
```
[Try it online!](https://tio.run/##S85KzP3/X10lwEn5/38A "CJam ‚Äì Try It Online")
Explanation:
I derived it from Dennis' answer, but looked for combinations of numbers which would yield a higher result. I almost gave up, but I saw that `P` is the variable for \$\pi\$, and that \$\pi^{11} \approx 294000\$. The letter `B` has a value of 11 in CJam, giving the code above. 
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 5 bytes, $262'144
```
'$YI#
```
[Try it online!](https://tio.run/##S85KzP3/X10l0lP5/38A "CJam ‚Äì Try It Online")
### How it works
```
'$     Push '$'.
  Y    Push 2.
   I   Push 18.
    #  Pop 2 and 18 and perform exponentiation, pushing 262144.
```
[Answer]
# [R](https://www.r-project.org/), 20 bytes, `$103540.9`
```
T=pi+pi;cat("$",T^T)
```
[Try it online!](https://tio.run/##K/pvmGqmZWQQp6tnbvo/xLYgU7sg0zo5sURDSUVJJyQuRPP/fwA "R ‚Äì Try It Online")
The max for 20 bytes is `$105737.1`, so this is quite close to the salary cap!
This would be a nice raise, and if I get paid to do code golf......
[Answer]
# [GS2](https://github.com/nooodl/gs2), (5 bytes) $292,929
```
‚Ä¢$‚ò∫‚ÜîA
```
A full program (shown here using [code-page 437](https://en.wikipedia.org/wiki/Code_page_437#Character_set)). (Maximum achievable salary @ 5 bytes is $299069.75)
**[Try it online!](https://tio.run/##Sy82@v//UcMilUczdj1qm@L4/z8A "GS2 ‚Äì Try It Online")**
Builds upon Dennis's [GS2 answer](https://codegolf.stackexchange.com/a/171179/53748)...
```
‚Ä¢$‚ò∫‚ÜîA                             []
‚Ä¢$    - push '$'                  ['$']
  ‚ò∫   - push unsigned byte:
   ‚Üî  -   0x1d = 29               ['$',29]
    A - push top of stack twice   ['$',29,29,29]
      - implicit print            $292929
```
[Answer]
# [Self-modifying Brainfuck](https://soulsphere.org/hacks/smbf/), 16 bytes, $124444
```
<.<++.+.++..../$
```
[Try it online!](https://tio.run/##K85NSvv/30bPRltbDwi19YBAX@X/fwA "Self-modifying Brainfuck ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), 21 bytes $99649.9
```
cat("$",min(lynx^pi))
```
[Try it online!](https://tio.run/##K/qfnJSZl6JhaGFlZKxjmGqmBWFqxunqmZtq/k9OLNFQUlHSyc3M08ipzKuIK8jU1Pz/HwA "R ‚Äì Try It Online")
A different `R` approach - see also [Giuseppe's answer](https://codegolf.stackexchange.com/a/171171/80010)
Very close to the maximum of $101937 for this bytecount.
## Bonus: `object.size()`
### [R](https://www.r-project.org/), 24 bytes $89096
```
cat("$",object.size(ls))
```
[Try it online!](https://tio.run/##K/qfnJSZl6JhaGFlZKpjmGqmBWFqxunqmZtq/k9OLNFQUlHSyU/KSk0u0SvOrErVyCnW1Pz/HwA "R ‚Äì Try It Online")
This is probably system-dependent, but when I ra this on TIO I got $89096 - close to the limit of 92223 for 24 bytes.
[Answer]
# JavaScript (ES6), 19 bytes, $109,839
```
_=>atob`JDEwOTgzOQ`
```
[Try it online!](https://tio.run/##FcwxDoIwFADQnVP8rW3Ushi3MhhdHCRGdym1hZLaT9oCwcsj7C@vk6OMKtg@HTx@9GLE8haFTFhXt8t1Kl/Nr3xUS55Dj2421jkwGIBsgjKyh6m1qgUbwWMCCV4mO2q4rxfvIpjBq2TRZ5sHARFEAefBGB24CfilEXZA1obUMurTkTCe8JmC9Q0ltfUyzIRlmUIf0WnusKGGMrb8AQ "JavaScript (Node.js) ‚Äì Try It Online")
\$109839\$ is the highest integer \$\le 109884\$ which does not produce any digit when prefixed with **'$'** and encoded in base64.
---
# Without `atob()` (Node.js), 26 bytes, $86,126
```
_=>'$'+Buffer('V~').join``
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k5dRV3bqTQtLbVIQz2sTl1TLys/My8h4X9yfl5xfk6qXk5@ukaahqbmfwA "JavaScript (Node.js) ‚Äì Try It Online")
The concatenation of **'$'** with the ASCII codes of **'V'** (86) and **'~'** (126).
[Answer]
# PHP, $131116 (8 bytes)
Didn't see one for php and wanted to throw one up. I know someplace in php is a bad typecast that would cut this in half but I can't find it right now.
```
$<?=ERA;
```
This just takes advantage of PHP short tags and the PHP built in constants.
**[Try it online!](https://tio.run/##K8go@P9fxcbe1jXI0fr/fwA)**
[Answer]
# [GS2](https://github.com/nooodl/gs2), 5 bytes, $291'000
```
‚Ä¢$‚ò∫‚Üî‚àü
```
This is a [CP437](https://en.wikipedia.org/wiki/Code_page_437#Character_set) representation of the binary source code.
[Try it online!](https://tio.run/##Sy82@v//UcMilUczdj1qm/KoY/7//wA "GS2 ‚Äì Try It Online")
### How it works
```
‚Ä¢$     Push '$'.
  ‚ò∫‚Üî   Push 29.
    ‚àü  Push 1000.
```
[Answer]
## Excel 19 bytes $107899.616068361
```
="$"&CODE("(")^PI()
```
**Explanation:**
```
     CODE("(")        // find ASCII code of ( which is 40
              ^PI()   // raise to power of Pi  (40^3.141592654)
 "$"&                 // append $ to the front of it
=                     // set it to the cell value and display
```
[Answer]
## vim, ~~$99999~~ ~~$110000~~ $120000
```
i$=&pvh*&ur
```
[Try it online!](https://tio.run/##K/v/P1NFyFatoCxDS620iOv/fwA)
Uses the expression register (note that there is a <C-r> character, which is invisible in most fonts, between the `$` and `=`, for a total of **13 bytes**) to insert the value of the `'pvh'` option times the value of the `'ur'` option.
`'previewheight'` is the option that controls the height of preview windows, which is 12 by default.
`'undoreload'` is the maximum number of lines a buffer can have before vim gives up on storing it in memory for undo, and it defaults to 10,000.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~$256000 $256256~~ (6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)) $257256
```
‚Åπ‚Äò‚Äù$;;
```
A full program. (Maximum achievable salary @ 6 bytes is $260847.43)
**[Try it online!](https://tio.run/##y0rNyan8//9R485HDTMeNcxVsbb@/x8A "Jelly ‚Äì Try It Online")**
### How?
```
‚Åπ‚Äò‚Äù$;; - Main Link: no arguments
‚Åπ      - Literal 256                            256
 ‚Äò     - increment                              257
  ‚Äù$   - single '$' character                   '$'
    ;  - concatenate                            ['$',257]
     ; - concatenate                            ['$',257,256]
       - implicit print                      -> $257256
```
---
Previous...
5 bytes $256256
```
‚Äù$;‚Åπ‚Å∫
```
('$' concatenate 256, repeat 256 - causing interim implicit printing)
6 bytes $256000:
```
‚Åπ√ó»∑·π≠‚Äù$
```
(256 √ó 1000 ·π≠ack '$')
[Answer]
# C#
## Full program, ~~72 bytes, $40448~~ 66 bytes, $43008
```
class P{static void Main()=>System.Console.Write("$"+('T'<<'i'));}
```
[Try it online!](https://tio.run/##Sy7WTc4vSv3/PzknsbhYIaC6uCSxJDNZoSw/M0XBNzEzT0PT1i64srgkNVfPOT@vOD8nVS@8KLMkVUNJRUlbQz1E3cZGPVNdU9O69v9/AA "C# (.NET Core) ‚Äì Try It Online")
### Explanation
Left-shift operator treats chars `'T'` and `'i'` as integers 84 and 105 respectively and performs shift
## Lambda, ~~19 bytes, $109568~~ 17 bytes, $118784
```
o=>"$"+('t'<<'j')
```
[Try it online!](https://tio.run/##JcpLCsIwEADQq4QiJMHPBZJ2I7gTCi5chzHISJyBzEQopWePgqu3eSBH4Jp7E6SnuS2i@R2gJBEzr6JJEcyH8WGuCcn59dIIomj97YP5O6Wx8zgNu2HvrNoY7cv6Hs5MwiWf7hU1u@SoleJ92Lb@BQ "C# (.NET Core) ‚Äì Try It Online")
**Edit** Thanks to @LegionMammal978 and @Kevin for saving 2 bytes
[Answer]
# PHP, 13 Bytes, $144000 Salary
Unfortunately for this job, moving to Mauritius is required (well, I could move slightly less far eastward, however every timezone less would yield at $36k drop in salary.) To compensate for the inconvenience, my salary increases by $1 every leap year.
```
$<?=date(ZL);
```
This just puts out `Z` the timezone in seconds and appends whether or not it's a leap year.
[Answer]
# [brainfuck](https://esolangs.org/wiki/Brainfuck), 43 bytes, $58888
```
++++++[>++++++<-]>.<++++[>++++<-]>+.+++....
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwyi7SC0jW6snZ4NQgTE19YDMvSA4P9/AA "brainfuck ‚Äì Try It Online")
### How it works
```
++++++[>++++++<-]>.  write 36 to cell one and print (36 is ASCII for $)
<++++[>++++<-]>+.    add 17 to cell 1 and print (cell 1 is now 53, ASCII for 5) 
+++....              add 3 to cell 1 and print 4 times (cell 1 is now 56, ASCII for 8)
```
[Answer]
# [Python 3](https://docs.python.org/3/), (22 bytes) $ 98,442
```
print('$',ord('òÇä'))
```
**[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ11FXSe/KEVD/cOMpi51Tc3//wE "Python 3 ‚Äì Try It Online")**
Much like Doorknob's [Ruby answer](https://codegolf.stackexchange.com/a/171180/53748), the 4 byte Unicode character used here, `òÇä`, has an ordinal value of the maximal integer salary achievable in 22 bytes.
Note that `print()` prints its unnamed arguments separated by spaces by default (`sep` is an optional named argument).
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), $207680 in 8 bytes
```
'o**n; $
```
[Try it online!](https://tio.run/##S8/PScsszvj/Xz1fSyvPWkHl/38A "Gol><> ‚Äì Try It Online")
### How it works:
```
'        Start string interpretation. Pushes the ASCII value of every character until it wraps back around to this character
 o       Output the top stack value as ASCII. This is the $ at the end of the code
  **     Multiply the top 3 stack values (This is the ASCII of 'n; ', 110*59*32
    n    Output top of stack as integer.
     ;   Terminate program
       $ (Not run, used for printing the $)
```
Interestingly enough, you can use `h` instead of `n;`, which yields `'o**h5$` with a score of $231504, but you can't use 0-9, and there isn't another 1-byte way to push 53, the ASCII value of `5`
[Answer]
# Mathematica, 18 bytes, $107,163.49
```
$~Print~N[E^(E!E)]
```
Full program; run using `MathematicaScipt -script`. Outputs `$107163.4882807548` followed by a trailing newline. I have verified that this is the highest-scoring solution of the form `$~Print~N[*expr*]` where `*expr*` is comprised of `Pi`, `E`, `I`, and `+-* /()!`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E) (5 bytes), $262626
```
'$‚ÇÇ√êJ
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fXeVRU9PhCV7//wMA "05AB1E ‚Äì Try It Online")
\$262626 < 299069\$. Pushes the character `$` to the stack, then pushes the integer \$26\$. From here, the program triplicates the integer, leaving the stack as `["$", 26, 26, 26]` and joins (`J`) the stack.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 23 bytes, $65535
```
_=>"$"+ +(~~[]+`xFFFF`)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k5JRUlbQVujri46Vjuhwg0IEjT/Wyfn5xXn56Tq5eSna6RpaOooGKaaaWkoKWmnaerlpOall2RoaenqmZtq/gcA "JavaScript (Node.js) ‚Äì Try It Online")
This is the best I can get without `atob`, though there is a large improvement space tbh
You know, having no short character to ascii conversion function sucks A LOT.
***AFTER A WHOLE DAY***
# [JavaScript (Node.js)](https://nodejs.org), 30 bytes, $78011
```
_=>"$"+`ìÇª`.codePointAt(![])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k5JRUk74cPkpt0JeslA0YD8zLwSxxINxehYzf/J@XnF@Tmpejn56RppGpqa/wE "JavaScript (Node.js) ‚Äì Try It Online")
## or: 29 bytes, $80020
```
_=>"$"+`ÚÄÄ†`.codePointAt(!_)
```
Where `ÚÄÄ†` is `U+13894 INVALID CHARACTER`
Oh `String.codePointAt`! I've just completely forgotten this!
## A joke one (15B, $130000), not vaild at all but just for fun
```
_=>"$ÂçÅ‰∏âËê¨"
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes, $210176.48625619375
```
‚ÅΩ¬Ω"√ó¬Ω‚Äù$,
```
3535 (`‚ÅΩ¬Ω"`) multipli(`√ó`)ed by its sqrt (`¬Ω`).
[Try it online!](https://tio.run/##y0rNyan8//9R495De5UOTz@091HDXBWd//8B "Jelly ‚Äì Try It Online")
[Answer]
# Perl 5.26.2, 12 bytes, $146002
```
say$]^"\x11\x0e\x01\x06"
```
Hex escapes only shown because ASCII control chars are filtered out.
[Try it online!](https://tio.run/##K0gtyjH9/784sVIlNk5dkI@RTf3//3/5BSWZ@XnF/3V9TfUMDA0A "Perl 5 ‚Äì Try It Online")
You can get a bit more with different Perl versions, for example $155012 with 5.25.12.
[Answer]
## MATLAB, 17 bytes, $112222
```
['$','..////'+pi]
```
Old answer:
```
['$','RRUUTR'-'!']
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 34 bytes, $69999
```
+[->-[---<]>-]>.[-->+++<]>.+++....
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1rXTjdaV1fXJtZON9ZOD8i009bWBvL0gJQeEPz/DwA "brainfuck ‚Äì Try It Online")
### Explanation:
```
+[->-[---<]>-]>.   Generate and print 36 ($)
[-->+++<]>         Divide by 2 and multiply by 3 to get 54 (6)
          .        Print 6
           +++.... Print 9999
```
[Answer]
## Ruby, $119443
```
$><<?$<<?ùäì.ord
```
[Try it online!](https://tio.run/##KypNqvz/X8XOxsZeBYg/zO2arJdflPL/PwA)
The maximum integer output for 17 bytes. The Unicode character is U+1D293, which is 119443 in hex.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), $353535 (4 bytes)
```
'$W‚àô
```
[Try it online!](https://tio.run/##y00syUjPz0n7/19dJfxRx8z//wE "MathGolf ‚Äì Try It Online")
## Explanation
```
'$    Push "$"
  W   Push 35
   ‚àô  Triplicate top of stack
```
## Disclaimer
This language was created after the posting of this question. While the language is a general language, it is designed with numerical questions in mind. It contains a lot of 1-byte number literals, and other nifty things for number-related questions. It is still a work in progress. 
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), $169169 10 bytes
```
Dd*d[$]nnn
```
[Try it online!](https://tio.run/##S0n@/98lRSslWiU2Ly/v/38A "dc ‚Äì Try It Online")
This prints 13 (`D`) squared, twice
[Answer]
# Japt, 5 bytes, $262144
```
'$+I¬≥
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.6&code=JyQrSbM=)
---
Explanation
`I` is the Japt constant for `64`, `¬≥` cubes it and then `'$+` concatenates that with the dollar symbol.
]