Luke Russell

Luke Russell is a former professional Australian rules footballer who played for the Gold Coast Football Club in the Australian Football League (AFL). He was drafted as an underage player from Burnie Dockers. He made his debut against Melbourne[1] in round 4 of the 2011 season, He soon returned to Tasmania to flip burgers as a cult hero at the Burnie dockers.

Luke Russell
Russell playing for Gold Coast in 2012
Personal information
Full name Luke Russell
Date of birth (1992-01-24) 24 January 1992
Place of birth Burnie, Tasmania, Australia
Original team(s) Burnie Dockers (TFL)
Draft Underage recruit, Gold Coast
Height 175 cm (5 ft 9 in)
Weight 108 kg (238 lb)
Position(s) Forward / Midfielder
Playing career1
Years Club Games (Goals)
2011–2016 Gold Coast 73 (29)
1 Playing statistics correct to the end of 2016.
Career highlights

nil

Sources: AFL Tables, AustralianFootball.com

Early life

Luke Russell was born in Burnie, Tasmania and grew up playing Basketball. He represented Tasmania at the state level in Basketball and would be chosen in the Australian u19 development squad in 2007. Due to many injuries he would give up playing Basketball in 2008 and focus on Australian rules football solely.

Junior football

Russell began his junior football with the Burnie Dockers who compete in the Tasmanian Football League and made his debut in the seniors team in 2008 as a 16-year-old. His form for Burnie in 2008 would earn him a spot in the Tasmanian team that competed in the Australian U16 Championships and was given an AIS scholarship later that year. At 17 years old he would be selected as the captain of the U18 Tasmanian team that competed in the 2009 AFL National Under 18 Championships. Following his performance in the National Championships he was signed as an underage recruit by the Gold Coast Football Club to compete in the Victorian Football League in 2010. In November 2009 he relocated to the Gold Coast with Burnie teammate Maverick Weller to play for the Gold Coast in the VFL.

AFL career

He made his AFL debut against Melbourne at the Gabba in round 4 of the 2011 season. In his second game for the Gold Coast he would come on as a substitute and kick the winning goal in the club's first ever AFL victory. He was delisted at the conclusion of the 2016 season.[2]

Russell joined VFL side, Northern Blues, in November 2016.

Statistics
[3]
Legend
 G  Goals  B  Behinds  K  Kicks  H  Handballs  D  Disposals  M  Marks  T  Tackles
Season Team No. Games Totals Averages (per game)
G B K H D M T G B K H D M T
2011 Gold Coast 81159694911830270.50.86.34.510.72.72.5
2012 Gold Coast 814651328521766360.40.49.46.115.54.72.6
2013 Gold Coast 8186515311226574390.30.38.56.214.74.12.2
2014 Gold Coast 81364916015142270.50.37.04.611.63.22.1
2015 Gold Coast 814661057818342340.40.47.55.613.13.02.4
2016 Gold Coast 8302141933770.00.74.76.311.02.32.3
Career 73 29 31 564 403 967 261 170 0.4 0.4 7.7 5.5 13.2 3.6 2.3
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. Stubbs, Brett (18 April 2011), "Footy Confidential", Hobart Mercury
  2. Boswell, Tom (1 September 2016). "Gold Coast Suns delist four players from their list". Gold Coast Bulletin. News Corp Australia. Retrieved 1 September 2016.
  3. "Luke Russell stats". AFL Tables. Retrieved 8 November 2016.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.