My partner is non-binary, so this search wouldn’t work on them.

Short

That is also assuming the lights are not recessed into the ceiling.

And the even more egregious assumption that you could even reach the lightbulb.

Kernel level anticheat still can’t detect all possible cheats, like Neuromuscular Aim Assist.

May I recommend Japanese numbers, but ordered alphabetically by romaji?

I’m still disappointed that tags are absent from the mobile app.

I have used AI to give me the syntax and function names I need, then researched those functions and found better ones instead.

I once asked AI to show me how to do something and it gave me a 20 line script. After 2 hours working with it, I finally got it to work. Another 30 minutes of optimizing and got it down to 3 lines. A bit more research and I discovered that what I wanted was actually a language feature, and I just needed to call a single function with a single argument.

AI occasionally saves me time, and usually causes a significant time waste.

Is “main” a valid Java identifier?

package main;

public class main {

    static main main;
    String Main;

    main(String main) {
        Main = main;
    }

    main(main main) {
        System.out.println(main.Main);
    }

    main main(main main) {
        return new main(main);
    }

    public static void main(main...Main) {
        main:
        for (main main : Main) {
            main = (main instanceof Main) ? new main(main): main.main(main);
            break main;
        }
    }

    public static void main(String[] args) {
        main = new main("main");
        main.main(main, main);
        main = main.new Main(main) {
            main main(main main) {
                return ((Main)main).main();
            }
        };
        main.main(main);
        main.main(main,main);
    }

    abstract class Main extends main {
        Main(main main) {
            super("main");
        }

        main main() {
            main.Main = "Main";
            return main;
        }
    }
}

Hello World

It was the best option at the time, and I didn’t feel like setting up Windows more than once as I gradually added new software and removed other software.

That particular VM doesn’t get booted very often anymore.

I use it in a VM because it’s better than Windows 10, some programs refuse to run on Linux, and I don’t need to provide the VM with an internet connection.

My actual server is an old laptop and it does not run Windows.

Even my friend who insists that Windows is superior still uses Linux for his gaming server because it’s easier to set up and manage.

Promising a reward for making the deadline then deciding to move the release date is like promising a reward for anyone who can finish a race in under 10 minutes, then just deciding not to look at the stopwatch for 15 minutes even though people have already finished.

The devs have earned the reward you promised. You’re just refusing to look at the stopwatch so you can pretend they didn’t.

Or Malbolge

I decided to use NAND instead of NOR, but it’s effectively the same thing.

Scala:

//main
@main
def main(): Unit =
  var i = 15 //Choose any number here
  i = add(i, 1) //this increments i
  println(i)

//Adds 2 numbers in the most intuitive way
def add(a: Int, b: Int): Int =
  val pairs = split(a).zip(split(b))
  val sumCarry = pairs.scanLeft(false, false)((last, current) => fullAdder(current._1, current._2, last._2))
  return join(sumCarry.map(_._1).tail.reverse)

//Converts an integer to a list of booleans
def join(list: Seq[Boolean]): Int = BigInt(list.map(if (_) '1' else '0').mkString, 2).toInt

//Converts a list of booleans to an integer
def split(num: Int): Seq[Boolean] = num.toBinaryString.reverse.padTo(32, '0').map(_ == '1')

//Adds 2 booleans and a carry in, returns a sum and carry out
def fullAdder (a: Boolean, b: Boolean, c: Boolean): (Boolean, Boolean) =
  (NAND(NAND(NAND(NAND(a, NAND(a, b)), NAND(NAND(a, b), b)), NAND(NAND(NAND(a, NAND(a, b)), NAND(NAND(a, b), b)), c)), NAND(NAND(NAND(NAND(a, NAND(a, b)), NAND(NAND(a, b), b)), c), c)), NAND(NAND(NAND(NAND(a, NAND(a, b)), NAND(NAND(a, b), b)), c), NAND(a, b)))

//The basis for all operations
def NAND(a: Boolean, b: Boolean): Boolean = !a || !b

EDIT: replaced Integer.parseInt with BigInt(...).toInt to fix NumberFormatException with negative numbers.

try it online here

Xed

It opens quickly

A better comment would be delay in seconds as that is the one thing not obvious from glancing at the code.

Try Linux Mint with Cinnamon.

Cinnamon was built for Mint. The only time I’ve run Cinnamon on another distro, I encountered a bunch of confusing bugs.

At least this will tell you which bugs are caused by Cinnamon, and which are due to the integration with a custom distro.

It makes a pretty rainbow.

I agree with Steve, it is a good morning.