To be fair, I never actually tried to implement app signing.  It was only from a discussion with BrandonW that I concluded it would be either too complicated or too slow to implement so I didn't want to waste time writing it.  But under a minute sounds pretty good, although still a bit long for me personally when I can do it on the computer instantly, but certainly short enough to have as a useful option.  Luckily though, you don't actually need to sign the apps to run them, only to transfer them to another calculator.  So debugging can be done with the unsigned app and once the user is ready to publish, they can sign it.

Oh, and if I forgot to mention it earlier in this thread, this is an awesome program!  This style of editing was exactly what I was actually intending to have for Axe when it was still all on paper.  But then I decided to just use the TI-BASIC editor instead because I realized the familiarity would be an advantage for users transitioning from BASIC (my target audience) and it was a hell of a lot easier to not have to write my own editor   But you did a great job on it!

Its less code (I think) to just use a temporary:

A->r6
B->A
r6->B

But I am considering adding an "ultra temporary variable" (the pi token) to the axe language to allow greater code optimization. It would use the assembly instruction "ex de,hl" to take advantage of the de register for extremely temporary storage when using store commands, small number incrementing/decrementing, power-of-2 multiplication and referencing commands.  Pretty much anything else will destroy this extremely fragile variable.  Using it for an exchange command for instance would look like this:

A->pi
B->A
pi->B

This would only be 14 bytes instead of 18 from the earlier example.  There are other exploits you can take advantage of too.  After a multiplication (non-optimized) the pi variable would hold the high order word of the result so you can essentially compute the high order *^ and regular * multiplication simultaneously.

Okay, some reviews:

THEaxeGamePack
This was one of my favorites.  I liked how most of the games were completely original and others took otherwise simple games and added some twists to them.  Especially the pseudo-3D paddle game was pretty impressive with the scaling sprite sizes.  The main downside though is that the games tend to get repetitive after a while with no change in difficulty as you progress (as far as I could tell).  But overall this was a very enjoyable pack of games with simple but effective graphics.

Jump!
For a last minute entry this felt surprisingly playable, I couldn't believe it that it was completed in such a short amount of time!  I did feel that it borrowed a lot from the impossible game though (including nearly identical sprites) except that it runs on randomly generated levels and lacks the obstacles.  It was fun to play but after a while but also gets repetitive.  Sometimes it seemed like I had a was supposed to land a jump but still fell through the cracks somehow.  Overall, it was a very simple game (maybe a little too simple) but still manages to provide some entertainment.

Blur
Blur is essentially another tunnel game, but it goes a little further with changeable ships, some animations, and multiple highscores.  The game was surprisingly polished meaning that there were very few bugs or things that distracted gameplay.  Of problems I did see though was that the run indicator was flashing in the menus and some of the controls felt a little inconvenient like pressing clear doesn't actually end the game, you have to navigate to the quit button.  For what it was though, I'd say it was done pretty well.

Minesweeper
Honestly probably the best minesweeper game for the 83/84 series calculators.  Although not much was added from the windows version other than the undo (although the mine field wrapping would have been really cool had that option been implemented).  The graphics were great in grayscale too and felt very natural with the controls when playing.  One thing I noticed though was that when you lose and want to retry, all the mines are shown at once and can spoil the fun of undoing and trying again since you know where they all are now.  This was another game I felt was very very polished and actually felt like a complete game.

By the way, my personal vote in the poll was for Simul because I had the most fun playing it (even if it wasn't the most elaborate entry)

Oooh! The reults are finally out!

Congratulations to all the winner! I hope everyone had a fun time making and playing these games.   If anyone wants a more in-depth review of their entry or how I judged, feel free to ask.

You know, you can save your stack pointer first and then return out of an arbitrary number of nested calls at once without memory leaks.

;Say this is on the base level before you start calling everything
  ld (save_sp),sp

;Now start calling away...
  call L1
L1:
  call L2
L2:
  call L3
L3:
  ...
LN:

;Now you decide you want to return to the base level again,
;but you don't know how many nested subs you actually used.
;So you just load the base address directly into sp again.

  ld sp,(save_sp)

;You are now back at the base level again.
;So in essence, you have returned out of all the subroutines
;and can do as you please at the base level.


De Google Translate:

Pour l'histoire de fonctionnalités, vous pouvez consulter le fichier changelog.txt qui donne les dates et une bonne compréhension de la progression des commandes. Autres informations: Le premier jeux a été "Guess The Number" en 0.0.2, le premier vrai jeu "Starship" est sorti en 0.0.6, Axe a obtenu une interface utilisateur et la documentation en 0.2.0, il a été présenté sur ticalc.org après 0.2.5, le concours a été annoncé après 0.2.6.  Est-il autre chose que vous voulez savoir?

Don't use that!  If I decide to move where the variables are located, that code will no longer work and be outdated.  Use 1->{^oA}^r instead as this will guarantee that you have the right address even if I move them.  And yes, it will be the exact same in the executable as 1->A byte-for-byte.