Anna’s archive, known for “open-sourced” books. They scraped spotify recently.

Your link gives the exact years (1859 & 1862) for 2 definitions, without a single citation.

It’s just basic statistics. Let’s say that 1 in 100 (murders are rare, as people usually don’t like killing) people kills someone, for one reason or another, like self-defense, money, revenge, war, paranoia, a quest, removing witnesses, minor annoyance or just general other+offence. Then, there are about 10-ish billiard bouillon bi-something people. Now, multiply the sample size by the probability and you get 10,00,00000,0000 deaths. That’s more than the population of a small country!

Does Chinese only have the one 1st person pronoun?

Disclaimer: I’m learning Japanese & I don’t know Chinese.

It looks like the original character for the 3rf person pronoun is now the masculine pronoun & the female pronoun is made by substituting the person component (人, I don’t know how to type the left-component form) with the woman component (女).

Communism was previously provided by Marxism-Leninism, but it has been mostly unmaintained for a while, and was thus dropped from the latest Debian. Try the more actively developed Maoism fork.

You got the kernel from Debian’s official (read: central) repo, didn’t you? The decentralized mirrors exist for a reason, bootlicker!

my new laptop literally is more than double in each spec

13.6"

Where did you find a laptop with a 27.2" or larger screen?

I don’t know what I was thinking.

But, if you borrow C’s semantics, you are allowed to “optimize” away side-effect-less loops, even if they would never terminate. But that would require the random method to be pure.

The compiler should be able to optimize all of them to the same machine code.

1. This is already good.
2. Easily optimized by constant folding.
3. This one depends on the semantics of signed underflow, so it may not do what you want.
4. The loop can only exit if x==10, so as long as the nextInt() method doesn’t have side effects, the loop should be eliminated. But, again, language semantics can affect this.

I’m not Swiss, but I’ve understood that Switzerland adopts many EU laws, but not all of them. I’ve also heard that a right-wing party, which wants the country to be more independent from the EU is pretty popular there.

As this is just based on things that I’ve heard, I don’t have any sources to link.

What I mean is, Switzerland is an European country, but as I’ve understood, any specific EU law or regulation may or may not apply.

In your guide, Proton’s services have the EU flag, but the company is Swiss.

Their vision is based on movement, stay perfectly still.

You’re thinking of a different kind of predator. I don’t think that would work against sexual predators.

Unlike Windows, on Linux you need to run ./<command> instead of just <command> for executables in you current directory.

Just remember that it’s never too late to start drawing. ;)

recommended my

I don’t know how bad it is, but you should get better the more you practice.

Lemmy is written in Rust.

As the label states, the map is old. NATO has more members now, with at least Finland & Sweden joining since then.

The article requires logging in to read.

Archived version: https://archive.is/oQ8lm

After a quick look, looks like it tries to split the (unencrypted) hostname into multiple packets, or at least scramble it slightly. I’m not sure how much it helps in practice, but it might help against naïve filtering/scanning, as the hostname is either sent in different packets, or split and sent unordered in the same packet. It probably only helps if encrypted client hello isn’t supported.

TL;DR: If I’ve understood everything correctly, it just moves chunks of the plaintext hostname around & tries to split it into multiple packets.

Note: Mostly based on comments, as it’s late & I’m too tired to parse too much cryptography code.

Full source of the limit_chunks function, formatted with Rustfmt:

const fn limit_chunks<'a>(
    left: (u64, &'a [u8]),
    right: (u64, &'a [u8]),
    limit: usize,
) -> ((u64, &'a [u8]), (u64, &'a [u8])) {
    let (left_offset, mut left) = left;
    let (mut right_offset, mut right) = right;
    if left.len() + right.len() <= limit {
        // Nothing to do. Both chunks will fit into one packet, meaning the SNI isn't spread
        // over multiple packets. But at least it's in two unordered CRYPTO frames.
    } else if left.len() <= limit {
        // `left` is short enough to fit into this packet. So send from the *end*
        // of `right`, so that the second half of the SNI is in another packet.
        let right_len = right.len() + left.len() - limit;
        right_offset += right_len as u64;
        (_, right) = right.split_at(right_len);
    } else if right.len() <= limit {
        // `right` is short enough to fit into this packet. So only send a part of `left`.
        // The SNI begins at the end of `left`, so send the beginnig of it in this packet.
        (left, _) = left.split_at(limit - right.len());
    } else {
        // Both chunks are too long to fit into one packet. Just send a part of each.
        (left, _) = left.split_at(limit / 2);
        (right, _) = right.split_at(limit / 2);
    }
    ((left_offset, left), (right_offset, right))
}

Same, but for write_chunk:

fn write_chunk<B: Buffer>(
    offset: u64,
    data: &[u8],
    builder: &mut packet::Builder<B>,
) -> Option<(u64, usize)> {
    let mut header_len = 1 + Encoder::varint_len(offset) + 1;

    // Don't bother if there isn't room for the header and some data.
    if builder.remaining() < header_len + 1 {
        return None;
    }
    // Calculate length of data based on the minimum of:
    // - available data
    // - remaining space, less the header, which counts only one byte for the length at
    //   first to avoid underestimating length
    let length = min(data.len(), builder.remaining() - header_len);
    header_len += Encoder::varint_len(u64::try_from(length).expect("usize fits in u64")) - 1;
    let length = min(data.len(), builder.remaining() - header_len);

    builder.encode_varint(FrameType::Crypto);
    builder.encode_varint(offset);
    builder.encode_vvec(&data[..length]);
    Some((offset, length))
}

Link to the MIT license file