[Question]
      [
Whoa, whoa, whoa ... stop typing your program. No, I don't mean "print `ABC...`." I'm talking the capitals of the United States.
Specifically, print all the city/state combinations given in the following list
* in any order
* with your choice of delimiters (e.g., `Baton Rouge`LA_Indianapolis`IN_...` is acceptable), so long as it's unambiguous which words are cities, which are states, and which are different entries
* without using any of `ABCDEFGHIJKLMNOPQRSTUVWXYZ` in your source code
Output should be to STDOUT or equivalent.
### EDIT - Whoops!
`<edit>`
While typing up the list from memory (thanks to the Animaniacs, as described below), I apparently neglected Washington, DC, which *isn't* a state capital, but *is* in the song, and is sometimes included in "lists of capitals" (like the Mathematica [answer](https://codegolf.stackexchange.com/a/60664/42963) below). *I had intended to include that city in this list, but missed it, somehow.* As a result, answers that *don't* have that city won't be penalized, and answers that *do* have that city won't be penalized, either. Essentially, it's up to you whether `Washington, DC` is included in your ouput or not. Sorry about that, folks!
`</edit>`
```
Baton Rouge, LA
Indianapolis, IN
Columbus, OH
Montgomery, AL
Helena, MT
Denver, CO
Boise, ID
Austin, TX
Boston, MA
Albany, NY
Tallahassee, FL
Santa Fe, NM
Nashville, TN
Trenton, NJ
Jefferson, MO
Richmond, VA
Pierre, SD
Harrisburg, PA
Augusta, ME
Providence, RI
Dover, DE
Concord, NH
Montpelier, VT
Hartford, CT
Topeka, KS
Saint Paul, MN
Juneau, AK
Lincoln, NE
Raleigh, NC
Madison, WI
Olympia, WA
Phoenix, AZ
Lansing, MI
Honolulu, HI
Jackson, MS
Springfield, IL
Columbia, SC
Annapolis, MD
Cheyenne, WY
Salt Lake City, UT
Atlanta, GA
Bismarck, ND
Frankfort, KY
Salem, OR
Little Rock, AR
Des Moines, IA
Sacramento, CA
Oklahoma City, OK
Charleston, WV
Carson City, NV
```
(h/t to Animaniacs for the list of capitals)
Take a bonus of **-20%** if your submission doesn't explicitly have the numbers `65` through `90` or the number `1` in the code. *Generating* these numbers (e.g., `a=5*13` or `a="123"[0]` or `a=64;a++` or the like) is allowed under this bonus, explicitly having them (e.g., `a=65` or `a="1 23 456"[0]`) is not.
## Leaderboard
```
var QUESTION_ID=60650,OVERRIDE_USER=42963;function answersUrl(e){return"http://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"http://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;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-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("{{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 SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+(?:[.]\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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>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></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>{{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>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```

[Answer]
# Mathematica, ~~168~~ ~~153~~ 149 bytes - 20% = 119.2 bytes
```
u="\.55nited\.53tates";\.41dministrative\.44ivision\.44ata[{#,u}&/@\.43ountry\.44ata[u,"\.52egions"],{"\.43apital\.4eame","\.53tate\.41bbreviation"}]
```
Obligatory, but I did not know that any character can be replaced by `\.xx` or `\:xxxx` with the appropriate hex code.
Edit: Cut of 4 more characters by replacing `Thread` with a pure function.
Output:
```
{{Montgomery,AL},{Juneau,AK},{Phoenix,AZ},{Little Rock,AR},{Sacramento,CA},{Denver,CO},{Hartford,CT},{Dover,DE},{Washington,DC},{Tallahassee,FL},{Atlanta,GA},{Honolulu,HI},{Boise,ID},{Springfield,IL},{Indianapolis,IN},{Des Moines,IA},{Topeka,KS},{Frankfort,KY},{Baton Rouge,LA},{Augusta,ME},{Annapolis,MD},{Boston,MA},{Lansing,MI},{Saint Paul,MN},{Jackson,MS},{Jefferson City,MO},{Helena,MT},{Lincoln,NE},{Carson City,NV},{Concord,NH},{Trenton,NJ},{Santa Fe,NM},{Albany,NY},{Raleigh,NC},{Bismarck,ND},{Columbus,OH},{Oklahoma City,OK},{Salem,OR},{Harrisburg,PA},{Providence,RI},{Columbia,SC},{Pierre,SD},{Nashville,TN},{Austin,TX},{Salt Lake City,UT},{Montpelier,VT},{Richmond,VA},{Olympia,WA},{Charleston,WV},{Madison,WI},{Cheyenne,WY}}
```
[Answer]
# R, ~~96 bytes~~ 98 bytes -20% -> 78.4
Thanks to @plasticinsect for the bonus!
```
library(maps);data(us.cities);cat(gsub("()( \\w+)$",",\\2",us.cities$n[us.cities$ca==2]),sep="\n")
```
Previous code at 96 bytes:
```
library(maps);data(us.cities);cat(gsub("( \\w+)$",",\\1",us.cities$n[us.cities$ca==2]),sep="\n")
```
From package `maps`, it loads a dataset of US cities. Column `capital` contains a `2` if it is a state capital. The names of the cities are given is column `name` in the form "City StateAbbreviation" (i. e. `Albany NY`), so one need to add an explicit delimiter in between before output. ~~To do so I eventually use the regex `\1` meaning I can't have the bonus I suppose.~~ To avoid using `\1` in the regex I added an empty group so that I can use `\2`.
Usage:
```
> library(maps);data(us.cities);cat(gsub("()( \\w+)$",",\\2",us.cities$n[us.cities$ca>1]),sep="\n")
Albany, NY
Annapolis, MD
Atlanta, GA
Augusta, ME
Austin, TX
Baton Rouge, LA
Bismarck, ND
Boise, ID
Boston, MA
Carson City, NV
Charleston, WV
Cheyenne, WY
Columbia, SC
Columbus, OH
Concord, NH
Denver, CO
Des Moines, IA
Dover, DE
Frankfort, KY
Harrisburg, PA
Hartford, CT
Helena, MT
Honolulu, HI
Indianapolis, IN
Jackson, MS
Jefferson City, MO
Juneau, AK
Lansing, MI
Lincoln, NE
Little Rock, AR
Madison, WI
Montgomery, AL
Montpelier, VT
Nashville, TN
Oklahoma City, OK
Olympia, WA
Phoenix, AZ
Pierre, SD
Providence, RI
Raleigh, NC
Richmond, VA
Sacramento, CA
Saint Paul, MN
Salem, OR
Salt Lake City, UT
Santa Fe, NM
Springfield, IL
Tallahassee, FL
Topeka, KS
Trenton, NJ
```
[Answer]
# CJam, 312 bytes
```
".ýç9.5i-jæ¤þ¸«Ã«cj|ù;ÎüÄ`Ñ¯Äÿçsøi4ÔÚ0;¾o'ÈàÚãÕ»®¼v{Ðù·*ñfiö\^é]ù¬ðö¸qÚpÿ©a$ÿÆhk¥½éØ×ïÕ{ñ9ÁÛ%Ðø¦ð·âßxâj   Öë¬¯,Ð+?Û¡!ù%Âí©Úfx`¤|}¼>qñµÉÎ4Óæj-wöÄÆ 4,üÖáÌxsÍ·üãýÛêmÁj±æ0?³¢¶§%Û57Ëmc.~`b=´á¥ÉpË,ôb¶ÌsÁì¾*§òÿ_Ö©;<tíèz6ljç¸b§èäø>`ÍÚ×¤ÒòÔ§~hÝ®Ú8¼}8Ì7rÿé×ÔÎîæ¡©)Ô@"'[fm256,f=)b27b'`f+'`/{_2>'q/32af.^' *o2<eup}/
```
The code is **390 bytes** long and qualifies for the **20% bonus**.
Note that the code is riddled with unprintable characters. Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%22%06.%C3%BD%C3%A79.%025%C2%86i%C2%97-%C2%95%C2%99j%C3%A6%C2%95%C2%A4%C3%BE%14%C2%92%C2%B8%C2%AB%C2%8D%C3%83%1E%C2%AB%7Fcj%C2%AD%0B%7C%C3%B9%3B%C3%8E%C2%86%C3%BC%C3%84%60%C2%97%C2%AD%C3%91%C2%AF%C3%84%C3%BF%C3%A7%1Ds%1D%C3%B8%1F%C2%90i4%C3%94%C3%9A0%3B%C2%87%C2%BE%19o%C2%9D'%C3%88%C3%A0%16%C2%93%C3%9A%C3%A3%C3%95%C2%98%C2%BB%C2%AE%C2%BC%1Av%7B%C3%90%C3%B9%C2%B7*%C2%95%C3%B1fi%C3%B6%5C%5E%C3%A9%5D%C3%B9%C2%AC%C3%B0%C3%B6%C2%83%C2%B8%17q%C3%9Ap%C3%BF%C2%A9a%C2%99%24%C3%BF%C3%86hk%C2%A5%C2%BD%C3%A9%C3%98%C3%97%C3%AF%C3%95%7B%C3%B19%C3%81%C3%9B%C2%81%25%C3%90%C3%B8%7F%C2%A6%C3%B0%C2%B7%C3%A2%C3%9Fx%C3%A2%7F%C2%81j%09%C3%96%02%C2%86%C3%AB%C2%AC%C2%8E%C2%AD%C2%AF%2C%1B%C3%90%2B%3F%04%C3%9B%C2%A1%C2%87%C2%9A!%C3%B9%25%C3%82%C3%AD%C2%A9%C3%9Afx%60%C2%8B%C2%A4%11%16%16%7C%C2%8E%7D%C2%BC%3Eq%C3%B1%C2%8B%C2%B5%C3%89%C3%8E4%C2%90%10%C3%93%C3%A6j-w%C3%B6%C3%84%C3%86%204%2C%C2%87%C3%BC%C3%96%C2%8F%16%C3%A1%C3%8Cxs%C3%8D%C2%B7%C3%BC%C3%A3%C3%BD%C3%9B%C3%AA%05m%C3%81j%C2%B1%C3%A60%3F%C2%B3%C2%9E%04%C2%A2%C2%95%C2%B6%C2%A7%25%C2%91%C3%9B57%C3%8B%13mc.~%60b%3D%C2%B4%C3%A1%12%C2%A5%C3%89p%C3%8B%0F%1A%2C%C3%B4%C2%89b%C2%85%C2%8E%C2%B6%08%C3%8Cs%C3%81%C3%AC%1A%C2%BE*%C2%A7%C3%B2%C2%95%C3%BF%11%C2%95_%C2%8C%C3%96%C2%A9%1B%3B%3Ct%C3%AD%C3%A8%08z6%C2%8Dlj%C3%A7%01%C2%B8b%C2%A7%C3%A8%C3%A4%C3%B8%3E%60%C3%8D%C3%9A%C2%9D%15%C3%97%1B%04%C2%A4%C3%92%C2%83%C3%B2%C3%94%C2%A7~h%C2%87%C3%9D%C2%AE%C3%9A8%C2%BC%7D8%C3%8C7r%C3%BF%C3%A9%1C%C3%97%C2%91%17%C2%9D%C3%94%C3%8E%C3%AE%C2%82%C3%A6%C2%A1%15%C2%A9)%C3%94%40%22'%5Bfm256%2Cf%3D)b27b'%60f%2B'%60%2F%7B_2%3E'q%2F32af.%5E'%20*o2%3Ceup%7D%2F).
### Idea
We have to encode the output somehow without using uppercase letters or the numbers 1 and 65 to 90 anywhere in the code.
We start by rewriting the desired output as
```
akjuneau`paharrisburg`txaustin`maboston`wvcharleston`azphoenix`kyfrankfort`msjackson`mdannapolis`vtmontpelier`ndbismarck`hihonolulu`meaugusta`nvcarsonqcity`sccolumbia`ohcolumbus`wycheyenne`casacramento`arlittleqrock`nmsantaqfe`mnsaintqpaul`idboise`tnnashville`codenver`nhconcord`almontgomery`inindianapolis`riprovidence`utsaltqlakeqcity`ilspringfield`ncraleigh`labatonqrouge`sdpierre`dedover`orsalem`waolympia`kstopeka`varichmond`cthartford`nyalbany`milansing`njtrenton`mthelena`iadesqmoines`gaatlanta`wimadison`nelincoln`fltallahassee`okoklahomaqcity`mojefferson
```
By subtracting the character ``` from all characters of that string, we obtain an array containing integers from 0 to 26. We can convert this array from base 27 to base 229, yielding an array of integers from 0 to 228.
If we add 91 to each base-229 digit and take the results modulo 256, we map the range **[0, …, 164]** to **[91, … 255]**, and the range **[165, …, 228]** to **[0, …, 63]**. This leaves the characters with code points from **64** (`@`) to **90** (`Z`) unused.
The string to encode is not in the same order as the sample output in the question. I tried several permutation until I found one that contains no null bytes, linefeeds, carriage returns or non-breaking spaces (problematic with the online interpreter), and no double quotes (require escaping).
### Code
```
"…@"   e# Push a string of 342 ISO-8859-1 characters.
'[fm   e# Subtract the char '[' (code point 91) from each char of the string.
256,f= e# Compute the remainder of the differences divided by 256.
)      e# Pop the last integer from the array ('@' -> 27 -> 229).
b27b   e# Convert the remaining array from base 229 to base 27.
'`f+   e# Add the character '`' to the resulting digits.
       e# This pushes the string from the "Idea" section.
