What's the World's Fastest Computer Used For?

Sharing an interesting article

Albeit it's a specialized machine, that's still pretty effin' impressive! I thought it intersting that the primary server is a Xeon based machine considering all the press about Cray with their Opteron based machines.

Enjoy!

http://en.wikipedia.org/wiki/MDGRAPE-3

Would love to see the F@H scores. 8O

...Not interested, moving on .



I wonder how fast it would be if they let Wusy overclock it. 8O

Why would you want it if you cannot even benchamrk it, yet alone play games,.

...Snooze

But....
Does the computer have any c2ds? No.
Any PCI-E ATI/Nvidia flagship cards? No.
At least the new SB XiFi? Not a chance.


Does it come with the new 30in displays? Nope.
Does it have a Razor gamming mouse? Nuh uh.
Does it have any Raptor 10k rpm disks? No.

Does it run Dos games any faster? Doubt it.
Can it cacluate how soon it will be a waste of 800 million dollars? Ya, but so can my Ti83.


(a joke).
Its amazing what these computers can actualy do.

Hmm...who could that be???

Stock Air Cooling. The processors at the very bottom of the CPU "chimney" have been upgraded to Zalman CPU coolers.

Doughbuy...

"I am invincible" Are you refering to Mr. Burns? Cause thats the best moment in the Simpsons series.

James Bond Goldeneye "Boris Grishenko" aka Alan Cumming

How many ATI boards would that equate to?

Ummm Russian Computer geek from James Bond: Goldeneye.

With that machine, you could play Mindsweeper in a field a googolplex^2 with a trillion trillion trillion trillion trillion trillion mines. May be a bit boring though. Might want to up the mine count to 10x10^10^10^2

As a side note, i read in Pop Sci a few months ago about a cluster of PCs that run some evolution software. This software is meant to solve problems/ fit specifications for many things. It works by taking into account all physical laws and design specifications, then through evolution simulation (this mixed with that gives.... the result is then mixed with that yields etc) it comes up with a solution.

The example problem Pop Sci talked about was a project from NASA it was given to find the perfect design for an antenna to transmit or recieve (i forget) a certain signal... its solution was very surprising in its physical attributes, but it functioned optimally over any other design available. (it endede up being about the size of a paper clip undone, in some strange shape made up of bends all over the place.)

I want that software on my PC!!

Meh, if Zalman was selling fans for that supercomputer, they would make so much money with their overpriced pieces of metal...

I'm pretty sure they keep the area superclean too, wonder how loud it is, since they probably use a combination of A/C and fans like most servers do... shrug

You beat me to it Vas.

Sure and then a lively game of solitaire.

Why not look it up on top500.org?

Post it here. remember to include every number from 0-1 googleplex. Thanks.

Note: sorry it ment to say "to 1 googleplex".

.... it was ajoke. You cant post every number from 1 to a googlepex, not even for $100 bucks.

O RRY?
[code:1:1e5ec22f0b]#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <io.h>
#include <alloc.h>
#include <ctype.h>
#include <conio.h> // Dasicksayshi;)
#include <string.h>

#ifndef __LARGE__
#error PI should compiled in the LARGE memory model for best results!
#endif

#ifdef __cplusplus
long min(long value1, long value2);
long min(long value1, long value2)
{
return ( (value1 < value2) ? value1 : value2);
}

long max(long value1, long value2);
long max(long value1, long value2)
{
return ( (value1 > value2) ? value1 : value2);
}
#endif

#define MAX_STOR 10^100000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
0000000000000000000000000000000000^1000000000000
000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
^10000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000
^10000000000000000000000000000000000000000000000
// You wanted a googol.

static struct {
long
count,n,i,col,col1,loc, swaps,
stor[MAX_STOR];
} GLOBAL = {
0, 0, 0, 0, 0, 0, 0,
{0} // We need to initialize only stor[0].
};

/****************************************************************************/

