Give me your tired, your poor, Your huddled masses yearning to breathe free

Question

A bronze plaque in the pedestal of the Statue of Liberty displays the poem "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 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 1

Jelly, 19 bytes

Ẇ“©ØḌKAƑ⁶2ɼU’b8ȷ¤ịY

Try it online! or try it with some other text.

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 2

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 3

Bash, 76 65 60 bytes

echo "TIRED
POOR
${1:36:39}
${1:81:37}
HOMELESS
${1:146:12}"

Try it online!

Answer 4

Mathematica, 71

Column@StringTake[#,List@@@{14|18,26|29,37|75,82|118,137|144,147|158}]&

Answer 5

PowerShell, 72 bytes

"$args"-split'[/,.]'-replace'^.*?(YOUR|\bTHE) |^ | TO ME'-match'^[^S G]'

Try it online!

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 -replaced 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 6

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 7

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 8

Retina, 38 32 bytes

It can probably be improved, but this is a job for regexes!

!`(?<=R |HE ).*?(?=[,.])|\w+-\w+

Try it online!