How does async methods with for loops work in C#?

I have a code in C# like this:

FirstMethod();
Console.WriteLine("OK");
Console.ReadKey();

static async void FirstMethod()
{
    for(int i = 0; i < 10; i++)
        await FileLengthAwaiter(i);
}

static async Task FileLengthAwaiter(int i)
{
    Console.WriteLine($"start method {i}");
    await Task.Delay(1000);
    Console.WriteLine($"end method {i}");
}

When I run this code, in the first iteration of the for loop, when i equals to 0, by running the await statement, the method 'FirstMethod' will return and the "OK" will be printed by the Console statement.
But for the remained iterations of the for loop, when running the await statement, it returns the method 'FirstMethod', but it doesn't print the "OK".
Why does this happen? I expect the code to run the Consule statement and prints "OK" for each iteration of the for loop. But it doesn't happen.
Could anyone help me?
The output is like this:

start method 0
OK
end method 0
start method 1
end method 1
start method 2
end method 2
start method 3
end method 3
start method 4
end method 4
start method 5
end method 5
start method 6
end method 6
start method 7
end method 7
start method 8
end method 8
start method 9
end method 9

> FirstMethod();

This will run the code in the method until it gets to the first await, i.e. when it gets to Task.Delay(1000), so it will print "start method 0". Since FirstMethod() is not awaited, the main thread will then continue to run the rest of the code. I.e.

Console.WriteLine("OK");
Console.ReadKey();

The main thread will then get stuck inside ReadKey. After 1000ms has elapsed the Task.Delay will complete, and the execution will continue where it left of, on a thread pool thread, and print "end method 0". It will then continue until it gets to the next Task.Delay. At that point the threadpool thread will just be returned back to the pool until the task completes.

After the loop eventually completes nothing more will happen, and since FirstMethod() does not return any task there will be no way to check if the method actually reached the end of the loop or somehow failed. This is sometimes called "fire and forget", and should be avoided outside of button event handlers or similar.

Since the Console.WriteLine("OK") is not inside the loop it should not print more than once.

If you want to read more about how async await is implemented I would recommend reading Dissecting the async methods in C#