static void out(char *s, ...);
static void out(char *s, ...)
/* Prints args to stdout, and, if stdout is not a tty, to stderr, too. */
{
va_list argptr; /* Pointer to arguments */

va_start(argptr, s);
vfprintf(stdout, s, argptr);
//if (!isatty(fileno(stdout))) vfprintf(stderr, s, argptr);
va_end(argptr);
}

#if 0
void shift(long *l1,long *l2,long lp,long lmod)
{
long k;

k =((*l2) > 0 ? (*l2) / lmod : -(-(*l2) / lmod) -1);
*l2 -= k * lmod;
*l1 += k * lp;
}
#endif

#define shift(l1,l2,lp,lmod) { \
k =((l2) > 0 ? (l2) / (lmod) : -(-(l2) / (lmod)) -1); \
l2 -= k * (lmod); \
l1 += k * (lp); \
}

static void yprint(long m);
static void yprint(long m)
{
if (GLOBAL.count < GLOBAL.n)
{
if (++GLOBAL.col == 6)
{
GLOBAL.col = 1;
if (++GLOBAL.col1 == 10)
{
GLOBAL.col1 = 0;
out("\n%4ld", m%10);
} else {
out("%2ld", m%10);
}
} else {
out("%ld", m);
}
GLOBAL.count++;
}
}

static void xprint(long m);
static void xprint(long m)
{
long ii,wk,wk1;

if (m < 8) {
for (ii = 1; ii <= GLOBAL.loc;)
yprint(GLOBAL.stor[(int)(ii++)]);
GLOBAL.loc = 0;
} else if (m > 9) {
wk = m / 10;
m %= 10;
for (wk1 = GLOBAL.loc; wk1 >= 1; wk1--)
{
wk += GLOBAL.stor[(int)wk1];
GLOBAL.stor[(int)wk1] = wk % 10;
wk /= 10;
}
}

GLOBAL.stor[(int)(++GLOBAL.loc)] = m;
#if 0
if (GLOBAL.loc >= MAX_STOR) {
fprintf(stderr, "GLOBAL.loc = %ld, MAX_STOR=%ld.\n", GLOBAL.loc, MAX_STOR);
}
#endif
}

//------------------------------------------------------------------------

static int
CONT=0, // 1 when continuing a saved session
SWAP_FILES_OPEN=0,
ALL_IN_RAM=0;
// Whether enough RAM was allocated to do computations w/o swap files

static long SWAPS=0; // How many swaps done this session

static long huge *mf, huge *ms;
static FILE *MF_FP=NULL, *MS_FP=NULL;

static long
RANGE_SIZE = 0, // How many longs are allocated to mf/ms
RANGE_LOW = 0, // VIRTUAL index of mf/ms[0]
RANGE_HIGH = 0, // VIRTUAL index of mf/ms[RANGE_COUNT-1]
RANGE_COUNT = 0; // How many valid longs in mf/ms

static char* SWAPPATHNAME1 = "";
static char* SWAPPATHNAME2 = "";
static char* DATAPATHNAME = "";

static char SWAPBASENAME1[] = "PI_MF.SWP";
static char SWAPBASENAME2[] = "PI_MS.SWP";
static char DATABASENAME[] = "PI.DAT";

static char
*SWAPFILENAME1, // Gets built out of SWAPPATHNAME1 + SWAPBASENAME1
*SWAPFILENAME2, // Ditto, respectively
*DATAFILENAME; // Ditto, respectively

static int NO_SWAP=0; // 1 = Don't use swap files
static int REDIRECTED; // Whether output was redirected to a file