'`/    e# Split the result at backticks.
{      e# For each resulting chunk C:
  _2>  e#   Copy C and remove its first to characters.
  'q/  e#   Split at occurrences of 'q'.
  32a  e#   Push [32].
  f.^  e#   Mapped, vectorized XOR; XOR the first character of each chunk
       e#   with 32. This changes its case.
  ' *  e#   Join the resulting chunks, separating by spaces.
  o    e#   Print.
  2<   e#   Reduce the original C to its first two characters.
  eu   e#   Convert to uppercase.
  p    e#   Print, enclosed in double quotes, and followed by a linefeed.
}/     e#
```
[Answer]
# Perl, 605 bytes - 20% = 484
```
$_="baton rouge,laindianapolis,incolumbus,ohmontgomery,alhelena,mtdenver,coboise,idaustin,txboston,maalbany,nytallahassee,flsanta fe,nmnashville,tntrenton,njjefferson,morichmond,vapierre,sdharrisburg,paaugusta,meprovidence,ridover,deconcord,nhmontpelier,vthartford,cttopeka,kssaint paul,mnjuneau,aklincoln,neraleigh,ncmadison,wiolympia,waphoenix,azlansing,mihonolulu,hijackson,msspringfield,ilcolumbia,scannapolis,mdcheyenne,wysalt lake city,utatlanta,gabismarck,ndfrankfort,kysalem,orlittle rock,ardes moines,iasacramento,caoklahoma city,okcharleston,wvcarson city,nv";s/,../uc"$&;"/eg;s/\b./\u$&/g;print
```
My first version was invalid because it used \U to convert to uppercase. This one uses \u on each letter of the state abbreviation. I also had to add a dummy capture group to avoid using $1.
**Edit:** I was able to shave off 8 bytes by using uc() with the e flag. (Thank you Dom Hastings.)
[Answer]
# javascript, ~~727~~ 687 bytes - 20% = 549.6
```
alert('baton rouge;indianapolis;columbus;montgomery;helena;denver;boise;austin;boston;albany;tallahassee;santa fe;nashville;trenton;jefferson;richmond;pierre;harrisburg;augusta;providence;dover;concord;montpelier;hartford;topeka;saint paul;juneau;lincoln;raleigh;madison;olympia;phoenix;lansing;honolulu;jackson;springfield;columbia;annapolis;cheyenne;salt lake city;atlanta;bismarck;frankfort;salem;little rock;des moines;sacramento;oklahoma city;charleston;carson city'.split`;`.map((a,i)=>a.split` `.map(b=>b[0][u='to\x55pper\x43ase']()+b.slice(-~0)).join` `+0+'lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv'[u]().substr(i*2,2)))
```
javascript is particularly tough as well, considering their long function names and camelcase. splitting out the states saved a ton on delimiters, and made it easier to work with all around.
@mbomb007 nothing in the post capitalized for a reason ;)
[Answer]
# C, ~~703~~ 700 bytes - 20% = 560 bytes
```
main(){int c=!0;char*p="@baton@rouge[la*indianapolis[in*columbus[oh*montgomery[al*helena[mt*denver[co*boise[id*austin[tx*boston[ma*albany[ny*tallahassee[fl*santa@fe[nm*nashville[tn*trenton[nj*jefferson[mo*richmond[va*pierre[sd*harrisburg[pa*augusta[me*providence[ri*dover[de*concord[nh*montpelier[vt*hartford[ct*topeka[ks*saint@paul[mn*juneau[ak*lincoln[ne*raleigh[nc*madison[wi*olympia[wa*phoenix[az*lansing[mi*honolulu[hi*jackson[ms*springfield[il*columbia[sc*annapolis[md*cheyenne[wy*salt@lake@city[ut*atlanta[ga*bismarck[nd*frankfort[ky*salem[or*little@rock[ar*des@moines[ia*sacramento[ca*oklahoma@city[ok*charleston[wv*carson@city[nv*";while(*++p)c+=*p<97?2+*p/91:0,printf("%c",c?--c,*p-32:*p);}
```
I changed the loop a bit to make it compile with non-C99 compilers. [Online version](http://codepad.org/8pYOWViJ)
[Answer]
# javascript (es6) 516 (645-20%) ~~532 (664-20%)~~
test running the snippet below in any recent browser: the only es6 feature used is `template strings`
```
alert(`
labaton rouge
inindianapolis
ohcolumbus
almontgomery
mthelena
codenver
idboise
txaustin
maboston
nyalbany
fltallahassee
nmsanta fe
tnnashville
njtrenton
mojefferson
varichmond
sdpierre
paharrisburg
meaugusta
riprovidence
dedover
nhconcord
vtmontpelier
cthartford
kstopeka
mnsaint paul
akjuneau
nelincoln
ncraleigh
wimadison
waolympia
azphoenix
milansing
hihonolulu
msjackson
ilspringfield
sccolumbia
mdannapolis
wycheyenne
utsalt lake city
gaatlanta
ndbismarck
kyfrankfort
orsalem
arlittle rock
iades moines
casacramento
okoklahoma city
wvcharleston
nvcarson city
`.replace(/(\n..)(.)| ./g,(w,x,y)=>(y?x+','+y:w)['to\x55pper\x43ase']()))
```
[Answer]
# [Funciton](http://esolangs.org/wiki/Funciton), 5045 − 20% = 4036 bytes
This code contains only one number, and it’s not in the range 65 through 90. Nor is it the number 1. In fact, this number is 4187 decimal digits, which cleanly factorizes into primes 79×53.
As always, get nicer rendering by executing `$('pre').css('line-height',1);` in your browser console.
```
╔═══════════════════════════════════════════════════════════════════════════════╗
║7136715096855386138244201921379984522081157959387689102965666099527710666770872║
║8632405046019650473694855863386057142772501332293800147289916078651647760772443║
║8725652766505885348060772769789231580343563435533130895917300237406562638030980║
║3711194146648873765244744781953334585902685570475123886704870369061449702689564║
║3595572359214492754563209811697465519112054922140302657793458997381684588970868║
║7793823212145990790477442216616349142872430200820970858787998435483524660584416║
║6164882066597488329789212167115912389108306700132767580336075847661452995278441║
║4608506136620095732142590833871485553260077395557115141102093496100483811080395║
║6552804273104384398276311006450509670233242612250087379855689038722276735360412║
║6878753848057526563710344191563893599886868947829201220173418232286377514939888║
║5826479634935379423693839085984565815131964110239432620200938530722481854602826║
║9037704900171802579729347376622932167603510862768435434759967894116610786905139║
║7412487476129828359043674372610945304257752777678880166233522176263310236004692║
║0559345181857154078616512980811741354072155133642234106705715867670036797456411║
║3264775046807948785891163930492821367841190494057926544207551600789781134233199║
║4931373746463823081063091455500394879663289567724955802959562627212816895887920║
║2489552640528826478935177736926106383314641517898028085103843993947923512080284║
║1297634633899484758145253947029431905171166312060063580822580997396575916969283║
║8159188436765390151074141915725490631912068692580040188837785831216953037087556║
║0321645257600479747768084542577912902995339088536912361110657756023624089620615║
║5158613866208649015722071421838484405731207470388752536584022013701916919845375║
║3209922919010373613440766178725948038885270419846274466164969481905438092706837║
║6125745847739006120558864887675350117798119205719776692338137137532239709753293║
║8995102505657504327982204450387974737246780507128822708181598416111438056330283║
║4785530759635414792062372089201435348108257958259667891277855066169836153935818║
║4849044313927545256942990267263122642672090579649898429311837755460330426123991║
║0865666851722460685754104973378688314066186075716326618952555696686125861179585╟
║7767008528632788251800639156553539356488180142086268151130154661765322967918167║
║6359863162328432204277806522752416226370770476079674225817370337594249020946663║
║1822184578010876426310754786368155838502939742370374540683825491575130213369657║
║2120804668997619419445916101731942338784683470192383635854329364775377151471990║
║2655205750667024595911951526939478313795716952326483704217123605616832952264503║
║8356212760984291960912048067411637475389334580447270650407546381067041317195274║
║3658815060537830411410963930585836537141345277217896786840243174681916988181583║
║8390084258839955570465021603546831767108002881554379542200508579678822598563892║
║8621176190864640015677903257299296220003472794175916462345690686103548377723578║
║6760505049046712538526435515066511975271300115330547105472335029933058732991785║
║5589232894601143279598099962031945524489480851133384138840761826907713777131329║
║9653475711559777326388996740771947433446060772704682592783253818915955015393899║
║8513366910314301930539317844646403762279062435716757707854074235922915355490960║
║9007713445763282900095169953058848056683723033266818136479787173846475991012202║
║9462375527766882809250645176534521094942659081258046722219759280486004661723805║
║6786432900677055552677470564184679327084173152258835307889916896828977570843423║
║3265510347632679682249919679555731735198061941806081777484490821424077128775482║
║4866960679621740266038712499696089430677992126743925060145440886995190894304525║
║3469457565680576996559817327023534136403178656947913819462072799063875416015296║
║0646268276069839972076911667210841845209380552353634062961962574981823297845248║
║7817510295701815725710777747052257272070773995280590130309991890195320939352205║
║3629070121725848802522009518874134452415909082137665653417182020188245139223466║
║1804690429428088774753298257855093982064922470661344462996583642233273038068537║
║5899655675409028134860922908216970845189239846431322757349357911553610461726138║
║9065104191927373357937390905721074233359257891159853454407258925428691711525208║
║0898360915775189300266760522953739009955921695946386500512104598494398514200642║
╚═══════════════════════════════════════════════════════════════════════════════╝
```
Edit: Kiri-ban! This answer is codegolf.SE post #61000!
[Answer]
## x86 machine code, 764 bytes
612 if bonus awarded
Totally self-contained program. Only relies upon (a) Bios int 0x10 being available to print each char and (b) DS, ES, SP and SS being initialized before program is called, DOS does this.(and DOS-Box too) Otherwise, the code relies on nothing.
The absolute minimum without any dependencies at all except for the BIOS rom, would be about 2 floppy disk sectors @512 bytes each.
It doesn't seem to exploit any of the standard loop-holes, though while some bytes of the program are 01, these are not numbers in the source. However, since I'd like to submit the binary code as my solution, I imagine that would disallow the 01 bytes.?
Hex-editor view of binary:
```
68 98 01 E8 1D 00 CD 20 B3 62 FE CB 88 DF 80 C7 19 38 D8 72 0D 38 F8 77 09 30 DB FE C3 C0 E3 05 -   h˜.è..Í ³bþËˆß€Ç.8Ør.8øw.0ÛþÃÀã.
28 D8 C3 55 89 E5 81 C5 04 00 8B 76 00 89 F7 AC A8 FF 74 3E 80 3E 96 01 00 75 0A E8 CA FF AA A2 -   (ØÃU‰å.Å..‹v.‰÷¬¨ÿt>€>–..u.èÊÿª¢
96 01 E9 EA FF 3C 2C 75 18 AA AC E8 BA FF AA AC E8 B5 FF AA AC AA AC E8 AE FF AA A2 96 01 E9 CE -   –.éêÿ<,u.ª¬èºÿª¬èµÿª¬ª¬è®ÿª¢–.éÎ
FF 80 3E 96 01 20 75 03 E8 9D FF AA A2 96 01 E9 BD FF 8B 76 00 AC A8 FF 74 1A 3C 2D 75 0F B0 0D -   ÿ€>–. u.è.ÿª¢–.é½ÿ‹v.¬¨ÿt.<-u.°.
B4 0E CD 10 B0 0A B4 0E CD 10 E9 E8 FF B4 0E CD 10 E9 E1 FF 5D C3 00 00 62 61 74 6F 6E 72 6F 75 -   ´.Í.°.´.Í.éèÿ´.Í.éáÿ]Ã..batonrou
67 65 2C 6C 61 2D 69 6E 64 69 61 6E 61 70 6F 6C 69 73 2C 69 6E 2D 63 6F 6C 75 6D 62 75 73 2C 6F -   ge,la-indianapolis,in-columbus,o
68 2D 6D 6F 6E 74 67 6F 6D 65 72 79 2C 61 6C 2D 68 65 6C 65 6E 61 2C 6D 74 2D 64 65 6E 76 65 72 -   h-montgomery,al-helena,mt-denver
2C 63 6F 2D 62 6F 69 73 65 2C 69 64 2D 61 75 73 74 69 6E 2C 74 78 2D 62 6F 73 74 6F 6E 2C 6D 61 -   ,co-boise,id-austin,tx-boston,ma
2D 61 6C 62 61 6E 79 2C 6E 79 2D 74 61 6C 6C 61 68 61 73 73 65 65 2C 66 6C 2D 73 61 6E 74 61 66 -   -albany,ny-tallahassee,fl-santaf
65 2C 6E 6D 2D 6E 61 73 68 76 69 6C 6C 65 2C 74 6E 2D 74 72 65 6E 74 6F 6E 2C 6E 6A 2D 6A 65 66 -   e,nm-nashville,tn-trenton,nj-jef
66 65 72 73 6F 6E 2C 6D 6F 2D 72 69 63 68 6D 6F 6E 64 2C 76 61 2D 70 69 65 72 72 65 2C 73 64 2D -   ferson,mo-richmond,va-pierre,sd-
68 61 72 72 69 73 62 75 72 67 2C 70 61 2D 61 75 67 75 73 74 61 2C 6D 65 2D 70 72 6F 76 69 64 65 -   harrisburg,pa-augusta,me-provide
6E 63 65 2C 72 69 2D 64 6F 76 65 72 2C 64 65 2D 63 6F 6E 63 6F 72 64 2C 6E 68 2D 6D 6F 6E 74 70 -   nce,ri-dover,de-concord,nh-montp
65 6C 69 65 72 2C 76 74 2D 68 61 72 74 66 6F 72 64 2C 63 74 2D 74 6F 70 65 6B 61 2C 6B 73 2D 73 -   elier,vt-hartford,ct-topeka,ks-s
61 69 6E 74 20 70 61 75 6C 2C 6D 6E 2D 6A 75 6E 65 61 75 2C 61 6B 2D 6C 69 6E 63 6F 6C 6E 2C 6E -   aint paul,mn-juneau,ak-lincoln,n
65 2D 72 61 6C 65 69 67 68 2C 6E 63 2D 6D 61 64 69 73 6F 6E 2C 77 69 2D 6F 6C 79 6D 70 69 61 2C -   e-raleigh,nc-madison,wi-olympia,
77 61 2D 70 68 6F 65 6E 69 78 2C 61 7A 2D 6C 61 6E 73 69 6E 67 2C 6D 69 2D 68 6F 6E 6F 6C 75 6C -   wa-phoenix,az-lansing,mi-honolul
75 2C 68 69 2D 6A 61 63 6B 73 6F 6E 2C 6D 73 2D 73 70 72 69 6E 67 66 69 65 6C 64 2C 69 6C 2D 63 -   u,hi-jackson,ms-springfield,il-c
6F 6C 75 6D 62 69 61 2C 73 63 2D 61 6E 6E 61 70 6F 6C 69 73 2C 6D 64 2D 63 68 65 79 65 6E 6E 65 -   olumbia,sc-annapolis,md-cheyenne
2C 77 79 2D 73 61 6C 74 20 6C 61 6B 65 20 63 69 74 79 2C 75 74 2D 61 74 6C 61 6E 74 61 2C 67 61 -   ,wy-salt lake city,ut-atlanta,ga
2D 62 69 73 6D 61 72 63 6B 2C 6E 64 2D 66 72 61 6E 6B 66 6F 72 74 2C 6B 79 2D 73 61 6C 65 6D 2C -   -bismarck,nd-frankfort,ky-salem,
6F 72 2D 6C 69 74 74 6C 65 20 72 6F 63 6B 2C 61 72 2D 64 65 73 20 6D 6F 69 6E 65 73 2C 69 61 2D -   or-little rock,ar-des moines,ia-
73 61 63 72 61 6D 65 6E 74 6F 2C 63 61 2D 6F 6B 6C 61 68 6F 6D 61 20 63 69 74 79 2C 6F 6B 2D 63 -   sacramento,ca-oklahoma city,ok-c
68 61 72 6C 65 73 74 6F 6E 2C 77 76 2D 63 61 72 73 6F 6E 20 63 69 74 79 2C 6E 76 00             -   harleston,wv-carson city,nv.
```
'Un-golfed' version (source - 3126 bytes)
```
[section .text]
[bits 16]
[org 0x100]
entry_point:
    push    word capital_list
    call    output_string
    int 0x20
