enum TypeGender {

  MaleOrFemale = "⚥",

  Male = "♂",

  Female = "♀",

  MaleAndFemale = "⚤"

}

interface TypeDecBin {

  Dec:number;

  Bin:string;  

};

interface TypeNorRev {

  Nor:TypeDecBin;

  Rev:TypeDecBin;  

};

interface TypeSexNorRev extends TypeNorRev{

  Sex:TypeGender;

};

interface TypePersonId {

  Sosa:{    

    Ego:TypeSexNorRev;

    Dad:TypeSexNorRev;

    Mom:TypeSexNorRev;

    Kid:TypeSexNorRev;

  };

  Gene:{

    Tier:TypeDecBin;

    Sosa:{

      Min:TypeDecBin;

      Max:TypeDecBin;

    };    

    Sort:[TypeNorRev,TypeNorRev];

  };

  Line:{

    Dad:{

      Gene:TypeDecBin;

      Tier:TypeDecBin;

      Name:TypeDecBin;

      Sort:TypeDecBin;

    };

    Mom:{

      Gene:TypeDecBin;

      Tier:TypeDecBin;

      Name:TypeDecBin;

      Sort:TypeDecBin;

    };

  };

}

function createIdInfoForPerson(sosa:number):TypePersonId{

  const SosaEgoGender  = sosa<2 ? TypeGender.MaleOrFemale : (sosa)%2==0 ? TypeGender.Male : TypeGender.Female;

  const SosaEgoNormal  = Base2AndBase10(sosa);

  const GeneTier       = Base2AndBase10(Math.floor(Math.log2(sosa))+1);

  const GeneSosaMin    = Base2AndBase10(Math.pow(2,Math.floor(Math.log2(sosa))));

  const GeneSosaMax    = Base2AndBase10(Math.pow(2,Math.floor(Math.log2(sosa))+1)-1);

  const SortNormal1    = Base2AndBase10(sosa+1-GeneSosaMin.Dec);

  const SortNormal0    = Base2AndBase10(SortNormal1.Dec-1);

  const SortRevers1    = Base2AndBase10(GeneSosaMax.Dec+1-sosa);

  const SortRevers0    = Base2AndBase10(SortRevers1.Dec-1);

  const SosaEgoRevers  = Base2AndBase10(GeneSosaMax.Dec-SortNormal0.Dec);

  const LineDadSort    = Base2AndBase10(SortNormal1.Dec==1?GeneTier.Dec:Base2EndZerosCount(SortNormal0.Bin)+1);

  const LineMomSort    = Base2AndBase10(SortRevers1.Dec==1?GeneTier.Dec:Base2EndZerosCount(SortRevers0.Bin)+1);

  const LineDadTier    = Base2AndBase10(Base2EndZerosClear(SosaEgoNormal.Bin));

  const LineMomTier    = Base2AndBase10(Base2EndZerosClear(SosaEgoRevers.Bin));

  const LineDadName    = Base2AndBase10(LineDadTier.Dec+1);

  const LineMomName    = Base2AndBase10(LineMomTier.Dec+2);

  const LineDadGene    = Base2AndBase10(LineDadTier.Bin.length);

  const LineMomGene    = Base2AndBase10(LineMomTier.Bin.length);

  const SosaDadGender  = TypeGender.Male;

  const SosaDadNormal  = Base2AndBase10(SosaEgoNormal.Dec*2);

  const SosaDadRevers  = Base2AndBase10(SosaEgoRevers.Dec*2+1);

  const SosaMomGender  = TypeGender.Female;

  const SosaMomNormal  = Base2AndBase10(SosaEgoNormal.Dec*2+1);

  const SosaMomRevers  = Base2AndBase10(SosaEgoRevers.Dec*2);

  const SosaKidGender  = Math.floor(sosa/2)<2 ? TypeGender.MaleOrFemale : Math.floor(sosa/2)%2==0 ? TypeGender.Male : TypeGender.Female;

  const SosaKidNormal  = Base2AndBase10(Math.floor(SosaEgoNormal.Dec/2));

  const SosaKidRevers  = Base2AndBase10(Math.floor(SosaEgoRevers.Dec/2));

  function Base2AndBase10(a:number):TypeDecBin {

    return { Dec: a, Bin: Number(a).toString(2) };

  }

  function Base2EndZerosCount(a:string):number{

    let r = 0;

    let t = true;

    const e = Array.from(a);

    let l = e.length;

    while (l>0 && t) {

      if (e[l-1]=="0") {

        r++

      } else {

        t = false;      

      }

      l--;    

    }

    return r;

  }

  function Base2EndZerosClear(a:string):number{

    const c = a.replace(/[0]+$/,"");

    const r = parseInt(c,2);

    return r;

  }

  return {

    Sosa:{

      Ego:{Sex: SosaEgoGender, Nor: SosaEgoNormal, Rev: SosaEgoRevers},

      Dad:{Sex: SosaDadGender, Nor: SosaDadNormal, Rev: SosaDadRevers},

      Mom:{Sex: SosaMomGender, Nor: SosaMomNormal, Rev: SosaMomRevers},

      Kid:{Sex: SosaKidGender, Nor: SosaKidNormal, Rev: SosaKidRevers}

    },

    Gene:{

      Tier:GeneTier,

      Sosa:{

        Min:GeneSosaMin,

        Max:GeneSosaMax

      },

      Sort:[{Nor:SortNormal0,Rev:SortRevers0},{Nor:SortNormal1,Rev:SortRevers1}]

    },

    Line:{

      Dad:{

        Gene:LineDadGene,

        Tier:LineDadTier,

        Name:LineDadName,

        Sort:LineDadSort

      },

      Mom:{

        Gene:LineMomGene,

        Tier:LineMomTier,

        Name:LineMomName,

        Sort:LineMomSort

      }

    }

  };

}