static void wipeswapfiles(void);
static void wipeswapfiles(void)
{
long count;

fputs("Wiping swap files...", stderr);

for (count = (GLOBAL.n + 3) / RANGE_SIZE; count > 0; count--) {
if (fwrite(mf, sizeof(long), RANGE_SIZE, MF_FP) != RANGE_SIZE) {
fprintf(stderr, "wipeswapfiles(): fwrite() failed for %ld longs to MF_FP (1).\n", RANGE_SIZE);
exit(-1);
}
if (fwrite(ms, sizeof(long), RANGE_SIZE, MS_FP) != RANGE_SIZE) {
fprintf(stderr, "wipeswapfiles(): fwrite() failed for %ld longs to MS_FP (1).\n", RANGE_SIZE);
exit(-1);
}
}

if ((count = ((GLOBAL.n + 3) % RANGE_SIZE)) != 0) {
if (fwrite(mf, sizeof(long), count, MF_FP) != count) {
fprintf(stderr, "wipeswapfiles(): fwrite() failed for %ld longs to MF_FP (2).\n", count);
exit(-1);
}
if (fwrite(ms, sizeof(long), count, MS_FP) != count) {
fprintf(stderr, "wipeswapfiles(): fwrite() failed for %ld longs to MS_FP (2).\n", count);
exit(-1);
}
}

fputs("done.\n", stderr);
}

static void openswapfiles(void);
static void openswapfiles(void)
{
SWAP_FILES_OPEN = 1;

fputs("Opening swap files...", stderr);

if ((MF_FP = fopen(SWAPFILENAME1, CONT ? "r+b" : "w+b")) == NULL) {
fprintf(stderr, "openswapfiles(): fopen() failed for '%s'.\n", SWAPFILENAME1);
exit(-1);
}
//fprintf(stderr, "Swap file '%s' opened.\n", SWAPFILENAME1);

if ((MS_FP = fopen(SWAPFILENAME2, CONT ? "r+b" : "w+b")) == NULL) {
fprintf(stderr, "openswapfiles(): fopen() failed for '%s'.\n", SWAPFILENAME2);
exit(-1);
}
//fprintf(stderr, "Swap file '%s' opened.\n", SWAPFILENAME2);

fputs("done.\n", stderr);

if (!CONT) {
wipeswapfiles();
}
}

static void closeswapfiles(void);
static void closeswapfiles(void)
{
fputs("Closing swap files...", stderr);

if (fclose(MF_FP)) {
fprintf(stderr, "closeswapfiles(): fclose() failed for MF_FP.\n");
}
//fprintf(stderr, "Swap file '%s' closed.\n", SWAPFILENAME1);

if (fclose(MS_FP)) {
fprintf(stderr, "closeswapfiles(): fclose() failed for MS_FP.\n");
}
//fprintf(stderr, "Swap file '%s' closed.\n", SWAPFILENAME2);

fputs("done.\n", stderr);
}

static void loadrange(long i);
static void loadrange(long i)
{
size_t r1, r2;

if (fseek(MF_FP, i*sizeof(long), SEEK_SET)) {
fprintf(stderr, "loadrange(): fseek() failed for %ld'th long in MF_FP.\n", i);
exit(-1);
}
if (fseek(MS_FP, i*sizeof(long), SEEK_SET)) {
fprintf(stderr, "loadrange(): fseek() failed for %ld'th long in MS_FP.\n", i);
exit(-1);
}

r1 = fread(mf, sizeof(long), RANGE_SIZE, MF_FP);
r2 = fread(ms, sizeof(long), RANGE_SIZE, MS_FP);

if (r1 != r2) {
fprintf(stderr, "%ld longs read from MF_FP, %ld read from MS_FP.\n", r1, r2);
exit(-1);
}

RANGE_LOW = i;
RANGE_HIGH = RANGE_LOW + (RANGE_COUNT = r1) - 1;

//fprintf(stderr, "Virtual range mf[%ld..%ld] loaded.\n", RANGE_LOW, RANGE_HIGH);
}

