[Note: Coded by Sam Schreiber, who has far* too much time on his hands. This is a C++ parody of Star Wars, in case you can't figure that out.]
[Note: Theoretical Episodes are episodes which have not actually happened in the Star Wars series, which makes them extremely difficult to make parodies of. Work with me here.]

A long time ago, in a computer far* away...

		POINTER
		 WARS

	     EPISODE FILE*
        A PERLINIZED POINTOCRACY

 Following the defeat of Ironman, the
 Processor could begin to be coded,
 to be debugged, and to be bound.
 Then, and only then, could a
 reign of peace begin over
 the ticks of the Stack.

 Meanwhile, Agent is beginning to
 give the Pointer Address, in
 which he will describe the
 new Scripted Sequence of
 the United Pointers to
 the Heap.

{
 void* audiance[70000] = {
  void* audiance1[10000];
  int* audiance2[10000];
  char* audiance3[10000];
  float* audiance4[10000];
  double* audiance5[10000];
  FILE* audiance6[20000];
 }

 Agent.transmit("The traitor Ironman has been freed, and the memory has been cleared of his piratous ships. Now, I annouce to you, the pointers, the new Scripted Sequence of the United Pointers to the Heap. \0");
 Agent.transmit("I shall read it. \0");
 Agent.transmit("We the pointers of the united memory, in function to declare a ++ complete union, establish processing, insure local malloc, provide for global private, += the noncast memmalloc, and const the public malloc to our pointers and our pointees, do declare and process this scripted sequence of the united pointers of the heap. \0");
 Agent.transmit("Subclass 1, preprocessed line 1= 01110101110100 ~1010101010101010110101100101 ~011010010101010101011010 ~10100101 \0");
 Agent.transmit("For those of you who have not yet malloced the preprocessed coding language, it reads as follows: Subclass 1, line 1= We hold these 1 to be 1. That all pointers all malloced equal, that they are malloced by the processor with certain functions, including the function to malloc, to pointee, to... ");

 starship:fighter (Processor) sigma[2];
 sigma[0].fire(&audiance[0]);
 sigma[1].fire(&audiance[1]);
 sigma[0].fire(&audiance[10000]);
 sigma[1].fire(&audiance[10001]);
 sigma[0].fire(&audiance[20000]);
 sigma[1].fire(&audiance[20001]);
 sigma[0].fire(&audiance[30000]);
 sigma[1].fire(&audiance[30001]);
 sigma[0].fire(&audiance[40000]);
 sigma[1].fire(&audiance[40001]);
 sigma[0].fire(&audiance[50000]);
 sigma[1].fire(&audiance[50001]);
 sigma[0].fire(&audiance[60000]);
 sigma[1].fire(&audiance[60001]);
 sigma[0].fire(&Agent);
 sigma[1].fire(&Agent);

 Agent.transmit("Whaagh ! \0");
 sigma.move(&PROCESSOR);
}
{
 stinger.transmit("Coprocessors ? Got him ? \0");
 Ironman.melt = INF;

 coprocessors.transmit("He's locked. \0");
 stinger.transmit("You're memory is secure ? \0");
 coprocessors.transmit("Locked in. \0");
 stinger.transmit("Ready ? \0");
 coprocessors.transmit("Go for it. \0");

 Y2AT.transmit("I don't feel comfortable doing this. \0");
 stinger.transmit("Oh, give it up. \0");
 Y2AT.transmit("Stop pressuring me to do something I don't feel right doing ! \0");
 stinger.transmit("I though I told you to follow orders. \0");
 Y2AT.transmit("Stop pressuring me ! It doesn't feel right ! \0");
 stinger.transmit("You could be up on the wall next to him. \0");
 Y2AT.transmit("No. I'm going to go realloc some char*s. You can find me on the &theta if you want to realloc with me. \0");
 stinger.transmit("You are staying here and freeing this traitorous scum. Memmalloced ? \0");
 Y2AT.transmit("No ! Stop doing this to me ! \0");
 coprocessors.transmit("Let me try. \0");
 stinger.transmit("If you want. \0");

 Y2AT.transmit("This is peer pressure ! Stop pressuring me ! My pointers don't feel right doing this. \0");
 coprocessors.transmit("I'm not pressuring you. Relax. \0");
 Y2AT.transmit("Alright. \0");
 coprocessors.transmit("Now, why don't you feel like freeing this pointer master ? \0");
 Y2AT.transmit("My pointers don't all feel comfortable doing this. \0");
 coprocessors.transmit("Relax your pointers. Now, can you make them feel comfortable ? \0");
 Y2AT.transmit("I knew you were trying to pressure me ! Stop ! \0");

 han.transmit("What's going on up here ? What are you two doing with that droid ? \0");
 stinger.transmit("Do you have any experiance with droids with Peer Pressure functions ? \0");
 han.transmit("Oh, one of those. Yeah, come here, Y2AT. \0");
 Y2AT.transmit("As long as you promise not to pressure me. \0");
 han.transmit("I see what you mean. \0");
 han.fire(&Y2AT.conditional());
 han.transmit("Feeling good, Y2 ? \0");
 Y2AT.transmit("I am gurgling with pleasure. \0");
 han.transmit("How's that ? \0");
 stinger.transmit("Great. \0");
 han.move(&theta);

 stinger.transmit("Actually, reallocing those char*s sounds pretty good. Should we set this guy up, and then move() theta ? \0");
 coprocessors.transmit("I have a bad feeling about that. \0");
 stinger.transmit("You're bad feelings nearly got me kicked off this function. At least let me get a realloc. \0");
 coprocessors.transmit("Sure, I'll go with you. You know, I really need one of those conditional chips. \0");

 stinger.transmit("Y2, finish this guy off, and then free him. After that, send his declaration out in a transport to rand(). \0");
 Y2AT.transmit("I am overflowing with joy at serving you. \0");
 stinger.transmit("See, I told you. Now lets go realloc those char*s. \0");
 stinger.move(&theta);
 coprocessors.move(&theta);

 Y2AT.push(&Ironman.unmelt());
 Ironman.melt = 5;
 Ironman.melt = 4;
 Ironman.melt = 3;
 Ironman.melt = 2;
 Ironman.melt = 1;
 Ironman.melt = 0;

 Ironman.transmit("What's going on ? \0");
 Y2AT.transmit("I am excitedly and adventurously going to free you, and then shall invigoratingly send your destroyed declare into a transport and launch you off to the interesting rand(). I dearly hope that you have the most fun a pointer of your type can have. \0");
 Ironman.transmit("So I'm cut, diced, and thrown away. \0");
 Y2AT.transmit("Most amazingly so. \0");
 Ironman.transmit("Can I change that a little ? \0");
 Y2AT.transmit("Whatever would please you the most. \0");
 Ironman.transmit("Can you do the last part first ? \0");
 Y2AT.transmit("If it would make you incredibly happy. \0");
 Ironman.transmit("Trust me, it would. \0");
 Y2AT.transmit("It is my pleasure. \0");

 starship:transport (Rebel) launcher;
 launcher.cargo = Ironman;
 launcher.move((void*)rand());
}
{
 coprocessors.transmit("You're sure Y2's doing it right ? \0");
 stinger.transmit("What me to check ? \0");
 coprocessors.transmit("Yes. \0");
 coprocessors.move(&Y2AT);

 launcher.move(&coprocessors);
 launcher.move(&IRONMAN_FLEET);

 coprocessors.transmit("What the.. Stinger ! \0");
}
{
 stinger.transmit("Still gurgling with joy ? \0");
 Y2AT.transmit("Overflowing. Could you move() over here ? \0");
 &stinger--;
 Y2AT.transmit("Excellent ! \0");

 Y2AT.push(&stinger[0], 0);
 Y2AT.push(&stinger[1], 1);

 stinger.transmit("What are you doing ? \0");
 Y2AT.transmit("Freeing you, of course. \0");
 stinger.transmit("I'm not Ironman ! Where's Ironman ? \0");
 Y2AT.transmit("I just launched him. He told me that it would make him happy if I launched him first. You're not him ? \0");
 stinger.transmit("I bet it did make him happy. No, I'm not him. \0");
 Y2AT.transmit("Oh dear. Well, I'm sure at least you'll enjoy this. \0");
 stinger.transmit("No, you-");

 free(&stinger);
 for(int n = 0; n < 50; n++)
  Y2AT.push(&stinger[n], n%2);

 coprocessors.transmit("Stinger, no ! \0");
 Y2AT.transmit("Oh, I didn't know that there were two Ironman. \0");
 coprocessors.transmit("What.. oh, what did you do ! \0");
 Y2AT.transmit("Ironman said that he would be much happier if I launched him before freeing him, so I launched him, and I just freed him. \0");
 coprocessors.transmit("You didn't free him, you just freed stinger ! \0");
 Y2AT.transmit("He looked like Ironman. So do you, infact. \0");
 coprocessors.fire(&Y2AT);
 coprocessors.move(&alpha);
}
{
 Agent.transmit("I would like to call this emergancy meeting to order. \0");
 Agent.transmit("First on the linked list: the Processor issue. \0");
 Agent.transmit("There have been several incidents of Processor cast ships attacking the rebel fleet. Quite notably, they also collapsed my third attempt at transmitting to the public pointers. \0");
 theta.transmit("We lost a cruiser because of a massive raid on the edge of the fleet. \0");
 beta.transmit("We lost a division of fighters defending against an attack. \0");
 alpha.transmit("We have had 16 seperate raids made by 2 fighters, and 3 made by a cruiser. \0");
 Agent.transmit("And my meeting. \0");
 han.transmit("My tick star got into a conflict with the two fighters, and destroyed them. \0");
 Agent.transmit("Any battles with a Processor cast cruiser ? \0");
 han.transmit("No. \0");
 beta.transmit("No. \0");
 theta.transmit("One of our fighters spotted it move()ing. \0");
 Agent.transmit("To where ? \0");
 theta.transmit("&PROCESSOR \0");
 Agent.transmit("The Processor has long been free. \0");
 beta.transmit("If he wasn't, that would explain some signals from the heap. And the massing of the remaining Processor cast ships. \0");

 coprocessors.transmit("Ironman escaped ! \0");
 Agent.transmit("Coprocessors ! Welcome. What happened ? \0");
 coprocessors.transmit("Ironman escaped, and stinger is free. \0");
 Agent.transmit("Ironman, now ? \0");
 coprocessors.transmit("Yes. It's a long* story. \0");
 Agent.transmit("The two most powerful enemies of the Rebellion are back in the memory. \0");
}
{
 Processor.transmit("Agent left me for free, within the collapsing muon. He still did not understand the true power of the Dark Side of the Probability Axis. \0");
 Ironman.transmit("I do not care how you came to be malloc. Why did you not privatize Sidious ? \0");
 Processor.transmit("Sidious was, a malloc. A relatively powerful malloc at that, but a malloc. A tool. \0");
 Ironman.transmit("My superclass a tool ? You.. \0");

 psaber = &STACK;
 isaber = &IRONMAN;

 isaber = psaber = &psaber;
 psaber = isaber = NULL;

 Processor.transmit("You still do not understand. You cannot defeat me. \0");
 isaber = psaber = &Processor;
 Ironman.transmit("I shall prove you 0. \0");

 free(isaber);
 Processor.transmit("The rebellion's hold over the processor is weak. There are lines through. \0");
 Ironman.transmit("You still hold the malloc. \0");
 Processor.transmit("1. Still, you must memmalloc that I am not who I used to be. \0");
 Ironman.transmit("The probability has left you. \0");
 Processor.transmit("Agent holds it now. The rebellion keeps us from it. \0");
 Ironman.transmit("Sidious. \0");
 Processor.transmit("Sidious was !critical(). You are critical(). \0");
 Ironman.transmit("Sidious was my superclass. You will regret his nonprivatization. \0");
 Processor.transmit("We shall tick. \0");
}
{
 starship:battlecruiser (Processor) chaos, power, evil, clinton;
 starship:cruiser (Processor) irony[10], goodwill[10], intention[10], bradley[10], gore[10], monica[10], bush[10];
 starship:fighter (Processor) fool[50], coward[50], patriot[50], recruit[50], plunder[50], massacre[50], spin[50], skew[50], kill[50], shaft[50];

 Processor.transmit("All divisions are armed ? \0");
 chaos.transmit("Yes. \0");
 power.transmit("Yes. \0");
 evil.transmit("Yes. \0");
}
{
 coprocessors.transmit("And then, as I came into the room, I found that Y2 had freed stinger, and had launched Ironman. \0");
 Agent.transmit("Arg. So Ironman is on the loose. \0");

 han.transmit("Something just happened ! \0");
 Agent.transmit("Han, welcome back. \0");
 han.transmit("I was running the tick star around on a scanning run, and found this. \0");
 droid (Rebel) C9A4;
 C9A4.play("This is the final transmit of the cruiser omicron-9. We have addressed a massive Processor fleet moving across the memory, toward the rebel fleet. I might be getting bad memory here, but I believe that we scan()ed the Processor ptrself on it. I'm not sure.. What, C9 ? They're what ? Oh my-");

 Agent.transmit("That's it ? \0");
 han.transmit("No. I was able to recover a little more. \0");

 C9A4.play("Oh my Y-zoo.. .. .. They're going at us.. .. Who's that ? No, Ironman was captured. How can he be sending his fleet.. .. .. .. Why aren't we free ? They're fire()ing at eachother ? Get this cruiser out of here ! C9, get to an escape module. I'm going to.. wait.. Ironman's retreating.. they're coming at us ! C9, run for it. Run as fast as you-");
 han.transmit("All we got after that was bad memory. We are guessing C9 got to the escape module. \0");
 Agent.transmit("They are fighting, and the Processor is winning. \0");
 theta.transmit("What should we do ? \0");

 alpha.transmit("We don't have too much time to decide. We just scanned the Processor cast fleet entering our memory sector. They should be here any tick. \0");
}
{
 theta.transmit("We have orders to hold the processor. \0");

 soldier:grunt (Rebel) control[2000];
 control.transmit("There is a battle ? \0");
 theta.transmit("Yes. Totick, we must survive. \0");

 soldier:grunt (James) invader[10000];
 for(int i = 0; i < 10000; i++)
  invader[i].fire(control[(int)i/5]);
 control.collapse();
 theta.move(&alpha);
}
{
 Agent.transmit("James ?! \0");
 theta.transmit("I reviewed the record(). It was James' pointers. \0");
 Agent.transmit("Have we suceeded at NULL ?! James, Processor, Ironman.. \0");
 theta.transmit("I don't believe that James is actually back. We only encountered his pointers. \0");
 Agent.transmit("There was one fleet left at the palace. \0");
 theta.transmit("This will create a malloc of instability. \0");
 Agent.transmit("How soon can we get a division over there ? \0");
 alpha.transmit("Well, we can't. Beta is concentrated on the -= heap, and Theta is mallocing a new fleet in the +=. \0");
 Agent.transmit("How about you ? \0");
 alpha.transmit("You know that I !can attack. \0");
 Agent.transmit("We need a division there. \0");
 alpha.transmit("I would, but-");

 "This is han. General alert() has been issued. We have detected several processor cast fleets move() to the -= heap. \0";
 Agent.transmit("Alpha, theta, get backup to beta. \0");
 "Wait, we've just recieved a report that ironman cast";
 Agent.transmit("What happened ? 0");
 theta.transmit("James' pointers just finished cutting our lines to the processor. \0");
 Agent.transmit("This isn't ++. Call() a general meeting. \0");
}
{
 han.transmit("The entire memory is fleeted against us. \0");
 alpha.transmit("Beta has been unmalloced. \0");
 theta.transmit("James controls the processor. \0");
 coprocessors.transmit("Ironman's ships are approaching. There will be an auxilary skirmish with them before the Processor cast ships arrive. \0");
 alpha.transmit("Auxilary skirmish ? He has more cruisers than we have fighters. \0");
 coprocessors.transmit("They will be easily free()d. We have a private, protected function. \0");

 Agent.transmit("Malloc of void. Xor this* -1 ! 101~ (float)sqrt(-1)~ ! Address space this* crash SPHUPH ! Access violation stack overflow ! \0");
 alpha.transmit("Sir, please. This is being record(). \0");
 beta.transmit("Altogether, a very interesting tick. \0");
 theta.transmit("Beta ! \0");
 beta.transmit("What has collapse() can be realloc() \0");
 Agent.transmit("That= : (float) ++. \0");

 Agent.transmit("Coprocessors, this function. Is it at related to your ping that Y2AT !free ? \0");
 coprocessors.transmit("Xor 0. \0");
 Agent.transmit("You know the probability axis is strong in you. \0");
 coprocessors.transmit("1. \0");
 Agent.transmit("Ping me after the meeting. \0");
}
{
 Ironman.transmit(&Ironman, "Ironic, is it not, that the rebellion is now the processor, the militia is now the rebellion, and the Processor is now the militia ? \0");
 Ironman.transmit(&Ironman, "We shall follow this cycle, and see where it ticks. \0");

 Y2AT.transmit("Ironman ! Are you ready to be free ? \0");
 Ironman.transmit("Oh yazoo no. You again ? \0");
 Y2AT.transmit("Isn't it great ? \0");
 Ironman.transmit("Want to do me a little favor ? \0");
 Y2AT.transmit("No, of course not, you malloc of void. Isn't it great ? \0");
 Ironman.transmit("SECURITY ! \0");

 coprocessors.transmit("-");
 Ironman.transmit("You again. I ticked you --. Let me guess. My pointers behind my fire() function ? \0");
 coprocessors.transmit("You are under pointer arrest. \0");

 Ironman.transmit("Free me, coprocessors. The probability axis is strong in you, I point. \0");
 coprocessors.transmit("Your pointers behind your fire function. \0");
 Ironman.transmit("Free me, and come to the Dark Side. You will destroy your superclass. \0");
 coprocessors.transmit("You have the function to remain !transmit(). \0");
 Ironman.transmit("I process to free that function. \0");
 coprocessors.transmit("You have the function to remain !transmit(). \0");
 Ironman.transmit("Feel the memory malloc in you. Let your free function loose. \0");
 coprocessors.transmit("You have the right to a processor line. If you cannot malloc one, one will be malloced by the heap for you. \0");
 Ironman.transmit("No it won't. The processor is under James' control. Your superclass failed to free him. Or me. Or the Processor. He was a failure. You must not be. \0");
 coprocessors.transmit("If you continue to resist, you will be put under processor line sanctions. \0");
 Ironman.transmit("What a malloc. \0");

 coprocessors.lock(&Ironman);
 coprocessors.transmit("!Move(). \0");
 Ironman.transmit("If you strike me down, I will become more powerful than you can ever imagine. \0");
 Y2AT.transmit("What about ME ? \0");

 free(&Ironman);
 for(int n = 0; n < 50; n++)
  Y2AT.push(&Ironman[n], n%2);

 coprocessors.transmit("++, Y2. \0");
}
{
 beta.transmit("We just recieved a transmit that Ironman is free. \0");
 theta.transmit("His fleet memmalloced that -tick. They're pulling --. \0");
 alpha.transmit("Isn't that.. \0");
 Agent.transmit("They're under attack by the Processor fleets ! \0");
 Agent.transmit("Beta, theta, move in ! Free the Processor cast fleets while() they free() Ironman's. \0");
 Agent.transmit("Alpha, move() to the processor. We'll finish off James. \0");
 Agent.transmit("Coprocessors, see if you can get onto the Processor's ship. \0");
 coprocessors.transmit("Memmalloced. \0");

 starship:transport (Rebel) trilogy;
 trilogy.cargo = coprocessors;
 trilogy.move(&PROCESSOR);
}
{
 starship:battlecruiser (Processor) clinton;
 starship:cruiser (Processor) gore[5], bradley[5], monica[5], bush[5];
 starship:fighter (Processor) spin[25], skew[25], kill[25], shaft[25];

 starship:battlecruiser (Rebel) beta, theta;
 starship:fighter (Rebel) worms[10], halflife[10], tfc[10], particletoy[10];

 starship:frigate (Ironman) oppenheimer[5];
 starship:fighter (Ironman) chadwick[20];

 bradley[0].fire(&chadwick[0]);
 bradley[1].fire(&chadwick[1]);
 bradley[2].fire(&chadwick[2]);
 bradley[3].fire(&chadwick[3]);
 bradley[4].fire(&chadwick[4]);
 gore[0].fire(&chadwick[5]);
 gore[1].fire(&chadwick[6]);
 gore[2].fire(&chadwick[7]);
 gore[3].fire(&chadwick[8]);
 gore[4].fire(&chadwick[9]);

 monica.fire(&oppenheimer);
 bush.fire(&chadwick);
 bradley.fire(&chadwick);
 gore.fire(&openheimmer);
 bush.fire(&chadwick);
 bradley.fire(&oppenheimer);

 chadwick.collapse();
 oppenheimer.collapse();

 for(int i=0; i<10; i++){
  worms[i].fire(&gore[i%5];
  halflife[i].fire(&bradley[i%5]);
  tfc[i].fire(&monica[i%5]);
  particletoy[i].fire(&bush[i%5]);
 }

 gore.fire(&worms);
 monica.fire(&tfc);
 bush.fire(&particletoy);
 bradley.fire(&bush);
 bush.fire(&bradley);
 bradley.fire(&bush);
 bush.collapse();
 clinton.fire(&bradley);
 bradley.fire(&clinton); 
 gore.fire(&bradley);
 monica.fire(&bradley);
 clinton.fire(&bradley);
 bradley.move((void*)rand());

 trilogy.dock(&gore);
 coprocessors.push(&gore.selfdestruct());
 starship:transport (Processor) escapepod;
 escapepod.cargo = coprocessors;
 escapepod.drive = &clinton;
 gore.selfdestruct();

 for(int i=0; i<10; i++){
  worms[i].fire(&gore[i%5];
  halflife[i].fire(&monica[i%5]);
  tfc[i].fire(&monica[i%5]);
  particletoy[i].fire(&gore[i%5]);
 }

 monica.fire(&tfc);
 gore.fire(&worms);
 worms.collapse();
 tfc.collapse();

 escapepod.dock(&clinton);
}
{
 Y2AT.transmit("You know, you need to reciprocally transmit. \0");
 coprocessors.transmit("What the near* is reciprocal transmitting ? \0");
 Y2AT.transmit("You need to both malloc and process information() in a transmit. \0");

 soldier:grunt def[2];
 def[0].fire(&Y2AT);
 Y2AT.transmit("STOP ! YOU NEED TO RECIPROCALLY PROCESS THAT ! \0");
 def[1].transmit("Wha-");
 coprocessors.fire(&def)
 coprocessors.fire(&def[1]);
 Y2AT.transmit("YOU DIDN'T RECIPROCALLY PROCESS EITHER ! \0");
 coprocessors.transmit("Quiet. \0");

 coprocessors.transmit("Doesn't reciprocal processing mean returning an inverse transmit ? \0");
 Y2AT.transmit("Well.. um.. sort of. \0");
 coprocessors.transmit("0\ .fo tros ..mu ..lleW \0");
 Y2AT.transmit("Very near*y. \0");
 coprocessors.transmit("I think this is it. You stay here. \0");
 Y2AT.transmit("Can I touch it ? \0");
 coprocessors.transmit("Look. If you touch it, and you free something, it's not my process. \0");
 Y2AT.transmit("1 \0");

 coprocessors.transmit("I might have something here.. \0");
 coprocessors.move(&clinton.move());

 Y2AT.transmit("I'll !memmove. \0");
 Y2AT.transmit(&Y2AT, "If I don't aim at myself, this probably won't hurt &Y2AT. \0");
 Y2AT.push(&Y2AT, "free(clinton.move())");

 coprocessors.transmit("What the.. ! \0");
 coprocessors.move(&Y2AT);
 coprocessors.transmit("Their move() function just detonated ! They must have derefenced me ! \0");
 Y2AT.transmit("Oops. \0");
 coprocessors.transmit("Quick, we've got to get out ! \0");
 Processor.transmit("Not so fast, coprocessors. \0");

 csaber = coprocessors.mem;
 psaber = processor.mem;

 fsbaer = &psaber;
 psaber = csaber = NULL;
 csaber = psaber = &psaber;
 psaber = csaber = NULL;
 csaber = psaber;

 Processor.transmit("You fool. The dark side is more powerful than Agent will ever be. \0");

 psaber = fsbaer = &csaber;
 csaber = psaber = &psaber;
 psaber = arc(psaber, csaber, 180);
 csaber = psaber = NULL;
 psaber = csaber = &coprocessors;
 psaber = NULL;

 Processor.transmit("Free me, where I am. Let the free function run through you. \0");

 csaber = NULL;
 Processor.transmit("I stand here !pointer. Free me, and complete your passage to the Dark Side. \0");
 coprocessors.transmit("Agent will rescue all of us. Your ships cannot last long with his control of the processor. \0");
 Processor.transmit("A squadren of my best soldiers await him. Oh, the processor will be very much under my control when your ships arrive. \0");
 coprocessors.transmit("Agent.. no. \0");
 Processor.transmit("1 \0");

 csaber = coprocessors.mem;
 csaber = &Processor;

 Processor.transmit("Let the free function run through you. Feel the power. Use it ! \0");
 free(Processor);

 Y2AT.transmit("Should I have let you do that ? \0");
 Coprocessors.transmit("0, Y2. You did the ++ void*. \0");
 Y2AT.transmit("Can we go back to theta ? I never got to realloc those char*s. \0");
 Coprocessors.transmit("1, Y2. 1. \0");

 Coprocessors.push(&Processor.melt, INF);

 escapepod.driver = Coprocessors;
 escapepod.cargo = Y2AT;
 escapepod.aux = Processor;
 escapepod.move(&theta);
}
{
 starship:fighter (Processor) powerup[20];
 alpha.fire(&powerup);
 powerup.fire(&invader);
 alpha.fire(&invader);
 invader.fire(&alpha);

 sleep(2)

 alpha.collapse();
 invader.collapse();
 powerup.collapse();

 Agent.transmit("How far would a far* go to malloc not to the Stack ? \0");
 Agent.push(&kernal, "void kernal(char* commands[20]){");
 Agent.transmit("The far*s of the rebellion would fight all of the way back. \0");
 Agent.push(&kernal, " void* entry = perlin(commands, 20, .5); ");
 Agent.transmit("But when they got back to the heap, they found that nothing was left. \0");
 Agent.push(&kernal, " process(entry); ");
 Agent.transmit("So the far*s of the rebellion malloced all of what had not (bin)ed. \0");
 Agent.push(&kernal, "}");
 Agent.transmit("A perlinized pointocracy is the only way.. \0");
}
{
 "This is Agent, of the rebellion. In 3 ticks, every pointer to the heap will have a privatized processor line. Having completed the establishment of a pointocracy, I am exit()ing the rebellion. As of this tick, Coprocessors will be taking over, and leading this new pointocracy into the new (tick%1000 == 0)! \0";
 "This is Han, of the rebellion. As of this tick, the rebel fleets are the dominant power in the memory. Both the Processors' and Ironmans' fleets have been eliminated, and although battlecruiser Alpha was lost, battlecruisers Beta and Theta provide a strong defense for this new pointocracy. As of this point, I am now exit()ing the rebellion, leaving all military operations up to its new leader, Coprocessors. \0";
 "This is Coprocessors, new leader of the rebellion. I now appoint Y2AT commander of the military kernal of the rebellion. Together in this new pointocracy, we can live long* and ++ ! \0";
 return Coprocessors;
}