I have a 64-bit gender

My gender is

{ toString: ()=>{String.prototype.toString = ()=>">:3"; return ":3";} }

A boolean, so 8 bits of freedom to fill up

That's why you use bitarrays and bitflags instead when you need more than just one or two arguments for a function.

That's only due to technical reasons on weird platforms like x86, 64bit x86 or ARM.

Solution: 1 bit computer

I guess in theory as there will only ever be a finite number of individuals, there will also necessarily only ever be a finite number of different gender expressions, so finite discrete probably works. (Not to say that peoples experiences of gender are fixed and equidistant, but more so that you could have a "gender enum" with an entry for each individual)

Of course, trying to say how many bits this would require is almost impossible because theres always going to be more people and more genders, but it is technically finite.

In any case, bagsies on (leading zeros)100101001

import isFemale

def isMale(Person):
     if isFemale(Person):
          return False
     else:
          return True

Gender is a struct

struct Gender {
  byte binaryBias;    ///Determines male (+) or female (-) bias if present
  ubyte binaryAm;    ///Determines the amount of binary gender(s) present
  bool isTrans;    ///True if assigned at birth gender does not equal with current one
  ubyte xenoAm;    ///Determines the amount of xenogender
  uint xenoGen;    ///Xenogender selection, 0 if not applicable
  Sex* sex;    ///Pointer to the person's current sex
}