static void saverange(void);
static void saverange(void)
{
size_t r1, r2;

if (fseek(MF_FP, RANGE_LOW*sizeof(long), SEEK_SET)) {
fprintf(stderr, "loadrange(): fseek() failed for %ld'th long in MF_FP.\n", RANGE_LOW);
exit(-1);
}
if (fseek(MS_FP, RANGE_LOW*sizeof(long), SEEK_SET)) {
fprintf(stderr, "loadrange(): fseek() failed for %ld'th long in MS_FP.\n", RANGE_LOW);
exit(-1);
}

r1 = fwrite(mf, sizeof(long), RANGE_COUNT, MF_FP);
r2 = fwrite(ms, sizeof(long), RANGE_COUNT, MS_FP);

if (r1 != r2) {
fprintf(stderr, "%ld longs written to MF_FP, %ld to MS_FP.\n", r1, r2);
exit(-1);
}

GLOBAL.swaps++; // Swaps for entire computation
SWAPS++; // Swaps this session (will be same if all 1 session)

//fprintf(stderr, "Virtual range mf[%ld..%ld] saved.\n", RANGE_LOW, RANGE_LOW+RANGE_COUNT-1);
}

static void swaprange(long i);
static void swaprange(long i)
{
if (REDIRECTED) fputs(" (swapping)", stderr);
saverange();
loadrange(i);
if (REDIRECTED) fputs("\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b", stderr);
}

static void allocate(long max_bytes);
static void allocate(long max_bytes)
{
long requested_n, requested_bytes, needed_bytes;
long huge *lp = NULL;
int reduced=0; // Whether we needed to reduce the requirements based on max_bytes

requested_n = (GLOBAL.n + 3);
needed_bytes = requested_bytes = 2 * requested_n * sizeof(long);

if (max_bytes && (requested_bytes > max_bytes)) {
requested_n = ((max_bytes / 2) / sizeof(long));
reduced = 1;
}

do {
requested_bytes = 2 * requested_n * sizeof(long);
if ((lp = (long *) farcalloc((unsigned long) requested_bytes, (unsigned long) 1)) != NULL) break;
requested_n--;
} while (requested_n > 0);

if (lp == NULL) {
fprintf(stderr, "allocate(): unable to allocate memory.\n");
exit(-1);
}

RANGE_HIGH = (RANGE_SIZE = RANGE_COUNT = requested_n) - 1;
mf = lp;
ms = lp + RANGE_SIZE;

ALL_IN_RAM = (requested_n == GLOBAL.n + 3);

if (!ALL_IN_RAM && NO_SWAP) {
fprintf(stderr, "Unable to allocate %ld bytes (%ld.%ld KB).\nTry decreasing the number of decimal places, or don't use the -n option.\n",
needed_bytes, needed_bytes/1024, (100*(needed_bytes%1024)) / 1024
);
if (reduced) {
fprintf(stderr, "Or, increase the amount of memory to use (specified with the -m option).\n");
}
farfree(mf);
exit(-1);
}

fprintf(stderr, "%ld bytes (%ld.%ld KB) allocated", requested_bytes, requested_bytes/1024, (100*(requested_bytes%1024)) / 1024);
if (!ALL_IN_RAM) {
fputs(" (swap files needed!)", stderr);
}
fputc('\n', stderr);

if (CONT || !ALL_IN_RAM) {
openswapfiles();
}
}

static void readdat(void);
static void readdat(void)
{
FILE *fp;

if ((fp = fopen(DATAFILENAME, "rb")) == NULL) {
fprintf(stderr, "readdat(): fopen() failed for data file.\n");
exit(-1);
}

if (fread(&GLOBAL, sizeof(GLOBAL), 1, fp) != 1) {
fprintf(stderr, "readdat(): fread() failed for data file.\n");
exit(-1);
}

fclose(fp);
}

static void writedat(void);
static void writedat(void)
{
FILE *fp;

if ((fp = fopen(DATAFILENAME, "wb")) == NULL) {
fprintf(stderr, "writedat(): fopen() failed for data file.\n");
exit(-1);
}

if (fwrite(&GLOBAL, sizeof(GLOBAL), 1, fp) != 1) {
fprintf(stderr, "writedat(): fwrite() failed for data file.\n");
exit(-1);
}

fclose(fp);
}

//------------------------------------------------------------------------

static char TITLE_LINE[] = "PI v1.1 7/25/1993 Kim Moser";

