An Implementation of the One Billion Row Challenge in Ada

Boredom pours out of me.  I learned about this challenge, and decided to participate without reason:
https://www.morling.dev/blog/one-billion-row-challenge/

Compared to my Common Lisp implementation, this Ada is larger and less flexible, but that's only its
nature.  Unlike the Common Lisp, I was able to use a language-defined subprogram to read temperature
values very strictly as fixed-point types; it was worthwhile to use my Trivial_Trie library to store
the intermediate results over anything like a hash table; and the lack of fill-pointers bit me while
testing the code and forgetting to take a slice here and there.  The Ada's undoubtedly faster, and I
enjoyed having a Get_Line subprogram accepting an array to fill; Common Lisp's READ-SEQUENCE doesn't
support such usage.  Besides this, both programs are similar, and this Ada was less boring to write.

It occurred to me that it should be trivial to increase the speed of this program, whatever it's, by
using more vague types over those precise, but that largely defeats the purpose of using Ada at all.

I invite any interested reader to see how my program performs.

My first program used fixed-point arithmetic, but the challenge demands the rounding characteristics
of floating-point, so a simple adjustment was made.  That fixed-point program was noticeably faster.
.