Syntactically valid C# program based on the the Lemon Demon song "Redesign your Logo"

Redesign your C# Logo - Lemon Demon.cs

using System;
using System.Collections.Generic;
using static System.Diagnostics.Debug;

public static class Program
{
    private enum Demographic
    {
        Men18To30,
        CollegeEducatedWomenOver40,
        SuicidalPoets,
        FatMidwesternFathers,
        KidsWithDiabetes,
        PentecostalPreachers,
        MothersUnder20,
        InterracialCouples,
        AtheistProfessors,
        GovernmentEmployees,
        XenophobesAndRacists,
        PrivateAviators
    }

    static object FindTheAngle(object? startingWith, params object?[] args) => new();

    static void Give(object? to, object? what)
    {
    }

    static void Main()
    {
        #region Init
        bool geomagnetism = true;
        Crucial gravity = new(), dna = new();
        We us = new();
        Logo yourLogo = new();
        ref Logo it = ref yourLogo;

        object?
            theEssence = new(),
            theFuture = new(),
            theCalculations = new(),
            innovation = new(),
            convention = new(),
            @this,
            yourRevolution = new(),
            allYourMoney = new(),
            language,
            recognition = new(),
            country,
            corporateColors = new();

        Genome humanGenome = new();
        Design conflict = new(true);

        #endregion Init

        Redesign(yourLogo);
        Assert(We.KnowWhatWereDoing);
        Assert(We.AreHereToHelpYou);
        Assert(Everything.IsConnected);
        Assert(Time.IsOf(theEssence));
        Assert(We.LiveIn(theFuture));
        Assert(Color.MakesUsHungry);
        Assert(Everything.IsConnected);

        Redesign(yourLogo);
        Assert(We.KnowHowToDo(it));
        var calculations = Make(theCalculations);
        var action = calculations;
        var angle = FindTheAngle(
            startingWith: convention);
        OnTo(innovation!);
        Assert(Everything.IsConnected);

        var circle = new Circle()
        {
            Smooth = true,
            Innoffensive = true
        };
        @this = new Basis()
        {
            For = yourRevolution
        };

        Assert(gravity.IsCrucial);
        Assert(geomagnetism);
        yourLogo = yourLogo with { What = "some calculation", Found = true };

        Assert(dna.IsCrucial);
        Assert(We.MustUnderstand(dna));
        humanGenome.Find(yourLogo);
        Everyone.WillSee(it);
        List<Demographic> everyDemographic;
        if (They.FailToSee(it))
        {
            Assert(!They.AreHuman);
        }

        everyDemographic = new()
        {
            Demographic.Men18To30,
            Demographic.CollegeEducatedWomenOver40,
            Demographic.SuicidalPoets,
            Demographic.FatMidwesternFathers,
            Demographic.KidsWithDiabetes,
            Demographic.PentecostalPreachers,
            Demographic.MothersUnder20,
            Demographic.InterracialCouples,
            Demographic.AtheistProfessors,
            Demographic.GovernmentEmployees,
            Demographic.XenophobesAndRacists,
            Demographic.PrivateAviators
        };
        Everyone.WillSee(it, everyDemographic!);

        Think(about: it, thisWay: () => "guided evolution");
        @this = new Breed()
        {
            CuttingEdge = true,
            Classic = true,
            FullyComplimentary = true,
            Bold = true,
            SelfSufficient = true,
            Symbolizing = new string[] { "freedom", "your product" }
        };

        yourLogo.Finish();
        var peopleInstantlyEnlighted = it.Unveil();
        Assert(7_000_000_000 == peopleInstantlyEnlighted!);
        Assert(Everyone.IsRebranded);
        Assert(AllTheFighting.IsOver);
        Say("goodbye", to: conflict);
        Assert(conflict.IsRejected);

        language = null;
        Assert(recognition is not null);
        country = null;
        Assert(corporateColors is not null);
        Assert(Color.MakesUsHungry);
        Assert(Hunger.MakesUsHuman);
        Assert(Everyone.CanSee(it));
        Assert(Everything.IsConnected);

        Redesign(yourLogo);
        Give(us, allYourMoney);
        Redesign(yourLogo);
        Give(us, allYourMoney);
        Redesign(yourLogo);
        Give(us, allYourMoney);
        Redesign(yourLogo);
        Give(us, allYourMoney);
    }

    static object Make(params object?[] args) => new();

    static void OnTo(params object?[] args)
    {
    }

    static void Redesign(params object?[] args)
    {
    }

    static void Say(string what, object? to)
    {
    }

    static void Think(object? about, Func<object?> thisWay)
    {
    }

    static class AllTheFighting
    {
        public static bool IsOver => true;
    }

    static class Color
    {
        public static bool MakesUsHungry => true;
    }

    static class Everyone
    {
        public static bool IsRebranded => true;

        public static bool CanSee(params object?[] args) => true;

        public static void WillSee(params object?[] args)
        {
        }
    }

    static class Everything
    {
        public static bool IsConnected => true;
    }

    static class Hunger
    {
        public static bool MakesUsHuman => true;
    }

    static class They
    {
        public static bool AreHuman => false;

        public static bool FailToSee(object? startingWith, params object?[] args) => true;
    }

    static class Time
    {
        public static bool IsOf(params object?[] args) => true;
    }

    class Basis
    {
        public object? For { get; init; }
    }

    private class Breed
    {
        public bool Bold { get; init; }
        public bool Classic { get; init; }
        public bool CuttingEdge { get; init; }
        public bool FullyComplimentary { get; init; }
        public bool SelfSufficient { get; init; }
        public IEnumerable<string> Symbolizing { get; init; }
    }

    class Circle
    {
        public bool Innoffensive { get; init; }
        public bool Smooth { get; init; }
    }

    class Crucial
    {
        public bool IsCrucial => true;
    }

    class Genome
    {
        public void Find(params object?[] args)
        {
        }
    }

    class We
    {
        public static bool AreHereToHelpYou => true;
        public static bool KnowWhatWereDoing => true;

        public static bool KnowHowToDo(params object?[] args) => true;

        public static bool LiveIn(params object?[] args) => true;

        public static bool MustUnderstand(params object?[] args) => true;
    }

    record Logo
    {
        public long Unveil() => 7_000_000_000;
        public void Finish() { }
        public object? What { get; set; }
        public bool Found { get; set; }
    }
    sealed record Design(bool IsRejected);
}