static void usage(void);
static void usage(void)
{
fprintf(stderr, "\
%s\n\
Computes Pi to a given number of decimal places\n\
\n\
usage: pi [-m<nnn>] [-s<n>=<path>] [-d<path>] <places> | -c\n\
\n\
-m = Allocate only up to <nnn> KB of RAM for workspace\n\
(default: use as much RAM as available)\n\
-s = Use <path> for swap file <n> (1='%s', 2='%s')\n\
-d = Use <path> for data file '%s' (when saving data)\n\
-n = Don't use swap files (and don't save session when aborting)\n\
<places> = how many decimal places to compute\n\
-c = continue where left off from previous session\n\
\n\
Based on a version which contained the following comment:\n\

TITLE_LINE,
SWAPBASENAME1,
SWAPBASENAME2,
DATABASENAME
);

exit(-1);
}

static int getkey(void);
static int getkey(void)
{
int r;

return (((r = getch()) != 0) ? r : getch()+256);
}

static void show_percent_done(long percent_done);
static void show_percent_done(long percent_done)
{
fprintf(stderr, "%ld of %ld places (%ld%%) done", GLOBAL.count, GLOBAL.n, percent_done);
}

static void status(long percent_done);
static void status(long percent_done)
{
fputs("\nStatus: ", stderr);

if (!REDIRECTED) {
show_percent_done(percent_done);
fputs("; ", stderr);
}

if (ALL_IN_RAM) {
fputs("no swap files in use.", stderr);
} else {
fprintf(stderr, "%ld swap%s total", GLOBAL.swaps, (GLOBAL.swaps==1 ? "" : "s"));
if (GLOBAL.swaps != SWAPS) {
fprintf(stderr, " (%ld this session).", SWAPS);
}
}

fputc('\n', stderr);
}

static void showkeys(void);
static void showkeys(void)
{
fputs("\
\n\
Press any of the following keys:\n\
\n\
<esc> = Save current state and quit\n\
? = Show status\n\
\n\
", stderr);
}

static char* buildfilename(char* path, char* base);
static char* buildfilename(char* path, char* base)
{
char* s;
char ch;

s = (char*) malloc(strlen(path) + strlen(base) + 3);
strcpy(s, path);
ch = strlen(path) ? path[strlen(path) - 1] : '\0';
if (ch && ch != ':' && ch != '\\') {
strcat(s, "\\");
}
strcat(s, base);
return (s);
}

#define kf 25
#define ks 57121L

int main(int argc,char *argv[])
{
long k;
long i, i_minus_1, temp, temp_minus_2, temp_times_kf, temp_times_ks,
i_minus_range_low, i_minus_1_minus_range_low;
long nd;
long outer_limit, inner_limit;
int stopped=0;
long max_kb=0; // Max KB to use (0=no limit)
long prev_count=-1;
long percent_done, prev_percent_done=-1;

REDIRECTED = !isatty(fileno(stdout));

SWAPFILENAME1 = buildfilename(SWAPPATHNAME1, SWAPBASENAME1);
SWAPFILENAME2 = buildfilename(SWAPPATHNAME2, SWAPBASENAME2);
DATAFILENAME = buildfilename(DATAPATHNAME, DATABASENAME);

if (argc < 2) usage();

for (i=1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (toupper(argv[i][1])) {
case 'C':
CONT = 1;
break;
case 'M':
if ((max_kb = atol(argv[i]+2)) <= 0) {
usage();
}
break;
case 'N':
NO_SWAP = 1;
break;
case 'S':
switch (atoi(argv[i]+2)) {
case 1:
SWAPPATHNAME1 = argv[i]+4;
break;
case 2:
SWAPPATHNAME2 = argv[i]+4;
break;
default:
usage();
break;
}
case 'D':
DATAPATHNAME = argv[i]+4;
break;
default:
usage();
break;
}
} else {
GLOBAL.n = atol(argv[i]);
}
}

if (CONT) readdat();

if (GLOBAL.n <= 0) usage();

fprintf(stderr, "%s\n", TITLE_LINE);

allocate(max_kb * 1024);

