This is realization of the God and the world 
	in Object Oriented way.
	
	The God is beleived to be Super Power .
	But According to a theory which i m going to explain
	OO way, says that the Super Power u think is not
	the God but its A Super Soul .

	Super Soul is the Super Power. The world is originated
	from this Super Soul. Even Trimurti (Brahma , Vishnu ,
	Mahesh have no separate existance without Super Soul.


	There is another postulate of the theory.
	It is like this :
		There is giant life wheel. It makes 1 revolution 
	in 5000 years. And it is continuously revolving. The Wheel
	is divided in 4 parts, each part covering 1250 years.
	These parts r called as YUG. First is SAT YUG. ( Time of Truth)
	God live on the earth in this time period. There is only
	peace , harmony , health , wealth and only good things.
	These gods are LakshmiNarayan.
	The next YUG is TRETA YUG. In this YUG RAM , KRISHNA and other
	inherited Gods live. This inheritance is from Famous Trimurthi.

	The next YUG is DWAPUR YUG.  In this YUG all next level inherited
	gods like BUDHA , YESHU KHRISTA , MAHAVIR etc. live
	
	The last one is KALI YUG. We live in this YUG.This is the YUG
	where all worst thing rule the world. Worst things are at their
	best in this time.
	Because of these worst things happening in this YUG, the world
	is distroyed and a new world is created. And The whole process
	repeats.


	This 1 revolution of the giant wheel is called one cycle.

	Now lets start with the theory.

	Now it is clear by now that The Base Class on top of all
	classes of the universe is Super Soul.

	So lets define the Class SuperSoul.



typedef  char *		SOUL_ID;

		// this defines a new type SOUL_ID which
		// represnts stringified soul identification value
		// each soul gets a uniques SOUL_ID

#define  MAX_POSSIBLE_SOULS   ............

		// this data member decides the maximum number of Souls
		// that can be instantiated in the whole cycle of 5000 years
		// this is initialized to an  arbitrary value which is unknown.

		// this value signifies that how many souls will be alive
		// in each YUG. 
		// There is a ratio which gives the proportion of souls in each
		// YUG. The exact ratio is also unknown.

	class SuperSoul :
	{
	  private :

		static  long NoOfSoulsInstantiated;

		// this data member which is static is the count of 
		// total number of Souls those were instantiated
		// from start of the World i.e. when the constructor
		// of the SuperSoul was called.
		// When this value exceeds MAX_POSSIBLE_SOULS
		// an exception 13  (Soul Fault) is raised.
		// Then the Destructor of the SuperSoul is called
		// and world gets distroyed.

		long  NoOfSoulsAlive;

		// This is the value which tells
		// how many souls in the world are alive
		// at any point of time.
		// significance of this value will be clear 
		// when we come across Destructor class

	
		Originator Brahma(long WhichYUG,long NoOfSoulsToCreate);

		// There is a class called Originator
		// which is responsible for creating souls
		// The name to the object of this class is BRAHMA
		// Its constructor is called with WhichYUG (to 
		// specify the YUG ) and number of Souls to create.
		// as this class in a private member of the SuperSoul
		// normal souls inherited from this SuperSoul
		// can not access Brahma members

		// The description of the classes used by SuperSoul
		// like Originator , Destructor , CareTaker
		// is given in the Appendix A.

		// This Brahma member functions are activated
		// as soon as constuctor of Brahma is called
		// then Brahma functions run in parallel with
		// other functions of SuperSoul.
		// This is beacuse, not all souls are created
		// at begining of each YUG. The process is
		// on till the end of the YUG.

		// Whenever Brahma creates a new soul on the earth
		// it increments both the data members
		// NoOfSoulsInstantiated and NoOfSoulsAlive by 1
		
		Destructor Shankar(long WhichYUG);

		// This Class Destructor is responsible
		// for killing all the souls that are  present
		// at that time in that YUG.

		// Brahma increments the data member
		// NoOfSoulsAlive everytime a new soul is created
		// Shankar decreases the same value by 1
		// when shankar destroys one soul.
		// when Shankar finds the value to be nonzero
		// +ve, it calls the random function and
		// decides whether to kill a soul or not .
		// then it calls a function Yama::GetSoulFromEarth(..);
		// then as control comes back, Shankar 
		// decrements the NoOfSoulsAlive by 1.
		// the pseudo code for this is given below

		if(NoOfSoulsAlive > 0 && random(1))
		{
			Yama::GetSoulFromEarth(GetSoulIDofAnAliveSoul());
			SuperSoul::NoOfSoulsAlive--;
		}

		// The Function GetSoulIDOfAnAliveSoul() returns
		// any random SoulID which is Alive
		// when Brahma Functions are stopped at the end of
		// one YUG ,Shankar starts a function  
		// called MegaWar.(in KALI YUG, this function is
		// known as THIRD WORLD WAR). 
		// With starting of this function , calls to
		// function Yama::GetSoulsFromEarth(..); are
		// made more frequently than any other time.

		// Class Destructor is declared as friend
		// of class Yama
		// Class Yama is not described in this text
		// as that class and and interclass 
		// communication between Yama and Shankar
		// is very complicated and it is out scope
		// of this text.

		PalanHaar Vishnu;

		// This  Vishnu Object is of type PalanHaar
		// which means one who protects others.
		// Vishnu takes care of every soul on the earth.
		// Vishnu protects the newly created soul by Brahma
		// from Shankar and Yama who are hunting for 
		// every soul to destroy.
		// Vishnu does this work in very simple
		// and intelligent way.
		// Firstly he talks to Shankar about the Dance
		// actually he praises Shankar for the tandav nrutya
		// that he performs very well.
		// As Shankar is BHOLA by nature , Vishnu offers Shankar
		// with BHANG which is Shankar's favourite drink.
		// now Shankar goes in to Zombie  State for some time
		// Now he bribes Chitragupta who supplies  Shankar
		// the result of GetSoulIDOfAnyAliveSoul()
		// with some money and tells Chitragupta to
		// run a fake random() function and return only
		// listed IDs by him. So the souls not in the 
		// list get protected for atleast some time.
		// Then vishnu turns to Yama. He does not
		// directly talk to Yama. Instead he supplies
		// Yama's vehicle REDA with heavy meal
		// so that REDA sleeps for few days.
		// This is done to double check the protection
		// given to souls.
		
		// This mechanism  is not sufficient to make
		// a soul mortal. As Brahma is continuously
		// creating new souls , Vishnu is unable 
		// to keep track of all the  souls alive 
		// and souls get destroyed after some avg. time
		// e.g. 50-60 years.
		// This keeps the population also in control.

		// See the references for further reading
		// about the object Vishnu.

	public:

		// here r some public member functions 
		// that can be called by any living soul.

		
		BOOL TalkToSoul(PeerSoulID);

		// This is the first public function available
		// to any soul. soul can give PeerSoulId 
		// to whom it wants to talk. This function
		// checks whether this soul can talk to PeerSoulId
		// if that soul doesnt exist it returns FALSE.
		// (hindi me) agar woh dil(soul) is dil ki aawaj
		// sunta hai to yeh function TRUE return karta hai.
		// agar is dil ki awaj us dil tak nahi pahoochati
		// ya woh dil ye awaj sun-ne se inkaar karta hai
		// to yeh function FALSE return karta hai.

		SOUL_ID	GetSoulId(name);

		// this function returns SOUL_ID of a soul with
		// name. this id is used for all other
		// inter-soul communication.

		void Talk()

		// this function is to be called only after
		// TalkToSoul function returns TRUE
		// once the connection between 2 souls is
		// established , there is now need to give
		// SOUL_ID again to this parameter

		// the connection between two souls is 
		// connection oriented and hence all the 
		// functions for connection management are
		// also supplied. as everyone knows about
		// it, i m not mentioning them again.
		// refer to Stevens for further information.


		SOUL_ID *ChatWith(SOUL_ID*)

		// this function allows one soul to talk to
		// many souls at a time.
		// This function is same as TalkToSoul
		// but it takes pointer to list of SOUL_ID
		// whom 2 talk.
		// it return list of SOUL_ID who r ready
		// to chat.
		// after this function is called Talk() function
		// is called. It initiates chat between all the
		// souls ready to chat.
	}
	// end of class SuperSoul

	SuperSoul also has some pure virtual member functions
	// but network went down while doing FTP from
	// location God.Heaven
	// i m unable to tell when i can download the rest of the part
	// but anyone of u can do ftp to God.Heaven with login
	// as anonymous and password as ur SOUL_ID.

	// but be sure that u know ur SOUL_ID and u enter it correctly
	// otherwise data will be transferred to some other user.

	// as network was unreachable i m unable to give Appendix
	// sections here. when ever the connection gets established
	// i'll mail you all the rest of the data.

	// also there is huge collection of classes inherited from
	// supersouls. Each of this class refers to its different
	// behavoiur and living style. Main classes are religion based
	// others are based on family background and financial status
	// this collection is ever increasing and i wont be able
	// to give you full information.
	// u can get a list of such classes by mailing to
	// LISTSERV@God.Heaven with body of the message as
	// GET SOUL-CLASS-LIST [type]
	// where type indicates which types of classes u want.
	// u can leave the field blank to get entire list

	// end of god theory document

	// written by Nilesh Mankikar 
	// alias manik. @

[ CHANGES , MODIFICATIONS ARE WELCOME .
do send them via mail, i have set mesg -n to my soul. so u can not 
directly talk 2 my soul]