int main()
{
std::cout << "Test of glm::translate(glm::vec3(dx, dy, dz)):" << std::endl;
std::cout << "==============================================" << std::endl;
std::cout << "glm::translate(glm::vec3(10.0f, 20.0f, 30.0f)) = " << std::endl
<< glm::translate(glm::vec3(10.0f, 20.0f, 30.0f)) << std::endl;
std::cout << "Test of glm::translate(dx, dy, dz):" << std::endl;
std::cout << "===================================" << std::endl;
std::cout << "glm::translate(10.0f, 20.0f, 30.0f) = " << std::endl
<< glm::translate(10.0f, 20.0f, 30.0f) << std::endl;
std::cout << "Test of glm::scale(glm::vec3(sx, sy, sz)):" << std::endl;
std::cout << "==========================================" << std::endl;
std::cout << "glm::scale(glm::vec3(10.0f, 20.0f, 30.0f)) = " << std::endl
<< glm::scale(glm::vec3(10.0f, 20.0f, 30.0f)) << std::endl;
std::cout << "Test of glm::scale(sx, sy, sz):" << std::endl;
std::cout << "===============================" << std::endl;
std::cout << "glm::scale(10.0f, 20.0f, 30.0f) = " << std::endl
<< glm::scale(10.0f, 20.0f, 30.0f) << std::endl;
float theta = 30.0f / 180.0f * glm::pi<float>();
std::cout << "Test of glm::rotateX(theta):" << std::endl;
std::cout << "============================" << std::endl;
std::cout << "glm::rotateX(30) = " << std::endl
<< glm::rotateX(theta) << std::endl;
std::cout << "Test of glm::rotateY(theta):" << std::endl;
std::cout << "============================" << std::endl;
std::cout << "glm::rotateY(30) = " << std::endl
<< glm::rotateY(theta) << std::endl;
std::cout << "Test of glm::rotateZ(theta):" << std::endl;
std::cout << "============================" << std::endl;
std::cout << "glm::rotateZ(30) = " << std::endl
<< glm::rotateZ(theta) << std::endl;
std::cout << "Test of glm::shearXY(glm::vec2(20.0f, 30.0f)):" << std::endl;
std::cout << "====================================" << std::endl;
std::cout << "glm::shearXY(glm::vec2(20.0f, 30.0f)) =" << std::endl
<< glm::shearXY(glm::vec2(20.0f, 30.0f)) << std::endl;
std::cout << "Test of glm::shearXY(20.0f, 30.0f):" << std::endl;
std::cout << "===================================" << std::endl;
std::cout << "glm::shearXY(20.0f, 30.0f) =" << std::endl
<< glm::shearXY(20.0f, 30.0f) << std::endl;
std::cout << "Test of glm::shearXZ(glm::vec2(20.0f, 30.0f)):" << std::endl;
std::cout << "====================================" << std::endl;
std::cout << "glm::shearXZ(glm::vec2(20.0f, 30.0f)) =" << std::endl
<< glm::shearXZ(glm::vec2(20.0f, 30.0f)) << std::endl;
std::cout << "Test of glm::shearXZ(20.0f, 30.0f):" << std::endl;
std::cout << "===================================" << std::endl;
std::cout << "glm::shearXZ(20.0f, 30.0f) =" << std::endl
<< glm::shearXZ(20.0f, 30.0f) << std::endl;
std::cout << "Test of glm::shearYZ(glm::vec2(20.0f, 30.0f)):" << std::endl;
std::cout << "====================================" << std::endl;
std::cout << "glm::shearYZ(glm::vec2(20.0f, 30.0f)) =" << std::endl
<< glm::shearYZ(glm::vec2(20.0f, 30.0f)) << std::endl;
std::cout << "Test of glm::shearYZ(20.0f, 30.0f):" << std::endl;
std::cout << "===================================" << std::endl;
std::cout << "glm::shearYZ(20.0f, 30.0f) =" << std::endl
<< glm::shearYZ(20.0f, 30.0f) << std::endl;
#if 0
glm::vec3 VRP(0.0f, 0.0f, 0.0f);
glm::vec3 VPN(0.0f, 0.0f, 1.0f);
glm::vec3 VUP(0.0f, 1.0f, 0.0f);
glm::vec3 PRP(0.0f, 0.0f, 5.0f);
glm::vec2 window_lower_left(-4.0f, -3.0f);
glm::vec2 window_upper_right(4.0f, 3.0f);
float front_clipping_plane = -5.0f;
float back_clipping_plane = -15.0f;
int window_width = 500;
int window_height = 300;
glm::mat4x4 Mtotal = ComputeMperpar(VRP, VPN, VUP,
PRP,
window_lower_left, window_upper_right,
front_clipping_plane, back_clipping_plane);
std::cout << "Mtotal" << std::endl;
std::cout << horizline << std::endl;
std::cout << Mtotal << std::endl;
std::cout << "Test of the extreme points" << std::endl;
std::cout << horizline << std::endl;
glm::vec4 Pxback(16.0f, 0.0f, -15.0f, 1.0f);
glm::vec4 TPxback = Mtotal * Pxback;
std::cout << "Pxback = [" << Pxback << "] --> [" << TPxback << "] --> ["
<< TPxback / TPxback.w << "]" << std::endl;
glm::vec4 Pyback(0.0f, 12.0f, -15.0f, 1.0f);
glm::vec4 TPyback = Mtotal * Pyback;
std::cout << "Pyback = [" << Pyback << "] --> [" << TPyback << "] --> ["
<< TPyback / TPyback.w << "]" << std::endl;
glm::vec4 Pbackcorner(16.0f, 12.0f, -15.0f, 1.0f);
glm::vec4 TPbackcorner = Mtotal * Pbackcorner;
std::cout << "Pbackcorner = [" << Pbackcorner << "] --> [" << TPbackcorner << "] --> ["
<< TPbackcorner / TPbackcorner.w << "]" << std::endl;
std::cout << std::endl;
glm::vec4 Pxfront(8.0f, 0.0f, -5.0f, 1.0f);
glm::vec4 TPxfront = Mtotal * Pxfront;
std::cout << "Pxfront = [" << Pxfront << "] --> [" << TPxfront << "] --> ["
<< TPxfront / TPxfront.w << "]" << std::endl;
glm::vec4 Pyfront(0.0f, 6.0f, -5.0f, 1.0f);
glm::vec4 TPyfront = Mtotal * Pyfront;
std::cout << "Pyfront = [" << Pyfront << "] --> [" << TPyfront << "] --> ["
<< TPyfront / TPyfront.w << "]" << std::endl;
glm::vec4 Pfrontcorner(8.0f, 6.0f, -5.0f, 1.0f);
glm::vec4 TPfrontcorner = Mtotal * Pfrontcorner;
std::cout << "Pfrontcorner = [" << Pfrontcorner << "] --> [" << TPfrontcorner << "] --> ["
<< TPfrontcorner / TPfrontcorner.w << "]" << std::endl;
#endif
return 0;
}
int main(int argc, char *argv[]) {
//declare the time period
extern int monthDay[12];
extern int periodStartYear, periodStartMonth, periodStartDay, periodStartHour, periodStartMinute;
extern int periodEndYear, periodEndMonth, periodEndDay, periodEndHour, periodEndMinute;
FILE *fp, *tmpfp, *dest;
int intbuf,qtm;
qtm = 0;
//type of scheduler
char* scheduleType = (char*)malloc(10);
//current number of array slot
int eventSize = 80;
//declare the event array, can be expanded its size twice to contain all events
Event *event = (Event*)calloc(eventSize, sizeof(*event));
//printf("allocate calloc space + %d",sizeof(*event));
int i, j,k,l,m,havevalidday;
int pid = 0;
// initialize all the data in event array (may not needed)
for (i=0; i<eventSize; i++) {
strcpy(event[i].type, "");
strcpy(event[i].name, "");
event[i].startYear = 0;
event[i].startMonth = 0;
event[i].startDay = 0;
event[i].startHour = 0;
event[i].dueYear = 0;
event[i].dueMonth = 0;
event[i].dueDay = 0;
event[i].dueHour = 0;
event[i].duration = 0;
event[i].priority = 0;
event[i].handled = 0;
event[i].startTimeValue = 0;
event[i].dueTimeValue = 0;
}
printf(" ~~WELCOME TO ASKS~~\n\n");
//declare the buffer to contain the input string
char input[100];
printf("Please enter:\n");
fgets(input, 100, stdin);
//initialize the period of schedule
char* tmp;
char* tmpforrr;
tmp = strtok(input, " ");
tmp = strtok(NULL, "-");
periodStartYear = atoi(tmp);
tmp = strtok(NULL, "-");
periodStartMonth = atoi(tmp);
tmp = strtok(NULL, " ");
periodStartDay = atoi(tmp);
tmp = strtok(NULL, ":");
periodStartHour = atoi(tmp);
tmp = strtok(NULL, " ");
periodStartMinute = atoi(tmp);
tmp = strtok(NULL, "-");
periodEndYear = atoi(tmp);
tmp = strtok(NULL, "-");
periodEndMonth = atoi(tmp);
tmp = strtok(NULL, " ");
periodEndDay = atoi(tmp);
tmp = strtok(NULL, ":");
periodEndHour = atoi(tmp);
tmp = strtok(NULL, " ");
periodEndMinute = atoi(tmp);
// time table array
int duryear = periodEndYear-periodStartYear+1;
int timetable [duryear][12][31][24];
int max = (periodEndYear-periodStartYear)*1000000+periodEndMonth*10000+periodEndDay*100+periodEndHour;
int min = periodStartMonth*10000+periodStartDay*100+periodStartHour;
int dayAmount = 0;
// initialization
int tmptime;
for(i=0; i<duryear; i++) {
for(j=0; j<12; j++) {
for(k=0; k<31; k++) {
havevalidday = 0;
for(l=0; l<24; l++) {
tmptime = i*1000000+(j+1)*10000+(k+1)*100+l;
if(tmptime<min||tmptime>max)
timetable[i][j][k][l] = -2; //day do not need, disable
else
timetable[i][j][k][l] = -1; //valid day, give -1
if(k>monthDay[j]-1)
timetable[i][j][k][l] = -2; //day do not exist, disable
if(timetable[i][j][k][l] == -1)
havevalidday = 1;
}
if(havevalidday == 1)
dayAmount++;
}
}
}
int timetablebyday[dayAmount][24];
// for counting the number of used array slot to decide whether there is need to expand the array
int eventCounter = 0;
//initialize the formal input event and put them into correct Event data type.
while(1) {
printf("Please enter:\n");
char input[100];
fgets(input, 100, stdin);
//decide whether this is the end of input
if (input[0]=='a'&&input[1]=='d'&&input[2]=='d') {
//initialize the type of event
tmp = strtok(input, " ");
for (i=3; i<strlen(tmp)+1; i++) {
*(tmp+i-3) = *(tmp+i);
}
strcpy(event[eventCounter].type, tmp);
//printf("%s\n",event[eventCounter].type);
//initialize the name of event
tmp = strtok(NULL, " ");
strcpy(event[eventCounter].name, tmp);
//printf("%s\n",event[eventCounter].name);
if (strcmp(event[eventCounter].type, "Project") != 0) {
//initialize the year of start time of this event
tmp = strtok(NULL, "-");
event[eventCounter].startYear = atoi(tmp);
//printf("%d\n",event[eventCounter].startYear);
//initialize the month of start time of this event
tmp = strtok(NULL, "-");
event[eventCounter].startMonth = atoi(tmp);
//printf("%d\n",event[eventCounter].startMonth);
//initialize the day of start time of this event
tmp = strtok(NULL, " ");
event[eventCounter].startDay = atoi(tmp);
//printf("%d\n",event[eventCounter].startDay);
//initialize the hour of start time of this event
tmp = strtok(NULL, ":");
event[eventCounter].startHour = atoi(tmp);
//printf("%d\n",event[eventCounter].startHour);
tmp = strtok(NULL, " ");
}
//test whether the event is project or assignment
if (strcmp(event[eventCounter].type, "Project") == 0 || strcmp(event[eventCounter].type, "Assignment") == 0) {
//initialize the year of due time of this event
tmp = strtok(NULL, "-");
event[eventCounter].dueYear = atoi(tmp);
//initialize the month of due time of this event
tmp = strtok(NULL, "-");
event[eventCounter].dueMonth = atoi(tmp);
//initialize the day of due time of this event
tmp = strtok(NULL, " ");
event[eventCounter].dueDay = atoi(tmp);
//initialize the hour of due time of this event
tmp = strtok(NULL, ":");
event[eventCounter].dueHour = atoi(tmp);
tmp = strtok(NULL, " ");
int minute = atoi(tmp);
if (minute > 0) {
event[eventCounter].dueHour++;
}
}
//initialize the duration
tmp = strtok(NULL, " ");
event[eventCounter].duration = atoi(tmp);
//printf("%d\n",event[eventCounter].duration);
tmp = strtok(NULL, " ");
event[eventCounter].priority = atoi(tmp);
//printf("%d\n",event[eventCounter].priority);
//expand dynamic array to contain more event (may need more tests)
eventCounter++;
if (eventCounter == eventSize) {
Event *tmpEvent = (Event*)calloc(eventSize, 80);
memcpy(tmpEvent, event, eventSize*80);
eventSize *= 2;
event = (Event*)calloc(eventSize, 80);
memcpy(event, tmpEvent, eventSize*40);
free(tmpEvent);
}
} else if(strcmp(strtok(input, "-"), "runASKS ") == 0) {
tmp = strtok(NULL, "|");
strcpy(scheduleType, tmp);
// printf("---%s---\n",scheduleType);
tmp = strtok(NULL, " ");
tmp = strtok(NULL, " ");
tmp = strtok(NULL, " ");
tmp[strlen(tmp)-2] = '\0';
fp = fopen("report.dat", "wt");
tmpfp = fopen("analysis.dat","wt");
break;
}
//printf("%d\n", eventCounter); //testing code
}//end of input module
// put all class and sleep into the timetable
int theYear;
int theMonth;
int theDay;
int theHour;
int timetablevalue;
int periodStartTimeValue = periodStartMonth*10000+periodStartDay*100+periodStartHour;
int periodEndTimeValue = duryear*1000000+periodEndMonth*10000+periodEndDay*100+periodEndHour;
for(m=0; m<eventCounter; m++) {
theYear = event[m].startYear - periodStartYear;
theMonth = event[m].startMonth;
theDay = event[m].startDay;
theHour = event[m].startHour;
if((event[m].startYear+event[m].startMonth+event[m].startDay+event[m].startHour)!=0) {
// if start time has been input, calculate the starttimevalue
event[m].startTimeValue = theYear*1000000+theMonth*10000+theDay*100+theHour;
}
else { // if start time not input, set it to the start of the period and calculate
event[m].startYear = periodStartYear;
event[m].startMonth = periodStartMonth;
event[m].startDay = periodStartDay;
event[m].startHour = periodStartHour;
theYear = event[m].startYear - periodStartYear;
theMonth = event[m].startMonth;
theDay = event[m].startDay;
theHour = event[m].startHour;
event[m].startTimeValue = theYear*1000000+theMonth*10000+theDay*100+theHour;
}
if((event[m].dueYear+event[m].dueMonth+event[m].dueDay+event[m].dueHour)!=0)
// calculate duetimevalue
event[m].dueTimeValue = (event[m].dueYear-periodStartYear)*1000000+event[m].dueMonth*10000+event[m].dueDay*100+event[m].dueHour;
// printf("%d %d %d %d\n",event[m].startYear,event[m].startMonth,event[m].startDay,event[m].startHour);
// printf("%d %d\n ",event[m].startTimeValue,event[m].dueTimeValue);
if(strcmp(event[m].type,"Class")==0||strcmp(event[m].name,"Sleep")==0) { // for class and sleep
if(event[m].startTimeValue<periodStartTimeValue) {
//printf("%s %d %d\n",event[m].name,event[m].startTimeValue,periodStartTimeValue);
continue;
}
//printf("%s %s \n",event[m].type,event[m].name);
for(i=theYear; i<duryear; i++) { //year
for(j=0; j<12; j++) { //month
for(k=0; k<31; k++) { //day
for(l=0; l<24; l++) { //hour
timetablevalue = (i)*1000000+(j+1)*10000+(k+1)*100+l+1;//time in this round of loop
if(timetablevalue > event[m].startTimeValue &&timetable[i][j][k][l] == -1) {
event[m].handled++;
// 啊啊啊腰疼疼疼疼 //printf("handled\n");
timetable[i][j][k][l] = m;
if(event[m].handled == event[m].duration) {
// printf("%d %d %d %d %s\n",i+1,j+1,k+1,l+1,event[m].type);
break;
}
}//if
if(event[m].handled == event[m].duration) {
break;
}
}//l
if(event[m].handled == event[m].duration) {
break;
}
}//k
if(event[m].handled == event[m].duration) {
break;
}
}//j
if(event[m].handled == event[m].duration) {
break;
}
}//i
}
}
//printf("%s\n",scheduleType);
if(strcmp(scheduleType, "FCFS ") == 0) {
// printf("fcfs\n");
FCFS(event,eventCounter,duryear,timetable);
scheduleType = "First Come First Serve";
}
else if(strcmp(scheduleType, "SJF ") == 0) {
// printf("sjf\n");
SJF(event,eventCounter,duryear,timetable);
scheduleType = "Short Job First";
}
else if(strcmp(scheduleType, "SRT ") == 0) {
// printf("srt\n");
SRT(event,eventCounter,duryear,timetable);
scheduleType = "Shortest Remaining Time";
}
else if(strcmp(scheduleType, "PR p ") == 0) {
// printf("pr p\n");
PRP(event,eventCounter,duryear,timetable);
scheduleType = "priority with preemption";
}
else if(strcmp(scheduleType, "PR n ") == 0) {
// printf("pr n\n");
PRN(event,eventCounter,duryear,timetable);
scheduleType = "priority without preemption";
}
else {
tmpforrr = strtok(scheduleType, " ");
if(strcmp(tmpforrr,"RR ")) {
qtm = atoi(strtok(NULL," "));
RRX(event,eventCounter,duryear,timetable,qtm);
scheduleType = "Round Robin with quantum of ";
}
}
/*for(i=0;i<duryear;i++){
for(j=0;j<12;j++){
// printf("month %d\n",j+1);
for(k=0;k<31;k++){
// printf("day %d\n",k+1);
for(l=0;l<24;l++){
if(timetable[i][j][k][l] != -2)
printf("%d ",timetable[i][j][k][l]);
}
// printf("\n");
}
}
}
printf("\n-----\n");
*/
//prepare for multi-process
int fd[2];
if(pipe(fd)<0) {
printf("pipe creation error!\n");
exit(1);
}
pid = fork();
if(pid == 0) { //child for output...
//printf("outer child %d %d\n",getpid(),getppid());
close(fd[1]);
for(i=0; i<dayAmount; i++) {
for(j=0; j<24; j++) {
if(i==0&&j<periodStartHour)
timetablebyday[i][j] = -2;
else if(i==dayAmount-1&&j>periodEndHour)
timetablebyday[i][j] = -2;
else {
read(fd[0],&intbuf,sizeof(int));
timetablebyday[i][j] = intbuf;
//printf(" %d",timetablebyday[i][j]);
}
}
}
pid = fork();
if(pid == 0) { //child of child for output
//printf("inner child %d %d\n",getpid(),getppid());
fprintf(fp, "Alex Timetable\n");
fprintf(fp, "%d-%02d-%02d %02d:%02d to %d-%02d-%02d %02d:%02d\n", periodStartYear, periodStartMonth, periodStartDay,periodStartHour, periodStartMinute, periodEndYear, periodEndMonth, periodEndDay, periodEndHour, periodEndMinute);
fprintf(fp, "time\t");
for(i=0; i<duryear; i++) {
for(j=0; j<12; j++) {
for(k=0; k<31; k++) {
havevalidday = 0;
for(l=0; l<24; l++) {
if(timetable[i][j][k][l] != -2)
havevalidday = 1;
}
if(havevalidday == 1)
fprintf(fp,"%d-%02d-%02d\t",i+periodStartYear,j+1,k+1);
}//k
}//j
}//i
fprintf(fp,"\n");
for(i=0; i<24; i++) {
fprintf(fp,"%02d:00\t",i);
for(j=0; j<dayAmount; j++) {
if(timetablebyday[j][i] == -1)
fprintf(fp,"N/A\t\t");
else if(timetablebyday[j][i] > -1)
fprintf(fp,"%s \t",event[timetablebyday[j][i]].name);
else
fprintf(fp,"invalid time\t");
}
fprintf(fp,"\n");
}
fclose(fp);
exit(0);
}
else { //parent of child for analysis
//printf("child parent %d %d\n",getpid(),getppid());
fprintf(tmpfp,"\n\n**Summary of assignments allocation**\n\n");
fprintf(tmpfp,"Algorithms used: %s",scheduleType);
if(qtm != 0)
fprintf(tmpfp,"%d",qtm);
fprintf(tmpfp,"\n");
int cnt=0;
for(i=0; i<eventCounter; i++) {
if(event[i].duration == event[i].handled)
cnt++;
}
int turntime = 0;
int tmpturntime = 0;
int tmpwaittime = 0;
int waittime = 0;
fprintf(tmpfp,"There are %d assignments scheduled. Details are as follows\n",cnt);
fprintf(tmpfp,"ASSIGNMENT\tSTART\t\t\tEND\t\t\tTURNAROUND TIME\n");
fprintf(tmpfp,"===========================================================================\n");
//finished calculate turnaround time and wait time
for(m=0; m<eventCounter; m++) {
tmpturntime = 0;
tmpwaittime = 0;
if(event[m].duration != event[m].handled)// not finished
continue;//pass
event[m].handled = 0;
for(i=0; i<duryear; i++) { //year
for(j=0; j<12; j++) { //month
for(k=0; k<31; k++) { //day
for(l=0; l<24; l++) { //hour
if(timetable[i][j][k][l]==-2)
continue;
timetablevalue = (i)*1000000+(j+1)*10000+(k+1)*100+l;//time in this round of loop
if(event[m].startTimeValue<timetablevalue+1) {
tmpwaittime++;
tmpturntime++;
}
if(timetable[i][j][k][l] == m) {
if(event[m].handled==0) {
event[m].startYear = i+periodStartYear;
event[m].startMonth = j+1;
event[m].startDay = k+1;
event[m].startHour = l;
}
event[m].handled++;
tmpwaittime--;
if(event[m].handled == event[m].duration) {
fprintf(tmpfp,"%s\t%d-%02d-%02d %02d:00\t%d-%02d-%02d %02d:00\t%dHrs\t\n",event[m].name,event[m].startYear,event[m].startMonth,event[m].startDay,event[m].startHour,i+periodStartYear,j+1,k+1,l,tmpturntime);
turntime = turntime + tmpturntime;
waittime = waittime + tmpwaittime;
break;
}
}
}//l
if(event[m].handled == event[m].duration) {
break;
}
}//k
if(event[m].handled == event[m].duration) {
break;
}
}//j
if(event[m].handled == event[m].duration) {
break;
}
}//i
}
fprintf(tmpfp," -end-\n");
fprintf(tmpfp,"\n===========================================================================\n");
fprintf(tmpfp,"**PERFORMANCE\n\n");
fprintf(tmpfp,"AVERAGE TURNAROUND TIME FOR ASSIGNMENTS: %d HRS\n",turntime/cnt);
fprintf(tmpfp,"AVERAGE WAITINGTIME FOR ASSIGNMENTS: %d HRS\n",waittime/cnt);
fprintf(tmpfp,"\n**Outstanding/Rejected List**\n\n");
m=0;
for(i=0; i<eventCounter; i++)
if(event[i].duration!=event[i].handled) {
m++;
fprintf(tmpfp,"%s %s\n",event[i].type,event[i].name);
}
fprintf(tmpfp,"There are %d events rejected.\n\n\n",m);
fclose(tmpfp);
//remove("analysis.dat");
waitpid();
exit(0);
}
}
else { //parent
close(fd[0]);
//printf("parent %d %d\n",getpid(),getppid());
for(i=0; i<duryear; i++) {
for(j=0; j<12; j++) {
for(k=0; k<31; k++) {
for(l=0; l<24; l++) {
if(timetable[i][j][k][l] != -2) {
intbuf = timetable[i][j][k][l];
// printf(" %d \n ",intbuf);
write(fd[1],&intbuf,sizeof(int));
}
}
}
}
}
waitpid();
sleep(1);
fp = fopen("report.dat", "r");
tmpfp = fopen("analysis.dat","r");
dest = fopen(tmp,"a+");
char byte;
while (!feof(fp)) {
fread(&byte, sizeof(char), 1, fp);
fwrite(&byte, sizeof(char), 1, dest);
}
close(fp);
while (!feof(tmpfp)) {
fread(&byte, sizeof(char), 1, tmpfp);
fwrite(&byte, sizeof(char), 1, dest);
}
close(tmpfp);
close(dest);
remove("report.dat");
remove("analysis.dat");
exit(0);
}
}