if (CONT) {
fprintf(stderr, "Continuing to compute Pi to %ld places...\n", GLOBAL.n);
loadrange(0);
} else {
// At this point, if swap file(s) were opened, assume
// current range loaded starts at virtual index 0.

if (!ALL_IN_RAM) {
fputs("Initializing swap files...", stderr);
}

mf[1] = 1;
for (i = 2; i <= GLOBAL.n;) {
if (i < RANGE_LOW || i+1 > RANGE_HIGH) {
//fprintf(stderr, "* i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld\n", i, RANGE_LOW, RANGE_HIGH);
swaprange(i);
}
for (outer_limit = min((RANGE_HIGH-1), GLOBAL.n);
i <= outer_limit; i += 2)
{
//if (i - RANGE_LOW < 0 || i - RANGE_LOW > RANGE_HIGH) fprintf(stderr, "aaa Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);
//if (i+1 - RANGE_LOW < 0 || i+1 - RANGE_LOW > RANGE_HIGH) fprintf(stderr, "bbb Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);

mf[i - RANGE_LOW] = -16;
mf[i + 1 - RANGE_LOW] = 16;
}
}

for (i = 1; i <= GLOBAL.n;) {
if (i < RANGE_LOW || i+1 > RANGE_HIGH) {
//fprintf(stderr, "** i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld\n", i, RANGE_LOW, RANGE_HIGH);
swaprange(i);
}
for (outer_limit = min((RANGE_HIGH-1), GLOBAL.n);
i <= outer_limit; i += 2)
{
//if (i - RANGE_LOW < 0 || i - RANGE_LOW > RANGE_HIGH) fprintf(stderr, "ccc Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);
//if (i+1 - RANGE_LOW < 0 || i+1 - RANGE_LOW > RANGE_HIGH) fprintf(stderr, "ddd Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);

ms[i - RANGE_LOW] = -4;
ms[i + 1 - RANGE_LOW] = 4;
}
}

if (!ALL_IN_RAM) {
fputs("done.\n", stderr);
}

fprintf(stderr, "Computing Pi to %ld places...\n", GLOBAL.n);
}

fputs("(Press <ESC> to quit, '?' for help)\n", stderr);

if (!CONT) out("\n 3.");

