Sure it looks quite messy. The : {"0":24, "1":74, "2":5, "8":5} is a Dictionary<string,int>, using the object style serialization to ensure uniqueness of the keys.

Solution 1: Custom converter

You can solve it by using your custom converter. at each element of the main array :
JsonToken.Null, StartObject,StartArray.
You can choose the right deserialization and populate your main list with the selected elements.

In the following example I choosed List<List>> for ease of use. online demo

public class FireBaseResult
{
    public static List<FireBaseResultElement> FromJson(string json) => JsonConvert.DeserializeObject<List<FireBaseResultElement>>(json, Converter.Settings);
}

public partial struct FireBaseResultElement
{
    public long?[] InnerArray;
    public static implicit operator FireBaseResultElement(long?[]  Items) => new FireBaseResultElement{InnerArray = Items};
}

internal static class Converter
{
    public static readonly JsonSerializerSettings Settings =
        new JsonSerializerSettings{MetadataPropertyHandling = MetadataPropertyHandling.Ignore, DateParseHandling = DateParseHandling.None, 
                                    Converters = {new FireBaseResultElementConverter(), new IsoDateTimeConverter{DateTimeStyles = DateTimeStyles.AssumeUniversal}}, };
    
    
}

internal class FireBaseResultElementConverter : JsonConverter
{
    public override bool CanConvert(Type t) => t == typeof(FireBaseResultElement) || t == typeof(FireBaseResultElement? );
    public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
    {
        switch (reader.TokenType)
        {
            case JsonToken.Null:
                return new FireBaseResultElement{};
            case JsonToken.StartObject:
                var objectValue = serializer.Deserialize<Dictionary<string, long?>>(reader);
                return new FireBaseResultElement{InnerArray=objectValue.Values.ToArray()};
            case JsonToken.StartArray:
                var arrayValue = serializer.Deserialize<long?[]>(reader);
                return new FireBaseResultElement{InnerArray=arrayValue};
        }

        throw new Exception("Cannot unmarshal type FireBaseResultElement");
    }

    public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
    {
        throw new Exception("Cannot marshal type FireBaseResultElement");
    }
}

I need to wrap the InnerArray into a class or a struct in order to reference a custom converter on it.

Solution 2: Direct parsing with Newtonsoft.Json.Linq.

Using Newtonsoft.Json.Linq, you can directly parse the Json using the same technique.

List<List<int?>> result = new List<List<int?>>();
JArray o = JArray.Parse(jsonInput);

foreach (JToken item in o)
{
    switch (item.Type)
    {
        case JTokenType.Null:
            result.Add(null); // r.Add(new list<int>);
            break;
        case JTokenType.Object:
            var objectValue = item.ToObject<Dictionary<string, int?>>();
            result.Add(objectValue.Values.ToList());
            break;

        case JTokenType.Array:
            var arrayValue = item.ToObject<List<int?>>();
            result.Add(arrayValue);
            break;

        default:
            throw new Exception("Cannot unmarshal type FireBaseResultElement, unexpected JToken.Type");
            break;
    }

}
Console.WriteLine(new String('#', 9));
foreach (List<int?> row in result)
{
    IEnumerable<string> vals = row?.Select(x => x == null ? "null" : x.ToString()) ?? new[] { "null" };
    Console.WriteLine(String.Join(", ", vals));
}