using System;

using System.Reflection.Emit;

using System.Runtime.CompilerServices;

using System.Threading.Tasks;

​

#nullable disable

​

Console.WriteLine("Hello");

​

class @record { }

class where { }

class String {

    public static implicit operator String(dynamic var) => null;

}

​

class dynamic { }

public class var { 

​

    dynamic dynamic => null;

    void record(where String = null, int y = default)

    {

        String s = this.dynamic;

    }    

    async Task<int> M() {

        var v = new();

        await v.async(new async());

        return 0;

    }

    async async async(async async) => 

        await async;

}

​

// Do you C what I'm doing here?

class C{ }

​

​

class await : INotifyCompletion {

    public bool IsCompleted => true;

    public void GetResult() { }

    public void OnCompleted(Action continuation) { }

}

​

[AsyncMethodBuilder(typeof(builder))]

class async { 

    public await GetAwaiter() => throw null;

}

​

class builder

{

    public builder() { }

    public static builder Create() => new();

    public void SetResult() { }

    public void SetException(Exception e) { }

    public void Start<TStateMachine>(ref TStateMachine stateMachine)

        where TStateMachine : IAsyncStateMachine => throw null;

    public async Task => null;

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(

        ref TAwaiter awaiter, ref TStateMachine stateMachine)

        where TAwaiter : INotifyCompletion

        where TStateMachine : IAsyncStateMachine => throw null;

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(

        ref TAwaiter awaiter, ref TStateMachine stateMachine)

        where TAwaiter : ICriticalNotifyCompletion

        where TStateMachine : IAsyncStateMachine => throw null;

    public void SetStateMachine(IAsyncStateMachine stateMachine) => throw null;

}

​