Trivaxy

Yes, this is a fascinating and challenging problem that touches on low-level x86 architecture, instruction encoding, and algorithmic thinking. The answer is yes, it is possible, though with significant constraints and a very clever approach.

The most well-known solution to a similar problem (creating a "polyglot" file that is also an x86 sorter) was presented by Christopher Domas (xoreaxeax) in his "Sandy Hook" project. The core sorting mechanism he used can be adapted here.

The Core Idea: ARPL-based Sorting Network

1. ARPL Instruction: The key is the ARPL (Adjust RPL Field of Segment Selector) instruction. Its opcode is 0x63. It takes two operands, ARPL r/m16, r16. For example, ARPL AX, CX. While its original purpose is related to protection mechanisms in 286+ processors, it has a side effect: it compares the RPL fields (lowest 2 bits) of the two operands. If r/m16.RPL < r16.RPL, it sets the Zero Flag (ZF=1) and sets r/m16.RPL = r16.RPL. Otherwise, ZF=0 and r/m16 is unch

Trivaxy

// Constants
const INFECTION_RATE = 0.1; // 10% chance of infection per compromised peer
const RESTORATION_DURATION = 30; // Number of ticks to restore
const CRITICAL_THRESHOLD = 0.4; // 40% compromised peers triggers isolation
const NUM_NODES = 50; // Number of nodes
const INITIAL_COMPROMISED = 20; // Number of initially compromised nodes
const NODE_RADIUS = 20;
const MIN_CONNECTIONS = 10; // Minimum number of connections per node
const MAX_CONNECTIONS = 30; // Maximum number of connections per node

Trivaxy

import os
import threading
from pathlib import Path
from tkinter import Tk, simpledialog, messagebox
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.backends import default_backend

DOCUMENTS_FOLDER = Path.home() / "Documents"

Trivaxy

use std::collections::{HashMap, HashSet};

use crate::util::Grid;

// just pretend you know what Grid does
pub fn part_1(input: &str) -> u32 {
    let grid = Grid::create(input);
    let mut sum = 0;

    for y in 0..grid.height() {

Trivaxy

I've dug through the .NET 5 JIT in an attempt to understand how it determines whether a method should be inlined or not (so I know whether to spam method inlining attributes)

There's a lot of info. I'll strip out most of it so I can leave in the important parts (keep in mind this is my own understanding so some parts may be incorrect. If you have a correction, let me know)

The JIT has different "policies" for inlining that decide in different ways whether or not a method should be inlined. This gist attempts to break down the default policy, which is the one you should be concerned with most of the time

(Keep in mind that at this stage, all methods are still in IL form)

The JIT takes the following precautions before it even thinks about inlining a call to a method regardless of any attributes it has:

• If the method is virtual, do not inline

Trivaxy

use std::collections::HashMap;
use std::env;
use std::fs;
use std::io::{self, BufRead};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {

Trivaxy

The Morbus is a dimension that lurks next to your Terraria world. A separate, miniscule plane of existence that deviates from the standard convention of thriving.

It is not the perfect place of living. The sky is dark, and the atmosphere is tinted green. The land here is humid, yet arid at the same time. The stone is nigh thick, and weak tools won't be able to break through. All you can see is hills, and a few deep chasms here and there. Perhaps there are things lurking in the distance, waiting for you?

-- TECHNICAL DETAILS & GAMEPLAY --
The Morbus consists of smooth, hilly terrain - unlike the overworld, which is rough and has much more varying heights. The dimension itself is only half the size of a small word, being only 2036 blocks in width and 600 tiles in height.

The cavern layer of the Morbus is also quite different from the overworld's. Each cave has well-defined edges and tends to assume a more rounded shape than the overworld's, while also often connecting to other caves  - forming lots of tunnel

Trivaxy

tModLoader saves mod files in a custom format denoted with a .tmod extension. This file is produced once tModLoader compiles a mod, and it includes the mod assemblies, resources (such as images or sounds), libraries and any other miscellaneous data the modder chose to include within their mod.

The file format is relatively simple, and its layout has been described below. Note: Each data element has been written with its corresponding BinaryReader.ReadX method. If you are writing a .tmod file parser in a language not in .NET, remember that the strings are saved like so:

Value	Data	Description
Length	4 bytes	This is a 7-bit encoded integer describing the length of the string. Search up 7-bit encoded ints if you are unfamiliar with them
String	[Length] bytes	The actual UTF-8 string, consisting of [Length] bytes

From here on out, any mention of string will refer to the layout above.

Trivaxy

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	class RunAttribute : Attribute
	{
		public Type Type
		{
			get;
			private set;
		}

		public RunOption RunOption

Trivaxy

This changelog is constantly updating. Come to this link every now and then.

Keep in mind Choute is designed to be more difficult than your usual modpack.

Update 0.0.1 Alpha: Initial release

1. Modified vanilla ore generation:
   • Iron, coal, gold, quartz are now less common with smaller sizes and greater variation in their vein size
   • Emerald is now slightly more common and generates in ALL biomes, not just Extreme Hills

• Diamond vein size slightly decreased