text:
Put together a Senate majority
There are one hundred members of the United States Senate. Assuming that nobody filibusters and that the Vice President isn't cooperating, at least fifty-one members are necessary to pass a bill. But some members work together better than others, entropy-wise.
Your task: Output the last names of at least 51 of the US senators at the time this question was posted in 2017. Any 51 are acceptable; put together a Cruz-Sanders coalition if you'd like. The names may be output in any order.
The full list is as follows (note that Van Hollen is one person):

Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker,
Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey,
Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto,
Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst,
Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham,
Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono,
Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar,
Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell,
Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul,
Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders,
Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange,
Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner,
Warren, Whitehouse, Wicker, Wyden, Young

Querying Wolfram Alpha (or any other database of senators) is specifically disallowed. Anything else is fair game; use gzip as a language if you'd like.

could we just output Palpatine because he is the Senate? ;)

QqOZ are letters that are unused in the senate.

Does there have to be a delimiter between each name, or can they just be concatenated together?

No delimiter is necessary.

do the names have to start with a capital letter?

Yes, they do (and Van Hollen needs his personal space).

Cortez Masto also has a "personal space"

Here's the list, sorted by length of name. Might help some folks. https://pastebin.com/1TQweeS9

"No delimiter is necessary" means we do not need to use a delimiter, as such many answers could be reduced in size... did you mean, "No[, use of a] delimiter is necessary."?

@Draco18s And the 51 shortest are Lee, Burr, Cruz, Enzi, King, Paul, Reed, Blunt, Brown, Casey, Coons, Crapo, Ernst, Flake, Hatch, Kaine, Leahy, Moran, Risch, Rubio, Sasse, Scott, Thune, Udall, Wyden, Young, Bennet, Booker, Capito, Cardin, Carper, Corker, Cornyn, Cotton, Daines, Durbin, Graham, Harris, Hassan, Heller, Hirono, Hoeven, Inhofe, Markey, McCain, Murphy, Murray, Nelson, Perdue, Peters, and Rounds.

No delimiter is necessary. It is not the case that a delimiter is necessary. The number of delimiters which are necessary is zero.

FYI: The min length of hard-coded names as a simple string with no delimiter is 272.