class SosaPlusDb{

  IdDb:Map<number,TypePersonId> = new Map;

  constructor(){}

  setFromGivenSosa(sosa:number){

    if(Number.isInteger(sosa) && sosa>0){

      this.IdDb.set(sosa,createIdInfoForPerson(sosa));

    }

  }

  setFromArraySosa(sosaArr:number[]){

    for (const sosa of sosaArr) {

      if(Number.isInteger(sosa) && sosa>0){

        this.IdDb.set(sosa,createIdInfoForPerson(sosa));

      }

    }

  }  

  setFromRangeSosa(sosaFirst:number,sosaLast:number){

    for (let sosa = sosaFirst; sosa < sosaLast+1; sosa++) {

      if(Number.isInteger(sosa) && sosa>0){

        this.IdDb.set(sosa,createIdInfoForPerson(sosa));

      }

    }

  }

  get getData():Map<number,TypePersonId>{

    return this.IdDb;

  }

  getOutFullAsJson():void{

    const iterator = this.IdDb[Symbol.iterator]();

    let Arr: TypePersonId[] = [];

    for (const x of iterator) {

      Arr.push(x[1]);

    }

    let Str = JSON.stringify(Arr);

    console.log(Str);

  }

  getOutFullAsCsv():void{

    const Col = ():string=>{

      return `"Gene.Tier.Dec", "Gene.Tier.Bin", `

            +`"Gene.Sosa.Min.Dec", "Gene.Sosa.Min.Bin", "Gene.Sosa.Max.Dec", "Gene.Sosa.Max.Bin", `

            +`"Gene.Sort.0.Nor.Dec", "Gene.Sort.0.Nor.Bin", "Gene.Sort.0.Rev.Dec", "Gene.Sort.0.Rev.Bin", `

            +`"Gene.Sort.1.Nor.Dec", "Gene.Sort.1.Nor.Bin", "Gene.Sort.1.Rev.Dec", "Gene.Sort.1.Rev.Bin", `

            +`"Sosa.Ego.Sex", "Sosa.Ego.Nor.Dec", "Sosa.Ego.Nor.Bin", "Sosa.Ego.Rev.Dec", "Sosa.Ego.Rev.Bin", `

            +`"Sosa.Dad.Sex", "Sosa.Dad.Nor.Dec", "Sosa.Dad.Nor.Bin", "Sosa.Dad.Rev.Dec", "Sosa.Dad.Rev.Bin", `

            +`"Sosa.Mom.Sex", "Sosa.Mom.Nor.Dec", "Sosa.Mom.Nor.Bin", "Sosa.Mom.Rev.Dec", "Sosa.Mom.Rev.Bin", `

            +`"Sosa.Kid.Sex", "Sosa.Kid.Nor.Dec", "Sosa.Kid.Nor.Bin", "Sosa.Kid.Rev.Dec", "Sosa.Kid.Rev.Bin", `

            +`"Line.Dad.Gene.Dec", "Line.Dad.Gene.Bin", "Line.Dad.Tier.Dec", "Line.Dad.Tier.Bin", `

            +`"Line.Dad.Name.Dec", "Line.Dad.Name.Bin", "Line.Dad.Sort.Dec", "Line.Dad.Sort.Bin", `

            +`"Line.Mom.Gene.Dec", "Line.Mom.Gene.Bin", "Line.Mom.Tier.Dec", "Line.Mom.Tier.Bin", `

            +`"Line.Mom.Name.Dec", "Line.Mom.Name.Bin", "Line.Mom.Sort.Dec", "Line.Mom.Sort.Bin" `

            +"\n";

    };

    const Row = (x:TypePersonId):string =>{

      return `"${x.Gene.Tier.Dec}", "${x.Gene.Tier.Bin}", `

            +`"${x.Gene.Sosa.Min.Dec}", "${x.Gene.Sosa.Min.Bin}", "${x.Gene.Sosa.Max.Dec}", "${x.Gene.Sosa.Max.Bin}", `

            +`"${x.Gene.Sort[0].Nor.Dec}", "${x.Gene.Sort[0].Nor.Bin}", "${x.Gene.Sort[0].Rev.Dec}", "${x.Gene.Sort[0].Rev.Bin}", `

            +`"${x.Gene.Sort[1].Nor.Dec}", "${x.Gene.Sort[1].Nor.Bin}", "${x.Gene.Sort[1].Rev.Dec}", "${x.Gene.Sort[1].Rev.Bin}", `

            +`"${x.Sosa.Ego.Sex}", "${x.Sosa.Ego.Nor.Dec}", "${x.Sosa.Ego.Nor.Bin}", "${x.Sosa.Ego.Rev.Dec}", "${x.Sosa.Ego.Rev.Bin}", `

            +`"${x.Sosa.Dad.Sex}", "${x.Sosa.Dad.Nor.Dec}", "${x.Sosa.Dad.Nor.Bin}", "${x.Sosa.Dad.Rev.Dec}", "${x.Sosa.Dad.Rev.Bin}", `

            +`"${x.Sosa.Mom.Sex}", "${x.Sosa.Mom.Nor.Dec}", "${x.Sosa.Mom.Nor.Bin}", "${x.Sosa.Mom.Rev.Dec}", "${x.Sosa.Mom.Rev.Bin}", `

            +`"${x.Sosa.Kid.Sex}", "${x.Sosa.Kid.Nor.Dec}", "${x.Sosa.Kid.Nor.Bin}", "${x.Sosa.Kid.Rev.Dec}", "${x.Sosa.Kid.Rev.Bin}", `

            +`"${x.Line.Dad.Gene.Dec}", "${x.Line.Dad.Gene.Bin}", "${x.Line.Dad.Tier.Dec}", "${x.Line.Dad.Tier.Bin}", `

            +`"${x.Line.Dad.Name.Dec}", "${x.Line.Dad.Name.Bin}", "${x.Line.Dad.Sort.Dec}", "${x.Line.Dad.Sort.Bin}", `

            +`"${x.Line.Mom.Gene.Dec}", "${x.Line.Mom.Gene.Bin}", "${x.Line.Mom.Tier.Dec}", "${x.Line.Mom.Tier.Bin}", `

            +`"${x.Line.Mom.Name.Dec}", "${x.Line.Mom.Name.Bin}", "${x.Line.Mom.Sort.Dec}", "${x.Line.Mom.Sort.Bin}" `

            +"\n";

    }

    let CSV:string = Col();

    const iterator = this.IdDb[Symbol.iterator]();

    for (const x of iterator) {

      CSV += Row(x[1]);

    }

    console.log(CSV);

  }

