[Question]
  [
A [bronze plaque](https://upload.wikimedia.org/wikipedia/commons/3/3a/Emma_Lazarus_plaque.jpg) in the pedestal of the [Statue of Liberty](https://en.wikipedia.org/wiki/Statue_of_Liberty) displays the poem "[The New Colossus](https://en.wikipedia.org/wiki/The_New_Colossus)" by Emma Lazarus, part of which reads:
> 
> Give me your tired, your poor,  
> 
>  Your huddled masses yearning to breathe free,  
> 
>  The wretched refuse of your teeming shore.  
> 
>  Send these, the homeless, tempest-tost to me,  
> 
>  I lift my lamp beside the golden door!
> 
> 
> 
To simplify this section of the poem for this challenge, we'll make it all uppercase and replace the newlines with slashes (`/`), keeping commas and other punctuation as is:
```
GIVE ME YOUR TIRED, YOUR POOR,/YOUR HUDDLED MASSES YEARNING TO BREATHE FREE,/THE WRETCHED REFUSE OF YOUR TEEMING SHORE./SEND THESE, THE HOMELESS, TEMPEST-TOST TO ME,/I LIFT MY LAMP BESIDE THE GOLDEN DOOR!
```
We'll call this string S. It has [md5 hash](http://www.miraclesalad.com/webtools/md5.php) `8c66bbb9684f591c34751661ce9b5cea`. You may optionally assume it has a trailing newline, in which case the md5 hash is `0928ff6581bc207d0938b193321f16e6`.
Write a program or function that takes in a single string. When the string is S, output *in order*, one per line, the six phrases that describe the type of people the poem depicts Lady Liberty asking for:
```
TIRED
POOR
HUDDLED MASSES YEARNING TO BREATHE FREE
WRETCHED REFUSE OF YOUR TEEMING SHORE
HOMELESS
TEMPEST-TOST
```
(This precise string, optionally followed by a single trailing newline, must be your output for input S.)
For *at least one* input string that is *not* S, your output should be any string other than the six lines above. This could be as simple as outputting only `TIRED` if the input is only `GIVE ME YOUR TIRED`. This rule is to prevent pure hardcoding. Otherwise, when the input string is not S, your code may do anything.
This is essentially a constant-output challenge where you are given an input that is relatively close to the output. You could of course mostly ignore the input and hardcode the output, but it may be better to, say, strip out the substrings of the input needed for the output.
For reference, here are the zero-based indices and lengths of the six output lines in S:
```
13 5, 25 4, 36 39, 81 37, 136 8, 146 12
```
**The shortest code in bytes wins.**
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ẇ“©ØḌKAƑ⁶2ɼU’b8ȷ¤ịY
```
**[Try it online!](https://tio.run/nexus/jelly#LY6xTsNAEER/ZekNlqjSXrix78Sd19o9g9zyJUlDQxq6RKJMkx8ABFRBQvAZ9o@Yc6CaN9LM7E7D2/24ejoePrfD6@bafD2O6@fLn49uXO3uFt8vx/3w/tBP01T7G1AE9dwJJS@wxR@3zFKUJ3SdtQGWolGFUg8jjW9qSkxLgUkOVAlQlDPdCtKVy2lB1SmIq/9tIM4ldSy4KBWNpZxXFLOQ44gA1ewQW2g6T6xpPhHzsKfgq0Sxp2BiS0uotzj1ag4WDdn87dkv "Jelly – TIO Nexus")** or try it with [some other text](https://tio.run/nexus/jelly#AUgAt///4bqG4oCcwqnDmOG4jEtBxpHigbYyybxV4oCZYjjIt8Kk4buLWf///1BST0dSQU1NSU5HIFBVWlpMRVMgJiBDT0RFIEdPTEY).
### How?
Indexes into the list of all non-empty contiguous slices of the input string and joins with line feeds.
```
Ẇ“©ØḌKAƑ⁶2ɼU’b8ȷ¤ịY - Main link: s
                ¤   - nilad followed by link(s) as a nilad
 “©ØḌKAƑ⁶2ɼU’       - base 250 number, 27003436588466956354336
              8ȷ    - 8 * 1e3 = 8000
             b      - convert to base, [824,635,7086,6796,1544,2336]
                 ị  - index into
Ẇ                   - all non-empty contiguous slices of s
                  Y - join with line feeds
```
---
Previous code, 22 bytes:
```
“ÇŒȷœ%LRw⁹ƊƓɠ‘ṬœṗµḊm2Y
```
Partitions the input string, takes every second element and joins with line feeds. `“ÇŒȷœ%LRw⁹ƊƓɠ‘` is a list of code page indexes, `Ṭ` makes a list of zeros with ones at those indexes, `œṗ` partitions the input at the truthy indexes of that list, `Ḋ` removes the first element, `m2` takes every second element, and `Y` joins with line feeds.
[Answer]
## JavaScript (ES6), ~~128~~ 69 bytes
May output empty lines or some garbage when the input is different from `S`.
```
let f =
s=>[837,1604,2343,5221,8712,9356].map(n=>s.substr(n>>6,n&63)).join`
`
console.log(f(`GIVE ME YOUR TIRED, YOUR POOR,
YOUR HUDDLED MASSES YEARNING TO BREATHE FREE,
THE WRETCHED REFUSE OF YOUR TEEMING SHORE.
SEND THESE, THE HOMELESS, TEMPEST-TOST TO ME,
I LIFT MY LAMP BESIDE THE GOLDEN DOOR!`))
console.log(f(`THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG`))
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~76~~ ~~65~~ 60 bytes
```
echo "TIRED
POOR
${1:36:39}
${1:81:37}
HOMELESS
${1:146:12}"
```
[Try it online!](https://tio.run/nexus/bash#NY7BTsQwDETv/Qqz4lioyqJl6a1Lpk2kpK7sFNTzaiVufADqt5ckwMlja@Z59tv184sO0QlMNTNLdf/ddsdTd3zdijyn7WWrLAd4qJZb@3zq2qftsO/76N5BAbTyIlQo9a/OrLop0i7GeBgKvSqUVvQyuWmkyHQR9NGCBgHqJqsPQXyzyS0YFgXx8McGQg6pZcFjo5gMJb@izoP@@6UNYYbGh8ga84uQwI68GyKFlXwfZrpAnUHJjewNJjKp7d0P "Bash – TIO Nexus")
[Answer]
## *Mathematica*, 71
```
Column@StringTake[#,List@@@{14|18,26|29,37|75,82|118,137|144,147|158}]&
```
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), 72 bytes
```
"$args"-split'[/,.]'-replace'^.*?(YOUR|\bTHE) |^ | TO ME'-match'^[^S G]'
```
[Try it online!](https://tio.run/nexus/powershell#LY7BasMwEETv/YqtKagNsv0JxanGtkCyjFZuMUkMbghtIYWQ5Oh/d@Wkp33LzszOnDyN569Lkl5Ox5@r2OQy24n0fDgdx/1BDNnq9bl3nZ@2n6HGC00DTRQcWYj0d7zuv8WwGZiqnZgf5jmp9DvijRYLBe2h5J1b57zMb1h3ShkosgUzmHoUvtFNtaSuPYr4hkoPyHyhD4/wVke1R9kxyJX/2YBdTFw7jyxnNIqiniGXQbWzMGCOG2wLDmlwHO7FZa7J6DKQ7ckUtqU1WCvcfJUzCg2p2PYx@QM "PowerShell – TIO Nexus")
### Explanation
This is a pretty crappy regex solution. 
Splitting the string into an array on `/` or `.` or `,` and then replacing parts of each string that match the first pattern, which gives an array of `-replace`d strings, then use the `-match` operator to return an array of the elements that match the second pattern (which gets rid of the blank lines and 2 lines that didn't get filtered before).
[Answer]
# Mathematica, 86 bytes
```
Riffle[s=#;s~Take~#&/@{{14,18},{26,29},{37,75},{82,118},{137,144},{147,158}},"
"]<>""&
```
Unnamed function taking a list of characters as input and returning a string. Just extracts the relevant substrings of the input and concatenates with newlines.
[Answer]
# TI-Basic, 58 bytes
Very straightforward. `Disp` is like `println`, so there are newlines in between.
```
Disp "TIRED","POOR",sub(Ans,37,39),sub(Ans,82,37),"HOMELESS",sub(Ans,147,12
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 38 32 bytes
It can probably be improved, but this is a job for regexes!
```
!`(?<=R |HE ).*?(?=[,.])|\w+-\w+
```
[Try it online!](https://tio.run/nexus/retina#LY5LbsMwDESvMtklrWJfoIHhVGNLgGQapNzCaAvkFtnk7q6cdkHwEZgPt8Pt2L1dFI9AnJqX7thdvlzzc3p831/PdbZtjB9EJlZZFCUqvfvjWURd@8SweJ/okXszGlb2OsVpRBFclX2p4YOSrt3pU1neQ1Urh8UIGf6zybybLIiyaY2TR9Ub3b4QJDPRrF7MM62ci1jZK3INjkhxKMgrUp9nXGnR8@kbJXlO8PXbwy8 "Retina – TIO Nexus")
]