; input:
;       al = char
; outpt:
;       if al if an alpha char, ensures it is in range [capital-a .. capital-z]
toupper:
    mov     bl, 98
    dec     bl              ; bl = 'a'
    mov     bh, bl
    add     bh, 25          ; bh = 'z'
    cmp     al, bl          ;'a'
    jb      .toupperdone
    cmp     al, bh
    ja      .toupperdone
    xor     bl, bl
    inc     bl
    shl     bl, 5           ; bl = 32
    sub     al, bl          ;capital'a' - 'a' (32)
.toupperdone:
    ret
;void outputstring(char *str)
outputstring:
    push    bp
    mov     bp, sp
    add     bp, 4
    mov     si, [bp + 0]        ; si --> string
    mov     di, si
; I run over the text in two passes - because I'm too tired right now to make it
;   a tighter, more efficient loop. Perhaps after some sleep.
; In the first pass, I just convert the appropriate chars to upper-case
.get_char_pass_1:
    lodsb
    test    al, 0xff
    jz      .pass_1_done
    cmp     [last_char], byte 0
    jne     .not_first_char
    call    toupper
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1
.not_first_char:
.check_if_sep:
    cmp     al, ','             ; if this char is a comma, the next 2 need to be uppercase
    jne     .not_seperator
    stosb                       ; spit out the comma, unchanged
    lodsb
    call    toupper
    stosb
    lodsb
    call    toupper
    stosb
.gobble_delim:
    lodsb                       ; take care of the '-' delimiter
    stosb
.capitalize_first_letter_of_city:
    lodsb                       ; the following char is the first char of the city, capitalize it
    call    toupper
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1    ; go back for more
.not_seperator:
    cmp     [last_char], byte ' '
    jne     .output_this_char
    call    toupper
.output_this_char:
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1
.pass_1_done:
; In the second pass, I print the characters, except for the delimiters, which are skipped and
;   instead print a CRLF pair so that each city/state pair begins on a new line.
;
pass_2:
    mov     si, [bp+0]          ; point to string again
.pass_2_load_char:
    lodsb
    test    al, 0xff
    jz      .pass_2_done
    cmp     al, '-'             ; current char is a delimiter, dont print it - instead,
                                ;  print a carriage-return/line-feed pair
    jne     .not_delim_2
    mov     al, 0xd             ; LF
    mov     ah, 0xe
    int     0x10
    mov     al, 0xa             ; CR
    mov     ah, 0xe
    int     0x10
    jmp     .pass_2_load_char
.not_delim_2:
    mov     ah, 0xe
    int     0x10
    jmp     .pass_2_load_char
.pass_2_done:
    pop     bp
    ret
last_char   db  0
[section .data]
capital_list    db  'batonrouge,la-indianapolis,in-columbus,oh-montgomery,al-helena,mt-denver,co-boise,id-'
                db  'austin,tx-boston,ma-albany,ny-tallahassee,fl-santafe,nm-nashville,tn-trenton,nj-'
                db  'jefferson,mo-richmond,va-pierre,sd-harrisburg,pa-augusta,me-providence,ri-dover,de-'
                db  'concord,nh-montpelier,vt-hartford,ct-topeka,ks-saint paul,mn-juneau,ak-lincoln,ne-'
                db  'raleigh,nc-madison,wi-olympia,wa-phoenix,az-lansing,mi-honolulu,hi-jackson,ms-'
                db  'springfield,il-columbia,sc-annapolis,md-cheyenne,wy-salt lake city,ut-atlanta,ga-'
                db  'bismarck,nd-frankfort,ky-salem,or-little rock,ar-des moines,ia-sacramento,ca-'
                db  'oklahoma city,ok-charleston,wv-carson city,nv',0