  getOutTiny():void{

    const iterator = this.IdDb[Symbol.iterator]();

    console.log(" ");

    console.log("               ╔"+"═".repeat(31)+"╗");

    console.log("               ║     INFO WITH FORMAT TINY     ║");

    console.log("╔═════════╦════╩═══╦═══════════╦═══════════╦═══╩══════╦══════════╦══════════╗");

    console.log("║ SEX+GEN ║  SOSA  ║  LINE-Y   ║  LINE-X   ║ SOSA-DAD ║ SOSA-MOM ║ SOSA-KID ║");

    for (const x of iterator) {

      console.log( `║  ${x[1].Sosa.Ego.Sex}  ${x[1].Gene.Tier.Dec} `.padEnd(10," ")

      +`║ ${x[1].Sosa.Ego.Nor.Dec}  `.padEnd(9," ")

      +`║ ${x[1].Line.Dad.Name.Dec} — ${x[1].Line.Dad.Sort.Dec} `.padEnd(12," ")

      +`║ ${x[1].Line.Mom.Name.Dec} — ${x[1].Line.Mom.Sort.Dec} `.padEnd(12," ")

      +`║ ${x[1].Sosa.Dad.Nor.Dec} `.padEnd(11," ")

      +`║ ${x[1].Sosa.Mom.Nor.Dec} `.padEnd(11," ")

      +`║ ${x[1].Sosa.Kid.Nor.Dec} `.padEnd(11," ")+"║");

    }    

    console.log("╚"+"═".repeat(9)+"╩"+"═".repeat(8)+"╩"+"═".repeat(11)+"╩"+"═".repeat(11)+"╩" +"═".repeat(10)+"╩"+"═".repeat(10)+"╩"+"═".repeat(10)+"╝");

  }

}

