void
finalcleanup ( void )
{
/* 10 */ smallnumber c ;
c = curmod ;
if ( jobname == 0 )
openlogfile () ;
while ( inputptr > 0 ) if ( ( curinput .indexfield > 15 ) )
endtokenlist () ;
else endfilereading () ;
while ( loopptr != 0 ) stopiteration () ;
while ( openparens > 0 ) {
print ( 1078 ) ;
decr ( openparens ) ;
}
while ( condptr != 0 ) {
printnl ( 1079 ) ;
printcmdmod ( 2 , curif ) ;
if ( ifline != 0 )
{
print ( 1080 ) ;
printint ( ifline ) ;
}
print ( 1081 ) ;
ifline = mem [condptr + 1 ].cint ;
curif = mem [condptr ].hhfield .b1 ;
loopptr = condptr ;
condptr = mem [condptr ].hhfield .v.RH ;
freenode ( loopptr , 2 ) ;
}
if ( history != 0 ) {
if ( ( ( history == 1 ) || ( interaction < 3 ) ) ) {
if ( selector == 3 )
{
selector = 1 ;
printnl ( 1082 ) ;
selector = 3 ;
}
}
}
if ( c == 1 )
{
;
#ifdef INIMF
if ( iniversion )
{
storebasefile () ;
goto lab10 ;
}
#endif /* INIMF */
printnl ( 1083 ) ;
goto lab10 ;
}
lab10: ;
}
void exitCustomFunc()
{
if(img == NULL)
{
img = NULL;
}
glColor3f(RGB(0x00), RGB(0x00), RGB(0x00));
printnl("Tem certeza que quer sair?", 100, 430, 8, 15);
//glRasterPos2i( 300, 100 );
//glDrawPixels( MAXCOL, MAXROW, GL_RGB, GL_UNSIGNED_BYTE, img );
printnl("Autor: CC5P28\nClique na imagem da esquerda ou aperte \"Sim\", e entao enter para sair.", 230, 100, 7, 15);
}
int main()
{
#if defined (__LINKED_LIST__)
struct node * n;
printnl(n); // detect a new type
#endif
printnl('a'); // prints "97"
printnl((char)'a'); // prints "a"
printnl(123); // prints "123"
printnl(1.234); // prints "1.234000"
return 0;
}
void printstringsw(char **ss, int n, int slen, int width)
{
int k, kmod ;
char fmt[10], s1[5] ;
sprintf(s1, "%ds", slen) ;
strcpy (fmt, "%") ;
strcat(fmt, s1) ;
for (k=0; k<n; ++k) {
if (ss[k] != NULL) printf(fmt, ss[k]) ;
else printf(fmt, "NULL") ;
kmod = (k+1) % width ;
if ((kmod == 0) && (k < (n-1))) {
printnl() ;
}
}
printnl() ;
}
void printstrings(char **ss, int n)
{
int k ;
for (k=0; k<n; ++k) {
if (ss[k] != NULL) printf("%s", ss[k]) ;
else printf("%s", "NULL") ;
printnl() ;
}
}
int main(int argc, char **argv)
{
char **eglist ;
int numeg ;
int i, j, k, pos;
int *vv ;
SNP *cupt, *cupt2 ;
Indiv *indx ;
double y1, y2, y ;
int n0, n1, nkill ;
int nindiv = 0 ;
int nignore, numrisks = 1 ;
SNP **xsnplist ;
Indiv **xindlist ;
int *xindex ;
int nrows, ncols, m ;
double *XTX, *cc, *evecs, *ww ;
double *lambda ;
double *tvecs ;
int weightmode = NO ;
int t ;
double *xmean, *xfancy ;
double *ldmat = NULL, *ldmat2 = NULL;
double *ldvv = NULL, *ldvv2 = NULL, *vv2 = NULL ;
int chrom, numclear ;
double gdis ;
int outliter, numoutiter, *badlist, nbad ;
int a, b, n ;
FILE *outlfile ;
int xblock, blocksize=10000 ;
double *tblock ;
OUTLINFO *outpt ;
int *idperm, *vecind ; // for sort
readcommands(argc, argv) ;
printf("## smartrel version: %s\n", WVERSION) ;
packmode = YES ;
setomode(&outputmode, omode) ;
if (parname == NULL) return 0 ;
if (xchrom == (numchrom+1)) noxdata = NO ;
if (fstonly) {
printf("fstonly\n") ;
numeigs = 0 ;
numoutliter = 0 ;
numoutiter = 0 ;
outputname = NULL ;
snpeigname = NULL ;
}
if (fancynorm) printf("norm used\n\n") ;
else printf("no norm used\n\n") ;
nostatslim = MAX(nostatslim, 3) ;
outlfile = ofile = stdout;
if (outputname != NULL) openit(outputname, &ofile, "w") ;
if (outliername != NULL) openit(outliername, &outlfile, "w") ;
if (fstdetailsname != NULL) openit(fstdetailsname, &fstdetails, "w") ;
numsnps =
getsnps(snpname, &snpmarkers, 0.0, badsnpname, &nignore, numrisks) ;
numindivs = getindivs(indivname, &indivmarkers) ;
k = getgenos(genotypename, snpmarkers, indivmarkers,
numsnps, numindivs, nignore) ;
if (poplistname != NULL)
{
ZALLOC(eglist, numindivs, char *) ;
numeg = loadlist(eglist, poplistname) ;
seteglist(indivmarkers, numindivs, poplistname);
}
else
{
setstatus(indivmarkers, numindivs, NULL) ;
ZALLOC(eglist, MAXPOPS, char *) ;
numeg = makeeglist(eglist, MAXPOPS, indivmarkers, numindivs) ;
}
for (i=0; i<numeg; i++)
{
/* printf("%3d %s\n",i, eglist[i]) ; */
}
nindiv=0 ;
for (i=0; i<numindivs; i++)
{
indx = indivmarkers[i] ;
if(indx -> affstatus == YES) ++nindiv ;
}
for (i=0; i<numsnps; i++)
{
cupt = snpmarkers[i] ;
chrom = cupt -> chrom ;
if ((noxdata) && (chrom == (numchrom+1))) cupt-> ignore = YES ;
if (chrom == 0) cupt -> ignore = YES ;
if (chrom > (numchrom+1)) cupt -> ignore = YES ;
}
for (i=0; i<numsnps; i++)
{
cupt = snpmarkers[i] ;
pos = nnint(cupt -> physpos) ;
if ((xchrom>0) && (cupt -> chrom != xchrom)) cupt -> ignore = YES ;
if ((xchrom > 0) && (pos < lopos)) cupt -> ignore = YES ;
if ((xchrom > 0) && (pos > hipos)) cupt -> ignore = YES ;
if (cupt -> ignore) continue ;
if (numvalidgtx(indivmarkers, cupt, YES) <= 1)
{
printf("nodata: %20s\n", cupt -> ID) ;
cupt -> ignore = YES ;
}
}
if (killr2) {
nkill = killhir2(snpmarkers, numsnps, numindivs, r2physlim, r2genlim, r2thresh) ;
if (nkill>0) printf("killhir2. number of snps killed: %d\n", nkill) ;
}
ZALLOC(vv, numindivs, int) ;
numvalidgtallind(vv, snpmarkers, numsnps, numindivs) ;
for (i=0; i<numindivs; ++i) {
if (vv[i] == 0) {
indx = indivmarkers[i] ;
indx -> ignore = YES ;
}
}
free(vv) ;
numsnps = rmsnps(snpmarkers, numsnps, NULL) ; // rid ignorable snps
if (missingmode)
{
setmiss(snpmarkers, numsnps) ;
fancynorm = NO ;
}
if (weightname != NULL)
{
weightmode = YES ;
getweights(weightname, snpmarkers, numsnps) ;
}
if (ldregress>0)
{
ZALLOC(ldvv, ldregress*numindivs, double) ;
ZALLOC(ldvv2, ldregress*numindivs, double) ;
ZALLOC(vv2, numindivs, double) ;
ZALLOC(ldmat, ldregress*ldregress, double) ;
ZALLOC(ldmat2, ldregress*ldregress, double) ;
setidmat(ldmat, ldregress) ;
vst(ldmat, ldmat, 1.0e-6, ldregress*ldregress) ;
}
ZALLOC(xindex, numindivs, int) ;
ZALLOC(xindlist, numindivs, Indiv *) ;
ZALLOC(xsnplist, numsnps, SNP *) ;
if (popsizelimit > 0)
{
setplimit(indivmarkers, numindivs, eglist, numeg, popsizelimit) ;
}
nrows = loadindx(xindlist, xindex, indivmarkers, numindivs) ;
ncols = loadsnpx(xsnplist, snpmarkers, numsnps, indivmarkers) ;
printf("number of samples used: %d number of snps used: %d\n", nrows, ncols) ;
/**
cupt = xsnplist[0] ;
for (j=0; j<nrows; ++j) {
k = xindex[j] ;
g = getgtypes(cupt, k) ;
indx = indivmarkers[k] ;
t = indxindex(eglist, numeg, indx -> egroup) ;
printf("yy1 %20s %20s %20s %d %d %d\n", cupt ->ID, indx -> ID, indx -> egroup, j, k, g) ;
}
printf("yya: ") ; printimat(xindex, 1, nrows) ;
printf("zzindxa: %s\n", indivmarkers[230] -> egroup) ;
*/
/* printf("## nrows: %d ncols %d\n", nrows, ncols) ; */
ZALLOC(xmean, ncols, double) ;
ZALLOC(xfancy, ncols, double) ;
ZALLOC(XTX, nrows*nrows, double) ;
ZALLOC(evecs, nrows*nrows, double) ;
ZALLOC(tvecs, nrows*nrows, double) ;
ZALLOC(lambda, nrows, double) ;
ZALLOC(cc, nrows, double) ;
ZALLOC(ww, nrows, double) ;
ZALLOC(badlist, nrows, int) ;
blocksize = MIN(blocksize, ncols) ;
ZALLOC(tblock, nrows*blocksize, double) ;
// xfancy is multiplier for column xmean is mean to take off
// badlist is list of rows to delete (outlier removal)
numoutiter = 1 ;
if (numoutliter>=1)
{
numoutiter = numoutliter+1 ;
ZALLOC(outinfo, nrows, OUTLINFO *) ;
for (k=0; k<nrows; k++)
{
ZALLOC(outinfo[k], 1, OUTLINFO) ;
}
/* fprintf(outlfile, "##%18s %4s %6s %9s\n", "ID", "iter","eigvec", "score") ; */
}
for (outliter = 1; outliter <= numoutiter ; ++outliter) {
if (fstonly) {
setidmat(XTX, nrows) ;
vclear(lambda, 1.0, nrows) ;
break ;
}
if (outliter>1) {
ncols = loadsnpx(xsnplist, snpmarkers, numsnps, indivmarkers) ;
}
vzero(XTX, nrows*nrows) ;
vzero(tblock, nrows*blocksize) ;
xblock = 0 ;
vzero(xmean, ncols) ;
vclear(xfancy, 1.0, ncols) ;
for (i=0; i<ncols; i++)
{
cupt = xsnplist[i] ;
chrom = cupt -> chrom ;
getcolxz(cc, cupt, xindex, nrows, i, xmean, xfancy, &n0, &n1) ;
t = MIN(n0, n1) ;
if (t <= minallelecnt) {
cupt -> ignore = YES ;
vzero(cc, nrows) ;
}
if (weightmode)
{
vst(cc, cc, xsnplist[i] -> weight, nrows) ;
}
if (ldregress>0)
{
numclear = 0 ;
for (k=1; k<= ldregress; ++k)
{
j = i-k ;
if (j<0)
{
numclear = ldregress-k+1 ;
break ;
}
cupt2 = xsnplist[j] ;
if (cupt2 -> chrom != chrom) gdis = ldlimit + 1.0 ;
else gdis = cupt -> genpos - cupt2 -> genpos ;
if (gdis>=ldlimit)
{
numclear = ldregress-k+1 ;
break ;
}
}
if (numclear>0) clearld(ldmat, ldvv, ldregress, nrows, numclear) ;
ldreg(ldmat, ldmat2, cc, vv2, ldvv, ldvv2, ldregress, nrows) ;
copyarr(ldmat2, ldmat, ldregress*ldregress) ;
copyarr(vv2, cc, nrows) ;
copyarr(ldvv2, ldvv, ldregress*nrows) ;
}
copyarr(cc, tblock+xblock*nrows, nrows) ;
++xblock ;
/** this is the key code to parallelize */
if (xblock==blocksize)
{
domult(tvecs, tblock, xblock, nrows) ;
vvp(XTX, XTX, tvecs, nrows*nrows) ;
xblock = 0 ;
vzero(tblock, nrows*blocksize) ;
}
}
if (xblock>0)
{
domult(tvecs, tblock, xblock, nrows) ;
vvp(XTX, XTX, tvecs, nrows*nrows) ;
}
symit(XTX, nrows) ;
/**
a = 0; b=0 ;
printf("zz1 %12.6f ", XTX[a*nrows+b]) ;
a = nrows-1; b=nrows-1 ;
printf(" %12.6f %15.9g\n", XTX[a*nrows+b], asum(XTX, nrows*nrows)) ;
*/
if (verbose)
{
printdiag(XTX, nrows) ;
}
y = trace(XTX, nrows) / (double) (nrows-1) ;
if (isnan(y)) fatalx("bad XTX matrix\n") ;
/* printf("trace: %9.3f\n", y) ; */
if (y<=0.0) fatalx("XTX has zero trace (perhaps no data)\n") ;
vst(XTX, XTX, 1.0/y, nrows * nrows) ;
/// mean eigenvalue is 1
eigvecs(XTX, lambda, evecs, nrows) ;
// eigenvalues are in decreasing order
if (outliter > numoutliter) break ;
// last pass skips outliers
numoutleigs = MIN(numoutleigs, nrows-1) ;
nbad = ridoutlier(evecs, nrows, numoutleigs, outlthresh, badlist, outinfo) ;
if (nbad == 0) break ;
for (i=0; i<nbad; i++)
{
j = badlist[i] ;
indx = xindlist[j] ;
outpt = outinfo[j] ;
fprintf(outlfile, "REMOVED outlier %s iter %d evec %d sigmage %.3f\n", indx -> ID, outliter, outpt -> vecno, outpt -> score) ;
indx -> ignore = YES ;
}
nrows = loadindx(xindlist, xindex, indivmarkers, numindivs) ;
printf("number of samples after outlier removal: %d\n", nrows) ;
}
if (outliername != NULL) fclose(outlfile) ;
m = numgtz(lambda, nrows) ;
/* printf("matrix rank: %d\n", m) ; */
if (m==0) fatalx("no data\n") ;
/** smartrel code */
for (i=0; i<numeigs; i++) {
y = sqrt(lambda[i]) ;
vst(ww, evecs+i*nrows, y, nrows) ;
subouter(XTX, ww, nrows) ;
}
free(tvecs) ;
n = 0 ;
ZALLOC(vecind, nrows*nrows/2, int) ;
for (i=0; i<nrows; i++) {
for (j=i+1; j<nrows; j++) {
k = i*nrows + j ;
y1 = XTX[i*nrows+i] ;
y2 = XTX[j*nrows+j] ;
y = XTX[k]/sqrt(y1*y2) ;
y += 1/(double)(nrows-1);
if (y<relthresh) continue ;
vecind[n] = k ;
evecs[n] = -y ;
++n ;
}
}
free(XTX) ;
if (n==0) {
printf("## nothing above relthresh!\n") ;
printf("##end of smartrel run\n") ;
return 0 ;
}
ZALLOC(idperm, n, int) ;
sortit(evecs, idperm, n) ;
for (i=0; i<n; i++) {
j = idperm[i] ;
k = vecind[j] ;
a = k/nrows ;
b = k%nrows ;
printf("rel: %20s ", xindlist[a] ->ID) ;
printf("%20s ", xindlist[b] ->ID) ;
printf(" %9.3f", -evecs[i]) ;
printnl() ;
}
printf("##end of smartrel run\n") ;
return 0 ;
}
void dopop3out(char **fglist, SNP **xsnplist, int ncols, char *line, char *outpop)
{
Indiv **xindlist ;
Indiv *indx ;
int *xindex, *xtypes ;
int nrows ;
int t, k, i, trun ;
double f3score, f3scoresig ;
double f2score, f2scoresig, y, y1, y2, p, q ;
char *eglist[4] ;
int numeg = 4 ;
double ytop, ybot, yxbot ;
double ztop, zbot ;
int col ;
SNP *cupt ;
double zztop[6], yytop[6] ;
double u, s1, s2, atop, btop, alphabot, betabot, alphatop ;
double ya, yb, za, zb, yt ;
char obuff[1024], *sx ;
int nsnp = 0 ;
copystrings(fglist, eglist, 3) ;
eglist[3] = strdup(outpop) ;
ZALLOC(xindex, numindivs, int) ;
ZALLOC(xindlist, numindivs, Indiv *) ;
setstatusv(indivmarkers, numindivs, NULL, NO) ;
setstatuslist(indivmarkers, numindivs, eglist, numeg) ;
nrows = loadindx(xindlist, xindex, indivmarkers, numindivs) ;
if (nrows == 0) {
for (i=0; i<numeg; ++i) {
printf("zz %s\n", eglist[i]) ;
}
fatalx("fatal error (probably missing pop)\n") ;
}
ZALLOC(xtypes, nrows, int) ;
for (i=0; i<nrows; i++) {
indx = xindlist[i] ;
k = indxindex(eglist, numeg, indx -> egroup) ;
xtypes[i] = k ;
}
ztop = zbot = 0.0 ;
vzero(zztop, 6) ;
for (col=0; col<ncols; ++col) {
cupt = xsnplist[col] ;
if (cupt -> ignore) continue ;
loadaa(cupt, xindex, xtypes, nrows, numeg) ;
f3scz(&ytop, &ybot, cupt, indivmarkers, xindex, xtypes, nrows, 2, 0, 1) ;
if (isnan(ytop)) fatalx("zznan\n") ;
if (ybot < -0.5) continue ;
f3scz(&yytop[0], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 0, 1) ; if (yxbot < -0.5) continue ;
f3scz(&yytop[1], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 0, 2) ; if (yxbot < -0.5) continue ;
f3scz(&yytop[2], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 1, 2) ; if (yxbot < -0.5) continue ;
f2scz(&yytop[3], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 0, 3) ; if (yxbot < -0.5) continue ;
f2scz(&yytop[4], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 1, 3) ; if (yxbot < -0.5) continue ;
f2scz(&yytop[5], &yxbot, cupt, indivmarkers, xindex, xtypes, nrows, 3, 2, 3) ; if (yxbot < -0.5) continue ;
ztop += ytop ;
zbot += ybot ;
if ((ytop>0) || (ybot > 0)) ++nsnp ; // monomorphic snps not counted
vvp(zztop, zztop, yytop, 6) ;
}
//verbose = YES ;
ztop /= zbot ;
vst(zztop, zztop, 1.0/zbot, 6) ;
u = zztop[0] ;
vsp(yytop, zztop, -u, 6) ;
s1 = yytop[1] ; /* alpha a */
s2 = yytop[2] ;
atop = yytop[3] ;
btop = yytop[4] ;
alphabot = s1/atop ;
betabot = s2/btop ;
alphatop = 1.0-betabot ;
y1 = -ztop -s1 ;
if (s2>s1) {
alphabot = MAX(alphabot, y1/(s2-s1)) ;
}
if (s2<s1) {
alphatop = MIN(alphatop, y1/(s2-s1)) ;
}
sx = obuff ;
sx += sprintf(sx, "%s", line) ;
//printf(" %12.6f", ztop) ;
sx += sprintf(sx, " %9.3f", alphabot) ;
sx += sprintf(sx, " %9.3f", alphatop) ;
/**
// next code is computing bounds on h (drift -> C)
za = alphatop; zb = 1.0-za ;
ya = s1/za; yb = s2/zb; yt = -za*zb*(ya+yb) ; y1 = ztop - yt ;
za = alphabot; zb = 1.0-za ;
ya = s1/za; yb = s2/zb; yt = -za*zb*(ya+yb) ; y2 = ztop - yt ;
sx += sprintf(sx, " %9.3f %9.3f", y1, y2) ;
sx += sprintf(sx, " %7d", nsnp) ;
*/
printf("%s", obuff) ;
printnl() ;
if (verbose) printmatwl(yytop, 1, 6, 6) ;
if (outputname != NULL) {
fprintf(ofile, "%s\n", obuff) ;
fflush(ofile) ;
}
free(xtypes) ;
free(xindex) ;
free(xindlist) ;
freeup(eglist, 4) ;
destroyaa() ;
return ;
}
int main(int argc, char **argv)
{
SNP **snpmarkers ;
Indiv **indivmarkers ;
int numsnps, numindivs ;
unsigned char *packg1, *packg2 ;
int **snppos ;
int *snpindx ;
int lsnplist, lindlist, numeg ;
int i,j;
SNP *cupt, *cupt1, *cupt2, *cupt3 ;
Indiv *indx ;
int ch1, ch2 ;
int fmnum , lmnum ;
int num, n1, n2 ;
int nkill = 0 ;
int t, k, x ;
int nignore, numrisks = 1 ;
char **genolist ;
int numgenolist ;
int maxmiss ;
tersem = YES ; // no snp counts
readcommands(argc, argv) ;
setomode(&outputmode, omode) ;
packmode = YES ;
settersemode(tersem) ;
nums1 =
getsnps(snp1, &snpm1, 0.0, NULL, &nignore, numrisks) ;
putped(1) ;
freeped() ;
nums2 =
getsnps(snp2, &snpm2, 0.0, NULL, &nignore, numrisks) ;
putped(2) ;
freeped() ;
for (x=0; x<nums1; ++x) {
cupt1 = snpm1[x] ;
cupt1 -> tagnumber = -1 ;
}
for (x=0; x<nums2; ++x) {
cupt2 = snpm2[x] ;
t = x %1000 ;
// if (t==0) printf("zz %d %d\n", x, nums2) ;
k = snpindex(snpm1, nums1, cupt2 -> ID) ;
if (k<0) {
cupt2 -> ignore = YES ;
continue ;
}
cupt1 = snpm1[k] ;
cupt1 -> tagnumber = x ;
t = checkmatch(cupt1, cupt2) ;
if (t==1) continue ;
if (t==2) {
cupt2 -> isrfake = YES ;
continue ;
}
if (t<0) {
cupt1 -> ignore = cupt2 -> ignore = YES ;
continue ;
}
printf("allele funny: %s", cupt1 -> ID) ;
printalleles(cupt1, stdout) ;
printalleles(cupt2, stdout) ;
printnl() ;
cupt1 -> ignore = cupt2 -> ignore = YES ;
continue ;
}
freesnpindex() ;
numi1 = getindivs(ind1, &indm1) ;
numi2 = getindivs(ind2, &indm2) ;
for (x=0; x<numi2; ++x) {
k = indindex(indm1, numi1, indm2[x] -> ID) ;
// this code could be modified to allow duplicate individuals
if (k>=0) fatalx("dup ind: %s\n", indm2[x] -> ID) ; // fix later?
}
setgenotypename(&geno1, ind1) ;
getped(1) ;
getgenos(geno1, snpm1, indm1,
nums1, numi1, nignore) ;
packg1 = (unsigned char *) getpackgenos() ;
clearpackgenos() ;
setgenotypename(&geno2, ind2) ;
getped(2) ;
getgenos(geno2, snpm2, indm2,
nums2, numi2, nignore) ;
packg2 = (unsigned char *) getpackgenos() ;
numindivs = mergeit(snpm1, snpm2, &indm1, indm2, nums1, nums2, numi1, numi2) ;
snpmarkers = snpm1 ;
numsnps = nums1 ;
indivmarkers = indm1 ;
free(packg1) ;
free(packg2) ;
outfiles(snpoutfilename, indoutfilename, genooutfilename,
snpmarkers, indivmarkers, numsnps, numindivs, packout, ogmode) ;
printf("##end of mergeit run\n") ;
return 0 ;
}
void aboutCustom()
{
glColor3f(0.0, 0.0, 0.0);
printnl(" Ping! Pong!, é um simulador 3d feito em C, que utiliza a API glut.\nO objetivo é simular a fisica, assim como permitir ao usuario mudar os parametros\nque mudam o jogo como gravidade.\n \nFeito por Vitor Hugo CC5P28\n \n \nReferencias\n + OBJ Loader (glm.h & glm.c) - Nate Robins\n + Fisica de Particulos (Adaptado pra trabalhar com esferas) - Interativo\n Computer Graphics, A top Down Approache(Fith Edition) PG 574, 1997 - 2000", 100, 430, 7, 15);
}
void controlsCustom()
{
glColor3f(0.0, 0.0, 0.0);
printnl("W - Move raquete pra frente\nS - Move raquete pra tras\nD - Move raquete pra direita\nA - Move raquete pra esquerda\nR - Reseta a bola\nB - Bola pingando\n \nG & R - Reseta Gravidade\nG & R - Reseta Gravidade\nG & - - Diminui Gravidade\nG & + - Aumenta Gravidade\nC - Desabilita Habilita Colisao\nF & D - Desabilita Friccao\nG & - - Diminui Friccao\nG & + - Aumenta Friccao\n \nEsc - Pausa o Jogo", 100, 430, 7, 15);
}
void
storebasefile ( void )
{
integer k ;
halfword p, q ;
integer x ;
fourquarters w ;
ASCIIcode * baseengine ;
selector = 5 ;
print ( 1074 ) ;
print ( jobname ) ;
printchar ( 32 ) ;
printint ( roundunscaled ( internal [14 ]) ) ;
printchar ( 46 ) ;
printint ( roundunscaled ( internal [15 ]) ) ;
printchar ( 46 ) ;
printint ( roundunscaled ( internal [16 ]) ) ;
printchar ( 41 ) ;
if ( interaction == 0 )
selector = 2 ;
else selector = 3 ;
{
if ( poolptr + 1 > maxpoolptr )
{
if ( poolptr + 1 > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + 1 ;
}
}
baseident = makestring () ;
strref [baseident ]= 127 ;
packjobname ( 743 ) ;
while ( ! wopenout ( basefile ) ) promptfilename ( 1075 , 743 ) ;
printnl ( 1076 ) ;
slowprint ( wmakenamestring ( basefile ) ) ;
flushstring ( strptr - 1 ) ;
printnl ( 261 ) ;
slowprint ( baseident ) ;
dumpint ( 1462914374L ) ;
x = strlen ( enginename ) ;
baseengine = xmallocarray ( ASCIIcode , x + 4 ) ;
strcpy ( stringcast ( baseengine ) , enginename ) ;
{register integer for_end; k = x ;for_end = x + 3 ; if ( k <= for_end) do
baseengine [k ]= 0 ;
while ( k++ < for_end ) ;}
x = x + 4 - ( x % 4 ) ;
dumpint ( x ) ;
dumpthings ( baseengine [0 ], x ) ;
libcfree ( baseengine ) ;
dumpint ( 228418379L ) ;
dumpthings ( xord [0 ], 256 ) ;
dumpthings ( xchr [0 ], 256 ) ;
dumpthings ( xprn [0 ], 256 ) ;
dumpint ( 0 ) ;
dumpint ( memtop ) ;
dumpint ( 9500 ) ;
dumpint ( 7919 ) ;
dumpint ( 15 ) ;
dumpint ( poolptr ) ;
dumpint ( strptr ) ;
{register integer for_end; k = 0 ;for_end = strptr ; if ( k <= for_end) do
dumpint ( strstart [k ]) ;
while ( k++ < for_end ) ;}
k = 0 ;
while ( k + 4 < poolptr ) {
w .b0 = strpool [k ];
w .b1 = strpool [k + 1 ];
w .b2 = strpool [k + 2 ];
w .b3 = strpool [k + 3 ];
dumpqqqq ( w ) ;
k = k + 4 ;
}
k = poolptr - 4 ;
w .b0 = strpool [k ];
w .b1 = strpool [k + 1 ];
w .b2 = strpool [k + 2 ];
w .b3 = strpool [k + 3 ];
dumpqqqq ( w ) ;
println () ;
printint ( strptr ) ;
print ( 1071 ) ;
printint ( poolptr ) ;
sortavail () ;
varused = 0 ;
dumpint ( lomemmax ) ;
dumpint ( rover ) ;
p = 0 ;
q = rover ;
x = 0 ;
do {
{ register integer for_end; k = p ;for_end = q + 1 ; if ( k <=
for_end) do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + q + 2 - p ;
varused = varused + q - p ;
p = q + mem [q ].hhfield .lhfield ;
q = mem [q + 1 ].hhfield .v.RH ;
} while ( ! ( q == rover ) ) ;
varused = varused + lomemmax - p ;
dynused = memend + 1 - himemmin ;
{register integer for_end; k = p ;for_end = lomemmax ; if ( k <= for_end)
do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + lomemmax + 1 - p ;
dumpint ( himemmin ) ;
dumpint ( avail ) ;
{register integer for_end; k = himemmin ;for_end = memend ; if ( k <=
for_end) do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + memend + 1 - himemmin ;
p = avail ;
while ( p != 0 ) {
decr ( dynused ) ;
p = mem [p ].hhfield .v.RH ;
}
dumpint ( varused ) ;
dumpint ( dynused ) ;
println () ;
printint ( x ) ;
print ( 1072 ) ;
printint ( varused ) ;
printchar ( 38 ) ;
printint ( dynused ) ;
dumpint ( hashused ) ;
stcount = 9756 - hashused ;
{register integer for_end; p = 1 ;for_end = hashused ; if ( p <= for_end)
do
if ( hash [p ].v.RH != 0 )
{
dumpint ( p ) ;
dumphh ( hash [p ]) ;
dumphh ( eqtb [p ]) ;
incr ( stcount ) ;
}
while ( p++ < for_end ) ;}
{register integer for_end; p = hashused + 1 ;for_end = 9769 ; if ( p <=
for_end) do
{
dumphh ( hash [p ]) ;
dumphh ( eqtb [p ]) ;
}
while ( p++ < for_end ) ;}
dumpint ( stcount ) ;
println () ;
printint ( stcount ) ;
print ( 1073 ) ;
dumpint ( intptr ) ;
{register integer for_end; k = 1 ;for_end = intptr ; if ( k <= for_end) do
{
dumpint ( internal [k ]) ;
dumpint ( intname [k ]) ;
}
while ( k++ < for_end ) ;}
dumpint ( startsym ) ;
dumpint ( interaction ) ;
dumpint ( baseident ) ;
dumpint ( bgloc ) ;
dumpint ( egloc ) ;
dumpint ( serialno ) ;
dumpint ( 69069L ) ;
internal [12 ]= 0 ;
wclose ( basefile ) ;
}