[Question]
  [
All the [quine](/questions/tagged/quine "show questions tagged 'quine'") challenges on this site are focused on byte count, or the characters themselves. This one is different. Your challenge is to write a program that produces output which has a code point sum identical to the source's code point sum.
To produce a code point sum:
1. Find the values of the characters in the program's character set.  
For example - `FOO` in ASCII: `F` = 70, `O` = 79, `O` = 79
2. Add them all together.  
Code point sum of `FOO` in ASCII: `F`+`O`+`O` = 70+79+79 = 228.
An example of an ASCII sum quine would be if the source code was `ABC` and the output was `!!!!!!`. This is because the sum of the the ASCII values of the source (`A` = 65, `B` = 66, `C` = 67, sum = 198) is the same as the sum of the ASCII values in the output (`!` = 33, 33\*6 = 198). `BBB` would also be valid output, as would `cc`.
# Rules
* Your program must not be a reverse, shuffled, error, or any other type of "true" quine. To elaborate: If the output contains all the same characters as the source, it is invalid.
* Your program cannot use any errors/warnings from the compiler/interpreter as the output.
* Your program's source must use the same codepage as the output.
* Your program may use any codepage that was created before this challenge was.
* Your program's output must not contain any unprintable characters (e.g. ASCII 0 through 31, or above 127) aside from linefeeds and tabs.
* Standard loopholes apply.
* If the source and/or output has a trailing linefeed, it must be included in the code point sum.
* Compiler flags need to be included in the final byte count (score), but not the source's code point sum.
* The output/source may not be empty.
# Scoring
Shortest answer in byte count (not code point sum) wins. Please use this header format answers:
```
# Jelly, 12 bytes, sum 56 (SBCS)
```
You can use [this tool](https://tio.run/##fVA9b8IwEN3zK45ISAkBqbQbUQbKhNShEmNbgeVcgqXERraTDlV/u3uHgYqh9WDfx3v3fE8uWilDUNpDL5TOOBC2lXOQR2FhNqNkzJOvBOioBjJuwqSCpxxikc/JEq/J0tcOhUNKzahqBP9pQJq@F7qGTmnkyUOP2jtojIX1brPdght6Bp2EVc7oSZqXt7EW/WA1LJax9J2cH@GkUvtRdAPuf4n8sfFt@XGh/wd6ZBANG42q/wLG7Z23192vK@48Be0KDlN3eNfpnCHlHeIFdeuPK5jWl36HOmMY4aKN5DEJRhYbkVEGFTyUZ8US6CqK/GYDd4sq9pI7qeigNDWeRItsZZRlYWLxmiGE9fMmSPkD) to calculate ASCII sums.
# Reference
Here are some useful codepage references.
* [ASCII table](http://asciitable.com)
* [UTF-8 table](http://www.utf8-chartable.de/)
* [UTF-16 table](http://www.fileformat.info/info/charset/UTF-16/list.htm)
* [EBCDIC table](http://www.astrodigital.org/digital/ebcdic.html)
* [Jelly SBCS table](https://github.com/DennisMitchell/jelly/wiki/Code-page)
* [CP-1252 table](https://en.wikipedia.org/wiki/Windows-1252#Character_set)
* [ISO-8859-1 table](https://en.wikipedia.org/wiki/ISO/IEC_8859-1#Codepage_layout)
```
/* Configuration */
var QUESTION_ID = 135571; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = (function(){
  var headerTag     = String.raw `h\d`
  var score         = String.raw `\-?\d+\.?\d*` // with negative/floating-point support
  var normalText    = String.raw `[^\n<>]*` // no HTML tag, no newline
  var strikethrough = String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
  var noDigitText   = String.raw `[^\n\d<>]*`
  var htmlTag       = String.raw `<[^\n<>]+>`
  return new RegExp(
  String.raw  `<${headerTag}>`+
  String.raw    `\s*([^\n,]*[^\s,]),.*?`+
  String.raw    `(${score})`+
  String.raw    `(?=`+
  String.raw      `${noDigitText}`+
  String.raw      `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+
  String.raw      `</${headerTag}>`+
  String.raw    `)`
  );
})();
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    lang = jQuery('<i>' + a.language + '</i>').text().toLowerCase();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link, uniq: lang};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.uniq > b.uniq) return 1;
    if (a.uniq < b.uniq) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  float: left;
}
#language-list {
  padding: 10px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654">
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# [Retina](https://github.com/m-ender/retina), 1 byte, sum = 58 (ASCII)
```
:
```
This counts the matches of `:` in the input (**0**), so it prints
```
0
```
The code points of `:`, `0`, and LF (linefeed) are **58**, **48**, and **10** (respectively), and **58 = 48 + 10**.
[Try it online!](https://tio.run/##K0otycxL/P/f6v9/AA "Retina – Try It Online")
[Answer]
# ArnoldC, 316 bytes, sum 20992 (ASCII)
Fun enough.
```
IT'S SHOWTIME
HEY CHRISTMAS TREE s
YOU SET US UP 1
HEY CHRISTMAS TREE iaV
YOU SET US UP 0
STICK AROUND s
GET TO THE CHOPPER iaV
HERE IS MY INVITATION iaV
GET UP 8
ENOUGH TALK
TALK TO THE HAND "H"
GET TO THE CHOPPER s
HERE IS MY INVITATION 2048
LET OFF SOME STEAM BENNET iaV
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED
```
I used [this](https://tio.run/##dZBRa8IwEMefl09x9GWWwXBjDyJ0kOlpgk0izdXhY6fdcGhXbDYE8bN3Z2EwhnvJkdzv/ztyzarYFu3Hy3u5CmCKTQXlIZTVugFZ10dxtS5fgZFVLwx92G@qt3ioq5Ac269iD83nLumLcLsr6t4heeTrTXKIBdf2JETNeNhWvS4eRZGmaw9euWfSBoXCJYxUpj0Z6YEyRGjE0uXgkSD3kM/h7hK0KRZ/sL7wpEczkJnL7ZgtU26RA1LIYTefY9alFGYI2oNZgrYLTZK0s13nHGDRQKB1@VQByXQmzsePRkkWRyq6pG7@Ed/3HwYiZd5NJuCdQfCE0sATWsuv57m/x42UTtPuZ0oukCm0QJgZbSXhmNcXx@LUfgM) and [this](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFBQzcWZkpqmAFSSrFFiFVxSlJmXrmnlmVdiW/2/LLFIobg019aAq0QvN7FAo8LWDsjVtq3Q5ALS/2u5uAqAykty8jTA2pWUlDy4RuFIhsAkoKnJVfsfAA) to do my calculations. Took me an hour and a half. But fun.
[Try It Online!](https://tio.run/##dY8xa8NADIX3@xWPLF3T0iHr1VEiEd/JnHQuHkO7FEIKzf/HPRsKpaSLBr3vfULnr@vn5f1tnsUfDMb66pIoME3ouIh5igYvRLiFSSuMHNVQBzzegz7O4x9sG8ylOyEWrXnfLMcWucKZWlmHgcraYioEMaQJkkfx6KJ5TZZCE@0CZa1Hhsf@FJbxo@HYxBve3FPf/hE/bZ93oW@8Hg4wTQRzigkvlHPbLnd/n@tY@n79jONIjaIMp5IkR6f9PH8D)
**How it works**
`STICK AROUND` is a loop, that loops `2048` times on the index `iaV`, but this index steps by `8`. So there is `256` loops, printing `H` and a linefeed (72+10 = 82, 82\*256 = 20992).
This is still *HIGHLY* golfable (by finding other calcs) but it is long and boring to measure your byte sum every time you do a modification.
Please tell me if I'm mistaken anywhere.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 1 byte, sum = 180 ([Charcoal SBCS](https://github.com/somebody1234/Charcoal/wiki/Code-page))
```
⁴
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R45b//wE "Charcoal – Try It Online") In Charcoal's code page, `⁴` has a code of `0xB4 = 180`, while the output is 4 `-`s which is `4 * 45 = 180`.
[Answer]
# Python 2, 11 bytes, sum 838 (ASCII)
```
print 76**8
```
prints
```
1113034787454976
```
Not very clever but it works
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EwdxMS8vi/38A "Python 2 – Try It Online")
[Answer]
# Jelly, 12 bytes, sum 948 (SBCS)
You said:
> 
> Jelly, 12 bytes
> 
> 
> 
then it's Jelly, 12 bytes.
```
\
³³³,:D+++
```
Was fun, since I don't know Jelly at all.
**How it works**
I don't have any idea.
But `³` does put 100 in the stack, `,` puts the stack in an array or something, `:` might concatenate the thing while `D` lists every letter of the last numeral (which does not exist), and +++ are for fun. The first and last line does not affect the output :)
[Try it Online!](https://tio.run/##y0rNyan8/z@G69BmENSxctHW1ub6/x8A)
Used [this](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFBQzcWZkpqmAFSSrFFiFVxSlJmXrmnlmVdiW/2/LLFIobg019aAq0QvN7FAo8LWDsjVtq3Q5ALS/2u5uAqAykty8jTA2pWUlGK4Dm0GQR0rF21tbS6giKYmhqJoEwMDHYXMvDQdBWMDg1iIotr/AA) to count.
[Answer]
# CJam/Japt/bc, 2 bytes, sum 97 (ASCII)
`A` 
[Try it Online](http://cjam.aditsu.net/#code=A%20) (CJam), [Try it Online](http://ethproductions.github.io/japt/?v=1.4.5&code=QSA=&input=) (Japt) (thanks @shaggy), 
The bc version works on command line, but not TIO.
Outputs `10`
Source: `A` + `Space` = 65 + 32 = 97
Output: `1` + `0` = 49 + 48 = 97
[Answer]
# [Haskell](https://www.haskell.org/), 9 bytes, byte sum 743 (ASCII)
Code:
```
show$29^9
```
Output:
```
14507145975869
```
[Try it online!](https://tio.run/##y0gszk7NyflfaBvzvzgjv1zFyDLO8n9uYmaegq1CQWlJcEmRQuH/f8lpOYnpxf91I5wDAgA "Haskell – Try It Online")
[Answer]
# [Cubically](https://git.io/cubically), 4 bytes, sum 141 (ASCII)
```
%44E
```
Outputs `3636`. [Try it online!](https://tio.run/##Sy5NykxOzMmp/P9f1cTE9f9/AA) And here's the [ASCII sum checker](https://tio.run/##fVA9a8MwEN39Ky4Ggx0n0DQhQ4yHUjoEOhQytiURsuwIbMlIsjuU/nb1LkpSMqQapPt4757u8XnDufdSOeiYVCkFzDR8BvzIDEynmIxZ9B0BHllDSk2YlLDMIBTp9AZ5dRq/tYJZgakeZSXAfWnguuuYqqCVStDkoRPKWai1gafd83YLdugI1DMjrVaTOCuuY41wg1EwX4TST3R6mOVS7kfWDmL/R6SPje@LzzP9P9AjgXDYqGV1Dxi2t85cdr@suHMYNBs4JPbwoeIZQYobxKtQjTtuIKnO/VaolGCICzaixygYWGREihmU8FCcFAvAK8@zqw3UzcvQi26kgoNcV6JnjSArgywJI4vW9N4nq9WLX66X618) I used.
Explanation:
* `%` means 'print face sum as integer'.
* `4` prints the sum of all values on the BACK face (36) twice.
* `E` is a no-op, just used to get the required sum.
[Answer]
*Some of these answers contain characters that will likely be invisible to you (particularly ASCII 17), click the TIO links to see their placement.*
# [Klein](https://github.com/Wheatwizard/Klein) 100/110, 4 bytes, sum 147
```
1
@
```
[Try it online!](https://tio.run/##y85Jzcz7/9@Qy0HwP5AyMAAA "Klein – Try It Online")
Output:
```
1 1
```
# [Klein](https://github.com/Wheatwizard/Klein) 201, 4 bytes, sum 147
```
1
@
```
[Try it online!](https://tio.run/##y85Jzcz7/1/QkMvh////RgaGAA "Klein – Try It Online")
Output:
```
1 1
```
# [Klein](https://github.com/Wheatwizard/Klein) (any topology), 5 bytes, sum 221 (ASCII)
```
111@
```
[Try it online!](https://tio.run/##y85Jzcz7/9/Q0NCB6////wYGBgA "Klein – Try It Online")
This prints
```
1 1 1
```
[Answer]
# Java 7, ~~88~~ 85 bytes, sum ~~7808~~ ~~7617~~ 7507 (ASCII)
```
class
w{public
static
void
main(String[]H){for(int
B=0;B<77;)System.out.print(B++);}}
```
Almost certainly golfable. It's pretty easy to tweak since we have some spare variables like the name of the class and the name of the program arguments parameter that we can change freely.
[Test it online!](https://tio.run/##fVJNT@MwEL3nVwyVkBIKyN9OyPaw3csi7WGlHlkEXscNlvJRxU7RqupvD3YDrDiAD7HH82bevBfrq1rrabKdh1bZLo0HNdT6EvSTGuDiIgT7LDkkEJbdQhqTcLYCmsF8GdduCHXbdPG7McqZEPZ7Wxnwzz3ovm1VV0FjOxM7j63pvINtP8D3zY/bW3BjG0E7NVjXd2eLrHxvOxg/Dh1c4fnqmJw25bS1D3vVjObhf2EcbH@H71/LvwKRCArN9r2tPgPO6p0f3rS/Sdz4cKhv4PHcPf7pFpcRUn5A/DJd7Z9u4Lx6zTemSyMs4GYbg8eBcK6KRqQhghWg8sRYQvgsl9m7DTG7XM255APV7KDuK7NTtYlWzrSROFRFmdM06UY5lzwfduPfxurEeeXDFtUnp38@S7q7/5kdwjTxCSTrFSrX36Qss80/50173Y/@@sSarsNo5fE4IUwo40LmBUYYY4IpZphjgSXOcUEQwYQQShjhRBBJclJQRDEllFJGORVU0pwWDDHMCKOMMc4EkyxnBUccc8IpZ5xzwSXPeSGQwIIIKpjgQggpclFIJLEkkkomuRQv "C (gcc) – Try It Online")
[Try it online!](https://tio.run/##Dcq7DkAwFADQvV/SRojNUJZOdqMYLkWuR9voRaTx7WU6y1nggtS60Sx6jXHYwHt2B3f2Gw7ME9DPZVGzHdDwhg40c9vVIkz24GiIqSqXqiwKKZrH07hn9qTM/Y24ShIh3zfGDw "Java (OpenJDK 8) – Try It Online")
---
# Java 8, 84 bytes, sum 7434
Credit goes to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen).
```
interface A{static void main(String[]G){for(int A=59;A-->0;)System.out.print("~");}}
```
[Test it online!](https://tio.run/##nVFNa8JAEL3nV0wDQqJGtKWHGlIIPRShh4JHK7psJnEh2ZXdTUoR/evpfqjFQ3voHJKdnTfz9r2hSUVp3zOuoSGMR/ZAZEXHQHdEwnBoki4ODgGYYCVEtgh3GTzE4C9t7KXpK6PwvUai0KSiYwWC/hRARdMQXkDNONrJbYNcKyiFhHz5sliAahsL2hPJlOB3YZxex0rUreSQzPzVMXA/oihjm47ULW5@Gu3DutVsfW7/C3RvQWZYJ1jxG9CrV1petF8kLrU5VHPYDtT2g4djC0lvEG/IK72bw6A412vkkYUZnLfReGwIfZc1IjIZZDBNHWMK5jMaxVcbbHWU@VpwQ@UdpKLAPanQWulpLbHpsjJ7t1yUJaEI@UFpohkFJ90t3OtZrV/jg3mK23@ePT6leZI8T9N4@aU0NhPR6okjjcKT2dDx2J/@H98 "C (gcc) – Try It Online")
[Try it online!](https://tio.run/##y0osS9TNL0jNy0rJ/v8/M68ktSgtMTlVwbG6uCSxJDNZoSw/M0UhNzEzTyO4pCgzLz061l2zOi2/SAOoVsHR1tTS2lFX187AWjO4srgkNVcvv7RErwCosERDqU5J07q29v9/AA "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 11 bytes, byte sum 854 (ASCII)
Code (with trailing newline):
```
print'z'*7
```
Output (with trailing newline):
```
zzzzzzz
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EvUpdy5zr/38A "Python 2 – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 3 bytes - byte sum 255 (ISO-8859-1)
```
-.¤
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fV@/Qkv//AQ "brainfuck – Try It Online")
Requires 8-bit cells. Prints the character `ÿ`, which is value 255. `¤` is a no-op to fill the sum.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 2 bytes, Sum 255 (Latin1)
```
á
```
[Try it online!](https://tio.run/##K/v/X@7wwv//AQ "V – Try It Online")
Hexdump:
```
00000000: 1ee1                                     ..
```
The first character is `ctrl-^`, or LATIN1/ASCII code-point `0x1E`. The second character is `alt-a`, or the LATIN1 character `0xE1`. This program outputs `ÿ`, which is `0xFF` in LATIN1.
How does it work?
The first character is a no-op. It has no effect on the program at all. The second character is the *append single character* command. But we don't specify what character to append. So, due to [implicit endings](https://codegolf.stackexchange.com/a/124600/31716), it appends the character that V uses to signal the program is over, which just so happens to be `0xFF`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes, sum 256 (05AB1E Base-255 Translation)
```
ΔTnon
```
[Try it online!](https://tio.run/##MzBNTDJM/a/0/9yUkLz8vP9Kh7Z5H1qpF6Z0eL@Si865rUampoe31bro@OscWofK/w8A "05AB1E – Try It Online")
---
This outputs:
`1606938044258990275541962092341162602522202993782792835301376`
Which, using 05AB1E's code-page results in:
`[1, 6, 0, 6, 9, 3, 8, 0, 4, 4, 2, 5, 8, 9, 9, 0, 2, 7, 5, 5, 4, 1, 9, 6, 2, 0, 9, 2, 3, 4, 1, 1, 6, 2, 6, 0, 2, 5, 2, 2, 2, 0, 2, 9, 9, 3, 7, 8, 2, 7, 9, 2, 8, 3, 5, 3, 0, 1, 3, 7, 6]`
Which is:
`256`
---
Where the code is:
`ΔTnon`
With code-points:
`[79, 29, 49, 50, 49]`
Which is:
`256`
[Answer]
# [Taxi](https://bigzaphod.github.io/Taxi/), 543 bytes, sum 47124 (ASCII)
```
374 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.Pickup a passenger going to The Underground.'~' is waiting at Writer's Depot.Go to Writer's Depot:w 1 r 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n.[a]Pickup a passenger going to Cyclone.Pickup a passenger going to Post Office.Go to Zoom Zoom:n.Go to Post Office:w 3 l 2 r 1 l.Go to The Underground:n 1 r 1 l.Switch to plan "R" if no one is waiting.Pickup a passenger going to The Underground.Go to Cyclone:n 3 l 2 l.Switch to plan "a".[R]
```
[Try it online!](https://tio.run/##lZBfS8MwFMW/yqEvfQvoBKGvCr7p2BTBsYeQpullWW5JUupe/Oq161KcVYa@5M@9N@d3cqJ8p75f3N6AAjpJkZyBjFhH6VVNtsRju9eeLZuDeGBE/rVVdLiCxTX8uJ/OVixJ7doGEo0MQTujPQwfCYPMc63x4krtjefWlSL/yGceXj1F7fOAe91wTPTvxZE7Mf1F3t1BWXY6yaRb4cRGbv/y7NLMkkPEU1WRmuTfmPfjMgBOlbOZwfTiK6zUn8VRuOljYt1RVPVxprHSIVtloAqOMdg6S@xfYc9CSH5@smQmNqtt338C) ([Score verification](https://tio.run/##7VNRa9swEH7Pr7gaSpymNUszGDjkoXQwCmMLTctgWWiFLNuiss5IskMp61/3JMtum2wL7dNedg@S7u67@@4@Y3qSUdo0XBooCJehexCV0WOgOVFwdGSdejR4GIA1nkLoknAwh@kIfNBZqWxdGgYLwYhm1sWaJwzMBoFiURCZgOCSuc5VwaTRkKKCs@X5xQXoqnCgkiiuUR4Eo9lTW8VMpSScTHzo56C9iKac39REVOzmudANVq8m6658H@jUgWyzGnnyN6DfXhvV796vuDT2kcVwe6hvf8jg2EFmW4jPTGYmj@Ew6fKCydDBLM7LaDW2hL7KCRFaD@bwbtYyzsAe4/HoSQaXHc99brBF5RWkmLCSZMxJ6Wkdsa1yazZNM/3wHriGDeHGjg7EwNIQRXMuEvhiv4dCgdl99AnB4B9T8QYmIOAUVHv7t4gWnN5VJRAoidZ2aaYgQ8dg21zlDK5lwlSmsJJJNHwc7szwTXHD1FDDR1ai6di3gy1vz6n28p3fU4GSdW06L5bRiqxfU7YPs0Bt4Guactq3/45YtIcl8JEXGDv09FmsLr8jRyz7xaLlhhuaO0wpiITgMnC/mUSwY71Q7E1i74jQzfM7Fwmi1eW6efxv/8B@AQ))
The output is 374 tildes `~`.
[Answer]
# Mathematica, 2 bytes, sum=101 (ASCII)
E + Space returns e
```
E 
```
# Mathematica, 2 bytes, sum=105 (ASCII)
it works for I, too 
I + Space returns i
```
I 
```
[Answer]
# [Factor](https://factorcode.org/), 7 bytes, sum 250
```
7/2 .
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQnVqUl5qjUFCUWlJSWVCUmVeiUJxaWJqal5xarGD931zfSEGPi@u/EpgRkxeTp6RQXJoLFFMy1jbUN4Lz/wMA "Factor – Try It Online")
Outputs `3+1/2` and a newline.
Factor has a rational number type. When an improper fraction (numerator > denominator) is printed, it is converted to a mixed fraction form (integer part + proper fraction part).
Since the easiest way to adjust the byte value sum is to add spaces or newlines (which are the only token separators in Factor), I tried various fractions until the code's sum is higher than the output's sum by a multiple of 10, and added a couple newlines at the end.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes, sum = 152 (ASCII)
```
58+
```
[Try it online!](https://tio.run/##y0rNyan8/9/UQvv/fwA "Jelly – Try It Online")
[Answer]
# [Brain-Flak (Rain-Flak)](https://github.com/DJMcMayhem/Brain-Flak), 79 bytes
```
(((((((((((((((((((((((((((((((((()()()()){}){})))))))))))))))))))))))))))))))
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/X4Mg0IRAzepaEMIPuP7/BwA "Brain-Flak – Try It Online")
This prints `16` and a newline 31 times.
# [Brain-Flak (BrainHack)](https://github.com/Flakheads/BrainHack), 55 bytes
```
(((((((((((((((((((((()()()()){}){})))))))))))))))))))#
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fAyvQhEDN6loQwgTK//8DAA "Brain-Flak (BrainHack) – Try It Online")
This prints `16` and a space 18 times.
# Also 55 bytes
```
((((((((((((((((((((((()()()){}){}))))))))))))))))))))
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fAzvQBEHN6loQwgIY//8HAA "Brain-Flak (BrainHack) – Try It Online")
This prints `12` followed by a space 19 times.
[Answer]
# [Vim](http://www.vim.org/), 3 bytes, sum 234 (ASCII)
```
3iN
```
Output:
```
NNN
```
[Try it online!](https://tio.run/##K/v/3zjT7/9/AA "V – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 20 bytes, code point sum 1505
```
OuOOQ++OOOOU@>!OOO<
```
Contains the unprintable character `DEL` (ascii 127).
`Q` pushes `"` (the largest constant available in cubix), then repeatedly prints out (`O`) `68` or `102` enough times to get it to `68686868686868102102102102102` which is 1505; through some trial and error I realized that I needed 81 more points than `.` (a Cubix no-op and ASCII `46`) which resulted in needing `DEL`, which is still a no-op in Cubix.
[Try it online!](https://tio.run/##Sy5Nyqz4/9@/1N8/UFvbHwhCHewUgVS9zf//AA "Cubix – Try It Online")
On a cube:
```
    O u
    O O
Q + + O O O O U
@ > ! O O O  <
    . .
    . .
```
[Answer]
# dc, 7 bytes, sum 720 (ASCII)
```
[my]fff
```
(91+109+121+93+(102\*3)=720)
Outputs:
```
my
my
my
```
((109+121+10)\*3=720)
[Answer]
# [Carrot](https://github.com/kritixilithos/Carrot/), 4 bytes, sum = 279 (ASCII)
```
]^*2
```
[Try it online!](http://kritixilithos.github.io/Carrot/)
Prints `]]]`.
[Answer]
# [Cubically](https://github.com/aaronryank/cubically), 3 bytes, sum = 105 (ASCII)
```
%4
```
The third byte is **DLE**, which has code point **16**, so the code point sum of the source code is  
**37 + 52 + 16 = 105**.
The program prints
```
36
```
whose code point sum is **51 + 54 = 105**.
[Try it online!](https://tio.run/##Sy5NykxOzMmp/P9f1UTg/38A "Cubically – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 11 bytes, byte sum 954 (ASCII)
Code:
```
vOw~N(!@O^|
```
Output:
```
998877665544332211
```
[Verified here!](https://tio.run/##fVDJbsIwEL3nKwYkpISA1LBDFKlVT0hVqcSxC1iOEywlNrKdcOjy68GDgYpD64M9y3vzPI/2c0qbhgsDJeHCx4ConPaA7oiCbtcmdeB9emAPz8DHJrQSGAbginj2yvIyv/1SMKKZTWXNUwbmIIHKsiQihYILhpOrkgmjIZMKHtaPyyXoqkTQniiupWi1g/g6VjFTKQH9yJW@vdNDNOV8U5OiYptfIn6sfo3ez/T/QAME2WG15OlfQLe9Nuqy@2XFtbFBvoBtR2/fRLuHkPgG8cREbnYL6KTnfsGEjzCLczZaj62gY6ERvs0ggbv4pBiDvcIwuNqA3TBxPe9GyjlIZcr2JGdopZNFYcvCNZummc9ns@l0MhmPR6PhcDCIoqZeHX6e/db96uPrCA "C (gcc) – Try It Online")
[Try it online!](https://tio.run/##Sy5Nyqz4/7/Mv7zOT0PRwT@u5v9/AA "Cubix – Try It Online")
Cubified:
```
    v O
    w ~
N ( ! @ O ^ | .
. . . . . . . .
    . .
    . .
```
* `N` initializes the stack with 10
* `(!` decrement and test for truthy
	+ `@` on zero halt
* `O^O` output current number redirect to top face and output again
* `vw` redirect back to the `(` decrement to begin the loop again
[Watch it run](https://ethproductions.github.io/cubix/?code=ICAgIHYgTwogICAgdyB+Ck4gKCAhIEAgTyBeIHwgLgouIC4gLiAuIC4gLiAuIC4KICAgIC4gLgogICAgLiAuCg==&input=&speed=20)
[Answer]
# [INTERCAL](http://www.catb.org/~esr/intercal/), ~~47~~ ~~46~~ 45 bytes, sum = 2945 (ASCII...?)
```
PLEASE,8<-#38DO,8SUB#8<-#6DOREADOUT,8DOGIVEUP
```
[Try it online!](https://tio.run/##y8wrSS1KTsz5/z/Ax9Ux2FXHwkZX2djCxV/HIjjUSRnEM3PxD3J1dPEPDdEBirt7hrmGBvz/DwA "INTERCAL – Try It Online")
Prints seven null bytes followed by thirty-one underscores. One of six possibilities generated by a somewhat revised [awful hacky Python script](https://tio.run/##fZBNa4NAEIbP8VcMeNgdo6BpU4rEQ4pSCoWEpvYiHrRqXdisy2okRfLbrYZIUwgd5rDM8@47H/K7KStx1/d6U7IahjTKSimW8tzQsryAgjNJj@hqsxQ8SJmgi@WDdcRo4caR61pOPJK5B8QmBn20eC5oiqjNVN4clIC8TTgldkrmKWpaUSngwASoRHzl1LHtwRmGGEH7C4YeFzDB5OqX6dhXdFLUoyIixCRA4r94krB/TaaQw6IF2b4G613Q1SezS04rS@/4yd@M7134pHfsXGqH0luw9jfh@0j8zfPLRxBuyU1bVgDlFmWWg2icz9oieB7Uhz3dJ5JWKjMlIiQig/GKEmHlwf3y9pDnQRUTDZXmRW7CZ6noxRmx738A).
[Answer]
# [Labyrinth](https://github.com/m-ender/labyrinth), 6 bytes, sum 271 (ASCII)
```
92
9!@
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/f0ojLUtHh//9/@QUlmfl5xf91UwA "Labyrinth – Try It Online")
Outputs `92299` (the number 92, then the number 299, without separators).
I experimented with small layouts that print some digits in the code twice until I got
```
99
9!@
```
whose output's ASCII sum is 7 higher than code's. Decreasing a digit on the top row by one decreases two digits in the output, which leads to the solution above.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 4 bytes, sum 334 ([Husk SBCS](https://github.com/barbuz/Husk/wiki/Codepage))
```
up63
```
Output:
```
[3,7]
```
The value of a digit is given by `0x3?` (where `?` stands for that digit) and `u`,`p`,`[`,`]`,`,` have values `0x75`,`0x70`,`0x5b`,`0x5d`,`0x2c` - thus the sums are:
```
0x75 + 0x70 + 0x36 + 0x33        = 0x14e
0x5b + 0x33 + 0x2c + 0x37 + 0x5d = 0x14e
```
[Try it online!](https://tio.run/##yygtzv7/v7TAzPj/fwA "Husk – Try It Online")
[Answer]
## JavaScript (ES6), 6 bytes, sum = 385 (ASCII)
```
Y=>1E7
```
Outputs `10000000`. There are other 6 byte answers such as `h=>1e8`. Try this code point counter:
```
<input oninput=o.textContent=[...this.value].reduce(function(s,c){return(s+c.charCodeAt())},0)><pre id=o>0
```
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 5 bytes, sum 238 (ASCII)
```
#3::$
```
Outputs `1,2,3`, or in cQuents terms, prints the first three terms of the sequence `1,2,3,4,5,6...`.
Now listen. This was, literally, the first program I tried. The reason I tried it was because this was the program I used for [Output with the same length as code](https://codegolf.stackexchange.com/a/131540/65836). And it freaking worked.
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X9nYykrl/38A "cQuents – Try It Online")
]