// ======example usage =====

const AAA = new SosaPlusDb();

AAA.setFromGivenSosa(44);

AAA.setFromArraySosa([153,1324,9848]);

AAA.setFromArraySosa([153,1324,15432]);

AAA.setFromRangeSosa(1,32);

AAA.getOutTiny();

AAA.getOutFullAsCsv();

AAA.getOutFullAsJson();

// ======example usage =====

use std::collections::HashMap;

use std::fmt;

#[derive(Debug)]

struct TypeMain {

    sosa: TypeSosa,

    gene: TypeGene,

    line: TypeLine,

}

#[derive(Debug)]

struct TypeSosa {

    ego: TypeSexNorRev,

    dad: TypeSexNorRev,

    mom: TypeSexNorRev,

    kid: TypeSexNorRev,

}

#[derive(Debug)]

struct TypeGene {

    tier: TypeDecBin,

    sosa: TypeMinMax,

    sort: [TypeNorRev; 2],

}

#[derive(Debug)]

struct TypeLine {

    dad: TypeLineInner,

    mom: TypeLineInner,

}

#[derive(Debug)]

struct TypeLineInner {

    gene: TypeDecBin,

    tier: TypeDecBin,

    name: TypeDecBin,

    sort: TypeDecBin,

}

#[derive(Debug)]

struct TypeSexNorRev {

    sex: String,

    nor: TypeDecBin,

    rev: TypeDecBin,

}

#[derive(Debug)]

struct TypeNorRev {

    nor: TypeDecBin,

    rev: TypeDecBin,

}

#[derive(Debug)]

struct TypeDecBin {

    dec: u32,

    bin: String,

}

#[derive(Debug)]

struct TypeMinMax {

    min: TypeDecBin,

    max: TypeDecBin,

}

#[derive(Debug)]

enum TypeGender {

    MaleOrFemale,

    Male,

    Female,

    MaleAndFemale,

}

fn create_id_info_for_person(sosa: u32) -> TypeMain {

    let sosa_ego_gender = if sosa <