Bubblegum, 165 164 163 162 161 160 bytes
00000000: 1dc6 410a 0231 0c00 c0bf b50a c22a 880a  ..A..1.......*..
00000010: e231 b4c1 0697 6449 5aa5 bede c4cb 303b  .1....dIZ.....0;
00000020: 2046 5bc2 5b1b 0ead 2b59 5a07 f72c 5eb6   F[.[...+YZ..,^.
00000030: bdb2 f9c5 c75f 4ac8 8c7d 09eb cc60 1818  ....._J..}...`..
00000040: c5b5 12bb 1bea a964 886f d425 2b6c cef8  .......d.o.%+l..
00000050: 5e4b 83ee 4aef 49e5 c3d9 23ae f20c 5fa8  ^K..J.I...#..._.
00000060: f759 9193 4894 4a08 ca7f 15f9 e092 1d04  .Y..H.J.........
00000070: df71 3370 7b69 572f 5ec8 625c 51ed 8c3d  .q3p{iW/^.b\Q..=
00000080: 84b1 ded0 bc59 4a53 e093 0443 1566 727d  .....YJS...C.fr}
00000090: 5b9b 4784 0017 e2e7 05b1 3e64 789c 6a3f  [.G.......>dx.j?

Try it online!
Output

DainesKaineThuneTillisBluntCollinsErnstCoonsEnziBennetKennedyCaseyCassidyCardinCarperMcCainCapitoCrapoCruzSchatzScottBrownCottonCornynCorkerWydenBookerWickerWarnerWarrenHarrisHoevenHassanHatchSasseRischSandersPetersPaulTesterCochranMoranMurrayBurrMurphyLeahyLeeKingReedYoungRounds

How I generated this
Previous versions were generated by simulated annealing, but now I’ve switched strategies to late acceptance hill-climbing.  I’m not sure whether it’s fundamentally better or I just got luckier this time, but I do appreciate that LAHC has fewer parameters to tweak to get good results.
from __future__ import print_function
import random
import zlib

try: range = xrange
except NameError: pass

senators = b'Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker, Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey, Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto, Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst, Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham, Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono, Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar, Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell, Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul, Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders, Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange, Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner, Warren, Whitehouse, Wicker, Wyden, Young'.split(b', ')
assert len(senators) == 100

random.shuffle(senators)
score = 9999
best = score
recent = 65536 * [score]
recent_index = 0

while True:
    old_score = score
    step = random.randrange(2)
    if step == 0:
        i, j = 100, 100
        while i >= 51 and j >= 51:
            i, j = random.sample(range(100), 2)
        senators[i], senators[j] = senators[j], senators[i]
    else:
        i, j, k = 100, 100, 100
        while i >= 51:
            i, j, k = sorted(random.sample(range(101), 3))
        senators[i:k] = senators[j:k] + senators[i:j]

    bound = max(old_score, recent[recent_index])

    z = zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS, 9)
    sin = b''.join(senators[:51])
    sout = bytearray(z.compress(sin) + z.flush())
    score = len(sout) * 8
    if score - 7 <= bound:
        for bit in range(7):
            sout[-1] ^= 128 >> bit
            try:
                if zlib.decompress(bytes(sout), -zlib.MAX_WBITS) == sin:
                    score -= 1
                else:
                    break
            except zlib.error:
                break

    if score > bound:
        if step == 0:
            senators[i], senators[j] = senators[j], senators[i]
        else:
            j = i + k - j
            senators[i:k] = senators[j:k] + senators[i:j]
        score = old_score
    elif score < recent[recent_index]:
        recent[recent_index] = score
        if score < best:
            best = score
            print(score, b''.join(senators[:51]).decode())
    recent_index = (recent_index + 1) % len(recent)

How do you get shorter than the existing Bubblegum answer using longer names?

@Challenger5 Using longer names with more shared substrings for better compression! This is definitely a challenge that is not trivialized merely by using Bubblegum.

+1 for the nice simulated annealing code; I will steal it for general purposes!! :)

This is fairly impressive. To put it in perspective, consider that if you just use Huffman compression on a semi-optimally chosen set of 51 of the names, the compressed string (by itself--without code to decompress it) comes out to around this size (depending somewhat on the exact form of Huffman compression you use, of course).

Never thought I would upvote a Bubblegum answer. Nice work.

Jelly, 128 bytes
“¡e:©*ḲṣṛḷYx½NḢṀPtU9'*KṪmbpƊæ n¥×Ƭḥ0mṀC%kçaḶw'øȤ€ðzṬ¢Ỵi⁷ṅọTṛỵṙḳAf"Zƙ~^RỊṙ.Jþ°ọṄ2l+ṇ=×ıƓ:ẊƒmJJḂs}ẹ~ɗƲ³£ɓȤɗƘṪruzṂµẈ+Ç9ḋ4^(ḤạFƑỤʠ>»

A niladic link returning a list of characters - the names (with spaces between since it's shorter):
Alexander Baldwin Bennet Blunt Booker Brown Burr Cardin Carper Casey Cochran Corker Cotton Crapo Cruz Durbin Ernst Fischer Flake Gardner Graham Harris Hatch Heinrich Heller Johnson Kennedy King Lee McCain McCaskill McConnell Moran Murphy Murray Nelson Paul Perdue Portman Reed Sanders Sasse Scott Shelby Strange Sullivan Tester Udall Warner Warren Whitehouse

Try it online!
How?
Boring - 53 of the names are dictionary entries (the unused ones here being Wicker and Young), so all of the code is a single compressed string using those dictionary entries. Maybe something clever could make for less bytes, but probably not (brownlee is in the dictionary, but manipulating the result to capitalise the L & add the space to keep format will cost more that the saving of 2 bytes).

Jelly has a built-in in dictionary?

Yes, and compressed strings may be built from mixtures of their indexes and other printable ASCII characters (or newlines) - there is a useful script for doing so painlessly created by Lynn in the Jelly tips page too.

SOGL V0.12, 118 117 bytes
│▲S⁹@^V'/¾Π;○ccΠæ▒¡$λ‼⌠Æķ□~─┼∑>°⅔′κļ    ≥Y#⁄◄‰Νļ┘Υp\¹øDK%◄ρhpš,ιPΖοh≠wΜø⅞ƨω6Η√⁶┌B∞žΤΟ⅜Γ\=M»⁶»□⁽ø⁴┌¦nč+ÆB(k° Π→→∙Æ═'x¹ξ‘ū

Note that that code has tabs, so Try it Here!
I was extremely lucky that in the SOGL english dictionary exactly 51 names existed :o
The program is almost all (.....‘) a compressed string, and as SOGLs dictionary only has lowercase words, ū uppercases each words first letter.
-1 byte by rearranging the names

Drat, I was hoping that the names would be unusual enough to evade dictionaries.

05AB1E has 9 hehe...

@MagicOctopusUrn how many words are in its dictionary? (SOGL has 65536 and 256 on different byte tiers)

Are the spaces implicit? Could you produce a result without spaces for the same count? If so note that brownlee may well be in your dictionary...

@JonathanAllan Yes, the spaces are implicit (it would be ~150 bytes without spaces), and, no, brownlee isn't in the dictionary, and if it would, I'd still have to capitalize the L

...almost the same set of problems with me using it, except it's in Jelly's dictionary.

What does ρhp translate to?

@Challenger5 it's a part of the compressed text which starts out as a base-256 number. that's like asking what does 123 mean in the number 2725068212313724212 when the first thing that happens to the number is divide by 8

Oh, OK. That's too bad.

;#, 28571 bytes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Try it online!
Everyone's favourite antigolfing language! As ;# is a subset of ;#+, the TIO can be used.

I thought Lenguage held that title.

Bash, 277 bytes
echo LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds

Just a simple solution to get things started :)
Try it online!

Do you really need those commas?

gonna wait a bit before accepting that answer :P

Isn't this missing Cortez Masto and Von Hollen?

@Cowsquack I suppose not

@MagicOctopusUrn The question states to output at least 51 senators, not all of them

By the way, this only outputs 50, not 51 - Rounds is missing here.

@notjagan Thank you, fixed

Bubblegum, 194 193 bytes
0000000: 1d4e cb4e c330 10fc b7b8 05a3 36a8 4a41  .N.N.0......6.JA
0000010: 88e3 361e 6aab 6636 5adb 20f7 eb71 b9cc  ..6.j.f6Z. ..q..
0000020: 61de 4760 6a66 ceda 7dcf 7b3a 245e 4fd2  a.G`jf..}.{:$^O.
0000030: f202 8429 37d6 c9f4 974e 0aba 5365 7126  ...)7....N..Seq&
0000040: 9bee 8da5 3e65 b9c1 4b5d e341 1271 84c4  ....>e..K].A.q..
0000050: 3eab 0997 54d6 b8b4 4bd2 b394 82f3 aab5  >...T...K.......
0000060: bec5 46bc 07c9 f9a3 07f0 531b af13 48d4  ..F.......S...H.
0000070: 49f5 0673 b2a5 aa4e 2ca4 3166 db60 d46e  I..s...N,.1f.`.n
0000080: ffc8 4e37 1a94 bbc7 4cd9 35bb 243e 9b44  ..N7....L.5.$>.D
0000090: f9f6 6296 8a47 ceb0 5986 bffb 644a 5d46  ..b..G..Y...dJ]F
00000a0: 7d28 73b3 6d5c 5add c8bd 30ea 174e b0d0  }(s.m\Z...0..N..
00000b0: 0656 d843 35e9 7e3c 147a c50f f88a 5c94  .V.C5.~<.z....\.
00000c0: 7f                                       .

Try it online!
This answer currently works, but I will likely post a shorter version later seeing as I currently have a Python script running to generate these.
Python Script (using 3rd party library hexdump)
from itertools import permutations
from hexdump import hexdump
import zlib

senators = ['Lee', 'Burr', 'Cruz', 'Enzi', 'King', 'Paul', 'Reed', 'Blunt', 'Brown', 'Casey', 'Coons', 'Crapo', 'Ernst', 'Flake', 'Hatch', 'Kaine', 'Leahy', 'Moran', 'Risch', 'Rubio', 'Sasse', 'Scott', 'Thune', 'Udall', 'Wyden', 'Young', 'Bennet', 'Booker', 'Capito', 'Cardin', 'Carper', 'Corker', 'Cornyn', 'Cotton', 'Daines', 'Durbin', 'Graham', 'Harris', 'Hassan', 'Heller', 'Hirono', 'Hoeven', 'Inhofe', 'Markey', 'McCain', 'Murphy', 'Murray', 'Nelson', 'Perdue', 'Peters', 'Rounds']
min_length = 1000
for perm in permutations(senators):
    z = zlib.compressobj(level=9, wbits=-15)
    z.compress("".join(perm).encode())
    compressed = z.flush()
    length = len(compressed)
    if length < min_length:
         min_length = length
         best = compressed
         hexdump(best)
         print("Length:", length)
         file = open("bub_out.txt", "bw")
         file.write(best)
         file.close()

print(best)

Your output seems to be broken currently. I think you need to remove header and footer to get a raw DEFLATE stream.

@ovs Thanks for the heads-up, fixed (also brought down the byte count).

Python 2, 329 279 bytes
-50 bytes Thanks @caird coinheringaahing: [avoid the delimiter-spaces]
print'LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds'

Try it online!
String Generated by this program(get list from the data string, sort the strings by length, take first 51 elements, join)
a='Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker, Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey, Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto, Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst, Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham, Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono, Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar, Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell, Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul, Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders, Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange, Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner, Warren, Whitehouse, Wicker, Wyden, Young'.split(', ')
a.sort(key=lambda x:len(x))
print(''.join(a[:51]))

Try it online!

Ironically, I finished sorting the entire list (by length) only a few minutes after you posted this answer. :D There are probably still some improvements that could be made (Warren and Warner differ by a single letter, while Booker and Boozman share a common initial 3) but still a valid approach.

The list is so entropical, It would be very hard to compress. A program tha could statistically analyze the maximum occuring sub-string could do the trick. :D

Oh it definitely has a lot of entropy. I'm just speculating (the Warren/Warner observation may be the only case where decent compression is possible).

You can remove all the spaces between the names to save ~50 bytes as OP has said that no delimiter is needed.

PHP, 270 bytes
<?=strtr(K3gLeeBurrC5d3C5p0Co7sCruzEnziHat6He40Ka3eM163Mor1PaulReedRis6Uda4W5n0W5r2Wyd2B2netBluntBook0BrownCaseyCo6r1Co43sCork0Cott7CrapoDa3esDurb3ErnstFis60FlakeFr1k2G5dn0H5risHass1Hir7oHoev2LeahyM5keyMcCa3Nels7P0duePet0sRubioS1d0sSasseS6atz,[er,an,en,in,ll,ar,ch,on]);

Try it online!
PHP, 270 bytes
<?=strtr(H02K4gLeeS0eBurrC6d4C6p1Co8sCruzEnziHat7He51Ka4eM274Mor2PaulReedRis7Uda5W6n1W6r3Wyd3B6r0oB3netBluntBook1BrownCaseyC0idyCo7r2Co54sCork1Cott8CrapoDa4esDurb4ErnstFis71FlakeFr2k3G6dn1H6risHir8oHoev3LeahyM6keyMcCa4Nels8P1duePet1sRubio,[ass,er,an,en,in,ll,ar,ch,on]);

Try it online!

Add++, 2131 bytes
+76
&
+25
&
&
-57
&
-12
&
+34
&
+51
&
-3
&
&
-70
&
-12
&
+35
&
+47
&
+3
&
+5
&
-78
&
-12
&
+37
&
+41
&
+12
&
-17
&
-61
&
-12
&
+43
&
+30
&
+5
&
-7
&
-59
&
-12
&
+48
&
+17
&
+20
&
-9
&
-64
&
-12
&
+50
&
+19
&
&
-1
&
-56
&
-12
&
+34
&
+42
&
+9
&
-7
&
+6
&
-72
&
-12
&
+34
&
+48
&
-3
&
+8
&
-9
&
-66
&
-12
&
+35
&
+30
&
+18
&
-14
&
+20
&
-77
&
-12
&
+35
&
+44
&
&
-1
&
+5
&
-71
&
-12
&
+35
&
+47
&
-17
&
+15
&
-1
&
-67
&
-12
&
+37
&
+45
&
-4
&
+5
&
+1
&
-72
&
-12
&
+38
&
+38
&
-11
&
+10
&
-6
&
-57
&
-12
&
+40
&
+25
&
+19
&
-17
&
+5
&
-60
&
-12
&
+43
&
+22
&
+8
&
+5
&
-9
&
-57
&
-12
&
+44
&
+25
&
-4
&
+7
&
+17
&
-77
&
-12
&
+45
&
+34
&
+3
&
-17
&
+13
&
-66
&
-12
&
+50
&
+23
&
+10
&
-16
&
+5
&
-60
&
-12
&
+50
&
+35
&
-19
&
+7
&
+6
&
-67
&
-12
&
+51
&
+14
&
+18
&
&
-14
&
-57
&
-12
&
+51
&
+16
&
+12
&
+5
&
&
-72
&
-12
&
+52
&
+20
&
+13
&
-7
&
-9
&
-57
&
-12
&
+53
&
+15
&
-3
&
+11
&
&
-64
&
-12
&
+55
&
+34
&
-21
&
+1
&
+9
&
-66
&
-12
&
+57
&
+22
&
+6
&
-7
&
-7
&
-59
&
-12
&
+34
&
+35
&
+9
&
&
-9
&
+15
&
-72
&
-12
&
+34
&
+45
&
&
-4
&
-6
&
+13
&
-70
&
-12
&
+35
&
+30
&
+15
&
-7
&
+11
&
-5
&
-67
&
-12
&
+35
&
+30
&
+17
&
-14
&
+5
&
+5
&
-66
&
-12
&
+35
&
+30
&
+17
&
-2
&
-11
&
+13
&
-70
&
-12
&
+35
&
+44
&
+3
&
-7
&
-6
&
+13
&
-70
&
-12
&
+35
&
+44
&
+3
&
-4
&
+11
&
-11
&
-66
&
-12
&
+35
&
+44
&
+5
&
&
-5
&
-1
&
-66
&
-12
&
+36
&
+29
&
+8
&
+5
&
-9
&
+14
&
-71
&
-12
&
+36
&
+49
&
-3
&
-16
&
+7
&
+5
&
-66
&
-12
&
+39
&
+43
&
-17
&
+7
&
-7
&
+12
&
-65
&
-12
&
+40
&
+25
&
+17
&
&
-9
&
+10
&
-71
&
-12
&
+40
&
+25
&
+18
&
&
-18
&
+13
&
-66
&
-12
&
+40
&
+29
&
+7
&
&
-7
&
+13
&
-70
&
-12
&
+40
&
+33
&
+9
&
-3
&
-1
&
+1
&
-67
&
-12
&
+40
&
+39
&
-10
&
+17
&
-17
&
+9
&
-66
&
-12
&
+41
&
+37
&
-6
&
+7
&
-9
&
-1
&
-57
&
-12
&
+45
&
+20
&
+17
&
-7
&
-6
&
+20
&
-77
&
-12
&
+45
&
+22
&
-32
&
+30
&
+8
&
+5
&
-66
&
-12
&
+45
&
+40
&
-3
&
-2
&
-8
&
+17
&
-77
&
-12
&
+45
&
+40
&
-3
&
&
-17
&
+24
&
-77
&
-12
&
+46
&
+23
&
+7
&
+7
&
-4
&
-1
&
-66
&
-12
&
+48
&
+21
&
+13
&
-14
&
+17
&
-16
&
-57
&
-12
&
+48
&
+21
&
+15
&
-15
&
+13
&
+1
&
-71
&
-12
&
+50
&
+29
&
+6
&
-7
&
-10
&
+15
&
-71
&
-12
&
+51
&
+16
&
+5
&
-7
&
+19
&
+6
&
P

Try it online!
I love hardcoding these! They are so fun!
Each line is either [+-]\d+, & or P.

& adds the char in the accumulator to the output string, without outputting.
P prints the output string
Numbers add or subtract that value from the accumulator

05AB1E, 455 bytes (all 100, I misread)
Im more excited about this challenge now and will indeed fix this in time.
.•вÏ–lāä˜(~Îíˆ^ÅËð3µpñ»ú¶›;β›vGĀ½W PToÚ+ćLöт'Ç@qu¿>ßH3^eoèL«Oт©zβü)Åëîƶ¿n77¯Þ»øδëΩŽÐ∊ÿ–R9ÑÄÿÂMD∊Ê'Ƶ~°Aº≠₄›Š∞"Óн=Üg2Ua‘èǝʒ·ªd±{-wγrWÉ₃§¯Ωnι“âÝvγ+ŸõÊ×|Ù¨LòΛÍ_Ð®\‡,–Ç+Q^ú€ÉƵÙD“≠ŒC½ŒÉÃ₅Ç^þ:†ÆÜãôвΩæĀîAìëƵôÄê“¬{/¯ÐaĆXõ₅ñγÃµ¶P\¹oÓΣθºõ®5ù@ïwÛ-þoÅÇóÌ»"ηÆ!PÑ₅§₆úñ©C½[RV7Y#:ìÎmÓžĆº´aΩ. ªƶтñΔo
H!®àrα¤´¢gËZLβθŽ#§ƶl¸±0ª©öδgYÃÀQ1œuYÎ₂Ä¾éï¶çÉsžÏT®é®§šŒE[7èœ~Õм-4UÃн₄Î^Rs›k€’(∞S₃˜\‘½ÊÀsΣǝP¶²Ï4oÍ‘Δýε¿(†Û)ŽαΔ…p§¼móe,k£í¥‡8(ÖöÍDÒ₆OÅÇ0vÆÖΩ¼ì>^ŸćrʒðĆтÄε%D™¶ÞZ®=4¦?µ×•'q¡„, ý™

Try it online!

Here's a boring answer, but base compression and complex methods in 05AB1E won't cut it for how random this is... I tried a more scientific approach:
[['j', 1], ['x', 1], [' ', 2], ['v', 3], ['f', 6], ['z', 6], ['g', 7], ['p', 9], ['w', 11], ['y', 15], ['b', 16], ['k', 18], ['d', 19], ['m', 19], ['u', 20], ['t', 28], ['h', 31], ['c', 33], ['i', 33], ['l', 37], ['s', 43], ['o', 44], ['a', 53], ['r', 59], ['n', 65], ['e', 69], [',', 99]]

Calculated the frequencies of the letters; but I can't really get lower because I'm only able to easily use 8-bit replacements of the... well 8-bit equivalents. If there was an easier way to do binary compression in 05AB1E, maybe?
'MJP1MOCPNQAMJC8IOQAMNNMKKLQAPOOPFQAJEDPOFGMJQAJEOFQALLBPNQALL5DMOQANL8OQAENNQHMOF8PJJQHM7IFLQHMNCIOQHMN7PNQHMKP9QHMKKIC9QHLHGNMOQHLJJIOKQHLLOKQHLNBPNQHLNO9OQHLNFP52DMKFLQHLFFLOQHNM7LQHNE5QCMIOPKQCLOOPJJ9QCEHB8LNFGQCENAIOQPO5IQPNOKFQ4PIOKFPIOQ4IKHGPNQ4JMBPQ4NMOBPOQ6MNCOPNQ6IJJIANMOCQ6NMGMDQ6NMKKJP9QGMNNIKQGMKKMOQGMFHGQGPIONIHGQGPIFBMD7QGPJJPNQGINLOLQGLP3POQIOGL4PQIKMBKLOQ0LGOKLOQBMIOPQBPOOPC9QBIO6QBJLAEHGMNQJMOB4LNCQJPMG9QJPPQDMOHGIOQDMNBP9QDHHMIOQDHHMKBIJJQDHHLOOPJJQDPOPOCP5QDPNBJP9QDLNMOQDENBL8KBIQDEN7G9QDENNM9QOPJKLOQ7MEJQ7PNCEPQ7PFPNKQ7LNFDMOQNPPCQNIKHGQNLAPNFKQNLEOCKQNEAILQKMOCPNKQKMKKPQKHGMF5QKHGEDPNQKHLFFQKGMGPPOQKGPJA9QKFMAPOL8QKFNMO6PQKEJJI3MOQFPKFPNQFGEOPQFIJJIKQFLLDP9QECMJJQ3MO2GLJJPOQ8MNOPNQ8MNNPOQ8GIFPGLEKPQ8IHBPNQ89CPOQ9LEO6'

Ended up with that, which was worse.

You don't need all 100, just so you know, only more than 50

you can definitely save bytes by removing the delimiter ", "

196 bytes (basically the 51 shortest names sorted alphabetically with space delimiter).

Bubblegum, 195 193 bytes
00000000: 05c1 514e eb30 1404 d0bd c5ed 7b41 6d50  ..QN.0......{AmP
00000010: 9482 109f b7c9 505b 3173 a3b1 0d72 57cf  ......P[1s...rW.
00000020: 3957 6001 b633 9f69 b696 2f89 8fa0 f61c  9W`..3.i../.....
00000030: 9af4 2fdb 8ea5 dd93 5f2c 11c1 0afa 6df5  ../....._,....m.
00000040: 5a27 97f1 0a8b fd2c 96fa d137 f02d 3662  Z'.....,...7.-6b
00000050: 90ff f2d3 1b1f a3d5 3506 7796 f7cd 721e  ........5.w...r.
00000060: 7263 0db2 c397 54d6 78b3 5210 ec48 d567  rc....T.x.R..H.g
00000070: 686b 3835 dd13 27d3 8e3e 5a29 c631 c9e9  hk85..'..>Z).1..
00000080: afc8 c539 adc1 1283 e980 46e4 0c05 d70e  ...9......F.....
00000090: 8d8e 1f70 3429 9501 24ea d424 ebc1 b425  ...p4)..$..$...%
000000a0: be30 fa17 82d7 ea0c 2e76 9e2c 11e5 bf2c  .0.......v.,...,
000000b0: daf7 e0be 4353 d311 fbe2 8d5b 9951 a1f2  ....CS.....[.Q..
000000c0: 07                                       .

Try it online!

I think this prints 50 senators, don't we need 51?

@musicman523 There are 52 capital letters in the output and McCain is the only senator with two capital letters in his name.

MAWP, 5624 bytes
88WM;269WW;1689MWA;358WW;1277WWA;19M29MW;455WW;1689MWA;67W89WM;159WA;48W;288WM;1277WWA;269WW;455WW;789MW;357WW;19M29MW;159WA;48W;288WM;1277WWA;67W89WM;67W89WM;1277WWA;2949MWA;2949MWA;1278WWA;159WA;48W;288WM;1689MWA;19M29MW;19M29MW;1689MWA;1949MWA;159WA;48W;288WM;269WW;949MW;1269WWM;1689MWA;19M29MW;1949MWA;849MW;1277WWA;269WW;159WA;48W;288WM;269WW;949MW;19M29MW;1949MWA;159WA;48W;288WM;1278WWA;1278WWA;1269WWA;1689MWA;67W89WM;159WA;48W;288WM;1278WWA;1278WWA;2279WAW;1269WWM;1277WWA;19M29MW;159WA;48W;288WM;67W89WM;1278WWA;789MW;19M29MW;159WA;48W;288WM;949MW;67W89WM;67W89WM;159WA;48W;388WM;1277WWA;19M29MW;1949MWA;789MW;1689MWA;269WW;269WW;159WA;48W;388WM;1277WWA;278WW;357WW;1949MWA;1278WWA;159WA;48W;388WM;1277WWA;67W89WM;455WW;357WW;19M29MW;159WA;48W;388WM;1277WWA;67W89WM;278WW;1689MWA;67W89WM;159WA;48W;388WM;1277WWA;2949MWA;1689MWA;1358WWM;159WA;48W;388WM;1277WWA;2949MWA;2949MWA;357WW;455WW;1358WWM;159WA;48W;388WM;1278WWA;929MW;849MW;67W89WM;1277WWA;19M29MW;159WA;48W;388WM;1278WWA;269WW;269WW;357WW;19M29MW;2949MWA;159WA;48W;388WM;1278WWA;1278WWA;19M29MW;2949MWA;159WA;48W;388WM;1278WWA;67W89WM;1269WWA;1689MWA;67W89WM;159WA;48W;388WM;1278WWA;67W89WM;19M29MW;1358WWM;19M29MW;159WA;48W;388WM;1278WWA;67W89WM;1949MWA;1689MWA;2279WAW;48W;499WA;1277WWA;2949MWA;1949MWA;1278WWA;159WA;48W;388WM;1278WWA;1949MWA;1949MWA;1278WWA;19M29MW;159WA;48W;388WM;67W89WM;1277WWA;278WW;1278WWA;159WA;48W;388WM;67W89WM;949MW;2279WAW;159WA;48W;488WM;1277WWA;357WW;19M29MW;1689MWA;2949MWA;159WA;48W;488WM;1278WWA;19M29MW;19M29MW;1689MWA;269WW;269WW;1358WWM;159WA;48W;488WM;949MW;929MW;1269WWA;789MW;1278WWA;67W89WM;1949MWA;849MW;159WA;48W;488WM;949MW;67W89WM;277WW;357WW;19M29MW;159WA;48W;389WA;19M29MW;2279WAW;357WW;159WA;48W;389WA;67W89WM;19M29MW;2949MWA;1949MWA;159WA;48W;257WW;1689MWA;357WW;19M29MW;2949MWA;1949MWA;1689MWA;357WW;19M29MW;159WA;48W;257WW;357WW;2949MWA;929MW;849MW;1689MWA;67W89WM;159WA;48W;257WW;269WW;1277WWA;1269WWA;1689MWA;159WA;48W;257WW;67W89WM;1277WWA;19M29MW;1269WWA;1689MWA;19M29MW;159WA;48W;189WA;1277WWA;67W89WM;455WW;19M29MW;1689MWA;67W89WM;159WA;48W;189WA;357WW;269WW;269WW;357WW;277WW;67W89WM;1277WWA;19M29MW;455WW;159WA;48W;189WA;67W89WM;1277WWA;849MW;1277WWA;1269WWM;159WA;48W;189WA;67W89WM;1277WWA;2949MWA;2949MWA;269WW;1689MWA;1358WWM;159WA;48W;89W;1277WWA;67W89WM;67W89WM;357WW;2949MWA;159WA;48W;89W;1277WWA;2949MWA;2949MWA;1277WWA;19M29MW;159WA;48W;89W;1277WWA;1949MWA;929MW;849MW;159WA;48W;89W;1689MWA;357WW;19M29MW;67W89WM;357WW;929MW;849MW;159WA;48W;89W;1689MWA;357WW;1949MWA;1269WWA;1277WWA;1269WWM;278WW;159WA;48W;89W;1689MWA;269WW;269WW;1689MWA;67W89WM;159WA;48W;89W;357WW;67W89WM;1278WWA;19M29MW;1278WWA;159WA;48W;89W;1278WWA;1689MWA;1949MWM;1689MWA;19M29MW;159WA;48W;189WM;19M29MW;849MW;1278WWA;689MW;1689MWA;159WA;48W;189WM;2949MWA;1277WWA;1269WWA;2949MWA;1278WWA;19M29MW;159WA;48W;289WM;1278WWA;849MW;19M29MW;2949MWA;1278WWA;19M29MW;159WA;48W;355WW;1277WWA;357WW;19M29MW;1689MWA;159WA;48W;355WW;1689MWA;19M29MW;19M29MW;1689MWA;455WW;1358WWM;159WA;48W;355WW;357WW;19M29MW;1849MWA;159WA;48W;355WW;269WW;1278WWA;277WW;949MW;929MW;849MW;1277WWA;67W89WM;159WA;48W;489WM;1277WWA;19M29MW;1269WWA;689MW;1278WWA;67W89WM;455WW;159WA;48W;489WM;1689MWA;1277WWA;849MW;1358WWM;159WA;48W;489WM;1689MWA;1689MWA;159WA;48W;499WA;1277WWA;19M29MW;929MW;849MW;357WW;19M29MW;159WA;48W;499WA;1277WWA;67W89WM;1269WWA;1689MWA;1358WWM;159WA;48W;499WA;929MW;388WM;1277WWA;357WW;19M29MW;159WA;48W;499WA;929MW;388WM;1277WWA;2949MWA;1269WWA;357WW;269WW;269WW;159WA;48W;499WA;929MW;388WM;1278WWA;19M29MW;19M29MW;1689MWA;269WW;269WW;159WA;48W;499WA;1689MWA;19M29MW;1689MWA;19M29MW;455WW;1689MWA;2279WAW;159WA;48W;499WA;1689MWA;67W89WM;1269WWA;269WW;1689MWA;1358WWM;159WA;48W;499WA;1278WWA;67W89WM;1277WWA;19M29MW;159WA;48W;499WA;949MW;67W89WM;1269WWA;1278WWA;789MW;2949MWA;1269WWA;357WW;159WA;48W;499WA;949MW;67W89WM;278WW;849MW;1358WWM;159WA;48W;499WA;949MW;67W89WM;67W89WM;1277WWA;1358WWM;159WA;48W;399WA;1689MWA;269WW;2949MWA;1278WWA;19M29MW;159WA;48W;199WA;1277WWA;949MW;269WW;159WA;48W;199WA;1689MWA;67W89WM;455WW;949MW;1689MWA;159WA;48W;199WA;1689MWA;1949MWA;1689MWA;67W89WM;2949MWA;159WA;48W;199WA;1278WWA;67W89WM;1949MWA;1269WWM;1277WWA;19M29MW;159WA;48W;199WM;1689MWA;1689MWA;455WW;159WA;48W;199WM;357WW;2949MWA;929MW;849MW;159WA;48W;199WM;1278WWA;277WW;1689MWA;67W89WM;1949MWA;2949MWA;159WA;48W;199WM;1278WWA;949MW;19M29MW;455WW;2949MWA;159WA;48W;199WM;949MW;277WW;357WW;1278WWA;159WA;48W;299WM;1277WWA;19M29MW;455WW;1689MWA;67W89WM;2949MWA;159WA;48W;299WM;1277WWA;2949MWA;2949MWA;1689MWA;159WA;48W;299WM;929MW;849MW;1277WWA;1949MWA;2279WAW;159WA;48W;299WM;929MW;849MW;949MW;1269WWM;1689MWA;67W89WM;159WA;48W;299WM;929MW;1278WWA;1949MWA;1949MWA;159WA;48W;299WM;849MW;1277WWA;849MW;1689MWA;1689MWA;19M29MW;159WA;48W;299WM;849MW;1689MWA;269WW;277WW;1358WWM;159WA;48W;299WM;1949MWA;1277WWA;277WW;1689MWA;19M29MW;1278WWA;789MW;159WA;48W;299WM;1949MWA;67W89WM;1277WWA;19M29MW;1849MWA;1689MWA;159WA;48W;299WM;949MW;269WW;269WW;357WW;1949MWM;1277WWA;19M29MW;159WA;48W;267WW;1689MWA;2949MWA;1949MWA;1689MWA;67W89WM;159WA;48W;267WW;849MW;949MW;19M29MW;1689MWA;159WA;48W;267WW;357WW;269WW;269WW;357WW;2949MWA;159WA;48W;267WW;1278WWA;1278WWA;1269WWM;1689MWA;1358WWM;159WA;48W;499WM;455WW;1277WWA;269WW;269WW;159WA;48W;599WM;1277WWA;19M29MW;48W;89W;1278WWA;269WW;269WW;1689MWA;19M29MW;159WA;48W;699WM;1277WWA;67W89WM;19M29MW;1689MWA;67W89WM;159WA;48W;699WM;1277WWA;67W89WM;67W89WM;1689MWA;19M29MW;159WA;48W;699WM;849MW;357WW;1949MWA;1689MWA;849MW;1278WWA;949MW;2949MWA;1689MWA;159WA;48W;699WM;357WW;929MW;1269WWA;1689MWA;67W89WM;159WA;48W;699WM;1358WWM;455WW;1689MWA;19M29MW;159WA;48W;899WM;1278WWA;949MW;19M29MW;1849MWA;

Try it!
Made using Arnauld's MAWP string printer. Somehow it's not the biggest solution in here.

Javascript, 275 bytes
alert`LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds`

Trivial Answer.

05AB1E, 234 192 191 bytes
.•–¯¼‡=/–nhVηÕÞ·×üΣA₁OúÝá=‘Î¦δk∍˜§ýz†ÂËt@ä‹A‡4)нW¯/kΓoʒÇ4ùŽY„¥₂2Æ²FƒtāË¹kyØ¢øÏ‹Õ.γbÓÄ
₃%‡íéZ'Oδ{)©»Õ¡Ôº₃j
Qyù+íw¬uÂ®ÃÑ3ô₂вÊîv/˜āø¡м¨Z{4∞ä”ôsó×JËP¹pWǝŽèñÇdb]qÀS¼ª†šвε:Ω¢ùÉfΣS€…Ÿ>и²%É(A90þ’8ˆ•™

Try it online!
Outputs: Bennet Blunt Booker Brown Burr Capito Cardin Carper Casey Coons Corker Cornyn Cotton Crapo Cruz Daines Durbin Enzi Ernst Flake Graham Harris Hassan Hatch Heller Hirono Hoeven Inhofe Kaine King Leahy Lee Markey Moran Murphy Murray Nelson Paul Perdue Peters Reed Risch Rounds Rubio Sasse Scott Thune Udall Wyden Young

The question author said that names must start with a capital letter.

@AndersKaseorg Thanks for pointing that out! I golfed it a bit too. If that wasn't a requirement I could golf it down to just 161 bytes.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Extract Local Maxima
Given an array of positive integers, output an array of all the elements that are greater than or equal to the adjacent ones. Most elements will have two adjacent elements; the first and last element are special cases, as they only have one adjacent element.
You may assume that the array contains at least two elements.
Test cases:
Input               | Output
[4,2,6,12,4,5,4,3]  | [4,12,5]
[1,2]               | [2]
[1,2,3,2,1]         | [3]
[3,2,1,2,3]         | [3,3]
[4,4]               | [4,4]
[2,4,4,4,1]         | [4,4,4]
[2,3,3,4]           | [3,4]
[4,3,3,4]           | [4,4]

This is code-golf, shortest code wins!

@PeterTaylor I think what's meant is "For the first or last element to be included in the output, ..."

@PeterTaylor xnor is correct.

Related

Also related: Finding Local Extremes

Can I propose [4,3,3,4] as a testcase. My solution didn't handle that one very well sadly.

@JarkoDubbeldam Done

I've voted to close this as a duplicate of Finding Local Extremes as this is a subset of that challenge

Jelly,  13 12  11 bytes
0;;0»3\f"⁸Ẏ

A monadic link taking a list of positive integers and returning the filtered list containing only those which are greater than or equal to all their neighbours.
Try it online!

Previous 12 byter:
0;INżI>0ḄNMị

Previous 13 byter:
0;;0ṡ3M€ċ€2Tị

How?
0;;0»3\f"⁸Ẏ - Link: list of positive integers, A
0;          - a zero concatenated with A
  ;0        - concatenate a zero
     3\     - 3-wise reduce with:
    »       -   maximum (yields a list of the maximums in each overlapping window of 3)
         ⁸  - chain's left argument, A
        "   - zip with:
       f    -   filter keep (i.e. keep the maximal if it is [in] the [length 1 list
            -                     of the] respective original element)
          Ẏ - flatten by one level

Well I think there may be a way to use 3-wise reduction but I have not worked it out.

I was right - a 3-wise reduce with the maximum dyad, » - how about 10 though..?

10 bytes. Also 10 bytes

@cairdcoinheringaahing indeed, I don't think either of those were possible at the time.

Python, 54 bytes
f=lambda l,*p:l and l[:p<=l[:1]>=l[1:2]]+f(l[1:],l[0])

Try it online!
I/O is with tuples rather than lists.

Python, 57 bytes
f=lambda l,p=0:l and l[:[p]<=l[:1]>=l[1:2]]+f(l[1:],l[0])

Try it online!
Alt 57:
f=lambda l,p=0:l and l[l<[max(p,*l[:2])]:1]+f(l[1:],l[0])

Mathematica 22 Bytes
Pick[#,MaxDetect@#,1]&

Incidentally, this would also work on higher dimension arrays.

Haskell, 50 49 42 bytes
f l=[j|i:j:k:_<-scanr(:)[0]$0:l,k<=j,i<=j]

Try it online!
scanr(:)[0] makes a list of the tails of (0:l), each with a final 0, e.g. for l = [4,3,3,4]: [[0,4,3,3,4,0],[4,3,3,4,0],[3,3,4,0],[3,4,0],[4,0],[0]] which is pattern matched agains i:j:k:_ to extract all lists with at least 3 elements which are named i, j, and k. Keep j if its >= i and j.
Edit:  Ørjan Johansen saved 7 bytes. Thanks!

i:j:k:_<-scanr(:)[0]$0:l is shorter. (Slightly adjusting the "standard" tails=scanr(:)[] trick.)

@ØrjanJohansen: oh, I've used that trick before myself, but somehow missed it here. Thanks a lot!

Dyalog APL, 31 30 28 22 21bytes
{⍵/⍨(⌈/=2⌷⊢)¨3,/∊0⍵0}

Try it online!
Explanation (I'm not good at explaining things):
0⍵0       - [0,input,0]   (it looks like a face!)
∊         - flatten
3,/       - split into overlapping sections of length 3.
(⌈/=2⌷⊢)¨ - Whether the middle element is the maximum (applied to every section)
⍵/⍨       - index

Haskell, 40 bytes
p%(h:t)=[h|h>=p,[h+1]>t]++h%t
_%e=e
(0%)

Try it online!

JavaScript (ES6), 40 bytes
a=>a.filter((e,i)=>!(e<a[i-1]|e<a[i+1]))

Python 3, 84 75* 71 bytes
lambda l,k=[0]:[j for x,j in enumerate(l)if(k+l+k)[x+2]<=j>=(k+l+k)[x]]

Try it online!

*@LeakyNun saved 9 bytes using a clever operator trick.

lambda l,k=[0]:[l[i]for i in range(len(l))if(k+l+k)[i+2]<=l[i]>=(k+l+k)[i]]

Jelly, 15 bytes
2ị⁼Ṁ
0;;0ṡ3Ç€Tị

Try it online!

05AB1E, 15  14  13 bytes
ü‹0¸«sĆÁü›+_Ï

Try it online!
Explanation
ü‹             # pairwise comparison for less than
  0¸«          # append 0
     s         # swap input to top of stack
      Ć        # enclose, append the head of the list
       Á       # rotate right
        ü›     # pairwise comparison for greater than
          +    # add the two boolean lists
           _   # logical negate
            Ï  # keep only elements of input that are true in the resulting list

Previous 15 byte solution
¬s¤)˜Œ3ùεZQ1è}Ï

Try it online!
Explanation
¬                # get head of input
 s¤              # get tail of input
   )˜            # wrap stack in flattened list
                 # produces the input list with the first and last element duplicated
     Œ3ù         # push sublists of length 3
        ε        # apply transformation on each triple
         ZQ      # ... check each element for equality to the max
          1è     # ... get the middle element
            }    # end transform
             Ï   # keep only elements of input that are true in the resulting list

