I won't mind handling the tilemapper since it is pretty difficult to understand unless you write it yourself (sorry).

Also, I have nothing to contest

Nice game, but it takes a long time to lose And I wish the current score was floating around somewhere >.>

Since the title of the thread is "patching the OS," I am assuming you actually want to modify the OS itself instead of simply using what the OS has to offer. In that, thepenguin77 is pretty knowledgeable. Really, it would most likely amount to toggling a handful of bits in the OS (bits, not even whole bytes would need to be edited). I haven't dabbled in that yet, but to expand a little on what was said before...

The hex code FDCB24DEC9 translates to:
     set 3,(iy+24h)
     ret
When you say you have assembly experience, I am not sure if you mean specifically Z80, or other assembly languages, but basically, the OS reserves the index register IY for its own use. It points tot he start of the system flags, and as its name implies, flags can thus be referenced as an offset from IY. so IY+0 would be the first byte, IY+1 would be the second, et cetera. Almost all of the instructions that use the register pair HL can use one of the two index registers (the other is IX). So for example, ld a,(iy+7) would load the contents 7 bytes ahead of where IY points into a.

The instructions starting with set res and bit allow you to modify or read an individual bit of an 8-bit register or the byte of ram pointed to by the register pair HL. SO this gives you b,c,d,e,h,l,(hl),a. With these, you can use an index register in place of (hl) allowing you to use (ix+const). Taking a look at the code above, again, we have:

     set 3,(iy+24h)
Since IY should be pointing to the flags, the OS keeps the offset 24h as the byte with the flag controlling lowercase mode. In particular, it is bit 3 at offset 24h that is the appropriate flag. You don't have to memorize the flags and offsets too much, though, if you don't want to. The ti83plus.inc file has defines and equates that will let you do something like:
     set lwrCaseActive,(iy+appLwrCaseFlag)

The links that Assemblybandit provided are to an excellent resource if you want to learn how the OS works. Hooks were intended to provide a safe way to modify the actions of or update functionality of the OS without actually needing to go in and permanently edit it.

I hope  this helps!

Wow, that looks really nice! I haven't played Frogger since I was like 4 or 5 years old. Back then, I thought they were crocodiles instead of turtles

I added a few 24-bit floating point routines including a log₂ routine. The advantage to the 24-bit floats is that it can all be done in the registers, giving them even better speed. The obvious downside is a much more limited range for accuracy (about 4 to 5 decimal digits), but it does provide a fast alternative to integer math. It could be used in languages like Axe or Grammer.

I haven't fully tested the log₂ routine, but I did test a few key values that were more likely to have issues with accuracy. I am pleased to say, that the worst I got was about .0000763 away from the actual value (but I won't be surprised if there are values that yield as much as an error of 5 times that). The main issue is that it doesn't handle negative inputs.

By the way, for timing, the log₂ routine is around 1200 to 3500 t-states, so it can do 1700 to 5000 computations per second at 6MHz. Graphing a log() equation should be pretty fast

I added the 80-bit Floating Point Addition routine which was friendlier than I expected. Also, for current timings, Division is a little under 60 000 t-states, multiplication is a little over 30 000 t-states, and addition is just under 1400 t-states. I need to make all of these faster

EDIT: Oh, also, The floating point addition code includes a routine for setting a number to infinity, keeping its sign, among other things. It also has rounding implemented.

EDIT: In my test app, here are the sizes so far:
FloatAdd : 244 bytes (this includes the code for handling infinity and a few other subroutines that will be shared by others)
FloatDiv : 244 bytes
FloatMul: 205 (this includes a subroutine routine for 64-bit integer multiplication)

I am in need of a subdr instruction right now That would let me subtract a big endian number from another.
Also, subir, addir, adddr would be nice. In fact, a bunch of instructions with increment/repeat or decrement/repeat would be nice. You could OR two buffers with:
ld hl,gbuf
 ld de,backbuf
 ld bc,768
 orir
Or shift a buffer right:
ld b,0
 ld d,64
 ld hl,gbuf
 ld c,12 \ srlir \ dec d \ jr nz,$-5