GM

Good morning nostr

# GOOᗪ ᗯEEKEᑎᗪ ᑎOᔕTᖇ

Its not that I hadn't realized 🥭-man is an asshat. I just never expected the man to actually be retarded. News out if USA are just getting stranger and stranger by the day, and honestly, 3 more years of this shit will be very tough to go through. Let's just hope we're all even alive after 3 more years, with this guy fully willing to gamble world peace away, accompanied by lies and deceptuin, just to seem like he's a tough guy. You're a tough guy alright, don't have to prove it by destroying the world.

# Gₒₒd ₘₒᵣₙᵢₙg ₙₒₛₜᵣ ---

GM

```csharp // --------------------------------------------------------------- // Fast AES‑128 (single‑block) – stackalloc + unsafe // --------------------------------------------------------------- using System; using System.Runtime.CompilerServices; namespace FastAes { public static unsafe class Aes128Fast { // ----------------------------------------------------------------- // 1. Tables (S‑box and MixColumns multiplication tables) // ----------------------------------------------------------------- private static readonly byte[] sbox = new byte[256] { 0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76, 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0, 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15, 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75, 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84, 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf, 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8, 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2, 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73, 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb, 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79, 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08, 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a, 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e, 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf, 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16 }; // Multiplication by 2 and 3 in GF(2^8) – used by MixColumns. // Pre‑computing avoids the branch in the classic xtime(). private static readonly byte[] mul2 = new byte[256]; private static readonly byte[] mul3 = new byte[256]; // Round constants (Rcon) – only the first 10 are needed for AES‑128. private static readonly uint[] rcon = new uint[11] { 0x00000000, 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000 }; // ----------------------------------------------------------------- // 2. Static constructor – fill the multiplication tables once // ----------------------------------------------------------------- static Aes128Fast() { for (int i = 0; i < 256; i++) { int x = i << 1; if ((x & 0x100) != 0) x ^= 0x11B; // reduce modulo the AES polynomial mul2[i] = (byte)(x & 0xFF); mul3[i] = (byte)(mul2[i] ^ i); } } // ----------------------------------------------------------------- // 3. Public entry point – encrypt a single 16‑byte block // ----------------------------------------------------------------- /// <summary> /// Encrypts exactly one 16‑byte block. Caller must ensure /// input, output and key are all 16 bytes long. /// </summary> public static void EncryptBlock( byte* input, // pointer to 16‑byte plaintext byte* output, // pointer to 16‑byte ciphertext buffer byte* key) // pointer to 16‑byte key { // ------------------------------------------------------------- // 3.1 Expand the key (produces 11 round keys = 44 uints) // ------------------------------------------------------------- uint* roundKeys = stackalloc uint[44]; // 44 * 4 = 176 bytes on the stack KeyExpansion(key, roundKeys); // ------------------------------------------------------------- // 3.2 Load the state matrix (column‑major) into four uints // ------------------------------------------------------------- uint* state = stackalloc uint[4]; for (int c = 0; c < 4; c++) state[c] = *(uint*)(input + 4 * c); // little‑endian load matches BitConverter // ------------------------------------------------------------- // 3.3 Initial AddRoundKey (round 0) // ------------------------------------------------------------- for (int c = 0; c < 4; c++) state[c] ^= roundKeys[c]; // ------------------------------------------------------------- // 3.4 Main rounds 1 … 9 (full round) // ------------------------------------------------------------- for (int round = 1; round < 10; round++) { SubBytes(state); ShiftRows(state); MixColumns(state); for (int c = 0; c < 4; c++) state[c] ^= roundKeys[round * 4 + c]; } // ------------------------------------------------------------- // 3.5 Final round (no MixColumns) // ------------------------------------------------------------- SubBytes(state); ShiftRows(state); for (int c = 0; c < 4; c++) state[c] ^= roundKeys[40 + c]; // round 10 // ------------------------------------------------------------- // 3.6 Store ciphertext back to the output buffer // ------------------------------------------------------------- for (int c = 0; c < 4; c++) *(uint*)(output + 4 * c) = state[c]; } // ----------------------------------------------------------------- // 4. Key schedule (expands 16‑byte key to 44 uints) // ----------------------------------------------------------------- private static void KeyExpansion(byte* keyPtr, uint* w) { // Copy the original key (big‑endian per AES spec) for (int i = 0; i < 4; i++) w[i] = ((uint)keyPtr[4 * i] << 24) | ((uint)keyPtr[4 * i + 1] << 16) | ((uint)keyPtr[4 * i + 2] << 8) | ((uint)keyPtr[4 * i + 3]); for (int i = 4; i < 44; i++) { uint temp = w[i - 1]; if ((i & 3) == 0) // i % 4 == 0 { // RotWord temp = (temp << 8) | (temp >> 24); // SubWord temp = (uint)( sbox[(temp >> 24) & 0xFF] << 24 | sbox[(temp >> 16) & 0xFF] << 16 | sbox[(temp >> 8 ) & 0xFF] << 8 | sbox[(temp ) & 0xFF]); // Rcon temp ^= rcon[i / 4]; } w[i] = w[i - 4] ^ temp; } } // ----------------------------------------------------------------- // 5. Core AES transformations (operating on the 4‑column state) // ----------------------------------------------------------------- [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void SubBytes(uint* state) { for (int i = 0; i < 4; i++) { uint v = state[i]; state[i] = (uint)sbox[(v >> 24) & 0xFF] << 24 | (uint)sbox[(v >> 16) & 0xFF] << 16 | (uint)sbox[(v >> 8 ) & 0xFF] << 8 | (uint)sbox[(v ) & 0xFF]; } } // ShiftRows works on the logical 4×4 byte matrix. // Because our state is column‑major, we can implement it by // rotating the bytes inside each column appropriately. [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void ShiftRows(uint* state) { // Extract the four rows into separate byte variables. // We'll rebuild the columns after the rotations. byte b00 = (byte)(state[0] >> 24); byte b01 = (byte)(state[1] >> 24); byte b02 = (byte)(state[2] >> 24); byte b03 = (byte)(state[3] >> 24); byte b10 = (byte)(state[0] >> 16); byte b11 = (byte)(state[1] >> 16); byte b12 = (byte)(state[2] >> 16); byte b13 = (byte)(state[3] >> 16); byte b20 = (byte)(state[0] >> 8); byte b21 = (byte)(state[1] >> 8); byte b22 = (byte)(state[2] >> 8); byte b23 = (byte)(state[3] >> 8); byte b30 = (byte)(state[0]); byte b31 = (byte)(state[1]); byte b32 = (byte)(state[2]); byte b33 = (byte)(state[3]); // Row 0 stays unchanged. // Row 1 rotates left by 1. byte t10 = b11, t11 = b12, t12 = b13, t13 = b10; // Row 2 rotates left by 2. byte t20 = b22, t21 = b23, t22 = b20, t23 = b21; // Row 3 rotates left by 3 (or right by 1). byte t30 = b33, t31 = b30, t32 = b31, t33 = b32; // Re‑pack columns. state[0] = (uint)(b00 << 24 | t10 << 16 | t20 << 8 | t30); state[1] = (uint)(b01 << 24 | t11 << 16 | t21 << 8 | t31); state[2] = (uint)(b02 << 24 | t12 << 16 | t22 << 8 | t32); state[3] = (uint)(b03 << 24 | t13 << 16 | t23 << 8 | t33); } // MixColumns uses the pre‑computed mul2/mul3 tables. [MethodImpl(MethodImplOptions.AggressiveInlining)] private static void MixColumns(uint* state) { for (int c = 0; c < 4; c++) { uint col = state[c]; byte a0 = (byte)(col >> 24); byte a1 = (byte)(col >> 16); byte a2 = (byte)(col >> 8); byte a3 = (byte)(col); // The AES mix‑column matrix: // [02 03 01 01] // [01 02 03 01] // [01 01 02 03] // [03 01 01 02] byte r0 = (byte)(mul2[a0] ^ mul3[a1] ^ a2 ^ a3); byte r1 = (byte)(a0 ^ mul2[a1] ^ mul3[a2] ^ a3); byte r2 = (byte)(a0 ^ a1 ^ mul2[a2] ^ mul3[a3]); byte r3 = (byte)(mul3[a0] ^ a1 ^ a2 ^ mul2[a3]); state[c] = (uint)(r0 << 24 | r1 << 16 | r2 << 8 | r3); } } } } ```