R, 44 bytes
pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])

which evaluates to the function:
function (x)
x[(x >= c(0, x) & x >= x[-1])[1:sum(x | 1)]]

Compares x to c(0,x), so with x shifted one position to the right. Also compares x to x[-1], so one position shifted to the left. These both are TRUE if there is a maximum there. & to take the AND of these booleans. Because of the wrapping nature of R's vectors when they are not the same length, we have to truncate the result at the length of x, which is found by taking sum(x|1). We then plug in the boolean vector, taking only the true indices of x and return that.
Note, because these logical operations are done with unequal length vectors, R will complain. A lot. But the correct output will be there amidst the warnings:
> pryr::f(x[(x>=c(0,x)&x>=x[-1])[1:sum(x|1)]])(c(4,2,6,12,4,5,4,3))
[1]  4 12  5
Warning messages:
1: In x >= c(0, x) :
  longer object length is not a multiple of shorter object length
2: In x >= x[-1] :
  longer object length is not a multiple of shorter object length
3: In x >= c(0, x) & x >= x[-1] :
  longer object length is not a multiple of shorter object length

R, 42 bytes
function(x)x[c(d<-diff(x),0)<=0&c(0,d)>=0]

Try it online!
2 bytes shorter than JAD's solution. diff computes successive differences; then keep only the entries greater than both neighbours.

