RheumatoidArthritis

You should be good with just a VPN. Tor over VPN (not the other alway round!) makes sense if you want to hide your use of Tor from whoever is watching, and especially if you use Tor Browser for something you want to hide, the timing of when you open and close Tor Browser could be correlated with the thing you're doing. Overkill for just watching videos in privacy.

Yeah, I had inverter feed cable just like the one in front of that board almost catch fire. The smell of melting insulation saved the day.

Oh if she's that inquisitive I wouldn't risk it. Or keep notes, but that kind of defeats the purpose of getting away with made-up dishes.

Welcome to the school system

https://stackoverflow.com/questions/3263036/file-system-that-uses-tags-rather-than-folders#3263550 but I remember reading elsewhere about actual file systems done this way, not overlays above hierarchical ones

I think this all has been tried and didn't get traction. Although it has been before everyone had devices that hide the filesystem from you.

I'm guessing made up names didn't work? Like Whispering Orchard Risotto when you dumped whatever felt tasty

Ooh so these doughs that never got the right consistency no matter how long i worked on them could be just bad flour, huh

I understand how good tomatos are better than bad ones, but how is good flour better? It's a question I'm not saying it isn't

Where do you buy your E-321 butylated hydroxytoluene?

/s

Good idea actually!

Well it's a program that turns a huge array of bytes into a directory tree by allocating some of these bytes for data structures holding directory structure, metadata etc. The simplest to understand example would be FAT16 or floppy formats from 80s home computers. These had a lot of shortcomings, which were solved by more and more complex data structures.

You can write a Python script that reads /dev/sda byte by byte and displays the directory tree. That would be a simple file system driver.

We rarely cook together, but when we do, one person does prep and the other cooks, like in a professional kitchen. Eliminates a lot of tension.

Yeah that's for online payments. Cash stands strong where I live but they're working on it, many chain stores have plenty of card-only self-checkout machines and a single cash register with a long queue.

EU is outlawing non-KYC methods of payment in 2027. It will be a crime to accept an anonymous/gift visa card. They're not issued in the EU for many years now, but now accepting foreign ones will be outlawed too.

I don't recall anonymous PO boxes or bank accounts ever existing here. At least parcel locker pickup still works without KYC, but the media is already preparing ground with stories about drugs and terrorism.

It was so widespread that around 2004-2005 you could buy dvd players that supported avi/mp4 files with external subtitles. They don't create products like that for niche markets.

It can not, at least here in the EU the governments are actively fighting the ability to make a purchase without leaving your full personal data set. KYC-free businesses exist but are increasingly regulated to be full-KYC.

Strong Amiga coding vibes.

1440 multiplications per second on my computer!

I didn't have the patience to do it myself bit wanted to see just how complex it would get:

fp32_mul() {
    local a=$1 b=$2
    local sa=$(( (a >> 31) & 1 ))
    local sb=$(( (b >> 31) & 1 ))
    local sign=$((sa ^ sb))

    local ea=$(( (a >> 23) & 0xff ))
    local eb=$(( (b >> 23) & 0xff ))
    local fa=$(( a & 0x7fffff ))
    local fb=$(( b & 0x7fffff ))

    # NaN / infinity / zero handling
    if (( ea == 255 )); then
        if (( fa != 0 )); then
            printf '%08x\n' $((0x7fc00000))
            return
        fi
        if (( eb == 0 && fb == 0 )); then
            printf '%08x\n' $((0x7fc00000))   # inf * 0 = NaN
            return
        fi
        printf '%08x\n' $(((sign << 31) | 0x7f800000))
        return
    fi

    if (( eb == 255 )); then
        if (( fb != 0 )); then
            printf '%08x\n' $((0x7fc00000))
            return
        fi
        if (( ea == 0 && fa == 0 )); then
            printf '%08x\n' $((0x7fc00000))
            return
        fi
        printf '%08x\n' $(((sign << 31) | 0x7f800000))
        return
    fi

    if (( ea == 0 && fa == 0 || eb == 0 && fb == 0 )); then
        printf '%08x\n' $((sign << 31))
        return
    fi

    # Convert subnormals to a normalized significand/exponent.
    # m is a 24-bit significand for normals.
    local ma mb
    if (( ea == 0 )); then
        ma=$fa
        ea=1
        while (( (ma & 0x800000) == 0 )); do
            ma=$((ma << 1))
            ((ea--))
        done
    else
        ma=$((fa | 0x800000))
    fi

    if (( eb == 0 )); then
        mb=$fb
        eb=1
        while (( (mb & 0x800000) == 0 )); do
            mb=$((mb << 1))
            ((eb--))
        done
    else
        mb=$((fb | 0x800000))
    fi

    # Multiply the two 24-bit significands.
    # Product is up to 48 bits.
    local p=$((ma * mb))
    local e=$((ea + eb - 127))

    # Normalize product.
    #
    # ma*mb has binary point after bit 46.  If bit 47 is set,
    # product is [2,4), otherwise [1,2).
    local shift
    if (( p & 0x800000000000 )); then
        shift=24
        ((e++))
    else
        shift=23
    fi

    # Extract 23 fraction bits plus guard/round/sticky information.
    local frac=$(( (p >> shift) & 0x7fffff ))
    local guard=$(( (p >> (shift - 1)) & 1 ))
    local round=$(( (p >> (shift - 2)) & 1 ))
    local sticky=0

    if (( shift >= 3 )); then
        local mask=$(( (1 << (shift - 2)) - 1 ))
        (( (p & mask) != 0 )) && sticky=1
    fi

    # Round-to-nearest, ties-to-even.
    if (( guard && (round || sticky || (frac & 1)) )); then
        ((frac++))
        if (( frac == 0x800000 )); then
            frac=0
            ((e++))
        fi
    fi

    # Overflow -> infinity.
    if (( e >= 255 )); then
        printf '%08x\n' $(((sign << 31) | 0x7f800000))
        return
    fi

    # Normal result.
    if (( e > 0 )); then
        printf '%08x\n' $(((sign << 31) | (e << 23) | frac))
        return
    fi

    # Underflow into the subnormal range.
    #
    # At this point the normalized significand represented by
    # (1.frac) must be shifted right by 1-e positions.
    local mant=$((0x800000 | frac))
    local rshift=$((1 - e))
    local lost=0
    local halfway=0
    local low=0

    if (( rshift >= 25 )); then
        # Everything rounds to zero (unless the exact value is
        # sufficiently close, which it cannot be here).
        mant=0
    else
        low=$((mant & ((1 << rshift) - 1)))
        mant=$((mant >> rshift))

        halfway=$((1 << (rshift - 1)))

        if (( low > halfway || (low == halfway && (mant & 1)) )); then
            ((mant++))
        fi
    fi

    # Rounding a subnormal can produce the smallest normal.
    if (( mant >= 0x800000 )); then
        printf '%08x\n' $(((sign << 31) | (1 << 23)))
    else
        printf '%08x\n' $(((sign << 31) | mant))
    fi
}