[Question]
  [
Your task is to print the text `Good morning, Green orb!`, with every character repeated in place as many times as the most frequent byte in your source (the mode). A trailing newline is permitted and need not be repeated.
For example if your source was
```
print p
```
Since `p` appears twice and every other byte appears once you would need to print
```
GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!
```
Answers will be scored by the product of their byte count and the number of times the output is repeated. For example the above code (if it worked) would score **7\*2 = 14**. The goal should be to minimize one's score.
Your code must contain at least 1 byte.
[Use this program to verify that your code and output match](https://tio.run/##LY5BasMwEEWvMgpZWGCXZp0okEXQAbosWci1ogzxzJixUmzI3VWlZPHh8d/m3cJ8j@NYkCbRDF/rnCN9nPkXVZgi53KF4Brnmo0XGYBEGTm14DVGBtHebI5Hp3Ea8Sfk2FBYkB70PdftnsuhC@3q3HJ5rhUv1tpCAdkNAkHTfOhSzKcK@0mR8/bavF5jPu0bdraUfwVT8bWgNgwARCKqzIjMKbUtgPdag2oSA7xc3xvzBw "Haskell – Try It Online")
  
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~384 \* 106~~ 366 \* 100 = 36,600
```
(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>(((({}<>()))))({}{}{}<>)<>{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}
```
[Try it online!](https://tio.run/##TU9BDsIwDPtOfOAHVSXeUe0wuICQOHCt@vZiO90gXdckduLk9tmf78d@f80Zy6CTpqAPnYgWdgEG2MyUp1hXvjIo0frYDtidMuMfToF8zXHr/8YOYTTlJeJsSoIqsrYhsT5KBb/KzDH6b5fIARe31KVAPlBzKbckkmkCYZqgVW2BrOSLNd@J9GCF/GICW5ROr3Glkn0qyBV1iDjnvFy/ "Brain-Flak (BrainHack) – Try It Online")
## Explanation
The first thing I do is push the string
```
!bro neerG ,gninrom dooG
```
to the stack using pretty standard brain-flak Kolmogorov-complexity tactics.
```
(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>({}<>())
```
Then we push a counter to the off stack to tell us how many times to duplicate each character. However I wasn't going to be able to determine what this counter was until I was done writing the program.
Next up we simultaneously reverse the string and duplicate each character in place the correct number of times. Specifically the counter + 1.
```
{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}
```
These two parts of the program have a mode of 99 open parentheses. However since we are most certainly going to need at least 1 parenthesis. Here is where I noticed that the last character we pushed `!` conveniently has character code 33 which means we can use it to create 99, the exact number we want using only one additional parenthesis. This is quite the coincidence but it works.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes \* 1 = 13
```
“¢Ȧ@XĊ'WÑṭḂ#»
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//4oCcwqLIpkBYxIonV8OR4bmt4biCI8K7//8 "Jelly – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 37 bytes × 3 = 111
*-20 thanks to H.PWiz. -25 thanks to nimi.*
```
"Good m\111rning, Green orb!"<*[2..4]
```
[Try it online!](https://tio.run/##y0gszk7NyflfbBvzX8k9Pz9FITfG0NCwKC8zL11Hwb0oNTVPIb8oSVHJRivaSE/PJPZ/bmJmnoKtQkFpSXBJkULx/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
Haskell's operators FTW.
Self-reminder to never golf on mobile. I keep making dumb mistakes. I can push at least half the blame on mobile. :P
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 235 x 77 = 18,095 points
Edit: -2 bytes thanks to @Dennis
```
-[>--<-------]>-[>+++++>+>+>+>+++++>+>+>+>+>+++>+++++>-->+>+>+>+>+>+>+>+++++>+>+>+>+++[<]>-]>>----------->+++++>++>->+>-------->-------->+++++>>->++++++>------>+>---->+>+++++>++>>->--------->++>++>>-[>+<---]>--------<<[>>[-<+<.>>]<<,<]
```
[Try it online!](https://tio.run/##XU9JCoBADHvQWF8Q8pHSgwqCCB4E3z/WWZzR9JK2SZf5nLZjvZY9RlGKQDKMnoYHLNFzJp4qIgzf@JoUPspIaagSNzO8Df7aLKQqirRtSJJ@aC752cgPFABKqiBgJA0YYDHe "brainfuck – Try It Online")
[TIO test](https://tio.run/##zZTNboQgEMdfBTc9aJRN91yYpIfGB@jRcGAra0kFDNJGk313y6rb3e15Dv4mJH@GYfia8Cn7L9W2kzad84G8j31QZv9mf7R31igbphORPOU83ZXO1cQ4b7VtClJ6pSxx/pjsALhXXas/ZFCpkYM236bqYzucB0ZlMXI@iPMYpciybDJSW147In3TM9qo8BrFS@e1DU@n9OJNkudsFYdsmmgFlDK6ICB28wuw2r2GWc8eSiF/tMdJFYupBAC9cQ2JkyH/G4B/w7CKa8QaelthDrlPurjittlygBXGKoCKspztAQRjBRNTiYnbLDUmBBODCeqdeUwsJhoT1J01mBSYoBYt6q@BWmdqs6DWGeprbvfXOGKSYPIL)
Wait, this *isn’t* code bowling?? \s
With only 8 usable characters, brainfuck is one of the worst languages to do this question. I had to start with minimising which character would inevitably appear the most, typically either `+` or `-`. After writing the first iteration of the code, I found it horribly unbalanced in favour of `+`s. I rearranged parts of the code, such as generation of larger numbers, to use more `-`. Finally, I ended up at ~~an *equal* amount of the two characters at 77~~ one less `-` than `+`. It’s certainly possible to reduce this further, which I’ll have a go at tomorrow. 
But hey, at least I beat the [Brainflak answer](https://codegolf.stackexchange.com/a/152042/76162)
[Answer]
## [Alice](https://github.com/m-ender/alice), 49 bytes \* 2 = 98 ~~144~~
```
/:G!4o3r8"1=5',0Grey9Z<@
\"b0=dnm 2'i%g<7R6~e.;o/
```
[Try it online!](https://tio.run/##S8zJTE79/1/fyl3RJN@4yELJ0NZUXcfAvSi10jLKxoErRinJwDYlL1fBSD1TNd3GPMisLlXPOl///38A "Alice – Try It Online")
### Explanation
```
/...@
\.../
```
This is the usual framework for linear programs that operate entirely in Ordinal mode. Unfolding the zigzag control flow, we get:
```
"G04d3m821i5g,7G6ee9;<:b!=onr "'=%'<0Rr~y.Zo@
```
The basic idea is to avoid characters which repeat more than twice with the help of a transliteration. The transliteration we're going to do is the following:
```
input: "G04d3m821i5g,7G6ee9;<:b!"
from:  "0123456789:;<"
to:    "onr "
```
The way transliteration works in Alice is that the `from` and `to` strings are first repeated to the LCM of their lengths, although in this case, all the matters is the length of the `from` string, so we get:
```
from:  "0123456789:;<"
to:    "onr onr onr o"
```
This way, we get four different characters to represent the `o`s, and three each for `n`, `r` and the space. We can generate the `from` string using range expansion as follows:
```
'<   Push "<".
0    Append a zero.
R    Reverse.
r    Range expansion.
```
The only issue now is that we'd need four `"` for both the `input` and the `to` string. To avoid that, we put them both into a single string and split it at a `=` used as a separator.
```
"G04d3m821i5g,7G6ee9;<:b!=onr "
     Push the string containing both parts.
'=%  Split around "=".
```
The rest is just:
```
~   Swap "from" and "to".
y   Transliterate.
.Z  Duplicate and interleave. This duplicates each character.
o   Print.
@   Terminate the program.
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~74×6=444~~[crossed out 444 is still regular 444](https://codegolf.stackexchange.com/questions/103403/print-the-f-%c3%97-f-times-table/146450?s=29|0.0000#146450) ~~77×5=385~~ 81×4=324
```
f(q){char*a="Go\157d morning, G\162een o\162b!";for(q=0;q<96;)putchar(a[q++/4]);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9No1CzOjkjsUgr0VbJPT/G0NQ8RSE3vygvMy9dR8E9xtDMKDU1TyEfxEhSVLJOyy/SKLQ1sC60sTSz1iwoLQHp1UiMLtTW1jeJ1bSu/Z@bmJmnoVmdpgHiAAA "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 62 × 3 = 186
```
lambda:`sum(zip(*['Good morning, Green \x6frb!']*3),())`[2::5]
```
[Try it online!](https://tio.run/##K6gsycjPM/pfUJSZV6Kg8T8nMTcpJdEqobg0V6Mqs0BDK1rdPT8/RSE3vygvMy9dR8G9KDU1TyGmwiytKElRPVbLWFNHQ1MzIdrIyso09r@mgobmfwA "Python 2 – Try It Online")
[Answer]
# Vim, ~~42~~ 41 keystrokes × 3 = 123
```
iGod morning, Green orb!<Esc>2|qsyl2pl@sqX0@s
```
Explanation:
1. `iGod morning, Green orb!<Esc>`  
Write the string `God morning, Green orb!` (one `o` missing).
2. `2|`  
Jump to the first `o`.
3. `qsyl2pl@sq`  
Create a recursive macro `s`.
As a side effect, triple the current `o`.
4. `X0`  
Remove one `o` and jump to the beginning.
5. `@s`  
Run the macro `s`, which repeat each character twice.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 68 × 3 = 204
```
0000000: 6a 3b 6d 61 69 6e 28 29 7b 77 68 69 6c 65 28 6a  j;main(){while(j
0000010: 3c 37 32 29 70 75 74 63 68 61 72 28 7e 22 b8 90  <72)putchar(~"..
0000020: 90 9b df 92 90 8d 91 96 91 98 d3 df b8 8d 9a 9a  ................
0000030: 91 df 5c 32 32 30 8d 9d de 22 5b 6a 2b 2b 2f 33  ..\220..."[j++/3
0000040: 5d 29 3b 7d                                      ]);}
```
*Thanks to @MDXF for saving 9 points and paving the way for 6 more!*
[Try it online!](https://tio.run/##jZHPbsIwDMbP5Ck@ceCPEKFNaNIMxItsO7RJS0FAWQGBxNird3HKAe00y0qsz/ZPdpJnp6q93RymDZZLDPkQK@xrV6zrXcltG3X2BpVB5lAOKoYyUAVECmGgc2gNlQbRQiWk@2JsF/tscxiN79dqsytGWxZAsUdJC6khRWiPoBPoOZQMkBhaEEF7vkCewkTAUovx8XK2VdaMfvqcdyjhUT5rcrgSRlCcOpgYRoUzhZOU8hDSM3LwP9ahJKFiKk4sDUbe0RxcmCTJaSmRBy8hJaE@hIg8o/@@nUxmskPNPSpxtJp/Lu3wL/scLx4tZ@zOeleLqX35AdYrbFWzXvij4@klg2@U9c6rwkenujn763LYfFH/U5g2h2f/A6uBYGxtX9kYDMBnGa8v5/YX "Bash – Try It Online")
### Alternate version, printable ASCII, 69 × 3 = 207
```
j;main(k){while(j<72)putchar("Gnmg$hiuf`dl -I}ut|3{gt6"[k=j++/3]^k);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/LOjcxM08jW7O6PCMzJ1Ujy8bcSLOgtCQ5I7FIQ8k9LzddJSOzNC0hJUdB17O2tKTGuDq9xEwpOts2S1tb3zg2LlvTuvb/fwA "C (gcc) – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 46 bytes × 2 = 92
(Contains unprintables)
```
2/⎕UCS(¯18+⍳24)+⎕UCS'X~r-yz|wqum1$Jtfem
ln]'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE4z0gXSoc7DGofWGFtqPejcbmWhqQ4TUI@rrinQrq2rKC0tzDVW8StJSc@Vy8mKl1f//BwA "APL (Dyalog Unicode) – Try It Online")
+Alot of bytes thanks to Dyalog's code page, thanks to @Adám for pointing that out.
[Answer]
# C, 78 × 4 = 312
```
*s=L" ÞÞÈ@ÚÞäÜÒÜÎX@äÊÊÜ@ÞäÄB";main(y){while(*++s)for(;y++%5;putchar(*s/2));}
```
[Try it online!](https://tio.run/##S9ZNT07@/1@r2NZHSeFQ3@F5QNjhcHgWkFpyeM7hSUDcF@EAlFhyuAsI5ziAJVqclKxzEzPzNCo1q8szMnNSNbS0tYs10/KLNKwrtbVVTa0LSkuSMxKLNLSK9Y00Na1r//8HAA)
## ~~356~~ ~~332~~
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 24 bytes \* 2 = 48
```
`Good ¶rÍÁ,
GÎ9 b!`m²·¸
```
Contains an unprintable. [Test it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=YEdvb2QgtnLNwSwKR845II5iIWBtsre4&input=)
The majority of the program is just a compressed string, which decompresses to
```
Good morning,
Green orb!
```
and `m²` then `m`aps each character by repeating it `²`wice okay, that was a bit of a stretch. Space is the only character that appears 3 times in the compressed string; to save one instance we replace it with a newline, then use `·¸` to split on newlines and immediately join on spaces. While 2 bytes longer, it substantially reduces the score (from 66 to 48).
Now if only there were a short way to do it using no character twice...
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 97 bytes \* 10 = 970
```
	S ='Good Morning, Green orb!'
y	S	LEN(1) . y rem . s	:f(p)
	x	=x DUPL(y,10)	:(y)
p	OUTPUT	=x
END
```
[Try it online!](https://tio.run/##Dcm7CoAgFADQ@foVtymFiIKmoC1p6QXlD0QWQXlDF/16azrDcYY2uqsYYcEm7Yh2HMiay5wZdlZrg2S3JGUBFujlyEuBOQa0@vl1UB/8FQw8NB5bNfc8ZGUhoOZBsBcmtc5q/Y/JsY3xAw "SNOBOL4 (CSNOBOL4) – Try It Online")
yeah........SNOBOL requires operators to be separated by whitespace, and there are whitespace requirements that are quite awkward. There are 9 `'\t'` and 10 `' '` in the code, so any improvements will require a fairly significant change in approach.
[Answer]
# [R](https://www.r-project.org/), ~~65 bytes \* 5 = 325~~ ~~59 bytes \* 5 = 295~~ 62 bytes \* 4 = 248
```
cat(gsub('(.)',strrep('\\1',4),"Good Mo\x72ning, Green orb!"))
```
[Try it online!](https://tio.run/##dY2xCsIwFEV3v@JZhySQCkpF/6A4uDlmSduXttAm8vIq/fsYOjgp3Dtd7jmUUmtZ9nFppJBHJXRkInxJYcxJ6Erpog6hg0cw6/XsR99rqAnRQ6BmXyi13YXxQu1mu0q2zYRyYXd7hrtnWfylb/yL0uYr@GUwWZGj4ABz6BDKEnhAQrC5FQQHEd9IdoJudC4PnqEdLNmWkWL6AA "R – Try It Online")
There are 4 `(or,')` characters. 
[Answer]
# [Ruby](https://www.ruby-lang.org/), 52 bytes × 3 = 156
```
puts"Good morning, Green \x6frb!".gsub(/(.)/,'\1'*3)
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFjJPT8/RSE3vygvMy9dR8G9KDU1TyGmwiytKElRSS@9uDRJQ19DT1NfRz3GUF3LWPP/fwA "Ruby – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 59 × 2 = 118 points
```
$_="GSSdYmoVRing,YGVIen orb!";y<H-Z>[d-t ],s<.>[$&x2]eg;say
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lbJPTg4JTI3PywoMy9dJ9I9zDM1TyG/KElRybrSxkM3yi46RbdEIVan2EbPLlpFrcIoNjXdujix8v//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 – Try It Online")
# [Perl 5](https://www.perl.org/), 51 × 3 = 153 ~~156~~ points
```
s""GOOd morning, Green orb!";y'O'o';s/./$&x3/eg;say
```
[Try it online!](https://tio.run/##K0gtyjH9/79YScnd3z9FITe/KC8zL11Hwb0oNTVPIb8oSVHJulLdXz1f3bpYX09fRa3CWD813bo4sfL//3/5BSWZ@XnF/3V9TfUMDA0A "Perl 5 – Try It Online")
# [Perl 5](https://www.perl.org/), 43 × 4 = 172 points
```
say"Good morning, Green orb!"=~s/./$&x4/egr
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVLJPT8/RSE3vygvMy9dR8G9KDU1TyG/KElRybauWF9PX0WtwkQ/Nb3o//9/@QUlmfl5xf91fU31DAwNAA "Perl 5 – Try It Online")
Saved 2 bytes in each solution thanks to @Xcali (a few changes ago). For all optimizations look at the edits.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 35 bytes \* 2 = 70
```
IG²od morning, GreeN ORb!5h3~Óˆ/°°
```
[Try it online!](https://tio.run/##K/v/39P90Kb8FIXc/KK8zLx0HQX3otRUPwX/oCRFadMM47rDkw916B/acGjD//8A "V – Try It Online")
Hexdump:
```
00000000: 4947 b26f 6420 6d6f 726e 696e 672c 2047  IG.od morning, G
00000010: 7265 654e 204f 5262 211b 3568 337e d388  reeN ORb!.5h3~..
00000020: 2fb0 b0                                  /..
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 16 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md) \* 1 = 16
```
7n]ēæ¬⁹≡qa╔αXE‘⁽
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=N24lNUQldTAxMTMlRTYlQUMldTIwNzkldTIyNjFxYSV1MjU1NCV1MDNCMVhFJXUyMDE4JXUyMDdE,v=0.12)
Compression!
Though, if `Green` wasn't capitalized like that, this could be 3 bytes shorter :/
[Answer]
# [Python 2](https://docs.python.org/2/), 62\*4 = 248
*Thanks to @ovs and @Giuseppe!*
```
lambda:"".join(c*4for(c)in"G\x6f\x6fd mor\x6eing, Green orb!")
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNykl0UpJSS8rPzNPI1nLJC2/SCNZMzNPyT2mwiwNhFMUcvOLgIzUzLx0HQX3otTUPIX8oiRFJc3/BUWZeSUKaRqa/wE)
# [Python 2](https://docs.python.org/2/), 51\*6 = 306
```
print"".join(c*6for c in"Good morning, Green orb!")
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69ESUkvKz8zTyNZyywtv0ghWSEzT8k9Pz9FITe/KC8zL11Hwb0oNTVPIb8oSVFJ8/9/AA)
# [Python 2](https://docs.python.org/2/), 70\*5 = 350
```
lambda:"".join(c*5for(c)in"Gxxd mxrning, Green xrb!".replace('x','o'))
```
[Try it online!](https://tio.run/##BcE5DoAgEADAryANYAyFiY2JNZ@w4VQMLGRjsb4eZ/r33g3WkY5zFFtdsDvn@mkZpJ@31FB6lYEbosAqIWS4FmYwRmCEbuIaYy/WRylILKIJpUbHDC9LUo0f)
*Thanks to @Mr. Xcoder for saving a byte from both versions!*
[Answer]
# [Ohm v2](https://github.com/nickbclifford/Ohm), 20 [bytes](https://github.com/nickbclifford/Ohm/blob/master/code_page.md) \* 1 = 20
```
”1Gäåa¬Î|òÙγy[õ↕~LzN
```
[Try it online!](https://tio.run/##ASgA1/9vaG0y///igJ0xR8Okw6VhwqzDjnzDssOZzrN5W8O14oaVfkx6Tv// "Ohm v2 – Try It Online")
Gotta love compression, although unfortunately it's not as good as SOGL's.
[Answer]
# [Clean](https://clean.cs.ru.nl), 77 bytes \* 3 = 231
```
import StdEnv
f=[[b,b..]%(0,2)\\a<-:"Qyyn*wy|xsxq6*Q|oox*\171|l+",b<-[a-'
']]
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRCG4JMU1r4wrzTY6OkknSU8vVlXDQMdIMyYm0UbXSimwsjJPq7yypqK4otBMK7AmP79CK8bQ3LAmR1tJJ8lGNzpRV51LPTb2f3BJItAwW4W0//@S03IS04v/6yb91/X0@e9SmZeYm5lcDAA "Clean – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 32 bytes × 2 = 64
```
"Gnmg$hiuf`dl -I}ut|3orb!"K,.^:_
```
[Try it online!](https://tio.run/##S85KzP3/X8k9LzddJSOzNC0hJUdB17O2tKTGOL8oSVHJW0cvzir@/38A "CJam – Try It Online")
Pushes a string, then XORs the first 20 character with `[0, 1, …, 19]`, then duplicates each character.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), Score: 22 (22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) \* 1)
```
…‚¿•´,„ˆ¨èã).ªðý23£'!«
```
[Try it online.](https://tio.run/##ATMAzP9vc2FiaWX//@KApuKAmsK/4oCiwrQs4oCey4bCqMOow6MpLsKqw7DDvTIzwqMnIcKr//8)
**Explanation:**
NOTE 1: The *wrap stack into list* builtin `)` is used instead of the builtin *pair* `‚`, because the `‚` is already part of the dictionary word `good`.  
NOTE 2: The two commas in the code `‚` and `,` may look the same, [but are different unicode characters](https://tio.run/##yy9OTMpM/f//cPv//48aZukAAA). The first one is usually used for the builtin *pair*, and the second for the builtin *print to STDOUT with trailing newline*. In this case they are used for the dictionary word `good`, and the expected comma in the output however.
```
…‚¿•´,        # 3-word dictionary string "good morning," (the comma counts as the third word)
„ˆ¨èã         # 2-word dictionary string "green orbit"
)             # Wrap everything on the stack into a list: ["good morning,","green orbit"]
 .ª           # Sentence capitalize all strings: ["Good morning,","Green orbit"]
   ðý         # Join by spaces: "Good morning, Green orbit"
     23£      # Only leave the first 23 characters: "Good morning, Green orb"
        '!«  '# Append a "!": "Good morning, Green orb!" (and output the result implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `…‚¿•´,` is `"good morning,"` and `„ˆ¨èã` is `"green orbit"`.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 46 bytes \* 4 = 184 points
```
"Good morning, Green orb!"-replace'.',('$0'*4)
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8k9Pz9FITe/KC8zL11Hwb0oNTVPIb8oSVFJtyi1ICcxOVVdT11HQ13FQF3LRPP/fwA "PowerShell – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~49\*5~~ 58 bytes \* 4 = 232 pts
-13 pts thanks to ASCII-only
```
-join("Good m{0}rning, Green {0}rb!"-f'o'|% t*y|%{"$_"*4})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XzcrPzNPQ8k9Pz9FIbfaoLYoLzMvXUfBvSg1NU8BxE9SVNJNU89Xr1FVKNGqrFGtVlKJV9IyqdX8/x8A "PowerShell – Try It Online")
Uses formatting to go from 5 `o`s to 4 to chip out some numbers
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 19 bytes, score 38
```
‛ƛ⁋`øø, ×ŀ ⋎Ė!`"Ṅ2•
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%E2%80%9B%C6%9B%E2%81%8B%60%C3%B8%C3%B8%2C%20%C3%97%C5%80%20%E2%8B%8E%C4%96!%60%22%E1%B9%842%E2%80%A2&inputs=&header=&footer=)
```
‛ƛ⁋                 # Compressed string
   `øø, ×ŀ ⋎Ė!`     # Compressed string
               "Ṅ   # Pair and join by spaces
                 2• # Double each character
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 31 bytes × 2 = 62 points
```
“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxyjwxuOdURpHJ7xcOfClBPbD@1/tHHdo4aZD3c2AyXd81MUcovyMtN1UpMUHzXMrTD6//9/tKGOERAa65jomAJpMx1zHQsgttQxNAAKGQIFDA1ByBzIA0kbGukYGsc@3NFqaAwA "Jelly – Try It Online")
**Explanation**
```
“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2
“2ðƈZ(Øṡdȷ¿Ɱ’                     Base 250 number
              “God mrnig,eb!”     Unique characters of "Good morning..."
             ṃ                    Convert the base 250 number in base 13 then index into the string "God mr..."
                             x2   Repeat each character twice because “ occurs twice in the source (and now 2)
```
[Answer]
# JavaScript (ES6), 61 bytes \* 3 = 183
```
_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")
```
```
f=
_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")
console.log(f())
```
# JavaScript (ES6), 51 bytes \* 4 = 204
```
_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')
```
Answer [suggested by @ETHproductions](https://codegolf.stackexchange.com/questions/152016/a-programming-puzzle-of-mode-golf/152025#comment371516_152025).
```
f=
_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')
console.log(f())
```
# JavaScript (ES6), 73 bytes \* 4 = 292
```
_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))
```
```
f=
_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))
console.log(f())
```
# JavaScript (ES6), 58 bytes \* 6 = 348
```
_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))
```
```
f=
_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))
console.log(f())
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 36×4=144
```
Good morning, Green orb!
.
$&$&$&$&
```
[Try it online!](https://tio.run/##K0otycxL/P@fyz0/P0UhN78oLzMvXUfBvSg1NU8hvyhJkUuPS0UNAv//BwA "Retina – Try It Online") There are three newlines and four `o`s, so there's nothing more to be done.
[Answer]
# Ruby, 55x4 = 220 points
```
"Good morning, Green orb!".split(//).each{|x|print x*4}
```
Im quite annoyed that using each\_char makes the count of r's 5..
]