Pyth, 20 bytes
-.b*YqYeSN.:++0Q03Q0

To be golfed...
Test suite.

R, 68 bytes
function(a)a[a==sapply(1:length(a),function(i)max(c(0,a,0)[i+0:2]))]

Try it online!

pryr::f(expression) is a shorter way to declare a function than function(a)expression.

Also, sum(a|1) is a shortcut for length(a).

See my solution for a shorter approach.

PHP, 67 bytes
for(;$g=$argv[+$i];$l=$g)$g<$l|$g<$argv[++$i]?:$r[]=$g;print_r($r);

Try it online!

Retina, 51 bytes
\d+
$*
^

M!`(?<=(^|1+) )(\1\d*)\b(?! 1\2)
^¶

%`1

Try it online

q, 39 bytes
{x where x = -1 _ next 3 mmax x,last x}

I've never heard of this language before. Do you know anywhere I can try or download it?

Sure, http://kx.com, docs: http://code.kx.com

Stax, 10 bytes
úâH◄(☼bM•Å

Run and debug it
It produces output as newline separated values on standard output.
Unpacked, ungolfed, and commented, it looks like this.
f       filter each value in input using the rest of the program; implicitly printing kept values
  x0|S  input pre- and post-pended with zero
  3B    split into batches of 3
  i@    get the i-th batch, where i is the iteration index
  |M=   is the current value equal to the max from the batch?

Run this one
Updated: Just found a 9-byte solution.  Will update explanation later:
Stax, 9 bytes
▀▓ûa¥╓╧↨⌐

Run and debug it

Perl 5 -a, 37 bytes
map{$_>=$F[++$i]&$_>=$p&&say;$p=$_}@F

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Construct a Permuter
For this challenge you are going to make a function (your function may be a complete program) that takes a list as input and returns a permutation of that list.  Your function must obey the following requirements.

It must be deterministic.
Composing your function with itself a variable number of times should be capable of getting a list to any of its permutations.

This is a code-golf question so answers will be scored in bytes, with less  bytes being better.
Further rules

You may take any type of list, ([Integer],[String],[[Integer]]) as long as it

Can be non empty
Can contain distinct objects with at least 16 possible values.  (You can't use a Haskell [()] and claim your function is id)
Can contain duplicate objects (no sets)

You may write a program or a function, but must obey standard IO.

But S_n is only cyclic for n<3

@LeakyNun, it's not asking for a single permutation which generates the symmetric group: it's asking for a next_permutation function.

Would it suffice to only permute lists of 0's and1's?

I'm not sure I understand the point of this restriction. If you allow lists of Booleans, what's the point of not allowing iterables over any two distinct items?

@Dennis You make a good point.  I will disallowed lists of booleans. Or types that have less than 16 possible values.

CJam (11 bytes)
{_e!_@a#(=}

Online demo showing the full cycle for a four-element list with one duplicate element.
Dissection
{      e# Define a block
  _e!  e#   Find all permutations of the input. Note that if there are duplicate
       e#   elements in the input then only distinct permutations are produced.
       e#   Note also that the permutations are always generated in lexicographic
       e#   order, so the order is independent of the input.
  _@a# e#   Find the index of the input in the list
  (=   e#   Decrement and get the corresponding element of the list
       e#   Incrementing would also have worked, but indexing by -1 feels less
       e#   wrong than indexing by the length, and makes this more portable to
       e#   GolfScript if it ever adds a "permutations" built-in
}

JavaScript (ES6), 145 139 137 134 108 bytes
Saved a whopping 25 bytes thanks to @Neil!
Takes input as an array of alphabetical characters. Returns the next permutation as another array.
a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

How?
This is a generation in lexicographic order that processes the 4 following steps at each iteration:

Find the largest index X such that a[X] < a[X+1]
a.map((v, i) => v < a[i + 1] ? (t = v, x = i) : ...)

Find the largest index Y greater than X such that a[Y] > a[X]
a.map((v, i) => v < a[i + 1] ? ... : y = i > x & v > t ? i : y)

Swap the value of a[X] with that of a[Y]
a[x] = a[y], a[y] = t

Sort the sequence from a[X + 1] up to and including the final element, in ascending lexicographic order
a.concat(a.splice(x + 1).sort())

Example:

Demo

let f =

a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,a.concat(a.splice(x+1).sort()))

for(a = ["A", "B", "C", "D"], n = 0; n < 25; n++) {
  console.log(a.join(','));
  a = f(a);
}

Can't you sort rather than reversing? Also I think v<a[i+1]&&(t=v,x=i) saves a byte, and you might be able to make more savings using splice instead of two slices.

@Neil Good catch!

I think I was able to merge the two maps as well, for 112 bytes: a=>(t=x=y=-1,a.map((v,i)=>v<a[i+1]?(t=v,x=i):y=i>x&v>t?i:y),a[x]=a[y],a[y]=t,t=a.splice(++x).sort(),a.concat(t))

I have to admit I didn't think a.concat(a.splice(++x).sort()) was going to work otherwise I would have tried it...

@Neil Thanks! Updated. (With 4 more bytes saved because we don't really need t to concat()).

Mathematica + Combinatorica (Built-in Package) 34 Bytes
19 bytes to load the package and 15 for the function.
<<"Combinatorica`";NextPermutation

Usage:
%@{c, b, a}

Without the built-in, 61 Bytes
Extract[s=Permutations[Sort@#],Mod[s~Position~#+1,Length@s]]&

Combinatorica is supposed to be fully incorporated into Mathematica, but I think the NextPermutation function was overlooked.

Python 3, 90 bytes
from itertools import*
def f(l):p=[*permutations(sorted(l))];return p[-~p.index(l)%len(p)]

Try it online!

C++, 42 bytes
#include <algorithm>
std::next_permutation

This exact operation is a builtin in C++.

Why the space after #include?

Jelly, 6 bytes
Œ¿’œ?Ṣ

Cycles through the permutations in descending lexicographical order.
Try it online!
How it works
Œ¿’œ?Ṣ  Main link. Argument: A (array)

Œ¿      Compute the permutation index n of A, i.e., the index of A in the
        lexicographically sorted list of permutations of A.
  ’     Decrement the index by 1, yielding n-1.
     Ṣ  Sort A.
   œ?   Getthe (n-1)-th permutation of sorted A.

Python 2, 154 bytes
x=input()
try:exec'%s=max(k for k in range(%s,len(x))if x[%s-1]<x[k]);'*2%tuple('i1kjii');x[i-1],x[j]=x[j],x[i-1];x[i:]=x[:i-1:-1]
except:x.sort()
print x

Try it online!

I think this is shorter as a function that permutes the list in-place.

I tried that, but exec gave me all kinds of errors in a function

C, 161 bytes
Actual O(n) algorithm.
#define S(x,y){t=x;x=y;y=t;}
P(a,n,i,j,t)int*a;{for(i=n;--i&&a[i-1]>a[i];);for(j=n;i&&a[--j]<=a[i-1];);if(i)S(a[i-1],a[j])for(j=0;j++<n-i>>1;)S(a[i+j-1],a[n-j])}

Example usage:
int main(int argc, char** argv) {
    int i;
    int a[] = {1, 2, 3, 4};

    for (i = 0; i < 25; ++i) {
        printf("%d %d %d %d\n", a[0], a[1], a[2], a[3]);
        P(a, 4);
    }

    return 0;
}

Jelly, 10 bytes
ṢŒ!Q©i⁸‘ị®

Try it online!
Sort > all permutation > find input > add 1 > index into "all permutation

@PeterTaylor I've fixed it.

There are specific builtins for permutations (i.e. you can just do Œ¿‘œ?Ṣ). I didn't feel like stealing since, well, same algo.

@EriktheOutgolfer it might be a bit messy for inputs that contain duplicates.

Hmm...I guess so, I had a version which did work for that previously but you seem to use the Q thingy. You can still golf to ṢŒ!Qµi³‘ị.

05AB1E, 7 bytes
œêD¹k>è

Try it online!

PHP, 117 bytes
Takes input/output as string list of lower letters

$a=str_split($s=$argn);rsort($a);if(join($a)!=$s)for($n=$s;($c=count_chars)(++$n)!=$c($s););else$n=strrev($s);echo$n;

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Military projection of a cube
Challenge closed, the shortest answer has been acccepted.
A military projection is a projection where all lengths and the angles in the X-Z plane remain unattuned.
Your task is to print a cube in military projection using /, |, \, -, and any whitespaces you want, given any integer greater than zero as it's side length. You can leave sides out that are not visible to the human eye.
Here are some examples:
  /-\
 /   \
|\   /| Side length:
| \ / | 2
 \ | /
  \|/

     /-\
    /   \
   /     \
  /       \
 /         \
|\         /|
| \       / | Side length:
|  \     /  |
|   \   /   | 5
|    \ /    |
 \    |    /
  \   |   /
   \  |  /
    \ | /
     \|/

 /-\  Side length:
|\ /|
 \|/  1

(Printing the side lengths is not required.)
For the uppermost corner you must use the dash.
As you can see, all sides are equal in length (when measured in characters).
You may use any kind of spacing you wish, and omit any characters that don't change the appearance of the cube.
This is code-golf, so the shortest answer in bytes wins!

Are we guaranteed that the input is a positive integer?

Hello, and welcome to PPCG! I'm going to vote to close this question as unclear because there are some things you need to specify. For example, will the input always be a positive integer? What range of inputs are possible? What do smaller or larger inputs look like? Could you explain in more detail how to draw the cube, and also provide some more examples? If you clarify these, I'll remove my close vote. :)

Hope I could satisfy your need for clarification.

You can leave sides out that are not visible to the human eye. so, should we or not? You should specify that.

Charcoal, 19 bytes
Ｎθ←¹↙θ↓θ→↘θ↑↑θ←↖θ‖Ｂ

Try it online!

Python 2.7, 198 185 172 bytes
i=n=input();x=1;s,l,r,p='/|\ '
print p*n+'/-\\'
exec'x+=2;i-=1;print p*i+s+p*x+r;'*~-n+'i-=2;'+'i+=1;print l+p*i+r+p*x+s+p*i+l;x-=2;'*n+'print(n-i)*p+r+p*i+l+p*i+s;i-=1;'*n

Try it online!
Immense scope for golfing. I'm missing something out here, most probably!
Edit 1: -13 bytes: That's a start
Edit 2: -13 bytes: courtesy Erik the Outgolfer

Sadly, Python needs extra bytes for escaping the backslashes, but nice answer anyway!

Thanks @racer290. Trying something out to see if it can be golfed any further.

'/|\\ '=>'/|\ '

Some other -13...

SOGL V0.12, 39 38 34 33 bytes
∫:┘ž}³№↕≥++┌.I1ž.┐∙:.2+.Iž0.I╬5╬⁷

Try it Here!
Explanation:
∫   }                              for 1-indexed range in the input
 :                                   duplicate current index
  ┘ž                                 at [index; index] in POP (by default the input, but in the 1st cycle it gets overwritten) insert a "\"
     ³                             triplicate that array of a big diagonal
      №↕                           mirror/reverse one of those vertically
        ≥                          put that at the stacks bottom
         ++                        join the three items together, resulting in the 3 diagonal lines of the result
           ┌.I1ž                   insert a dash at coordinates [input+1; 1] insert the dash
                .┐∙                get an array of vertical bars with the size of the input (aka a vertical bar)
                   :               duplicate that
                    .2+.Iž         at postition [input+2; input+1] insert the 2nd vertical bar in the 1st (resulting in the required vertical bars the correct distance apart)
                          0.I╬5    at position [0; input+1] insert the vertical bars without overwriting spaces; as the position numbers are 1-indexed this extends the array left
                               ╬⁷  palindromize horizontally, mirroring the required characters and with 1 overlap

Wow, creative solution! =)


text:
Have I had lunch yet?
You love lunch. However, you are on a diet and want to make sure you don't accidentally eat lunch twice in one day. So you need to make a program to help you make sure.
However, one complication is that you eat lunch on a very weird schedule. The time you eat lunch at is MONTH:DAY PM (you can use UTC or localized time zone). That's right, if the day is July 14, you eat lunch at 7:14 PM.
For your program, you need to use the current date and time (don't take input), and output a consistent truthy value if you have already eaten lunch for the day (or it is lunch time now), or a consistent falsy value if you haven't.
Examples: (Time you run program => output)

May 4th 11:35 AM => false (you will eat lunch at 5:04 PM)
June 3rd 5:45 PM => false (you will eat lunch at 6:03 PM)
July 28th 8:30 PM => true (you ate lunch at 7:28 PM)
December 15th 3:25 PM => true (you ate lunch at 12:15 PM)
February 29th 2:29 PM => true (it is exactly lunch time)
October 12th 12:00 AM => false (day just started)

Reference:
How a 12 hour clock works

Can't we use UTC instead?

@Mr.Xcoder Yeah, actually that's ok. I'll clarify.

If you eat lunch only at one specific time of day, how could you eat it twice? =p

How do you want seconds handled?

@Stilez Basically ignore them.

The fact that noon isn't 12AM makes this trickier.

Does it have to work in future years?

@MarkS. At least this century, let's say.

Doesn't everyone eat their lunch like this? Is it really only me?

Swift 3, 310 bytes
import Foundation;var n=String(describing:Date());var k=n.startIndex;print(Int(n[n.index(k,offsetBy:5)...n.index(k,offsetBy:6)])!*60+Int(n[n.index(k,offsetBy:8)...n.index(k,offsetBy:9)])!+720<=Int(n[n.index(k,offsetBy:11)...n.index(k,offsetBy:12)])!*60+Int(n[n.index(k,offsetBy:14)...n.index(k,offsetBy:15)])!)

Check it out!
This prints true and false, for truthy and falsy respectively.

NOTE: This only works until the year 9999, at 11:59:59 PM, because it uses Strings to compare the dates.

Swifts substringing always pains me to look at >_< :P

05AB1E, 15 18 bytes
žežb‚žf12+ža‚т*+`‹

Try it online!
Explanation
žežb‚žf12+ža‚т*+`‹
že                 # Push current day
  žb               # Push current minute
    ‚              # Wrap to array
     žf12+         # Push current month and add 12 to it
       ža          # Push current hour
         ‚         # Wrap these two to array as well
          т*       # Multiply each element in the second array by 100
            +      # Add both arrays together
             `     # Flatten the resulting array to stack
              ‹    # Is the first item smaller than the second one?

I don't think this works. Because it's 12:51 AM UTC right now, and it's outputting 1.

Nvm just realized i was checking against am not pm. Fixed at the cost of 3 bytes.

Octave, 61 bytes
diff(str2num([(d=datestr(now,'mmddHHMM'))(1:4);d(5:8)]))>1200

Try it online!
Explanation:
First the functions:

now() returns the time on a decimal format. The parentheses are optional.
datestr converts a decimal number to a string on the format given in its second argument
str2num converts a string to a number
diff takes the difference between two numbers

Breakdown:
We take this from the middle:
diff(str2num([(d=datestr(now,'mmddHHMM'))(1:4);d(5:8)]))>1200

datestr(now,'mmddHHMM'): First we take the current time now as input to datestr and specifies the format mmddHHMM. The letters mean: mm = month, dd = day, HH = hour, MM = minutes and AM specifies that the hours should be on a 12-hour format. No separators are included, to keep it as short as possible. It outputs d = 07142117 on the time of writing this explanation. I'll refer to that part as x from now.
[(d=x)(1:4);d(5:8)]: Stores the string above, as d, then creates an array with two elements, the first four characters, then the 5-9 characters. This gives:
ans =
0714
2122

Where the numbers are stored as strings, not numbers. We'll call the result above for y below.
str2num(y) converts the array of characters to numbers, where each row turns into one number. This gives [714; 2122]. We'll call the result for z.
diff(z)>1200 takes the difference between the two numbers and checks if the current time is 1200 higher than the current date. This accounts for AM/PM. This gives us the desired result.

does this check if it's actually PM?

It does now. :)

If "mmdd" is "1201" and "HHMM" is "1215" this should be trueish, no? I had to use mod 12 on the month to account for that somehow.

Pyth, 22 21 20 bytes
<0+g.d7.d5-.d6+12.d4

-1 byte thanks to @Mr.Xcoder
Try this!
old approach, 22 20 bytes
<+`+12.d4.d5+`.d6.d7

Try it!
explanation
<0+g.d7.d5-.d6+12.d4
              +12.d4   # Add 12 to the current month to make it PM
          -.d6         # subtract that from the current hour: negative it is too early,
                       # positive when it is past this hour, zero when its the same hour
   g.d7.d5             # Is the minute greater or equal than the day? True=1; False=0
  +                    # Add this to the hour result,
                       # so that 0 can turn positive if minutes are true
<0                     # Is the result larger than 0 ?

Wouldn't &g.d6+.d4 12g.d5.d7 work for 19 bytes? I am not sure and haven't really tested it yet but...

&g.d6+12.d4g.d5.d7 would be 18 actually. Also, in the old approach I don't think you need the ```, and that would become 18 bytes long. I don't know, I might be wrong.

@Mr.Xcoder if you use & then both have to be true e.g. in your code 22:17 wouldn't count as after 19:15, because the minutes are false. I can remove some of the ```, but not all of them. Thank you for saving me a byte.

Ok, I really didn't know if that was correct, I'm still learning Pyth :P

Then, I have found an alternative solution g++720.d5*60.d4+*60.d6.d7, but that is longer unfortunately (25 bytes). However, it might be a source of inspiration and I figured I should mention it.

Haskell, 135 129 bytes
import Data.Time
x(ZonedTime(LocalTime d(TimeOfDay h m _))_)|(_,x,y)<-toGregorian d=return(mod x 12<h-12&&y<m)
y=getZonedTime>>=x

this unpacking is quite annoying, maybe string handling is better suited
//edit: pattern guards safe 5 bytes

C#, 174 bytes
using System;public class Program{public static void Main(){Console.WriteLine(DateTime.Now>DateTime.Today.AddHours(DateTime.Today.Month+12).AddMinutes(DateTime.Today.Day));}}

Try it online!

I don't think you can add hours and minutes, you must set them.

Create an anonymous action (()=>...) as Action<bool> to save bytes. Use DateTime.Now when accessing the month and day. In general public is not needed and Program can be just one letter. Use using D=System.DateTime; to save bytes.Overall nice idea but could be golfed a lot. Welcome to PPCG!

@TheLethalCoder thanks for the advice! This was my first go at code golf but I'll definitely be trying more!

PHP and other languages with these common functions: about 28 to 29 bytes:
echo eval(date('Gi-1199>md'));

or alternatively
<?=eval(date('Gi-1199>md'))?>

both of which will print.
possibly with ?1:0 depending on representation.  Possibly bytes cut if a language is used that has implicit echo, or no final ';'.
Why would one get the values into variables and all the rest, when it's not needed :)
date() leaves anything as literals that isn't defined, so for example, 7 May 2017 17:22:43 passes the expression 1722 - 1200 >= 507 to eval(). Byte saved by changing it to the equivalent 1722 - 1199 > 507.
Who says eval is dead? ;-)

Mathematica, 65 64 62 bytes
3 Programs
p=Date[][[#]]&;{60,1}.#&/@(p[4;;5]>=p[2;;3]+{12+p@2~Mod~12,0})

{60,1}.#&/@(#[[4;;5]]>=#[[2;;3]]+{12+#[[2]]~Mod~12,0})&@Date[]

{60,1}.#&/@(#[4;;5]>=#[2;;3]+{12+#@2~Mod~12,0})&[Date[][[#]]&]

These are each one byte less if ≥ counts as a single byte in Mathematica.
Explanations

Date[] returns a list in the form {y,m,d,h,m,s}. So
Date[][[4;;5]] are the hours and minutes of the current time.
p=Date[][[#]]&; makes p a function that takes in the indices we
want and gives us those parts of the date.
{60,1}.#& is an anonymous function that takes the dot product of {60,1} and the input to get a way to compare times. It's one byte shorter than TimeObject.
p@2 is equivalent to p[2], the number of the month.
+{12+p@2~Mod~12,0} adds {12,0} to the month and date when we're not in December, and adds {0,0} otherwise. (Thanks, michi7x7!)
>= is the comparison operator, but we can't compare {hours, minutes} to {adjusted month, date} entrywise...
/@ maps {60,1}.#& to both sides of the inequality in parentheses, so we can compare times correctly.
For the programs that start with {60,1}.#&, they use # to represent the input to a big anonymous function, and & to signify the end.
@Date[] Applies the big function on its line (which extracts parts of a list) to the date list itself.
[Date[][[#]]&] Applies the big function on its line to another anonymous function, one which extracts parts of the date list.

Bonus
As an aside, if we ate lunch between 1AM and 12:59PM, then we could save 25 bytes with just {60,1}.#&[Date[][[#]]]&/@(4;;5>=2;;3).
You can test all of these out by pasting the code into the Wolfram Cloud sandbox and clicking Gear->Evaluate Cell or hitting Shift+Enter or Numpad Enter.

I believe that your bonus note is actually a valid solution - as your domain of valid times is 13:01 to 24:31

@TaylorScott Thanks for the code formatting (though the colorization seems to fail on some trickier cases). I'm not sure I understand your comment, though. If the If it's 7:20AM on July 19, then the "bonus" code would say "yes, you've had lunch" even though it's far from 7:20PM. The OP has test cases in the AM so I think this makes it invalid. What am I missing?

@Mark_S. I See - for some reason i had read that as being 11:59 PM rather than 12:59 -is there no concise way to add 12 hours to the bonus code?

@TaylorScott Well, we want to add 12 to the hour for most months so for January through November we could replace the Date[] in the bonus with  (Date[]+{0,12,0,0,0,0}) (there may be a way to golf that, but 12UnitVector[6,2] is longer). The problem is that on dates like December 3, we eat lunch at 12:03, not 24:03, so we need to add 12 except in December. This requires us to either 1. peek inside the date to see if we're in December or not (as in my answers), or 2. write a function that examines if we went to 24:XX after the fact, which would be longer.

@MarkS. 12+Mod[#[[2]],12] ?

@michi7x7 Good idea! Combining with infixing, that saves 2 bytes.

Java, 81 bytes
n->new Date().after(new Date(){{setHours(getMonth()+13);setMinutes(getDate());}})

Try it online!
Ungolfed:
n -> new Date().after(new Date() { //new Date() returns current date
    { //instance initialization
        setHours(getMonth() + 13); //month + 12 hours for PM + 1 because months are 0 indexed
        setMinutes(getDate()());
    }
})

Does this handle December correctly? I haven't worked with Java in a long time, but this looks like it might send December 1 to 24:01 instead of just after noon.

Don't forget to include your import of java.util.Date in the byte count.

q, 31 bytes
x>12:+"T"$(-3!x:.z.P)5 6 13 8 9

Example:
q).z.P
2017.07.16D19:35:26.654099000
q)x>12:+"T"$(-3!x:.z.P)5 6 13 8 9
1b

Interpreter is available here
Old version
{x:.z.p;x>"T"$":"sv"0"^2$/:string 12 0+`mm`dd$\:x}`

The 2$ pad will turn 6 to 6_ rather than _6, so you'd want (-2)$, but you can cancel out those extra 3 chars by using the shorthand for string  as ($)... or instead of using $ to pad, prepend "0" and then take the last 2 chars:
`{x:.z.P;x>"T"$":"sv -2#'"0",'($)12 0+`mm`dd$\:x}` for 49 bytes

good spot. the original was invalid. i added an even shorter version

Python 3, 104 bytes
from datetime import*
n=datetime.now();print(n>=n.replace(hour=[0,n.month+12][n.month<12],minute=n.day))

Try it online!
All datetime tests. I replaced Feb 29th with Feb 28th because the invalid date wasn't working.

Python 2.7, 130 bytes
from datetime import*
a=str(datetime.now()).split()
print int(''.join(a[0].split('-')[1:]))+1200<int(''.join(a[1].split(':')[:2]))

Try it online
Note: There may be a problem with the sign. Please excuse that because I follow IST and it's quite confusing because it's 2:28am here now. Do correct the sign if you feel it is wrong.

JavaScript (ES6), 75 bytes

f=
(d=new Date)=>(d.getHours()-d.getMonth()-13||d.getMinutes()-d.getDate())>=0
<input type=button value=Lunch? onclick=o.textContent=f()><tt id=o>

Those long function names...

JavaScript, 75 bytes
t=new Date,t.setHours(13+t.getMonth()),t.setMinutes(t.getDate()),new Date>t

Which is equivalent to the following code:
function didEat()
  const d = new Date()
  d.setHours(12 /* PM */ + d.getMonth() + 1)
  d.setMinutes(d.getDate())
  return new Date > d
}
didEat()

last t can be used while modify

t=new Date,t.setMinutes(t.getDate(t.setHours(13+t.getMonth(n=+t))))<n

R, 92 bytes
library(lubridate)
d=Sys.Date()
cat(Sys.time()>ymd_hm(paste0(d,'-',month(d)+12,'-',day(d))))

Try it online!
                                   month(d)+12,'-',day(d)    # get month and day and paste into a string, adding 12 hours for pm
                      paste0(d,'-',                      )   # add current date to beginning
               ymd_hm(                                    )  # turn whole thing into a date-time object
cat(Sys.time()>                                            ) # compare with current date-time and print

Perl, 45 chars
sub c{@a=gmtime;$a[2]-12>$a[4]&&$a[1]>=$a[3]}

If I have to provide a method, it will be 45 for sub c{...}.
If I have to print
say ()||0 even makes it 47. I will add that in if it's a requirement.

I believe that because the original question specifies you need to make a program to help you make sure that snippets are not allowed - that said either of your listed output methods are generally considered valid

fair enough, I will provide output then. Thanks for editing, I was not aware of the proper language tag! I was thinking perl -e was generally ok, but others have provided functions, so I edited it in.

Excel, 52 50 49 bytes
=TIME(MONTH(NOW())+12,DAY(NOW()),0)<=MOD(NOW(),1)

Input is this formula in any cell.
Output is either TRUE or FALSE.
Excel's built-in date handling helps a lot.
The TIME function returns the day's lunch time as a time value which, if converted to a date, would use Jan 0, 1900. We compare it against NOW - TODAY so we get the current time with a date value of 0 or Jan 0, 1900.
Saved 2 bytes thanks to Wernisch
Saved 1 byte thanks to Adam

Do you need the extra braces around NOW()-TODAY() ?

@Wernisch No, as it turns out. I had presumed it would evaluate the inequality before the subtraction but I didn't check it. Thanks.

I think you can save a byte by changing from now()-today() to mod(now(),1)

Excel VBA, 55 Bytes
Anonymous VBE immediate window function that takes no input and outputs a Boolean value representing whether I've had lunch to the VBE immediate window
n=Now:?TimeValue(n)>TimeValue(Month(n)&":"&Day(n)&"PM")

JavaScript, 62 chars
f=
_=>[,m,d,H,M]=(new Date).toISOString().split(/\D/),+m+12+d<=H+M

Test code below:

console.log(( // May 4, 5:03 PM, false (1 minute before lunch)
  [,m,d,H,M]=(new Date("2017-05-04T17:03Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

console.log(( // May 4, 5:04 PM, true (exact time)
  [,m,d,H,M]=(new Date("2017-05-04T17:04Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

console.log(( // May 4, 5:05 PM, true (1 minute after)
  [,m,d,H,M]=(new Date("2017-05-04T17:05Z")).toISOString().split(/\D/),+m+12+d<=H+M
));

Ruby, 64+7 = 71 bytes
Requires the -rtime flag because for some reason Time::parse is like, the only function requires it out of the entire Time module.
p Time.parse("#{t=Time.now}"[/.+-(..)-(..) /]+[$1,$2]*?:+'pm')<t

Try it online! (it also prints out the current time)

Julia 0.6.0 99 bytes
a=split(string(Dates.today()),"-");(Dates.hour(now())<parse(a[2]))&&Dates.minute(now())<parse(a[3])
Julia has built in function to use the clock/calendar of the computer.
My computer is running on ubuntu 16.04 and already with 12 hour clock, so I can't say if what I did works with other machine using different clock, but seems to works on my machine.

Matlab, 241 bytes
dt=datestr(now,'mm/dd');
dt(2)
dt(4:5)
CrctLchTm=[' ' dt(2) ':' dt(4:5) ' PM']
CrntTm=datestr(now,'HH:MM PM')
CrntTm(7)=='A'
if ans==1
    Lch='false'
else
    CrctLchTm=str2num([CrctLchTm(2) CrctLchTm(4:5)])
    CrntTm=str2num([CrntTm(2) CrntTm(4:5)])
    CrntTm<CrctLchTm
    if ans==1
        Lch='false'
    else
        Lch='true'
    end
end

Explanation: First, I obtain the date as a string. Then, I isolate the month and day. Since the problem states that it is always interpreted as PM, then I automatically write false if the time is in AM. If the current time is in PM, then I continue on and just compare the numbers of the time.
Note: I've formatted it slightly differently here for readability.

JavaScript ES6, 70 Bytes
_=>(h=x=>new Date().toJSON().substr(x,5).replace(/\D/,0))(5)+12e3<h(11)

Maybe not that right on some milliseconds...


text:
Prankster Santa
It is widely known that Santa Claus delivers presents to houses all over the world in December. However, not many people know what he does during the rest of the year. You see, Santa enjoys a jolly good prank, and he'll often find himself pranking entire cities when he's not busy making or delivering toys.
One place that he particularly enjoys pranking is the South Pole. You might be saying, "The South Pole isn't a city." You would be right, but Santa doesn't care. There are h houses in the South Pole, which are conveniently numbered from 1 to h. Whenever Santa is in the mood for pranking, he'll start at a particular house, s. He rings the doorbell, then runs to another house.
He always visits houses in order, but just so he doesn't arouse suspicion, he only knocks on every kth house (for example, every 2nd or 3rd house), where k ≥ 2. This is because the residents (who are penguins) would know that something's up if one or both of their next door neighbors were pranked as well. Once Santa pranks p houses that day (or passes house number h), he goes back home to the North Pole.
After pranking houses for d days, though, Santa feels bad for pranking the penguins so many times. To make things right, he decides that next Christmas he will award the biggest and best gift to the penguin who got pranked the most. If there are multiple houses that got pranked the most, he will award the gift to the penguin in the lowest numbered house.
The Problem:
Help Santa by telling him which house should receive the biggest and best gift the following Christmas. Santa, of course, wants to make amends each and every year so he needs your suggestion for each one.
The Input:
Two integers, h and d, representing the number of houses and the number of days that Santa pranked the South Pole that year, respectively. Additionally, take in multiple sets of three integers, s, k, and p, denoting the starting house, the number representing his frequency of visiting houses (he skips k-1 houses), and the maximum number of houses he pranks that day. Note that he will visit p houses unless he passes the very last house. You may take these inputs in any reasonable format.
Output g, where g is the house number that should receive the biggest and best gift (the house that got pranked the most, and the lowest house number in the case of a tie). Note that you may not use zero-based indexing, because Santa doesn't know what a computer is.
Test cases:
4 3
1 2 1
3 4 2
2 2 2
Output: 1

10 2
2 3 2
3 2 5
Output: 5

50 100
10 10 36
17 7 1
37 2 19
28 2 49
29 3 29
48 3 12
35 3 25
28 4 20
38 8 27
39 3 19
26 4 9
20 7 8
47 10 1
6 10 43
31 3 29
35 2 23
24 9 44
10 3 25
29 10 37
32 5 47
21 5 31
44 5 43
46 4 47
16 10 5
5 3 18
7 8 10
48 5 31
29 4 7
31 8 5
23 9 43
34 8 4
41 10 38
30 6 23
17 7 1
43 5 24
29 2 37
22 10 19
17 6 43
37 3 22
42 10 9
48 4 47
11 6 3
29 7 42
11 9 28
3 4 9
39 9 7
20 9 5
47 5 29
20 4 4
44 10 30
30 6 21
39 10 38
7 9 18
32 10 47
14 9 13
7 2 8
44 3 19
40 4 12
4 10 12
3 5 46
3 5 37
29 9 45
16 4 26
27 9 32
37 10 16
30 5 39
36 2 26
25 2 28
13 3 16
8 8 27
27 6 29
39 10 10
34 7 47
5 4 17
39 2 9
45 2 24
4 6 11
8 10 24
50 7 30
7 4 37
35 10 44
35 9 28
49 10 7
20 5 17
30 4 50
18 7 4
4 7 14
38 9 40
27 3 15
39 5 13
8 2 46
15 4 13
21 9 49
28 6 29
48 5 35
8 8 5
27 3 41
35 10 23
14 4 15
12 2 22
Output: 48

Scoring: Number of bytes. Subtract 20 bytes from your score if your program can handle inputs of up to 100,000 (both days and houses) in less than 5 seconds on a standard desktop PC. Note that in all these inputs k will be less than or equal to 10.

Yes, you can take input as parameters

Jelly, 20 bytes
Ḣrm⁸Ḣ¤ḣ⁸
ç€FµĠLÐṀḢḢị

A dyadic link taking a list of lists of numbers, the list of s,k,p values, and a number h (d is just the length of the list so is redundant), returning the house number.
Try it online!
How?
Builds lists of house numbers visited each day, then finds those visited the most and returns the minimal numbered one.
Ḣrm⁸Ḣ¤ḣ⁸ - Link 1, get houses visited on one day: list, [s,k,p]; number, h
Ḣ        - head  = s (modifies the list to become [k,p])
 r       - inclusive range = [s,s+1,s+2,...,h]
     ¤   - nilad followed by link(s) as a nilad:
   ⁸     -   chain's left argument = [k,p]
    Ḣ    -   head = k (modifies the list to become [p])
  m      - modulo slice (take the 1st item then every kth item of the range)
       ⁸ - chain's left argument = [p]
      ḣ  - head to index (vectorises) (take the first p items, or all if less
         -   this will yield a list of length 1 containing the truncated list)

ç€FµĠLÐṀḢḢị - Link: list of lists [[s1,k1,p1],[s2,k2,p2],...]; number, h
ç€          - call the last link as a dyad for €ach
  F         - flatten into a single list (all the houses visited)
   µ        - monadic chain separation, call that v
    Ġ       - group indexes by value (indexes of smallest houses will go first)
      ÐṀ    - filter to keep only those with maximal:
     L      -   length (the groups containing indexes of houses visited most)
        Ḣ   - head (get the first such group)
         Ḣ  - head (get the fist index from the group)
          ị - index into v (get the house number)

I edited the problem to make the input format more reasonable as you suggested.

Python 3, 158 bytes
r=range
def f(h,_,x):
 L=[0]*h
 for s,k,p in x:
  n=0
  for i in r(s,h+1,k):
   if n>p:break
   L[i-1]+=1
   n+=1
 return[i for i in r(h)if L[i]==max(L)][0]+1

Try it online
So this is barely golfed or optimized, but it's a start. I may return to it if I think of better ways to do it. And it doesn't get the bonus. v_v

Hint: Don't process the days one at a time. Abuse the fact that k <= 10.
(for the bonus_

You don't need to take input when you don't need it, so you can remove your second input.

Python 2, 78 bytes
h,a=input();l=[]
for s,k,p in a:l+=range(s,h+1,k)[:p]
print max(l,key=l.count)

Try it online!
Takes input without the numbers of days.