Goooood morning nostr ☀️

## “Politics is the gentle art of getting votes from the poor and campaign funds from the rich, by promising to protect each from the other. The hell with the left and the right. Stop dividing the people 💜” ### — Ryan Cohen, CEO of Gamestop Corporation

# GM ⢰⣶⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀ ⠀⣿⣿⣿⣷⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣶⣾⣿ ⠀⠘⢿⣿⣿⣿⣿⣦⣀⣀⣀⣄⣀⣀⣠⣀⣤⣶⣿⣿⣿⣿⣿⠇ ⠀⠀⠈⠻⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⠀ ⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⠋⠀⠀⠀ ⠀⠀⠀⢠⣿⣿⡏⠆⢹⣿⣿⣿⣿⣿⣿⠒⠈⣿⣿⣿⣇⠀⠀⠀ ⠀⠀⠀⣼⣿⣿⣷⣶⣿⣿⣛⣻⣿⣿⣿⣶⣾⣿⣿⣿⣿⡀⠀⠀ ⠀⠀⠀⡁⠀⠈⣿⣿⣿⣿⢟⣛⡻⣿⣿⣿⣟⠀⠀⠈⣿⡇⠀⠀ ⠀⠀⠀⢿⣶⣿⣿⣿⣿⣿⡻⣿⡿⣿⣿⣿⣿⣶⣶⣾⣿⣿⠀⠀ ⠀⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀ ⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀

