	Well, where should I start? The memory management system I have devised for my operating system seems to be complex
to even me - the person who designed it. However, I do feel it will do the job powerfully and I believe it will avoid the
pitfalls of Microsoft Windows by successfully deallocating memory when it is not needed. This way it won't become infamous
for "bogging down" like Windows does after a couple hours of use. Well, enough of the crap and into the details...
	Basic principal: I have created 3 main syscalls:
		1. sys_alloc_mem_csel - looks for requested amount of free space in memory and allocates it if available.
					Then it calls #2. In a failure by #2 it is able to deallocate the memory it just
					allocated.
		2. sys_create_sel_csel - This creates a selector into the gdt or current ldt with the base address and limit
					decided on by #1. It is able to reuse unused selectors in the gdt once all of the
					gdt is filled.
		3. sys_dealloc_sel - This takes a selector and deallocates it and the memory it is assigned to.
	Areas of protection: These will do their best to make sure the following don't happen:
		1. A program deallocates major system segments so that they will be overwritten and crash the OS.
		2. A program creates a code selector of its own at privelege level 00 or 01 in order to attack the OS or
		   other applications.
		3. A program gains access to memory areas that contain data such as passwords, etc.
		4. A program allocates many segments or segments with large amounts of memory in order to bog down the
		   system or eliminate all free resources or gdt entries.
	Methods of protection:
		1. Create an authorization syscall that works the following way:
			As task switches are taking place, the following happens:
				a. The new task's ldt is taken from the task_data segment and is stored in the shared_data
				   segment.
				b. A copy of the shared_data segment is made and made available to the new task. This will
				   prevent the actions of one program from giving another program false information.
				c. The current task's ID is saved in a place in memory only available to the OS.
			When a program tries to do an action which is high priveleged, a system privelege check is made.
			To do this, the system looks at the current task's ID and decides whether it is priveleged enough.
			The program will be able to do certain things not yet decided which may allow it to do the action.
			Possibilites are:
				a. A call to the system to have it prompt the root user whether that task can do the action.
				b. Provide a valid reason??? - If it does this, extra data will be recorded about the action
				   so that the system will be able to automatically stop/reverse this action should it detect
				   something is wrong...
		2. Save copies of major system data segments such as the shared_data segment, task_data segment, LDT, GDT,
		   and the not yet created special_system segment (for authorization and ID stuff) to disk. And possibly
		   save major disk areas like the Master Boot Sector to memory in case some kind of disk violation is created.
		   Also, it could also be possible to save the Master Boot Sector to the last sector in memory so that if
		   an "operating system not found" error by the BIOS because of an invalid Master Boot Sector occurs, a
		   backup disk can look to see if the old MBS is still in the last sector of memory and restore it if it is.
	Detailed Principal Behind Memory Management:
		1. 3 major syscalls explained above.
		2. Major data segments used by these calls and how they are used:

	How to use it:
		1. Allocate a simple segment (leave bit 3 of ah clear upon calling alloc_mem) or ...
		2. Create a twin segment: Set ah and al as if a data segment is being made except set bit3 of ah. and set bit2
		   accordingly (see the code). The data selector will be returned in dx and the code selector will be 
		   returned in ax. They will have the same base, limit and access rights, etc. The only difference will be 
		   that one is data and one is code... The conforming/expand down bit may be different in the GDT also.