Well, as flattered as I am, I am Sam, Sam I am, and I don't like green eggs or spam.

That sounds like a terrible coincidence It does make sense, though, and I actually think that that is an excellent policy. It is a way to potentially let power cycle and since everything is about politics, lately, it adds to the irony

I think May 1st, 2011 is the day Barack Obama won the game.

Yeah, Qwerty has it correct

Pretty much, _RclAns does several things:
-Stores the type that Ans is in the "a" register
-Stores the address of the vat entry in HL
-Stores the location of the size bytes in DE

If Ans is a real number, the real number is stored in OP1 and if it is a complex number, it is stored to OP1 and OP2 has the imaginary part.

You will also want to know how variables are stored by the OS. The data itself is stored so that the first two bytes tell the size and the data following is the actual variable data. SO for example, if the hex was 0301454699..., then the size is represented by the 0301 part. Since it is little endian (the little end, in) you need to count it as 0103 which is 259. This means there are 259 bytes of code. Also, because it is little endian, I stored the first byte to c and the second to b. That way, BC contains the total size

Well hello there! Welcome to the site! Here is some code for you to play with I have it organized so that there are mnemonics, then the hex code, then the explanation :
;=========================================================
;    Mnemonic            Hex       Explanation
;=========================================================
     bcall(_RclAns)     ;EFD74A    DE points to size bytes
     cp 4               ;FE04      To make sure Ans is a string
     ret nz             ;C0        Quits if a is not equal to 4
     ex de,hl           ;EB        Swaps hl and de. Now hl points to the size bytes of Ans
     ld c,(hl)          ;4E        loads the LSB (Least Significant Byte) of the size into c
     inc hl             ;23        hl points to the next size byte
;
;As a note, these next two lines can be replaced with
;ld b,0 in this case (because the name shouldn't be >8 bytes)
;but this is the general way to get the size of a variable.
;
     ld b,(hl)          ;46        now the MSB of the size is stored to b. BC is now equal to the size of the string in Ans
     inc hl             ;23        hl now points to the actual data
;
;At this point, HL points to the string in Ans
;and BC is the size of the string. This will be
;useful when we copy to OP1 :)
;
     inc a              ;3C        Since a is 4, this makes a=5 (the type for a program)
     ld de,OP1          ;117884    DE points to OP1
     ld (de),a          ;12        Stores a (which is 5) to the byte at OP1+0
     inc de             ;13        DE now points to the next byte (OP1+1)
     ldir               ;EDBO      Copies BC number of bytes from HL to DE. In other words, it copies the string in Ans to OP1
     xor a              ;AF        This makes A=0. It is an optimisation trick :)
     ld (de),a          ;12        This copies a (0) to (de) which is at the end of the string in OP1
     bcall(_ChkFindSym) ;EFF142    This searches for a var named in OP1
     ret nc             ;D0        This stops if the var already exists
     ld hl,256          ;210001    This is the size you want the program to be
     bcall(_CreateProg) ;EF3943    This creates the program
     ret                ;C9

It isn't the size, it is the trade off in limitations... right now, you have only 12 columns, but the sprites can be up to 96 pixels wide, they can still be drawn every pixel down, the sprite drawing is much faster (enough to create grayscale). The other method will be slower and be only for 8 pixels wide and the sprite masks will be limited. You haven't bugged me to finish making this, you have only complained to me that you don't like the current version. There is a reason for the "BatLib Ideas" topic.

Sorry.

EDIT: Also, on another note, I will be without internet for from May 9th to August 29th, so if I don't respond, that is why Also, if for some reason I cannot come back to college, I might not have internet for a long while after that.

Yes, there is a recallpic function (called PicHandle). The fastest way for creating grayscale with BatLib is to actually use the command that draws sprite directly to the LCD. That isn't the most simple version, though... To give an idea, BatLib has all the tools to store a bunch of pictures in one file, then reading it from archive, you can cycle through each picture rapidly.

Also, ReCode has a RecallPic function, so that could prove pretty useful...

Here is an example I made while trying to make a scaled down main menu:

@Xeda: Any polynomial interpolation will be bound to lose accuracy pretty quickly, considering that f(x)>2^(x-1) which is exponential.

I know, but he only asked for an equation for that data I would have to study more to figure it out to match that sequence