The goofballs on Wall St. have done it again. WordSpeed, an American chip manufacturer, has been shorted so much that MORE than the entire float has been sold before being bought (i.e. sold short). For those that remember, in 2021 the major financial institutions made the exact same mistake: they sold more shares than existed. When regular people realized that this implies fraudulent activities, such as naked short selling, where a market actor sells shares without borrowing them first, and consequently were at the mercy of actual shareholders being willing to trade the stock below these institutions' entries, they simply decided to stop selling any shares back to the crooks in suits. Instead, they started hoarding these shares, because they knew the short sellers would have to close their positions eventually or risk getting margin called. This resulted in an explosive move to the upside, with GameStop shares increasing by more than 11000% within a period of just six months. It is still trading more than 350% above the price before the explosive move in question. I wonder what might happen if investors in this particular American chip manufacturer did the same now... Would one see a similar situation play out, or have the bad actors found ways to avoid repeating their old mistakes (well, obviously, they've done the same old unethical thing, but can they now avoid a sneeze?) This is, of course, not financial advice, since I am just some random pleb with no education in financing. You should probably not make financial decisions based on what random people on the internet post. That includes me.

Sickening beyond belief!! Former member of Danish social democratic party receives pension meant for early retirement of those who cannot work, which in itself is absolutely absurd, considering the reason is he has been convicted of possession of terabytes of child pornography. The fact that he's receiving any pension at all is completely fucked up. But it gets worse. He's paid WAY MORE than any regular citizen would be paid in case they were unable to work. He should have any rights to anything revoked permanently and work for free for the rest of his life, scrubbing the toilets of the prison where he will spend the rest of his days behind bars. View quoted note →