for (;;) {
percent_done = ((100*GLOBAL.count) / GLOBAL.n);
if (REDIRECTED && (GLOBAL.count != prev_count || prev_percent_done != percent_done)) {
fputc('\r', stderr);
show_percent_done(percent_done);
prev_count = GLOBAL.count;
prev_percent_done = percent_done;
}

if (GLOBAL.count >= GLOBAL.n) break;

for (i = 1, outer_limit = (GLOBAL.n - GLOBAL.count); i <= outer_limit;)
{
if (i < RANGE_LOW || i > RANGE_HIGH) {
//fprintf(stderr, "Multiplying by 10.\n");
//fprintf(stderr, "*** i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld\n", i, RANGE_LOW, RANGE_HIGH);
swaprange(i);
}
for (inner_limit = min(RANGE_HIGH, (outer_limit)); i <= inner_limit; i++) {

//if (i - RANGE_LOW < 0 || i - RANGE_LOW > RANGE_HIGH) fprintf(stderr, "@ Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);

mf[i - RANGE_LOW] *= 10;
ms[i - RANGE_LOW] *= 10;
}
}

for (i = GLOBAL.n - GLOBAL.count; i >= 2;) {
if (i-1 < RANGE_LOW || i > RANGE_HIGH) {
//fprintf(stderr, "**** i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld\n", i, RANGE_LOW, RANGE_HIGH);
//fprintf(stderr, "(Loading range %ld.)\n", max(0, (i-RANGE_SIZE+1)));
swaprange(max(0, (i - RANGE_SIZE + 1)));
}
for (outer_limit = max((RANGE_LOW+1), 2); i >= outer_limit; i--)
{
i_minus_1 = i - 1;
temp = (2 * i) - 1;
temp_minus_2 = temp - 2;
temp_times_kf = temp * kf;
temp_times_ks = temp * ks;
i_minus_range_low = i - RANGE_LOW;
i_minus_1_minus_range_low = i_minus_1 - RANGE_LOW;

if (i_minus_1_minus_range_low < 0 || i_minus_1_minus_range_low > RANGE_HIGH) fprintf(stderr, "@@ Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);
if (i_minus_range_low < 0 || i_minus_range_low > RANGE_HIGH) fprintf(stderr, "@@@ Range violation: i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld.\n", i, RANGE_LOW, RANGE_HIGH);

shift(mf[i_minus_1_minus_range_low],mf[i_minus_range_low],temp_minus_2,temp_times_kf);
shift(ms[i_minus_1_minus_range_low],ms[i_minus_range_low],temp_minus_2,temp_times_ks);
}
}

// Prepare for next 2 shift()'s:
if (RANGE_LOW) {
//fprintf(stderr, "***** i=%ld, RANGE_LOW=%ld, RANGE_HIGH=%ld\n", i, RANGE_LOW, RANGE_HIGH);
//fprintf(stderr, "(Loading range %ld.)\n", max(0, (i-RANGE_SIZE+1)));
swaprange(0);
}
nd = 0;
shift(nd,mf[1],1L,5L);
shift(nd,ms[1],1L,239L);
xprint(nd);

if (kbhit()) {
int ch = toupper(getkey());
if (ch == '?') {
status(percent_done);
} else if (ch == 27) {
stopped = 1;
break;
} else {
showkeys();
}
}
}

fputs("\n\n", stderr);

fputs(stopped ? "Aborted.\n" : "Done.\n", stderr);

if (!NO_SWAP) {
if (CONT || stopped) {
fprintf(stderr, "Saving current state:\n");
writedat();
if (!SWAP_FILES_OPEN) openswapfiles();
saverange();
} else {
if (SWAP_FILES_OPEN) {
saverange();
}
}
if (SWAP_FILES_OPEN) closeswapfiles();
}

farfree(mf); // Don't free ms[], since it's just the second 1/2 of mf

return (0);
}

// use only if you've got monstrous memory....


[/code:1:1e5ec22f0b]

Reading that brings a tear of joy to my eye.

It also reminds me of my first wife. I married her when I was 17. She was a 1967 Fastback Mustang with a 289 and toploader 4 speed on a 8.8 inch rear with 2.73s. I bought her the equivelent of a boob job. (11:1 forged piston, 69cc 4v heads with 3/8 screw in studs, dual valve springs, teflon stem seals, cast in guide plates, a Crane Cams 298"fireball", Hipo rods, a factory Aluminum dual medium riser sporting twin Carter 600 CFM AVS and of course hooker headers. )There a few sounds in the world that compare to the bone rattling scream of a small block V8 spinning up over 8000 RPM.

My first car was a Supra Mk3 TT with a engine swap to a Toyota 2JZ-GTE TT sequential mated to a TRD 6 Gear tranny. Set up for uphill racing. Redlines at 11K RPM
I have that and a AE86 TRD 4A-GE NA super high revving engine. Peak is 14K RPM. Also mated to a TRD 6 speed tranny with a extended 1 gear. Set up for up hill. Nothing sounds like true Jspec power (I hate ricers)

You think I'm bad? My dad has both a Jeep SRT8 420 Hemi that he put a blower on and Audi S8 stock. My brother has a RX7 FD30 Effini and and my other brother has a FC RX7. My oldest brother owns a Mk4 Supra TT 15th Anniversary Edition. My mother is the conservative one with a M5.


Must be nice to be rich

Hmm...who could that be???
Not telling.....

I bet its that bloke and his heatsink on the other thread...

<.<
>.>
.......[/silence is damning]

Ummm Russian Computer geek from James Bond: Goldeneye.

mmmm Goldeneye........Izabella Scorupco.....mmmmmm

I AM INVINCIBLE
1978, Monty Pythons and the Holy Grail - King Arthur's duel with the Black Knight.

[BK]"I'm invincible!"
[KA]"You're a loony."