```
Output:
```
Baton Rouge,LA
Indianapolis,IN
Columbus,OH
Montgomery,AL
Helena,MT
Denver,CO
Boise,ID
Austin,TX
Boston,MA
Albany,NY
Tallahassee,FL
Santa Fe,NM
Nashville,TN
Trenton,NJ
Jefferson,MO
Richmond,VA
Pierre,SD
Harrisburg,PA
Augusta,ME
Providence,RI
Dover,DE
Concord,NH
Montpelier,VT
Hartford,CT
Topeka,KS
Saint Paul,MN
Juneau,AK
Lincoln,NE
Raleigh,NC
Madison,WI
Olympia,WA
Phoenix,AZ
Lansing,MI
Honolulu,HI
Jackson,MS
Springfield,IL
Columbia,SC
Annapolis,MD
Cheyenne,WY
Salt Lake City,UT
Atlanta,GA
Bismarck,ND
Frankfort,KY
Salem,OR
Little Rock,AR
Des Moines,IA
Sacramento,CA
Oklahoma City,OK
Charleston,WV
Carson City,NV
```
[Answer]
# Python 3, ~~1416~~ ~~793~~ ~~785~~ ~~779~~ ~~771~~ ~~755~~ 734 characters - 20% = 587.2
No algorithmic cleverness here, I just took the required output, sorted it (this lets zlib do a better job), compressed it (using `zopfli --deflate`), base64-encoded the result, and then changed the encoding around to avoid capital letters.
```
import zlib,base64;print(zlib.decompress(base64.b64decode('>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooaj<u;i5~y]^%u]{.},@_|h[,8^>zt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='.translate({ord(x):y+60+5 for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~',range(26))})),-9).decode('u8'))
```
Un-golfed:
```
import zlib, base64
DATA = '>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooaj<u;i5~y]^%u]{.},@_|h[,8^>zt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='
TR = { ord(x) : y+60+5
       for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~', range(26)) }
print(zlib.decompress(base64.b64decode(DATA.translate(TR)),
                      -9)
      .decode('utf-8'))
```
There is probably more to be squeezed out of this, especially if you can express the argument to `translate()` more compactly. Note that the punctuation in there is carefully chosen to avoid base64's own punctuation (+/=) and anything that would need backwhacking in a string literal.
Fun fact: the bz2 and lzma modules both do *worse* on this input than zlib:
```
>>> z = base64.b64decode('>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooaj<u;i5~y]^%u]{.},@_|h[,8^>zt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='.translate({ord(x):ord(y)-32 for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~','abcdefghijklmnopqrstuvwxyz')}))
>>> u = zlib.decompress(x,-9)
>>> len(u)
663
>>> len(z)
427
>>> len(zlib.compress(z))
437
>>> len(bz2.compress(z))
456
>>> len(lzma.compress(z))
620
```
[Answer]
# Pyth, (631 -20%) = 504.8
```
=k!kmrd=k-6kc"baton rouge,la,indianapolis,in,columbus,oh,montgomery,al,helena,mt,denver,co,boise,id,austin,tx,boston,ma,albany,ny,tallahassee,fl,santa fe,nm,nashville,tn,trenton,nj,jefferson,mo,richmond,va,pierre,sd,harrisburg,pa,augusta,me,providence,ri,dover,de,concord,nh,montpelier,vt,hartford,ct,topeka,ks,saint paul,mn,juneau,ak,lincoln,ne,raleigh,nc,madison,wi,olympia,wa,phoenix,az,lansing,mi,honolulu,hi,jackson,ms,springfield,il,columbia,sc,annapolis,md,cheyenne,wy,salt lake city,ut,atlanta,ga,bismarck,nd,frankfort,ky,salem,or,little rock,ar,des moines,ia,sacramento,ca,oklahoma city,ok,charleston,wv,carson city,nv"","
```
### Output:
```
['Baton Rouge', 'LA', 'Indianapolis', 'IN', 'Columbus', 'OH', 'Montgomery', 'AL', 'Helena', 'MT', 'Denver', 'CO', 'Boise', 'ID', 'Austin', 'TX', 'Boston', 'MA', 'Albany', 'NY', 'Tallahassee', 'FL', 'Santa Fe', 'NM', 'Nashville', 'TN', 'Trenton', 'NJ', 'Jefferson', 'MO', 'Richmond', 'VA', 'Pierre', 'SD', 'Harrisburg', 'PA', 'Augusta', 'ME', 'Providence', 'RI', 'Dover', 'DE', 'Concord', 'NH', 'Montpelier', 'VT', 'Hartford', 'CT', 'Topeka', 'KS', 'Saint Paul', 'MN', 'Juneau', 'AK', 'Lincoln', 'NE', 'Raleigh', 'NC', 'Madison', 'WI', 'Olympia', 'WA', 'Phoenix', 'AZ', 'Lansing', 'MI', 'Honolulu', 'HI', 'Jackson', 'MS', 'Springfield', 'IL', 'Columbia', 'SC', 'Annapolis', 'MD', 'Cheyenne', 'WY', 'Salt Lake City', 'UT', 'Atlanta', 'GA', 'Bismarck', 'ND', 'Frankfort', 'KY', 'Salem', 'OR', 'Little Rock', 'AR', 'Des Moines', 'IA', 'Sacramento', 'CA', 'Oklahoma City', 'OK', 'Charleston', 'WV', 'Carson City', 'NV']
```
The second parameter for `r` alternates between 5 (`capwords()`) and 1 (`upper()`)
[Answer]
# PowerShell, ~~1038~~ ~~976~~ ~~925~~ ~~904~~ ~~813~~ ~~768~~ ~~758~~ ~~749~~ 745 -20% = 596
```
"labaton rouge;inindianapolis;ohcolumbus;almontgomery;mthelena;codenver;idboise;txaustin;maboston;nyalbany;fltallahassee;nmsanta fe;tnnashville;njtrenton;mojefferson;varichmond;sdpierre;paharrisburg;meaugusta;riprovidence;dedover;nhconcord;vtmontpelier;cthartford;kstopeka;mnsaint paul;akjuneau;nelincoln;ncraleigh;wimadison;waolympia;azphoenix;milansing;hihonolulu;msjackson;ilspringfield;sccolumbia;mdannapolis;wycheyenne;utsalt lake city;gaatlanta;ndbismarck;kyfrankfort;orsalem;arlittle rock;iades moines;casacramento;okoklahoma city;wvcharleston;nvcarson city"-split";"|%{$a=-split$_;$b={$n,$i=$args;if($a[$n]){" "+(""+$a[$n][$i++]).toupper()+$a[$n].substring($i)}};$(&$b(0)2).trim()+$(&$b(3-2)0)+$(&$b(2)0)+","+$_.substring(0,2).toupper()}
```
**Ungolfed:**
```
"labaton rouge;inindianapolis;ohcolumbus;almontgomery;mthelena;codenver;idboise;txaustin;maboston;nyalbany;fltallahassee;nmsanta fe;tnnashville;njtrenton;mojefferson;varichmond;sdpierre;paharrisburg;meaugusta;riprovidence;dedover;nhconcord;vtmontpelier;cthartford;kstopeka;mnsaint paul;akjuneau;nelincoln;ncraleigh;wimadison;waolympia;azphoenix;milansing;hihonolulu;msjackson;ilspringfield;sccolumbia;mdannapolis;wycheyenne;utsalt lake city;gaatlanta;ndbismarck;kyfrankfort;orsalem;arlittle rock;iades moines;casacramento;okoklahoma city;wvcharleston;nvcarson city"-split";"|%{
   $a=-split$_;
   $b={
        $n,$i=$args;
        if($a[$n]){
          " "+
          (""+$a[$n][$i++]).toupper()+
          $a[$n].substring($i)
         }
      };
   $(&$b(0)2).trim()+
   $(&$b(3-2)0)+
   $(&$b(2)0)+
   ","+
   $_.substring(0,2).toupper()
 }
```
[Answer]
## [Minkolang 0.7](https://github.com/elendiastarman/Minkolang), ~~660~~ ~~705~~ 708 \* 0.8 = 566.4
```
99*32-+58*0p467+35*44*55*d8+d5+(99*2-23-r32-p)"baton rouge, laindianapolis, incolumbus, ohmontgomery, alhelena, mtdenver, coboise, idaustin, txboston, maalbany, nytallahassee, flsanta fe, nmnashville, tntrenton, njjefferson, morichmond, vapierre, sdharrisburg, paaugusta, meprovidence, ridover, deconcord, nhmontpelier, vthartford, cttopeka, kssaint paul, mnjuneau, aklincoln, neraleigh, ncmadison, wiolympia, waphoenix, azlansing, mihonolulu, hijackson, msspringfield, ilcolumbia, scannapolis, mdcheyenne, wysalt lake city, utatlanta, gabismarck, ndfrankfort, kysalem, orlittle rock, ardes moines, iasacramento, caoklahoma city, okcharleston, wvcarson city, nv"032-w
48*-o(d","=2&o)oo22$[48*-o]d?.25*o48*-o)
```
Thanks to **Sp3000** for reminding me that I can use `p` to put capital Os in the code!
### Explanation
The bit of the first line before the `"` does nothing but put a `R` (rotate stack) in place of `r` and then replace all of the instances of `o` with `O` on the second line.
After that, it's the list of capitals without newlines and all letters lowercased, which is pushed onto the stack in reverse order by Minkolang. There is a `01w` at the end which is a "wormhole" to the beginning of the second line. All capital letters are outputted by subtracting 32 from the lowercase letter, which is why `48*-` shows up four times.
`48*-O` outputs `B`, then `(` begins a while loop. The top of stack is checked against `,`. If it's not `,`, then `O)` outputs the character and jumps back to the beginning of the loop. If the top of stack *is* `,`, then the program counter jumps over `O)` because of `2&`, a conditional trampoline that jumps two spaces.
Now, I jump when I encounter a `,` because I know the next six characters are `, AB\nC`, which is what the rest of the loop does. There is a check to see if the stack is empty in the middle (after `AB` is printed, before `\nC`): `d?`. If it is, then the conditional trampoline is not taken and the program exits upon hitting the `.`. Otherwise, it's skipped and the loop continues.
[Answer]
# PHP 520 bytes (650 bytes - 20%)
```
foreach(explode(',','baton rouge,indianapolis,columbus,montgomery,helena,denver,boise,austin,boston,albany,tallahassee,santa fe,nashville,trenton,jefferson,richmond,pierre,harrisburg,augusta,providence,dover,concord,montpelier,hartford,topeka,saint paul,juneau,lincoln,raleigh,madison,olympia,phoenix,lansing,honolulu,jackson,springfield,columbia,annapolis,cheyenne,salt lake city,atlanta,bismarck,frankfort,salem,little rock,des moines,sacramento,oklahoma city,charleston,carson city')as$k=>$v)echo ucwords($v).','.strtoupper(substr('lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv',$k*2,2)).'_';
```
**Result**
>
> Baton Rouge,LA\_Indianapolis,IN\_ …
>
>
>
**Ungolfed:**
```
$cities = 'baton rouge,indianapolis,columbus,montgomery,helena,denver,boise,austin,boston,albany,tallahassee,santa fe,nashville,trenton,jefferson,richmond,pierre,harrisburg,augusta,providence,dover,concord,montpelier,hartford,topeka,saint paul,juneau,lincoln,raleigh,madison,olympia,phoenix,lansing,honolulu,jackson,springfield,columbia,annapolis,cheyenne,salt lake city,atlanta,bismarck,frankfort,salem,little rock,des moines,sacramento,oklahoma city,charleston,carson city';
$states = 'lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv';
foreach(explode(',',$cities) as $k => $v)
    echo ucwords($v)
         . ','
         . strtoupper(
             substr($states, $k * 2, 2)
         )
         . '_';
```
I tried various ways to compress the string, but in the end all solutions were longer than this straight forward approach.
[Answer]
# Python 2, 658 bytes \* 0.8 = 526.4
```
print zip([c.title()for c in"baton rouge.indianapolis.columbus.montgomery.helena.denver.boise.austin.boston.albany.tallahassee.santa fe.nashville.trenton.jefferson.richmond.pierre.harrisburg.augusta.providence.dover.concord.montpelier.hartford.topeka.saint paul.juneau.lincoln.raleigh.madison.olympia.phoenix.lansing.honolulu.jackson.springfield.columbia.annapolis.cheyenne.salt lake city.atlanta.bismarck.frankfurt.salem.little rock.des moines.sacramento.oklahoma city.charleston.carson city".split('.')],[s.upper()for s in map(''.join,zip(*[iter("lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv")]*2))])
```
Prints the result as a Python list of Python tuples. They are also enclosed in quotes. This definitely qualifies for the bonus since the only number in the code is 2.
Output:
```
[('Baton Rouge', 'LA'), ('Indianapolis', 'IN'), ('Columbus', 'OH'), ('Montgomery', 'AL'), ('Helena', 'MT'), ('Denver', 'CO'), ('Boise', 'ID'), ('Austin', 'TX'), ('Boston', 'MA'), ('Albany', 'NY'), ('Tallahassee', 'FL'), ('Santa Fe', 'NM'), ('Nashville', 'TN'), ('Trenton', 'NJ'), ('Jefferson', 'MO'), ('Richmond', 'VA'), ('Pierre', 'SD'), ('Harrisburg', 'PA'), ('Augusta', 'ME'), ('Providence', 'RI'), ('Dover', 'DE'), ('Concord', 'NH'), ('Montpelier', 'VT'), ('Hartford', 'CT'), ('Topeka', 'KS'), ('Saint Paul', 'MN'), ('Juneau', 'AK'), ('Lincoln', 'NE'), ('Raleigh', 'NC'), ('Madison', 'WI'), ('Olympia', 'WA'), ('Phoenix', 'AZ'), ('Lansing', 'MI'), ('Honolulu', 'HI'), ('Jackson', 'MS'), ('Springfield', 'IL'), ('Columbia', 'SC'), ('Annapolis', 'MD'), ('Cheyenne', 'WY'), ('Salt Lake City', 'UT'), ('Atlanta', 'GA'), ('Bismarck', 'ND'), ('Frankfurt', 'KY'), ('Salem', 'OR'), ('Little Rock', 'AR'), ('Des Moines', 'IA'), ('Sacramento', 'CA'), ('Oklahoma City', 'OK'), ('Charleston', 'WV'), ('Carson City', 'NV')]
```
I hope this is within the acceptable bounds of formatting.
[Answer]
# Groovy, ~~724~~ 681 - 20% = 545 bytes
```
c={it.capitalize()}
'labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfort,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city'.split(',').each{it.substring(2).split(' ').each{print c(it) + ' '}println c(it[0])+c(it[3-2])}
```
Inspired by Edc65's clever smushing together of state and city name!
[Answer]
## PowerShell, 627 -20% = 502 bytes
```
[regex]::replace('baton rougela;indianapolisin;columbusoh;montgomeryal;helenamt;denverco;boiseid;austintx;bostonma;albanyny;tallahasseefl;santa fenm;nashvilletn;trentonnj;jeffersonmo;richmondva;pierresd;harrisburgpa;augustame;providenceri;doverde;concordnh;montpeliervt;hartfordct;topekaks;saint paulmn;juneauak;lincolnne;raleighnc;madisonwi;olympiawa;phoenixaz;lansingmi;honoluluhi;jacksonms;springfieldil;columbiasc;annapolismd;cheyennewy;salt lake cityut;atlantaga;bismarcknd;frankfortky;salemor;little rockar;des moinesia;sacramentoca;oklahoma cityok;charlestonwv;carson citynv;','\b\w|..;',{"$args,"[3]+"$args".toupper()})
```
Which is this pattern:
```
[regex]::replace('baton rougela;','\b\w|..;',{"$args,"[3]+"$args".toupper()})
```
Uppercase the single letter after a word boundary, or the double letters before a colon. The `"$args,"[3]` selects either the comma in the case of a double letter state code, or overselects and returns null, and adds the state separators, saving ~50 in separators from the code line.
[Answer]
## Ruby, (925 \* 80%) = 740 bytes
```
require "zlib";eval "puts \x5alib::inflate('789c35925db2da300c85dfb50a16a04d98044a203f0ca450faa64b44e2892333b6c394dd57e1b66fdfb1251fe98c8dfb2279637d0323424fef6cc42a07931c4922fc61c0ccfd1c15ab8d624c56b0fd056b4a5e56273ff78ca581b58d1385fb88750e6b6f2363b140d422ac0c6414a2966736a9d305b28182e3cfe57551fc6611c6eb0d32efe6e9cb129eb37f3c476c76ca72f7a1c37a0739cb8b03668d525c55de0a472c0ce47e39ce37b00d24e3c38784871bec28041bbfe6d0e3d12c2a3d9677b21676ec58742b252f6ae566dc15504867e97f0e450d7bba8f7159e20c7b7e3c387c4403fb59986634072849a2951eab024aab533ac17aa39892630d48333127a8a8b34be7b580ca4beafdc4e18da6fca8273baba35f5aa8290e2feb1c635b43333a1afc44dfb1350768dc7b7a6a365703c7c1b3d83f687ec3517b03e3398763f02fdbb1dc194f059cc8b1ed07ac3338d9fb3079e9f062e04cf740134bf2982dca4a5a1d697658d5aa1c4fd89c1648ab9246fef6fed9ea89fe86d596b1aee0fc0cbaf0c3b2ebb028a125a783528cccb855e99f3c121eced086c546e3d8c35f3dcecbfd'.scan(/.{2}/).map {|i|i.hex.chr}.join)"
```
Oof, this one was hard. This is a Zlib compressed string in hex encoded bytes, which is then decompressed, turned into an array of strings by the scan regex, then each string is converted to a decimal integer, then to a character, and finally this array is joined into a string. I might post a better version later that uses a modified base64 encoding.
Though the encoded string may have some instances of 65-90 or 1's, I don't count those because the string is one huge number in hexadecimal. Thus this qualifies for the 20% bonus.
[Answer]
## Python 2, 639 bytes - 20% = 511.2
```
t="labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfurt,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city".split(",");print[(t[n][:2].upper(),t[n][2:].title())for n in range(50)]
```
The version bellow (675 bytes) has `''.join([w.capitalize()for w in t[n][2:].split()])` in it, which I just discovered can be replace by `.title()`, and is an anonymous function. In both answers, the state abbreviations are attached to the capitals.
```
lambda t="labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfurt,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city".split(","):[(t[n][:2].upper(),''.join([w.capitalize()for w in t[n][2:].split()]))for n in range(50)]
```
[Answer]
# x86 machine-code - 585 bytes, 468 with bonus
Dissapointed with how large my last entry was, I decided to try something very different this time. Drawing on `insertusernamehere`'s idea of separating the city names from the state names, thus avoiding unnecessary logic and unneeded terminators, I still thought I've gotta be able to make the program smaller than the raw strings are. UPX wouldn't help me to cheat, complaining that the program was already too small. Thinking about compression, I tried to compress the 662 byte text output with WinRar but still only got 543 bytes - and that was without anything to decompress it with. It still seemed far too large, given that it was just the result, without any code.
Then I realized - I'm only using 26 chars for the letters and another 2 for the spaces and the commas. Hmm, that fits into 32, which needs just 5 bits. So, I wrote a quick javascript program to encode the strings, assigning a-z to 0-25 and space and comma got 26 and 27. To keep things simple, every character is encoded in 5 bits, whether it needs this many or not. From there, I just stuck
all the bits together and broke them back into byte-sized chunks. This allowed me to pack the 563 bytes of strings into 353 bytes - a saving of 37.5% or some 210 bytes. I didn't quite manage to squeeze the program and data into the same space as just the unpacked data, but I came close enough to be happy.
Hxd view of binary:
```
68 3F 00 68 E8 01 68 4F 03 E8 1C 00 68 22 01 68 27 02 68 B3 03 E8 10 00     -   h?.hè.hO.è..h".h'.h³.è..
BE 83 05 C6 04 00 68 4F 03 68 B3 03 E8 62 00 C3 55 89 E5 81 C5 04 00 8B     -   ¾ƒ.Æ..hO.h³.èb.ÃU‰å.Å..‹
76 02 8B 7E 00 B6 05 30 DB AC B2 08 D0 D0 D0 D3 FE CA FE CE 75 1E 80 FB     -   v.‹~.¶.0Û¬².ÐÐÐÓþÊþÎu.€û
1A 75 05 B3 20 E9 0D 00 80 FB 1B 75 05 B3 2C E9 03 00 80 C3 61 88 1D 47     -   .u.³ é..€û.u.³,é..€Ãaˆ.G
B6 05 30 DB 08 D2 75 D4 FF 4E 04 75 CC 5D C2 06 00 53 B3 62 FE CB 88 DF     -   ¶.0Û.ÒuÔÿN.uÌ]Â..S³bþËˆß
80 C7 19 38 D8 72 08 38 F8 77 04 B3 20 28 D8 5B C3 55 89 E5 81 C5 04 00     -   €Ç.8Ør.8øw.³ (Ø[ÃU‰å.Å..
8B 76 00 31 C0 88 C2 89 C1 AC A8 FF 74 46 80 FA 20 74 35 08 D2 74 31 3C     -   ‹v.1ÀˆÂ‰Á¬¨ÿtF€ú t5.Òt1<
2C 75 30 B4 0E CD 10 89 CB 01 DB 03 5E 02 8A 07 E8 B6 FF CD 10 43 8A 07     -   ,u0´.Í.‰Ë.Û.^.Š.è¶ÿÍ.CŠ.
E8 AE FF CD 10 B0 0D CD 10 B0 0A CD 10 C6 06 4C 03 00 30 D2 41 E9 C1 FF     -   è®ÿÍ.°.Í.°.Í.Æ.L..0ÒAéÁÿ
E8 96 FF B4 0E CD 10 88 C2 E9 B5 FF 5D C2 04 00 58 10 D7 1C 0B 64 C4 E4     -   è–ÿ´.Í.ˆÂéµÿ]Â..X.×..dÄä
0E 77 60 1B 82 AD AC 9B 5A 96 3A A0 90 DE 06 12 28 19 1A 7A CC 53 54 98     -   .w`.‚.¬›Z–: .Þ..(..zÌST˜
D0 29 A4 68 AC 8B 00 19 62 0E 86 49 0B 90 98 3B 62 93 30 1A 35 61 D1 04     -   Ð)¤h¬‹..b.†I..˜;b“0.5aÑ.
50 01 01 CA B5 5B 50 08 26 E6 EA 2E A1 89 B4 34 68 03 40 F7 2D 12 D8 9C     -   P..Êµ[P.&æê.¡‰´4h.@÷-.Øœ
BA 30 34 96 D8 E6 CC CE 61 23 8D 9C 8B 23 41 B1 91 B5 24 76 17 22 44 D8     -   º04–ØæÌÎa#.œ‹#A±‘µ$v."DØ
29 29 A1 BB 0B A5 37 37 60 58 40 DC 6E 60 5A C0 70 4A 44 26 E4 06 CC 1A     -   ))¡».¥77`X@Ün`ZÀpJD&ä.Ì.
29 36 D0 48 F5 42 D6 4D CE 24 6C DC DD A4 85 29 23 27 37 71 40 8E C7 34     -   )6ÐHõBÖMÎ$lÜÝ¤…)#'7q@ŽÇ4
7B 7A 09 18 93 67 04 62 89 06 91 36 C1 43 52 53 06 DF 17 55 03 23 44 4D     -   {z..“g.b‰.‘6ÁCRS.ß.U.#DM
8D D5 24 76 27 34 4E 88 F6 C7 36 6F 22 D0 48 EC E0 8C CA E8 8F 73 73 C8     -   .Õ$v'4NˆöÇ6o"ÐHìàŒÊè.ssÈ
A0 6E 40 43 67 A7 82 8B DA 68 D2 02 9B 5A 1A 27 2D BB 88 16 44 18 FB 60     -    n@Cg§‚‹ÚhÒ.›Z.'-»ˆ.D.û`
06 89 39 BB 72 F0 C7 A0 1B 79 DC 46 A2 FB 58 1B 24 34 DB 3B 9A E5 D1 74     -   .‰9»rðÇ .yÜF¢ûX.$4Û;šåÑt
DA 40 25 49 CD DC 9F 14 34 C5 41 16 3D 89 CB A3 02 80 6C 0D 68 1E E5 A2     -   Ú@%IÍÜŸ.4ÅA.=‰Ë£.€l.h.å¢
5B 11 C9 82 35 A4 DC 80 B9 E9 60 51 34 24 4F 1B 04 D6 06 CC 1B 0A 24 C0     -   [.É‚5¤Ü€¹é`Q4$O..Ö.Ì..$À
44 4A D9 62 06 A8 AE 8C F7 20 2C 8C DA D1 39 AC 9A 8B 84 AD 8C 92 D3 1C     -   DJÙb.¨®Œ÷ ,ŒÚÑ9¬š‹„.Œ’Ó.
86 92 5B 90 05 10 30 8D 9B B6 E5 2C 07 73 01 A1 22 78 D8 8E 08 AC 92 9B     -   †’[...0.›¶å,.s.¡"xØŽ.¬’›
9B B1 02 32 73 74 24 4F 1B                                                  -   ›±.2st$O.
```
Source-code:
```
[section .text]
[bits 16]
[org 0x100]
entry_point:
    push    word 63                 ; no of bytes of packed data = (5/8) * unpacked_length    - rounded up tp nearest byte
    push    word states_packed
    push    word states_unpacked
    call    unpack_bytes
    push    word 290                ; no bytes of packed data
    push    word capitals_packed
    push    word capitals_unpacked
    call    unpack_bytes
    ; ensure there's a terminating null after the capitals
    mov     si, nullTerminator
    mov     [si], byte 0
    ;void outputStrings(char *cities, char *states)
    push    word states_unpacked
    push    word capitals_unpacked
    call    output_strings
;   int 0x20
    ret
;void unpack_states(char *unpackedDest, char *packedInput, int packed_length)
;unpack_capitals:
unpack_bytes:
    push    bp
    mov     bp, sp
    add     bp, 4
    mov     si, [bp + 2]        ; point to the packed input
    mov     di, [bp + 0]        ; point to the output buffer
    mov     dh, 5               ; number of bits remaining until we have a full output byte, ready to be translated from [0..25] --> [A..Z] (+65) or 26-->' ' or 27-->','
    xor     bl, bl              ; clear our output accumalator
.unpack_get_byte:
    lodsb
    mov     dl, 8           ; number of bits remaining in this packed byte before we need another one
.unpack_get_next_bit:
    rcl     al, 1           ; put most significant bit into carry flag
    rcl     bl, 1           ; and put it into the least significant bit of our accumalator
    dec     dl              ; 1 bit less before we need another packed byte
    dec     dh              ; 1 bit less until this output byte is done
    jnz     .checkInputBitsRemaining
.transform_output_byte:
    cmp     bl, 26          ; space is encoded as 26
    jne     .notSpace
    mov     bl, ' '
    jmp     .store_output_byte
.notSpace:
    cmp     bl, 27          ; comma is encoded as 27
    jne     .notComma
    mov     bl, ','
    jmp     .store_output_byte
.notComma:
.alphaChar:
    add     bl, 'a'         ; change from [0..25] to [A..Z]
.store_output_byte:
    mov     [di], bl        ; store it
    inc     di              ; point to the next output element
    mov     dh, 5           ; and reset the count of bits till we get here again
    xor     bl, bl
.checkInputBitsRemaining:
    or      dl,dl           ; see if we've emptied the packed byte yet
    jnz     .unpack_get_next_bit
    dec     word [bp + 4]       ; decrement the number of bytes of input remaining to be processed
    jnz     .unpack_get_byte    ; if we still have some, go back for more
.unpack_input_processed:
    pop     bp
    ret     6
; input:
;       al = char
; outpt:
;       if al if an alpha char, ensures it is in range [capital-a .. capital-z]
toupper:
    push    bx
    mov     bl, 98
    dec     bl              ; bl = 'a'
    mov     bh, bl
    add     bh, 25          ; bh = 'z'
    cmp     al, bl          ;'a'
    jb      .toupperdone
    cmp     al, bh
    ja      .toupperdone
    mov     bl, 32
    sub     al, bl          ;'A' - 'a'
.toupperdone:
    pop     bx
    ret
;void outputStrings(char *cities, char *states)
output_strings:
    push    bp
    mov     bp, sp
    add     bp, 4
    mov     si, [bp + 0]            ; si --> array of cities
    xor     ax, ax
;   mov     [lastChar], al          ; last printed char is undefined at this point - we'll use this to know if we're processing the first entry
    mov     dl, al
;   mov     [string_index], ax      ; zero the string_index too
    mov     cx, ax                  ; zero the string_index too
.getOutputChar:
    lodsb
    test    al, 0xff
    jz      .outputDone             ; if we've got a NULL, it's the string terminator so exit
;   cmp     byte [lastChar], ' '    ; if the last char was a space, we have to capitalize this one
    cmp     dl, ' '                 ; if the last char was a space, we have to capitalize this one
    je      .make_ucase
;   cmp     byte [lastChar], 0
    or      dl, dl                  ; if this is 0, then it's the first char we've printed, therefore we know it should be capitalized
    jz      .make_ucase
    cmp     al, ','                 ; if this is a comma, the city is done, so print the comma then do the state and a crlf, finally, increment the string_index
    jne     .printChar
    mov     ah, 0xe                 ; code for print-char, teletype output
    int     0x10                    ; print the char held in al
;   mov     bx, [string_index]
    mov     bx, cx;[string_index]
    add     bx,bx                   ; x2 since each state is 2 bytes long
    add     bx, [bp+2]              ; bx --> states_unpacked[string_index]
    mov     al, [bx]                ; get the first char of the state
    call    toupper                 ; upper case it
;   mov     ah, 0xe         ;not needed, still set from above
    int     0x10                    ; and print it
    inc     bx
    mov     al, [bx]                ; get the 2nd char of the state
    call    toupper                 ; uppercase it
;   mov     ah, 0xe         ;not needed, still set from above
    int     0x10                    ; and print it
    mov     al, 0x0d                ; print a CRLF
    int     0x10
    mov     al, 0x0a
    int     0x10
    mov     byte [lastChar], 0      ; zero this, so that the first letter of the new city will be capitalized, just like the first char in the string was
    xor     dl, dl                  ; zero this, so that the first letter of the new city will be capitalized, just like the first char in the string was
;   inc     word [string_index]     ; increment our index, ready for the next city's state
    inc     cx  ;word [string_index]        ; increment our index, ready for the next city's state
    jmp     .getOutputChar          ; go back and get the next char of the next city
.make_ucase:
    call    toupper
.printChar:
    mov     ah, 0xe
    int     0x10
;   mov     [lastChar], al
    mov     dl, al
    jmp     .getOutputChar          ; go back and get the next char of the next city
.outputDone:
    pop     bp
    ret     4                       ; return and clean-up the two vars from the stack
[section .data]
; 63 packed bytes, 100 unpacked (saved 37)
states_packed:
    db  01011000b, 00010000b, 11010111b, 00011100b, 00001011b, 01100100b, 11000100b, 11100100b
    db  00001110b, 01110111b, 01100000b, 00011011b, 10000010b, 10101101b, 10101100b, 10011011b
    db  01011010b, 10010110b, 00111010b, 10100000b, 10010000b, 11011110b, 00000110b, 00010010b
    db  00101000b, 00011001b, 00011010b, 01111010b, 11001100b, 01010011b, 01010100b, 10011000b
    db  11010000b, 00101001b, 10100100b, 01101000b, 10101100b, 10001011b, 00000000b, 00011001b
    db  01100010b, 00001110b, 10000110b, 01001001b, 00001011b, 10010000b, 10011000b, 00111011b
    db  01100010b, 10010011b, 00110000b, 00011010b, 00110101b, 01100001b, 11010001b, 00000100b
    db  01010000b, 00000001b, 00000001b, 11001010b, 10110101b, 01011011b, 01010000b
; 290 packed bytes, 463 unpacked (saved 173)
capitals_packed:
    db  00001000b, 00100110b, 11100110b, 11101010b, 00101110b, 10100001b, 10001001b, 10110100b, 00110100b, 01101000b, 00000011b, 01000000b, 11110111b, 00101101b
    db  00010010b, 11011000b, 10011100b, 10111010b, 00110000b, 00110100b, 10010110b, 11011000b, 11100110b, 11001100b, 11001110b, 01100001b, 00100011b, 10001101b
    db  10011100b, 10001011b, 00100011b, 01000001b, 10110001b, 10010001b, 10110101b, 00100100b, 01110110b, 00010111b, 00100010b, 01000100b, 11011000b, 00101001b
    db  00101001b, 10100001b, 10111011b, 00001011b, 10100101b, 00110111b, 00110111b, 01100000b, 01011000b, 01000000b, 11011100b, 01101110b, 01100000b, 01011010b
    db  11000000b, 01110000b, 01001010b, 01000100b, 00100110b, 11100100b, 00000110b, 11001100b, 00011010b, 00101001b, 00110110b, 11010000b, 01001000b, 11110101b
    db  01000010b, 11010110b, 01001101b, 11001110b, 00100100b, 01101100b, 11011100b, 11011101b, 10100100b, 10000101b, 00101001b, 00100011b, 00100111b, 00110111b
    db  01110001b, 01000000b, 10001110b, 11000111b, 00110100b, 01111011b, 01111010b, 00001001b, 00011000b, 10010011b, 01100111b, 00000100b, 01100010b, 10001001b
    db  00000110b, 10010001b, 00110110b, 11000001b, 01000011b, 01010010b, 01010011b, 00000110b, 11011111b, 00010111b, 01010101b, 00000011b, 00100011b, 01000100b
    db  01001101b, 10001101b, 11010101b, 00100100b, 01110110b, 00100111b, 00110100b, 01001110b, 10001000b, 11110110b, 11000111b, 00110110b, 01101111b, 00100010b
    db  11010000b, 01001000b, 11101100b, 11100000b, 10001100b, 11001010b, 11101000b, 10001111b, 01110011b, 01110011b, 11001000b, 10100000b, 01101110b, 01000000b
    db  01000011b, 01100111b, 10100111b, 10000010b, 10001011b, 11011010b, 01101000b, 11010010b, 00000010b, 10011011b, 01011010b, 00011010b, 00100111b, 00101101b
    db  10111011b, 10001000b, 00010110b, 01000100b, 00011000b, 11111011b, 01100000b, 00000110b, 10001001b, 00111001b, 10111011b, 01110010b, 11110000b, 11000111b
    db  10100000b, 00011011b, 01111001b, 11011100b, 01000110b, 10100010b, 11111011b, 01011000b, 00011011b, 00100100b, 00110100b, 11011011b, 00111011b, 10011010b
    db  11100101b, 11010001b, 01110100b, 11011010b, 01000000b, 00100101b, 01001001b, 11001101b, 11011100b, 10011111b, 00010100b, 00110100b, 11000101b, 01000001b
    db  00010110b, 00111101b, 10001001b, 11001011b, 10100011b, 00000010b, 10000000b, 01101100b, 00001101b, 01101000b, 00011110b, 11100101b, 10100010b, 01011011b
    db  00010001b, 11001001b, 10000010b, 00110101b, 10100100b, 11011100b, 10000000b, 10111001b, 11101001b, 01100000b, 01010001b, 00110100b, 00100100b, 01001111b
    db  00011011b, 00000100b, 11010110b, 00000110b, 11001100b, 00011011b, 00001010b, 00100100b, 11000000b, 01000100b, 01001010b, 11011001b, 01100010b, 00000110b
    db  10101000b, 10101110b, 10001100b, 11110111b, 00100000b, 00101100b, 10001100b, 11011010b, 11010001b, 00111001b, 10101100b, 10011010b, 10001011b, 10000100b
    db  10101101b, 10001100b, 10010010b, 11010011b, 00011100b, 10000110b, 10010010b, 01011011b, 10010000b, 00000101b, 00010000b, 00110000b, 10001101b, 10011011b
    db  10110110b, 11100101b, 00101100b, 00000111b, 01110011b, 00000001b, 10100001b, 00100010b, 01111000b, 11011000b, 10001110b, 00001000b, 10101100b, 10010010b
    db  10011011b, 10011011b, 10110001b, 00000010b, 00110010b, 01110011b, 01110100b, 00100100b, 01001111b, 00011011b
[section .bss]
lastChar        resb    1       ; last printed char - used to capitalize chars after a space (i.e the 2nd or third word of a city name)
string_index    resw    1       ; used to index into the array of states, which are each two bytes
states_unpacked         resb 100            ; 50 states, 2 bytes each
capitals_unpacked       resb 464
nullTerminator          resb   1
```
]


[Question]
      [
The cops thread can be found here: [The Mystery String Printer (Cops)](https://codegolf.stackexchange.com/questions/60328/the-mystery-string-printer-cops)
# Your challenge
* Choose a submission from the cops thread, and print out the string from an answer in that thread.
* The submission that you choose must not be safe (it must be newer than 7 days).
* Your program, function, or REPL script needs to follow the same rules as the cops thread. Just to recap:
	+ Your program must be ≤128 characters (if a cop's submission is in a smaller range of program lengths, your program must also be in that length range. For example, if a cop's program is ≤32 bytes, your program must be ≤32 bytes).
	+ The program must produce the same output every time it is run.
	+ No cryptographic functions.
	+ The program must not take input.
	+ No standard loopholes.
* All new submissions must use the same language. Submissions from before this rule was made are fine, even if they don't.
## Scoring
Scoring works similarly for robbers, but it is slightly different:
* Cracking any program of ≤8 bytes gives 1 point.
* Cracking a ≤16 byte program gives 2 points. ≤32 bytes gives 4 points, and so on.
* Every additional submission, no matter the length, earns +5 points
* Each cop's submission can only be cracked once- only the first person to crack each submission gets the points.
# Submissions
Each answer must include
* A link to the cop's submission.
* Your program and programming language.
* Also have the cop's program length (as a power of 2) as the last number in your header.
Additionally, please comment on the cop's submission with a link to your answer.
Here is a Stack Snippet to generate leaderboards. Please leave a comment if there is a problem with the snippet. If you would like to see all open cop submissions, see the snippet in the cops' challenge.
```
/* Configuration */
var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
/* App */
var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;
function answersUrl(index) {
  return "//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 "//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) {
        answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}
getAnswers();
var POINTS_REG = /(?:<=|≤|<=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  var open = [];
  answers.forEach(function(a) {
    var body = a.body;
    var cracked = false;
    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);
    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;
      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints
      });
    }
  });
  var pointTotals = [];
  valid.forEach(function(a) {
    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });
    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }
  });
  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });
  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });
  pointTotals.forEach(function(a) {
    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
  });
}
```
```
body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
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>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>
```
**This contest is now closed.**
**Overall winner: kennytm**
**Most submissions: Sp3000**
(Note that the amount of submissions doesn't translate exactly to the points, as the length of the cracked program is counted when calculating the score).

[Answer]
# [MATLAB, Tom Carpenter, ≤16](https://codegolf.stackexchange.com/a/60333/45151)
`v=ver;[v.Name]`
Thanks Martin for helping me out with this.
[Answer]
# [Fishing, Eridan, ≤ 32](https://codegolf.stackexchange.com/a/60394/3852)
```
v+CCCCCCCCCCC
  `65617`nSSP
```
Calculates `(65617^2)^2`.
[Answer]
# [Octave, flawr, ≤4](https://codegolf.stackexchange.com/a/60408/32353)
```
i^-i
```
which is equal to *e**π*/2 ≈ 4.8105.
[Answer]
# [Groovy, quartata, ≤128](https://codegolf.stackexchange.com/a/60370/32353)
Only checked on ideone, I'm not sure if the output is the same on all platforms.
```
ClassLoader.systemClassLoader.packages.each{if(!(it.name=~/ls$/))println it.name[6..-1].reverse()}
```
The `it.name=~/ls$/` is to filter out the additional `org.codehaus.groovy.tools` package.
[Answer]
# [vim, Doorknob, 16](https://codegolf.stackexchange.com/a/60414/3852)
```
:redi@"|Ni!
pg?G
```
[Answer]
# [MATLAB, Tom Carpenter, ≤4](https://codegolf.stackexchange.com/a/60441/39328)
```
pi^i
```
It's not hard when the absolute value is 1.
[Answer]
## [Javascript, Ludovic Zenohate Lagoua, ≤64](https://codegolf.stackexchange.com/a/60511/45052)
```
var a="'";for(var b=11;b<2004;b+=4){a+=b;}a+="'";console.log(a);
```
[Answer]
# [Python 2.7.2, Beta Decay, ≤ 64](https://codegolf.stackexchange.com/a/60516/21487)
```
import math,re;print zip(dir(math),dir(re))
```
I had 2.7.10 installed, and the additional `__loader__` messed with the results, but this is probably it (I had to confirm with @BetaDecay in chat).
[Answer]
# [STATA, bmarks, ≤32 bytes](https://codegolf.stackexchange.com/a/60433/33208)
```
set ob 82
g a=_n*9/8
set ob 99
l
```
This uses the free interpreter.
[Answer]
# [Brainfuck, Daniel M., ≤ 64](https://codegolf.stackexchange.com/a/60545/21487)
```
++++++++++[->++++>++++++>++++++++>+<<<<]>.>>.<.>>++[-<++.>]
```
The code points are
```
[40, 80, 60, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104]
```
So we print the first three separately, then using the 80 to increment by 2 each time for the rest of the chars.
[Answer]
## [Python 2, <=8](https://codegolf.stackexchange.com/a/60563/11006), by [Clear question with examples](https://codegolf.stackexchange.com/users/45676/clear-question-with-examples)
```
947**687
```
Factorizing this number took no time at all :-)
[Answer]
# [Hassium](http://hassiumlang.com/) [(in REPL), <=32 bytes, by](https://codegolf.stackexchange.com/a/60515/19438) [Jacob Misirian](https://codegolf.stackexchange.com/users/45045/jacob-misirian)
```
for(i=0;i<99;i++)print(i%6==0)
```
Not too much fancy in this one.
[Answer]
# [AppleScript, VTCAKAVSMoACE, ≤32 bytes](https://codegolf.stackexchange.com/a/60566/11006)
```
repeat 409 times
log "(**)"
end
```
The `log` command actually adds comment markers `(*`...`*)` to everything it outputs to the Messages window of the script editor, but it looks like they have to be added explicitly when printing to stdout. Either way, the program is still less than 32 characters.
I'm using [Digital Trauma's trick](https://codegolf.stackexchange.com/a/37644/11006) of replacing `end repeat` with `end` to save a few bytes.
---
**EDIT:** As kennytm correctly pointed out, this outputs to stderr instead of stdout. As a workaround, I can suggest the following:
```
osascript -e 'repeat 409
log "(**)"
end' 2>&1
```
Including line breaks, the script inside the single quotes is 25 bytes, Add 5 bytes for  `2>&1` at the end of the command line to redirect stderr to stdout, and it's still within the 32 byte limit.
[Answer]
# [Javascript, RononDex, ≤ 32 bytes](https://codegolf.stackexchange.com/a/60646/11006)
```
console.log(Math.log(42))
```
Very easy :-D
[Answer]
# [Thue, histocrat, ≤64](https://codegolf.stackexchange.com/a/60783/39328)
```
a::=yellowyellowyellowredyellowred
::=
aaaaaa
```
[Answer]
# [><>, Fongoid, ≤ 16](https://codegolf.stackexchange.com/a/60909/21487)
```
'$1-:0(?;$:o3+ !
```
That was some nice golfing practice.
[Answer]
# [AppleScript, VTCAKAVSMoACE, ≤ 2 Bytes](https://codegolf.stackexchange.com/a/60917/11006)
```
id
```
I have no idea why this produces the output `missing value`; I just wrote a bash script to test all pairs of printable ASCII characters. I also found that `it` and `me` result in the output `«script»`.
[Answer]
# [MATLAB, Tom Carpenter, ≤ 2](https://codegolf.stackexchange.com/a/61052)
```
!<
```
*Thanks to @AlexA. and @RetoKoradi for helping me test this. I don't have a Windows PC/VM...*
Googling the desired output immediately revealed it as a typical Windows Cmd error. In fact,
```
<
```
produces the desired output, and a MATLAB command that is prefixed by a `!` is a system command. I don't have MATLAB at hand to test this, but it should work.
[Answer]
# [><>, quartata, ≤ 32](https://codegolf.stackexchange.com/a/61081/21487)
```
1"qq"+\
v!?:  <$*d$-1
>~n;
```
I'd like to thank @quartata for make this interesting - despite being such a long number, it's actually just `13^226`.
[Answer]
# [><>, Fongoid, ≤64 Bytes](https://codegolf.stackexchange.com/a/60915/42833)
```
"!":"~"=a$.1+:"!"(?;::1-$oo20.
"+"f8+0pa0.2-"-"c0p"3"f7+0p
```
A little bit hard-coded since I had room and I couldn't really think of a good way to go down once I got to `~` in the output (there probably is one and I probably just don't see it).
You can try it online [here](http://fishlanguage.com/playground).
[Answer]
# [Pip, DLosc, ≤ 2](https://codegolf.stackexchange.com/a/60739/32852)
```
O_
```
I don't really understand what the code does, but 2 characters is wide open to brute force cracking.
[Answer]
# [Wolfram programming language, Eridan, ≤32](https://codegolf.stackexchange.com/a/61107/9288)
```
ContinuedFraction[Zeta[3],36]
```
It's sequence [A013631](http://oeis.org/A013631) on OEIS.
[Answer]
# [AppleScript, VTCAKAVSMoACE, ≤64](https://codegolf.stackexchange.com/a/60898/32353)
```
osascript -e 'repeat with i from 688 to 195049 by 629
log i mod 1e3
end' 2>&1
```
Needs a redirect to stdout, similar to <https://codegolf.stackexchange.com/a/60601/32353>. Total size is 64.
[Answer]
# [Lua, jcgoble3, ≤ 128](https://codegolf.stackexchange.com/a/61145)
```
x=111111111
h="haha"
p=h..3*x..2*x..h..7*x..h..2*x
q="ha"..6*x..p..p..h..6*x..h..7*x..h..4*x..h..5*x
"ha"..(q..h):rep(11)..q
```
124 bytes. Tested in Lua 5.3.1 REPL.
This is a cleaner version that can be executed as a single command or even a full program:
```
x=111111111 h="haha" p=h..3*x..2*x..h..7*x..h..2*x q=h..6*x..p..p..h..6*x..h..7*x..h..4*x..h..5*x print((q.."ha"):rep(11)..q)
```
125 bytes. Tested in Lua 5.3.1 REPL and [ideone](http://ideone.com/uRlne7).
[Answer]
# [Pyth, ConfusedMr\_C, ≤ 32](https://codegolf.stackexchange.com/a/60757/29577)
```
sm*2s_c4s_Mcd2%2_c4sCM127
```
Only needed 25 chars. Took some while though.
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=sm*2s_c4s_Mcd2%252_c4sCM127&debug=0)
The idea is to take all chars of the ranges 32-63 und 96-126 (Yes, 127 is not included), rearrange them, duplicate these strings and join them.
[Answer]
# [Self-modifying Brainfuck, mbomb007, ≤8](https://codegolf.stackexchange.com/a/60506/32353)
```
<[-.+<]
```
stdin needs to be /dev/null and disregard the output from stderr.
[Answer]
# [QBasic, DLosc, ≤16](https://codegolf.stackexchange.com/a/61449/3852)
```
?STRING$(3,34)
```
[Answer]
# [QBasic, DLosc, ≤8](https://codegolf.stackexchange.com/a/61448/3852)
```
?TAN(22)
```
Does the leading/trailing space thingy. I guess it's a QBasic quirk.
[Answer]
# [CJam, Eridan, ≤8](https://codegolf.stackexchange.com/a/61039/3852)
```
6C#E130#
```
I assumed it would be a list of numbers of the form *i^j*, so I did a search for those using substrings from output. I found that it was `str(6 ** 12) + str(14 ** 130)` using a Python script.
[Answer]
# [Python 3, ppperry, ≤32](https://codegolf.stackexchange.com/a/61653/32353)
```
0x1d4f620cb7a9ca2c585c639763613
```
]


[Question]
      [
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.

---
 This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/60152/edit)
So, you're browsing Programming Puzzles & Code Golf, and you see a new challenge. The author (*gasp*) forgot to say "No standard Loopholes". You decide to take advantage of this situation, and you read the answer from a file/network. However, you need to make sure that your answer is actually shorter than the legitimate answers, so you golf it, too.
# The Challenge
Write a complete program that prints out the contents of the file `definitelynottheanswer.txt` to STDOUT. This text file only contains valid ASCII characters. Alternatively, the program can get the file location from STDIN or command line args. The only input allowed is the file location if you choose to get the location from the user; otherwise, no input is allowed. There is no reward for getting the file location from the user, but the user input of the file location does not count against the byte total (in other words, `definitelynottheanswer.txt` wouldn't be included in the byte score).
The program must not write to STDERR.
## Bonus
Retrieve the file from the internet *instead* of a file (the URL must be user-supplied). **Reward: multiply source length by 0.85**
# Scoring
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the lowest score,`program length (bytes) * bonus`, wins.
* No (other) standard loopholes.
* If the language does not support reading files from disk, it cannot be used (sorry).

[Answer]
# GNU sed, 0 bytes
Even better..
[Answer]
# Bash, 7 bytes \* .85 = 5.9 bytes
```
curl $1
```
zzz
[Answer]
# Pyth - 2 bytes \* .85 = 1.7
```
'z
```
Does not work online.
[Answer]
## Bash, 6 bytes
```
cat $1
```
Provide filename as a command line argument. Probably breaks if the argument contains spaces or newlines or weird chars or whatever.
[Answer]
# CJam, 1.7 bytes
```
qg
```
For security reasons, this does not work in the online interpreter.
]


[Question]
      [
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.

---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/60042/edit).
Closed 8 years ago.
[Improve this question](/posts/60042/edit)
# Intro
In `Objective-C` (a superset of `C` and an object-oriented language), I can create an object called a `UIWebView`. There is a method for this object called `loadHTMLString:` in which I can load actual `HTML` into the `UIWebView` object itself. I can also inject Javascript into it using the method `stringByEvaluatingJavaScriptFromString:`.
If I were to write a program that created a UIWebView, loaded in my string (which happens to be HTML "code") and then injected a second string (which is Javascript code) I would be using 3 languages at once, in a functional program. (Not sure that `html` is really a programming language... so that's debatable haha)
You can also do things like embed `Python` into `C` (and other languages): <https://docs.python.org/2/extending/embedding.html>
---
This isn't too difficult, with any language you can use other languages inside it if you try hard enough.
---
# Challenge
The challenge here is to see how many languages you can cram into 1 functioning program in under 500 bytes. <https://mothereff.in/byte-counter>
The program can do literally any task, it just has to work. The languages all have to work together, so you can't have 2 languages running one task, and 3 other languages running a completely different task. So whatever your "task" may be (you decide), there should only be 1 task, and all `n` languages should work on just that 1 task in your 1 program.
---
# Objective
Your score is the number of languages you used. Whoever uses the most languages at once gets a cookie.
Since this is a popularity contest I will be accepting the answer with the most up-votes.
---
# Q&A
•Ray **asked**, "Just to clarify, you're looking for a program that uses multiple languages to accomplish different parts of a single task, as opposed to a polyglot that is a valid program in multiple languages?"
***Answer**, "Yes".*
•DanielM. **asked**, "does Regex count?" ***Answer**, "Yes, I personally WOULD count it. Again, this is a popularity contest, so it really is up to the voters to determine. HTML is not considered a programming language by some, but it has been successfully used in an answer already that has seen quite a few upvotes. (Also, Stack-overflow does define Regex as a programming language if that helps you make your decision to use it or not: <https://stackoverflow.com/tags/regex/info>)*

[Answer]
# make, sh, awk, sed, regex, yacc, lex, C; 8 languages.
## Including the input and output languages: brainfuck and D; 10 languages
This is a brainfuck to D compiler. It takes the brainfuck program over standard input and prints the D code to standard output.
Make uses awk, sed, and sh to generate a yacc program, which in conjunction
with a lex program is used to generate a C program that takes a brainfuck
program as input and outputs an equivalent D program. I tried to only use languages in ways that were actually useful, instead of just throwing in a bunch of no-ops. The lex/yacc/C combination is fairly standard for simple compilers, the make/sh combination is useful for building, and the awk/sed line was the only way I could get the whole thing under 500 bytes. (It's at 498 bytes currently.)
## Code
```
define L
%%
[][+-<>.,] return *yytext;
. ;
%%
endef
define Y
%{
#include <stdio.h>
%}
%left '+' '-' '.' ',' '>' '<' '[' ']'
%%
q: q q {}
+ p[i]++
- p[i]--
> i++
< i--
, p[i]=getchar()
. putchar(p[i])
[ while(p[i]){
] }
%%
yywrap(){}yyerror(){}main(){puts("import std.stdio;int p[30000];int i;void main(){");yyparse();puts("}");}
endef
export L
export Y
a:
    @echo "$$L">y;lex y;echo "$$Y"|awk '/^[+-^]/{printf("q: X%sX {puts(\"%s;\");}\n",$$1,$$2)} /^[^+-^]/'|sed "y/X/'/">y;yacc y;cc *.c;./a.out;:
```
## Example of use
```
$ cat helloworld.bf
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
$ make < helloworld.bf > tmp.d
y: warning: 8 shift/reduce conflicts [-Wconflicts-sr]
$ dmd tmp.d && ./tmp
Hello World!
```
[Answer]
# HTML, CSS, PHP, JavaScript, CoffeeScript, RegEx, sed, bash; 8 languages
Displays colors of the rainbow.
*(Only 396 bytes)* will try to add more languages
HTML + CSS is turning complete and counts as a valid language on PPCG. I've been [told](http://chat.stackexchange.com/transcript/message/24575556#24575556) CoffeeScript is different enough as JavaScript to be counted as a separate language. And RegEx has been specifically allowed also.
PHP allows for addition of many languages especially with `exec` and `shell_exec` functions.
Golfed to fit inside byte limit (ES6)
```
<html><style><?php foreach(explode(" ",exec('sed "s/;/ /g"<<<"red;orange;yellow;green;blue;violet"')) as $color){echo "#{$color} { color: $color }\n"}?></style><script>b="red orange yellow green blue violet".split(/ /).map(c=>`<p id="${c}">${c}</p>`)</script><script type="text/coffeescript">document.documentElement.innerHTML+=b.join "\n"</script><script src="http://v.ht/u31R"></script></html>
```
Uses:
* PHP to generate CSS
* PHP, uses exec to run bash
* sed to split color items for bash
* CSS to specify text colors
* JavaScript to generate elements
* RegEx to split color items for JS
* CoffeScript to print elements
* HTML as a wrapper / output
---
Faster & Ungolfed (All modern browsers)
```
<html>
<style>
  /* CSS */
  <?php// Loop through all colors
  foreach(explode(" ",
  exec('sed "s/;/ /g"<<<"red;orange;yellow;green;blue;violet"')) as $color) {
    // Print it out, add it to the CSS
    echo"#{$color} { color: $color }\n"}
 ?>
</style>

<script>
  // Create an element for each color, store as variable
  window.colors = "red orange yellow green blue violet".split(/ /).map(function(color) {
    return "<p id=\"" + color + "\">" + color + "</p>"
  });
</script>

<script type="text/coffeescript">
  document.documentElement.innerHTML += window.colors.join "\n"
</script>

<!-- CoffeScript Link -->
<script src="https://raw.githubusercontent.com/jashkenas/coffeescript/master/extras/coffee-script.js"></script>
</html>
```
]