rulesAssistantOptions.tw

			this.appendChild(new TonguePiercingList());
			this.appendChild(new ClitPiercingList());
			this.appendChild(new LabiaPiercingList());
			this.appendChild(new ShaftPiercingList());
			this.appendChild(new PerineumPiercingList());
			this.appendChild(new CorsetPiercingList());

			this.appendChild(new AutoBrandingList());
			this.appendChild(new BrandingLocationList());
			this.appendChild(new BrandDesignList());

			this.appendChild(new FaceTattooList());
			this.appendChild(new ShoulderTattooList());
			this.appendChild(new ChestTattooList());
			this.appendChild(new ArmTattooList());
			this.appendChild(new UpperBackTattooList());
			this.appendChild(new LowerBackTattooList());
			this.appendChild(new AbdomenTattooList());
			if (V.seeDicks || V.makeDicks)
				this.appendChild(new DickTattooList());
			this.appendChild(new ButtockTattooList());
			this.appendChild(new AnalTattooList());
			this.appendChild(new LegTattooList());
		}
	}

	class AutosurgerySection extends Section {
		constructor() {
			super("Autosurgery Settings", true);
			this.appendChild(new VisionSurgeryList());
			this.appendChild(new LactationSurgeryList());
			if (V.seeDicks || V.makeDicks) {
				this.appendChild(new SemenSurgeryList());
				this.appendChild(new VasectomyList());
			}
			this.appendChild(new CosmeticSurgeryList());
			this.appendChild(new LipSurgeryList());
			this.appendChild(new ButtSurgeryList());
			this.appendChild(new BreastSurgeryList());
			this.appendChild(new TighteningSurgeryList());
			this.appendChild(new BodyHairSurgeryList());
			this.appendChild(new HairSurgeryList());
			if (V.bellyImplants > 0)
				this.appendChild(new BellyImplantList());
		}
	}

	class ClothesList extends List {
		constructor() {
			const items = [
				["Select her own outfit", "choosing her own clothes"]
			];
			super("Clothes", items);

			const nclothes = [
				["No default clothes setting", "no default setting"],
				["Apron", "an apron"],
				["Bangles", "slutty jewelry"],
				["Bodysuit", "a comfortable bodysuit"],
				["Cheerleader outfit", "a cheerleader outfit"],
				["Clubslut netting", "clubslut netting"],
				["Cybersuit", "a cybersuit"],
				["Cutoffs and a t-shirt", "cutoffs and a t-shirt"],
				["Fallen nun", "a fallen nuns habit"],
				["Halter top", "a halter top dress"],
				["Hijab and abaya", "a hijab and abaya"],
				["Latex catsuit", "a latex catsuit"],
				["Leotard", "a leotard"],
				["Long Qipao", "a long qipao"],
				["Lederhosen", "lederhosen"],
				["Battlearmor", "battlearmor"],
				["Mounty outfit", "a mounty outfit"],
				["Dirndl", "a dirndl"],
				["Biyelgee costume", "a biyelgee costume"],
				["Maid (nice)", "a nice maid outfit"],
				["Maid (slutty)", "a slutty maid outfit"],
				["Military uniform", "a military uniform"],
				["Schutzstaffel uniform", "a schutzstaffel uniform"],
				["Schutzstaffel uniform (slutty)", "a slutty schutzstaffel uniform"],
				["Red Army uniform", "a red army uniform"],
				["Mini dress", "a mini dress"],
				["Monokini", "a monokini"],
				["Nice lingerie", "attractive lingerie"],
				["Nurse (nice)", "a nice nurse outfit"],
				["Schoolgirl", "a schoolgirl outfit"],
				["Silken ballgown", "a ball gown"],
				["Skimpy battledress", "battledress"],
				["Slave gown", "a slave gown"],
				["Slutty outfit", "a slutty outfit"],
				["String bikini", "a string bikini"],
				["Scalemail bikini", "a scalemail bikini"],
				["Succubus costume", "a succubus outfit"],
				["Suit (nice)", "nice business sattire"],
				["Suit (slutty", "slutty business attire"],
				["Spats and tank top", "spats and a tank top"]
			];
			const fsnclothes = [
				["Body oil (FS)", "body oil"],
				["Bunny outfit (FS)", "a bunny outfit"],
				["Chattel habit (FS)", "a chattel habit"],
				["Conservative clothing (FS)", "conservative clothing"],
				["Harem gauze (FS)", "harem gauze"],
				["Huipil (FS)", "a huipil"],
				["Kimono (FS)", "a kimono"],
				["Maternity dress (FS)", "a maternity dress"],
				["Maternity lingerie (FS)", "attractive lingerie for a pregnant woman"],
				["Slutty qipao (FS)", "a slutty qipao"],
				["Stretch pants and a crop-top (FS)", "stretch pants and a crop-top"],
				["Toga (FS)", "a toga"],
				["Western clothing (FS)", "Western clothing"],
			];
			fsnclothes.forEach(pair => { if (isItemAccessible(pair[1])) nclothes.push(pair); });
			const nice = new ListSubSection(this, "Nice", nclothes);
			this.appendChild(nice);

			const hclothes = [
				["Nude", "no clothing"],
				["Penitent nun", "a penitent nuns habit"],
				["Restrictive latex", "restrictive latex"],
				["Shibari ropes", "shibari ropes"],
				["Uncomfortable straps", "uncomfortable straps"]
			];
			const fshclothes = [
				["Chains (FS)", "chains"],
			];
			fshclothes.forEach(pair => { if (isItemAccessible(pair[1])) hclothes.push(pair); });

			const harsh = new ListSubSection(this, "Harsh", hclothes);
			this.appendChild(harsh);

			this.setValue(current_rule.set.clothes);
			this.onchange = (value) => current_rule.set.clothes = value;
		}
	}

	class CollarList extends List {
		constructor() {
			const items = [
				["No default collar setting", "no default setting"],
				["No collar", "none"],
			];
			super("Collar", items);

			const ncollars = [
				["Stylish leather", "stylish leather"],
				["Satin choker", "satin choker"],
				["Silken Ribbon", "silk ribbon"],
				["Heavy Gold", "heavy gold"],
				["Pretty jewelry", "pretty jewelry"],
				["Cowbell", "leather with cowbell"]
			];
			if (V.seeAge !== 0)
				ncollars.push(["Nice retirement counter", "nice retirement counter"]);
			const fsncollars = [
				["Bowtie collar", "bowtie"],
				["ancient Egyptian", "ancient Egyptian"],
			];
			fsncollars.forEach(pair => { if (isItemAccessible(pair[1])) ncollars.push(pair); });
			const nice = new ListSubSection(this, "Nice", ncollars);
			this.appendChild(nice);

			const hcollars = [];
			setup.harshCollars.forEach(item => {
				if (item.fs === "seeage" && V.seeAge === 0) return;
				else if (item.rs === "buyGag" && V.toysBoughtGags !== 1) return;
				else hcollars.push([item.name, item.value]);
			});
			const harsh = new ListSubSection(this, "Harsh", hcollars);
			this.appendChild(harsh);

			this.setValue(current_rule.set.collar);
			this.onchange = (value) => current_rule.set.collar = value;
		}
	}

	class ShoeList extends List {
		constructor() {
			super("Shoes", setup.shoes.map(i => [i.name, i.value]));
			this.setValue(current_rule.set.shoes);
			this.onchange = (value) => current_rule.set.shoes = value;
		}
	}

	class CorsetList extends List {
		constructor() {
			const bellies = [];
			setup.bellyAccessories.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					bellies.push([acc.name, acc.value]);
				else if (acc.fs === "repopulation" && V.arcologies[0].FSRepopulationFocus !== "unset")
					bellies.push([acc.name + " (FS)", acc.value]);
				else if (acc.rs === "boughtBelly" && V.clothesBoughtBelly === 1)
					bellies.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Corsetage", bellies);
			this.setValue(current_rule.set.bellyAccessory);
			this.onchange = (value) => current_rule.set.bellyAccessory = value;
		}
	}

	class LeggingsList extends List {
		constructor() {
			const items = [
				["no default settings"],
				["none"],
				["short stockings"],
				["long stockings"],
			];
			super("Leg accessory", items);
			this.setValue(current_rule.set.legAccessory);
			this.onchange = (value) => current_rule.set.legAccessory = value;
		}
	}

	class VagAccVirginsList extends List {
		constructor() {
			const accs = [];
			setup.vaginalAccessories.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					accs.push([acc.name, acc.value]);
				else if (acc.rs === "buyBigDildos" && V.toysBoughtDildos === 1)
					accs.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Vaginal accessories for virgins", accs);
			this.setValue(current_rule.set.virginAccessory);
			this.onchange = (value) => current_rule.set.virginAccessory = value;
		}
	}

	class VagAccAVirginsList extends List {
		constructor() {
			const accs = [];
			setup.vaginalAccessories.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					accs.push([acc.name, acc.value]);
				else if (acc.rs === "buyBigDildos" && V.toysBoughtDildos === 1)
					accs.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Vaginal accessories for anal virgins", accs);
			this.setValue(current_rule.set.aVirginAccessory);
			this.onchange = (value) => current_rule.set.aVirginAccessory = value;
		}
	}

	class VagAccOtherList extends List {
		constructor() {
			const accs = [];
			setup.vaginalAccessories.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					accs.push([acc.name, acc.value]);
				else if (acc.rs === "buyBigDildos" && V.toysBoughtDildos === 1)
					accs.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Vaginal accessories for other slaves", accs);
			this.setValue(current_rule.set.vaginalAccessory);
			this.onchange = (value) => current_rule.set.vaginalAccessory = value;
		}
	}

	class DickAccVirginsList extends List {
		constructor() {
			super("Dick accessories for anal virgins", setup.dickAccessories.map(i => [i.name, i.value]));
			this.setValue(current_rule.set.aVirginDickAccessory);
			this.onchange = (value) => current_rule.set.aVirginDickAccessory = value;
		}
	}

	class DickAccOtherList extends List {
		constructor() {
			super("Dick accessories for other slaves", setup.dickAccessories.map(i => [i.name, i.value]));
			this.setValue(current_rule.set.dickAccessory);
			this.onchange = (value) => current_rule.set.dickAccessory = value;
		}
	}

	class ButtplugsVirginsList extends List {
		constructor() {
			const accs = [];
			setup.buttplugs.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					accs.push([acc.name, acc.value]);
				else if (acc.rs === "buyBigPlugs" && V.toysBoughtButtPlugs === 1)
					accs.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Buttplugs for anal virgins", accs);
			this.setValue(current_rule.set.aVirginButtplug);
			this.onchange = (value) => current_rule.set.aVirginButtplug = value;
		}
	}

	class ButtplugsOtherList extends List {
		constructor() {
			const accs = [];
			setup.buttplugs.forEach(acc => {
				if (acc.fs === undefined && acc.rs === undefined)
					accs.push([acc.name, acc.value]);
				else if (acc.rs === "buyBigPlugs" && V.toysBoughtButtPlugs === 1)
					accs.push([acc.name + " (Purchased)", acc.value]);
			});
			super("Buttplugs for other slaves", accs);
			this.setValue(current_rule.set.buttplug);
			this.onchange = (value) => current_rule.set.buttplug = value;
		}
	}

	class ImplantVolumeList extends List {
		constructor() {
			const pairs = [
				["No changes", -1],
				["Empty implant", 0],
				["Early pregnancy", 1500],
				["Second trimester pregnancy", 5000],
				["Full-term pregnancy", 15000],
				["Full-term with twins", 30000],
				["Full-term with triplets", 45000],
				["Full-term with quadruplets", 60000],
				["Full-term with quintuplets", 75000],
				["Full-term with sextuplets", 90000],
				["Full-term with septuplets", 105000],
				["Full-term with octuplets", 120000]
			];
			super("Belly implant target volume (if present)", pairs);
			this.setValue(current_rule.set.bellyImplantVol);
			this.onchange = (value) => current_rule.set.bellyImplantVol = value;
		}
	}

	class AutosurgerySwitch extends List {
		constructor() {
			const pairs = [
				["Activate", 1],
				["Off", 0],
			];
			super("Assistant-applied implants (Autosurgery global switch)", pairs);
			this.setValue(current_rule.set.autoSurgery);
			this.onchange = (value) => current_rule.set.autoSurgery = value;
		}
	}

	class GrowthList extends Options {
		constructor() {
			super();
			this.sublists = [];
			const pairs = [
				["No default setting", () => this.nds()],
				["Girlish figure", () => this.girlish()],
				["Stacked figure", () => this.stacked()],
				["Huge but functional", () => this.huge()],
				["Unlimited", () => this.unlimited()],
				["None", () => this.none()]
			];
			pairs.forEach(pair => this.appendChild(new OptionsItem(...pair)));

			this.breasts = new BreastGrowthList();
			this.butts = new ButtGrowthList();
			this.lips = new LipGrowthList();
			this.sublists.push(this.breasts, this.butts, this.lips);

			if (V.seeDicks > 0 || V.makeDicks > 0) {
				this.dicks = new DickGrowthList();
				this.balls = new BallGrowthList();
				this.sublists.push(this.dicks, this.balls);
			}

			this.sublists.forEach(i => this.appendChild(i));
		}

		render() {
			const elem = document.createElement("div");
			const span = document.createElement("span");
			span.innerHTML = "Growth hormone regimes for healthy slaves: ";
			elem.appendChild(span);
			return elem;
		}

		nds() {
			[this.breasts, this.butts, this.lips, this.dicks, this.balls].forEach(i => {
				i.setValue("no default change");
				i.propagateChange();
			});
		}

		girlish() {
			this.breasts.setValue(350);
			this.butts.setValue(2);
			this.lips.setValue(25);
			if (this.dicks) this.dicks.setValue(0);
			if (this.balls) this.balls.setValue(0);
			this.sublists.forEach(i => i.propagateChange());
		}

		stacked() {
			this.breasts.setValue(1000);
			this.butts.setValue(4);
			this.lips.setValue(25);
			if (this.dicks) this.dicks.setValue(4);
			if (this.balls) this.balls.setValue(4);
			this.sublists.forEach(i => i.propagateChange());
		}

		huge() {
			this.breasts.setValue(9000);
			this.butts.setValue(10);
			this.lips.setValue(45);
			if (this.dicks) this.dicks.setValue(6);
			if (this.balls) this.balls.setValue(6);
			this.sublists.forEach(i => i.propagateChange());
		}

		unlimited() {
			this.breasts.setValue(48000);
			this.butts.setValue(20);
			this.lips.setValue(100);
			if (this.dicks) this.dicks.setValue(30);
			if (this.balls) this.balls.setValue(125);
			this.sublists.forEach(i => i.propagateChange());
		}

		none() {
			this.sublists.forEach(i => {
				i.setValue(0);
				i.propagateChange();
			});
		}
	}

	class BreastGrowthList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["B Cup", 350],
				["D Cup", 1000],
				["Monstrous", 9000],
				["Unlimited", 48000],
				["None", 0]
			];
			super("Breasts", pairs, true);
			this.setValue(current_rule.set.growth_boobs);
			this.onchange = (value) => current_rule.set.growth_boobs = value;
		}
	}

	class ButtGrowthList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Cute", 2],
				["Big", 4],
				["Huge", 6],
				["Unlimited", 20],
				["None", 0]
			];
			super("Butts", pairs, true);
			this.setValue(current_rule.set.growth_butt);
			this.onchange = (value) => current_rule.set.growth_butt = value;
		}
	}

	class LipGrowthList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Plump", 25],
				["Beestung", 45],
				["Facepussy", 100],
				["None", 0]
			];
			super("Lips", pairs, true);
			this.setValue(current_rule.set.growth_lips);
			this.onchange = (value) => current_rule.set.growth_lips = value;
		}
	}

	class DickGrowthList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Above average", 4],
				["Pornstar", 6],
				["Unlimited", 30],
				["None", 0]
			];
			super("Dicks, if present", pairs, true);
			this.setValue(current_rule.set.growth_dick);
			this.onchange = (value) => current_rule.set.growth_dick = value;
		}
	}

	class BallGrowthList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Sizeable", 4],
				["Cumslave", 6],
				["Unlimited", 125],
				["None", 0]
			];
			super("Balls, if present", pairs, true);
			this.setValue(current_rule.set.growth_balls);
			this.onchange = (value) => current_rule.set.growth_balls = value;
		}
	}

	class CurrativesList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["None", 0],
				["Preventatives", 1],
				["Curatives", 2],
			];
			super("Health drugs", pairs);
			this.setValue(current_rule.set.curatives);
			this.onchange = (value) => current_rule.set.curatives = value;
		}
	}

	class AphrodisiacList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["None", 0],
				["Standard", 1],
				["Extreme", 2],
				["Anaphrodisiacs", -1]
			];
			super("Aphrodisiacs", pairs);
			this.setValue(current_rule.set.aphrodisiacs);
			this.onchange = (value) => current_rule.set.aphrodisiacs = value;
		}
	}

	class ContraceptiveList extends List {
		constructor() {
			const drugs =  [
				["No default setting", "no default setting"],
				["Contraceptives", true],
				["Fertile", false],
			];
			super("Contraceptives for fertile slaves", drugs);
			this.setValue(current_rule.set.preg);
			this.onchange = (value) => current_rule.set.preg = value;
		}
	}

	class PregDrugsList extends List {
		constructor() {
			const pairs = [
				["No changes", "no default setting"],
				["None", "none"],
				["Fast gestation", "fast"],
				["Slow gestation", "slow"],
				["Birth supressors", "suppress"],
				["Birth stimulators", "stimulate"]
			];
			super("Pregnancy control agents for pregnant slaves", pairs);
			this.setValue(current_rule.set.pregSpeed);
			this.onchange = (value) => current_rule.set.pregSpeed = value;
		}
	}

	class FemaleHormonesList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Intensive Female", 2],
				["Female", 1],
				["None", 0],
				["Male", -1],
				["Intensive Male", -2]
			];
			super("Hormones for female slaves", pairs);
			this.setValue(current_rule.set.XX);
			this.onchange = (value) => current_rule.set.XX = value;
		}
	}

	class GeldingHormonesList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Intensive Female", 2],
				["Female", 1],
				["None", 0],
				["Male", -1],
				["Intensive Male", -2]
			];
			super("Hormones for geldings", pairs);
			this.setValue(current_rule.set.gelding);
			this.onchange = (value) => current_rule.set.gelding = value;
		}
	}

	class ShemaleHormonesList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Intensive Female", 2],
				["Female", 1],
				["None", 0],
				["Male", -1],
				["Intensive Male", -2]
			];
			super("Hormones for shemales", pairs);
			this.setValue(current_rule.set.XY);
			this.onchange = (value) => current_rule.set.XY = value;
		}
	}

	class OtherDrugsList extends List {
		constructor() {
			const drugs = [
				["No default setting", "no default setting"],
				["None", "none"],
				["Fertility drugs", "fertility drugs"],
				["Psychosuppressants", "psychosuppressants"],
				["Steroids", "steroids"],
				["Natural hormone enhancers", "hormone enhancers"],
				["Hormone blockers", "hormone blockers"],
				["breast injections"],
				["intensive breast injections"],
				["butt injections"],
				["intensive butt injections"],
				["lip injections"],
				["penis enhancement"],
				["intensive penis enhancement"],
				["testicle enhancement"],
				["intensive testicle enhancement"],
			];

			if (V.growthStim === 1)
				drugs.push(["Growth Stimulants (Research)", "growth stimulants"]);
			if (V.precociousPuberty === 1 && V.pubertyHormones) {
				drugs.push(["Female hormone injections (Research)", "female hormone injections"]);
				drugs.push(["Male hormone injections (Research)", "male hormone injections"]);
			}
			if (V.purchasedSagBGone === 1)
				drugs.push(["Sag-B-gone (Product)", "sag-B-gone"]);
			if (V.arcologies[0].FSSlimnessEnthusiastResearch === 1) {
				drugs.push(["Weight loss pills (FS)", "appetite suppressors"]);
				drugs.push(["breast redistributors"]);
				drugs.push(["butt redistributors"]);
				drugs.push(["lip atrophiers"]);
				drugs.push(["penis atrophiers"]);
				drugs.push(["testicle atrophiers"]);
			}
			if (V.arcologies[0].FSAssetExpansionistResearch === 1) {
				drugs.push(["hyper breast injections"]);
				drugs.push(["hyper butt injections"]);
				drugs.push(["hyper penis enhancement"]);
				drugs.push(["hyper testicle enhancement"]);
			}
			if (V.arcologies[0].FSYouthPreferentialistResearch === 1)
				drugs.push(["Anti-aging cream (FS)", "anti-aging cream"]);
			if (V.seeHyperPreg === 1 && V.superFertilityDrugs === 1)
				drugs.push(["Super fertility drugs", "super fertility drugs"]);
			super("Other drugs", drugs);
			this.setValue(current_rule.set.drug);
			this.onchange = (value) => current_rule.set.drug = value;
		}
	}

	class DietList extends List {
		constructor() {
			const diets = [
				["no default setting", "no default setting"],
				["Healthy diet", "healthy"],
				["Fix fat and skinny slaves", "attractive"],
				["Curvy", 30],
				["Average",  0],
				["Thin", -30]
			];
			if (V.feeder === 1) {
				diets.push(
					["Feminine", "XX"],
					["Masculine", "XY"]
				);
				if (V.dietXXY === 1)
					diets.push(["Futanari", "XXY"]);
			}
			if (V.dietCleanse === 1)
				diets.push(["Cleansing", "cleansing"]);
			if (V.dietFertility === 1)
				diets.push(["Fertility", "fertility"]);
			if (V.cumProDiet === 1)
				diets.push(["Cum production", "cum production"]);

			super("Slave diets", diets, true);
			this.setValue(current_rule.set.diet);
			this.onchange = (value) => current_rule.set.diet = value;
		}
	}

	class DietGrowthList extends List {
		constructor() {
			const pairs = [
				["On", 1],
				["Off", 0]
			];
			super("Diet support for growth drugs", pairs);
			this.setValue(current_rule.set.dietGrowthSupport);
			this.onchange = (value) => current_rule.set.dietGrowthSupport = value;
		}
	}

	class DietBaseList extends List {
		constructor() {
			// TODO: better data structure?
			const pairs = [
				["No default setting", {cum: "no default setting", milk: "no default setting"}],
				["Normal Diet", {cum: 0, milk: 0}],
				["Cum Added", {cum: 1, milk: 0}],
				["Milk Added", {cum: 0, milk: 1}],
				["Cum & Milk Added", {cum: 1, milk: 1}],
				["Cum-Based", {cum: 2, milk: 0}],
				["Milk-Based", {cum: 0, milk: 2}],
			];
			super("Diet base", pairs);
			this.setValue(this.value2string(current_rule.set.dietCum, current_rule.set.dietMilk));
			this.onchange = (value) => {
				current_rule.set.dietCum = value.cum;
				current_rule.set.dietMilk = value.milk;
			};
		}

		value2string(cum, milk) {
			return `cum: ${cum}, milk: ${milk}`;
		}

		setValue(what) {
			what = this.value2string(what.cum, what.milk);
			super.setValue(what);
		}

	}

	class MuscleList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["None", 0],
				["Toned", 20],
				["Ripped", 50],
				["Massive", 100],
				["Weak", -20]
			];
			super("Muscles", pairs, true);
			this.setValue(current_rule.set.muscles);
			this.onchange = (value) => current_rule.set.muscles = value;
		}
	}

	class BraceList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["None", "none"],
				["Straighten", "straighten"],
				["Universal", "universal"]
			];
			super("Braces", pairs);
			this.setValue(current_rule.set.teeth);
			this.onchange = (value) => current_rule.set.teeth = value;
		}
	}

	class LivingStandardList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Luxurious", "luxurious"],
				["Normal", "normal"],
				["Spare", "spare"]
			];
			super("Living standard", pairs);
			this.setValue(current_rule.set.livingRules);
			this.onchange = (value) => current_rule.set.livingRules = value;
		}
	}

	class PunishmentList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Confinement", "confinement"],
				["Whipping", "whipping"],
				["Chastity", "chastity"],
				["Situational", "situational"]
			];
			super("Typical punishment", pairs);
			this.setValue(current_rule.set.standardPunishment);
			this.onchange = (value) => current_rule.set.standardPunishment = value;
		}
	}

	class RewardList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Relaxation", "relaxation"],
				["Drugs", "drugs"],
				["Orgasm", "orgasm"],
				["Situational", "situational"]
			];
			super("Typical reward", pairs);
			this.setValue(current_rule.set.standardReward);
			this.onchange = (value) => current_rule.set.standardReward = value;
		}
	}

	class ReleaseList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Permissive", "permissive"],
				["Sapphic", "sapphic"],
				["Masturbation", "masturbation"],
				["Restrictive", "restrictive"]
			];
			super("Release rules", pairs);
			this.setValue(current_rule.set.releaseRules);
			this.onchange = (value) => current_rule.set.releaseRules = value;
		}
	}

	class SmartFetishList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Vanilla", "vanilla"],
				["Oral", "oral"],
				["Anal", "anal"],
				["Boobs", "boobs"],
				["Sub", "submissive"],
				["Dom", "dom"],
				["Humiliation", "humiliation"],
				["Preg", "pregnancy"],
				["Pain", "masochist"],
				["Sadism", "sadist"]
			];
			super("Smart piercing fetish target", pairs);
			this.setValue(current_rule.set.clitSetting);
			this.onchange = (value) => current_rule.set.clitSetting = value;
		}
	}

	class SmartXYAttractionList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Passionate", 100],
				["Attracted", 75],
				["Indifferent", 45],
				["None", 0]
			];
			super("Smart piercing XY attraction target", pairs);
			this.setValue(current_rule.set.clitSettingXY);
			this.onchange = (value) => current_rule.set.clitSettingXY = value;
		}
	}

	class SmartXXAttractionList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Passionate", 100],
				["Attracted", 75],
				["Indifferent", 45],
				["None", 0]
			];
			super("Smart piercing XX attraction target", pairs);
			this.setValue(current_rule.set.clitSettingXX);
			this.onchange = (value) => current_rule.set.clitSettingXX = value;
		}
	}

	class SmartEnergyList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Nympho", 100],
				["Sex Addict", 85],
				["Powerful", 65],
				["Healthy", 45],
				["Weak", 25],
				["Frigid", 0]
			];
			super("Smart piercing sex drive target", pairs);
			this.setValue(current_rule.set.clitSettingEnergy);
			this.onchange = (value) => current_rule.set.clitSettingEnergy = value;
		}
	}

	class SpeechList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["Permissive", "permissive"],
				["Suppress accents", "accent elimination"],
				["Restrictive", "restrictive"]
			];
			super("Speech rules", pairs);
			this.setValue(current_rule.set.speechRules);
			this.onchange = (value) => current_rule.set.speechRules = value;
		}
	}

	class RelationshipList extends List {
		constructor() {
			const pairs =[
				["No default setting", "no default setting"],
				["Permissive", "permissive"],
				["Just friends", "just friends"],
				["Restrictive", "restrictive"]
			];
			super("Relationship rules", pairs);
			this.setValue(current_rule.set.relationshipRules);
			this.onchange = (value) => current_rule.set.relationshipRules = value;
		}
	}

	class PornList extends List {
		constructor() {
			const pairs = [
				["No default setting", "no default setting"],
				["No broadcasting", -1],
				["No subsidy", 0],
				["1000", 1000],
				["2000", 2000],
				["3000", 3000],
				["4000", 4000],
				["5000", 5000]
			];
			super("Weekly porn publicity subsidy", pairs);
			this.setValue(current_rule.set.pornFameSpending);
			this.onchange = (value) => current_rule.set.pornFameSpending = value;
		}
	}

	class EyewearList extends List {
		constructor() {
			const pairs = [
				["no default setting"],
				["correct with glasses"],
				["correct with contacts"],
				["universal glasses"],
				["blur with glasses"],
				["blur with contacts"]
			];
			super("Eyewear", pairs);
			this.setValue(current_rule.set.eyewear);
			this.onchange = (value) => current_rule.set.eyewear = value;
		}
	}

	class LensesList extends Element {
		constructor() {
			super(current_rule.set.eyeColor);
			this.appendChild(new OptionsItem("No default Setting", () => this.setValue("no default setting")));
			this.colourlist = new LensesColourList();
			this.shapelist = new LensesShapeList();
			this.appendChild(this.colourlist);
			this.appendChild(this.shapelist);
		}

		render(color) {
			const elem = document.createElement("div");
			elem.innerHTML = "Eye coloring: ";
			this.label = document.createElement("strong");
			this.label.innerText = color;
			elem.appendChild(this.label);
			return elem;
		}

		combine() {
			const lst = [];
			if (this.colourlist.value !== "no default setting")
				lst.push(this.colourlist.value);
			if (this.shapelist.value !== "no default setting")
				lst.push(this.shapelist.value);
			if (lst.length === 0) return "no default value";
			else return lst.join(" ");
		}

		setValue(val) {
			if (val === undefined) val = this.combine();
			this.label.innerText = val;
			current_rule.set.eyeColor = val;
		}
	}

	class LensesColourList extends Options {
		constructor() {
			const items = [];
			[
				"no default setting",
				"blue",
				"black",
				"brown",
				"green",