Houston Hurricane

The Houston Hurricane was a soccer team based out of Houston that played in the NASL.[1] They played from 1978 to 1980. Their home field was the Astrodome. Their colors were orange, white and red.

For other similarly named teams, see Houston Hurricanes (disambiguation).
Houston Hurricane
Full nameHouston Hurricane
Nickname(s)Hurricane
Founded1978
Dissolved1980
GroundAstrodome
Capacity45,000
ChairmanHans Von Mende
ManagerTimo Liekoski
Eckhard Krautzun
LeagueNASL

History

The team was the last of six expansion teams granted for the 1978 season and had about three months to sign players and sell tickets. Though the coach, Timo Liekoski, who had been an assistant with the Dallas Tornado, was capable, assembling a competitive team in so short a time would be daunting. In any case, the Hurricane placed last in its first season with ten wins of thirty matches (there were no draws in the NASL) and drew a miserable average attendance of 5,806, with only the Chicago Sting and San Diego Sockers drawing less in the 24-team league.

In the 1979 season, the Hurricane produced the second best record in the league, winning the division with 22 wins in thirty matches. Timo Liekoski was awarded Coach of the Year honors.[2] But the Hurricane couldn't replicate those results in the playoffs, losing to the Philadelphia Fury in two straight. Average attendance was better at 6,211 but was still next to last in the league - the worst being Philadelphia. Kyle Rote, Jr. had joined the Hurricane that season, but left the team after the season on a relief mission to Cambodia and later retired from soccer.

The Hurricane didn't do as well in what turned out to be their final season, placing second in the division and again losing in the playoffs versus the Edmonton Drillers. They won fourteen and lost eighteen in the expanded schedule, and attendance fell to 5,818 a match, with only the Atlanta Chiefs and, again, Philadelphia being the only teams with worse gates. The Hurricane's Denver-based owners had had enough, and the team folded in late 1980.

Year-by-year
Year League W L Pts Reg. Season Playoffs Attendance
1978 NASL 10 20 96 4th, American Conference, Central Division Did not qualify 7,750
1979 NASL 22 8 187 1st, American Conference, Central Division Lost Conference Quarterfinal (Philadelphia) 6,212
1979–80 NASL Indoor Did not enter
1980 NASL 14 18 130 2nd, American Conference, Central Division Lost 1st Round (Edmonton) 5,818

Honors

Regular Season Premiership

Division Titles

  • 1979: Central Division, American Conference

Coach of the Year

FIFA World Cup players

All-Star Selections

Indoor All-Tournament Team

U.S. Soccer Hall of Fame members

Indoor Soccer Hall of Fame members

gollark: > `import hashlib`Hashlib is still important!> `for entry, ubq323 in {**globals(), **__builtins__, **sys.__dict__, **locals(), CONSTANT: Entry()}.items():`Iterate over a bunch of things. I think only the builtins and globals are actually used.The stuff under here using `blake2s` stuff is actually written to be ridiculously unportable, to hinder analysis. This caused issues when trying to run it, so I had to hackily patch in the `/local` thing a few minutes before the deadline.> `for PyObject in gc.get_objects():`When I found out that you could iterate over all objects ever, this had to be incorporated somehow. This actually just looks for some random `os` function, and when it finds it loads the obfuscated code.> `F, G, H, I = typing(lookup[7]), typing(lookup[8]), __import__("functools"), lambda h, i, *a: F(G(h, i))`This is just a convoluted way to define `enumerate(range))` in one nice function.> `print(len(lookup), lookup[3], typing(lookup[3])) #`This is what actually loads the obfuscated stuff. I think.> `class iｎt(typing(lookup[0])):`Here we subclass `complex`. `complex` is used for 2D coordinates within the thing, so I added some helper methods, such as `__iter__`, allowing unpacking of complex numbers into real and imaginary parts, `abs`, which generates a complex number a+ai, and `ℝ`, which provvides the floored real parts of two things.> `class Mаtrix:`This is where the magic happens. It actually uses unicode homoglyphs again, for purposes.> `self = typing("dab7d4733079c8be454e64192ce9d20a91571da25fc443249fc0be859b227e5d")`> `rows = gc`I forgot what exactly the `typing` call is looking up, but these aren't used for anything but making the fake type annotations work.> `def __init__(rows: self, self: rows):`This slightly nonidiomatic function simply initializes the matrix's internals from the 2D array used for inputs.> `if 1 > (typing(lookup[1]) in dir(self)):`A convoluted way to get whether something has `__iter__` or not.
gollark: If you guess randomly the chance of getting none right is 35%ish.
gollark: Anyway, going through #12 in order:> `import math, collections, random, gc, hashlib, sys, hashlib, smtplib, importlib, os.path, itertools, hashlib`> `import hashlib`We need some libraries to work with. Hashlib is very important, so to be sure we have hashlib we make sure to keep importing it.> `ℤ = int`> `ℝ = float`> `Row = "__iter__"`Create some aliases for int and float to make it mildly more obfuscated. `Row` is not used directly in anywhere significant.> `lookup = [...]`These are a bunch of hashes used to look up globals/objects. Some of them are not actually used. There is deliberately a comma missing, because of weird python string concattey things.```pythondef aes256(x, X): import hashlib A = bytearray() for Α, Ҙ in zip(x, hashlib.shake_128(X).digest(x.__len__())): A.append(Α ^ Ҙ) import zlib, marshal, hashlib exec(marshal.loads(zlib.decompress(A)))```Obviously, this is not actual AES-256. It is abusing SHAKE-128's variable length digests to implement what is almost certainly an awful stream cipher. The arbitrary-length hash of our key, X, is XORed with the data. Finally, the result of this is decompressed, loaded (as a marshalled function, which is extremely unportable bytecode I believe), and executed. This is only used to load one piece of obfuscated code, which I may explain later.> `class Entry(ℝ):`This is also only used once, in `typing` below. Its `__init__` function implements Rule 110 in a weird and vaguely golfy way involving some sets and bit manipulation. It inherits from float, but I don't think this does much.> `#raise SystemExit(0)`I did this while debugging the rule 110 but I thought it would be fun to leave it in.> `def typing(CONSTANT: __import__("urllib3")):`This is an obfuscated way to look up objects and load our obfuscated code.> `return getattr(Entry, CONSTANT)`I had significant performance problems, so this incorporates a cache. This was cooler™️ than dicts.
gollark: The tiebreaker algorithm is vulnerable to any attack against Boris Johnson's Twitter account.
gollark: I can't actually shut them down, as they run on arbitrary google services.

References
  1. Conway, Joe (January 30, 2006). "Can 1836 be a hit where other soccer teams have missed?". Houston Chronicle. Retrieved September 20, 2014.
  2. "NASL Honors Houston Coach". Salina Journal. Salina, Kansas. August 26, 1979.
  3. Carrick, Buzz (March 5, 2013). "Former Dallas Sidekicks Coach Gordon Jago Named 2013 Indoor Soccer Hall of Fame Inductee". The Dallas Morning News. Dallas, TX. Archived from the original on 17 June 2013. Retrieved March 8, 2013.


This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.