github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-21 13:53:55 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

chg; syntax suger

Browse source
This commit is contained in:
iceman1001 2016-08-14 17:38:11 +02:00
commit af17926620
1 changed files with 272 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

576
client/cmdlf.c
View file

@ -183,81 +183,68 @@ int CmdLFCommandRead(const char *Cmd) {
int CmdFlexdemod(const char *Cmd) int CmdFlexdemod(const char *Cmd)
{ {
int i; #define LONG_WAIT 100
for (i = 0; i < GraphTraceLen; ++i) { int i, j, start, bit, sum;
if (GraphBuffer[i] < 0) { int phase = 0;
GraphBuffer[i] = -1;
} else {
GraphBuffer[i] = 1;
}
}
#define LONG_WAIT 100 for (i = 0; i < GraphTraceLen; ++i)
int start; GraphBuffer[i] = (GraphBuffer[i] < 0) ? -1 : 1;
for (start = 0; start < GraphTraceLen - LONG_WAIT; start++) {
int first = GraphBuffer[start];
for (i = start; i < start + LONG_WAIT; i++) {
if (GraphBuffer[i] != first) {
break;
}
}
if (i == (start + LONG_WAIT)) {
break;
}
}
if (start == GraphTraceLen - LONG_WAIT) {
PrintAndLog("nothing to wait for");
return 0;
}
GraphBuffer[start] = 2; for (start = 0; start < GraphTraceLen - LONG_WAIT; start++) {
GraphBuffer[start+1] = -2; int first = GraphBuffer[start];
for (i = start; i < start + LONG_WAIT; i++) {
if (GraphBuffer[i] != first) {
break;
}
}
if (i == (start + LONG_WAIT))
break;
}
if (start == GraphTraceLen - LONG_WAIT) {
PrintAndLog("nothing to wait for");
return 0;
}
GraphBuffer[start] = 2;
GraphBuffer[start+1] = -2;
uint8_t bits[64] = {0x00}; uint8_t bits[64] = {0x00};
int bit, sum; i = start;
i = start; for (bit = 0; bit < 64; bit++) {
for (bit = 0; bit < 64; bit++) {
sum = 0; sum = 0;
for (int j = 0; j < 16; j++) { for (int j = 0; j < 16; j++) {
sum += GraphBuffer[i++]; sum += GraphBuffer[i++];
} }
bits[bit] = (sum > 0) ? 1 : 0; bits[bit] = (sum > 0) ? 1 : 0;
PrintAndLog("bit %d sum %d", bit, sum);
}
PrintAndLog("bit %d sum %d", bit, sum); for (bit = 0; bit < 64; bit++) {
} sum = 0;
for (j = 0; j < 16; j++)
sum += GraphBuffer[i++];
for (bit = 0; bit < 64; bit++) { if (sum > 0 && bits[bit] != 1) PrintAndLog("oops1 at %d", bit);
int j;
int sum = 0; if (sum < 0 && bits[bit] != 0) PrintAndLog("oops2 at %d", bit);
for (j = 0; j < 16; j++) {
sum += GraphBuffer[i++]; }
}
if (sum > 0 && bits[bit] != 1) {
PrintAndLog("oops1 at %d", bit);
}
if (sum < 0 && bits[bit] != 0) {
PrintAndLog("oops2 at %d", bit);
}
}
// HACK writing back to graphbuffer. // HACK writing back to graphbuffer.
GraphTraceLen = 32*64; GraphTraceLen = 32*64;
i = 0; i = 0;
int phase = 0; for (bit = 0; bit < 64; bit++) {
for (bit = 0; bit < 64; bit++) {
phase = (bits[bit] == 0) ? 0 : 1; phase = (bits[bit] == 0) ? 0 : 1;
int j; for (j = 0; j < 32; j++) {
for (j = 0; j < 32; j++) { GraphBuffer[i++] = phase;
GraphBuffer[i++] = phase; phase = !phase;
phase = !phase; }
} }
} RepaintGraphWindow();
return 0;
RepaintGraphWindow();
return 0;
} }
int CmdIndalaDemod(const char *Cmd) int CmdIndalaDemod(const char *Cmd)
@ -270,10 +257,9 @@ int CmdIndalaDemod(const char *Cmd)
// worst case with GraphTraceLen=64000 is < 4096 // worst case with GraphTraceLen=64000 is < 4096
// under normal conditions it's < 2048 // under normal conditions it's < 2048
uint8_t rawbits[4096]; uint8_t rawbits[4096];
int rawbit = 0;
int worst = 0, worstPos = 0; int rawbit = 0, worst = 0, worstPos = 0;
// PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32); // PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32);
// loop through raw signal - since we know it is psk1 rf/32 fc/2 skip every other value (+=2) // loop through raw signal - since we know it is psk1 rf/32 fc/2 skip every other value (+=2)
@ -448,51 +434,49 @@ int CmdIndalaDemod(const char *Cmd)
return 1; return 1;
} }
int CmdIndalaClone(const char *Cmd) int CmdIndalaClone(const char *Cmd){
{ UsbCommand c;
UsbCommand c;
unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7; unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7;
uid1 = uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0; uid1 = uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0;
int n = 0, i = 0; int n = 0, i = 0;
if (strchr(Cmd,'l') != 0) { if (strchr(Cmd,'l') != 0) {
while (sscanf(&Cmd[i++], "%1x", &n ) == 1) { while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
uid1 = (uid1 << 4) | (uid2 >> 28); uid1 = (uid1 << 4) | (uid2 >> 28);
uid2 = (uid2 << 4) | (uid3 >> 28); uid2 = (uid2 << 4) | (uid3 >> 28);
uid3 = (uid3 << 4) | (uid4 >> 28); uid3 = (uid3 << 4) | (uid4 >> 28);
uid4 = (uid4 << 4) | (uid5 >> 28); uid4 = (uid4 << 4) | (uid5 >> 28);
uid5 = (uid5 << 4) | (uid6 >> 28); uid5 = (uid5 << 4) | (uid6 >> 28);
uid6 = (uid6 << 4) | (uid7 >> 28); uid6 = (uid6 << 4) | (uid7 >> 28);
uid7 = (uid7 << 4) | (n & 0xf); uid7 = (uid7 << 4) | (n & 0xf);
} }
PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1, uid2, uid3, uid4, uid5, uid6, uid7); PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1, uid2, uid3, uid4, uid5, uid6, uid7);
c.cmd = CMD_INDALA_CLONE_TAG_L; c.cmd = CMD_INDALA_CLONE_TAG_L;
c.d.asDwords[0] = uid1; c.d.asDwords[0] = uid1;
c.d.asDwords[1] = uid2; c.d.asDwords[1] = uid2;
c.d.asDwords[2] = uid3; c.d.asDwords[2] = uid3;
c.d.asDwords[3] = uid4; c.d.asDwords[3] = uid4;
c.d.asDwords[4] = uid5; c.d.asDwords[4] = uid5;
c.d.asDwords[5] = uid6; c.d.asDwords[5] = uid6;
c.d.asDwords[6] = uid7; c.d.asDwords[6] = uid7;
} else { } else {
while (sscanf(&Cmd[i++], "%1x", &n ) == 1) { while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
uid1 = (uid1 << 4) | (uid2 >> 28); uid1 = (uid1 << 4) | (uid2 >> 28);
uid2 = (uid2 << 4) | (n & 0xf); uid2 = (uid2 << 4) | (n & 0xf);
} }
PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1, uid2); PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1, uid2);
c.cmd = CMD_INDALA_CLONE_TAG; c.cmd = CMD_INDALA_CLONE_TAG;
c.arg[0] = uid1; c.arg[0] = uid1;
c.arg[1] = uid2; c.arg[1] = uid2;
} }
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int CmdLFSetConfig(const char *Cmd) int CmdLFSetConfig(const char *Cmd) {
{
uint8_t divisor = 0;//Frequency divisor uint8_t divisor = 0;//Frequency divisor
uint8_t bps = 0; // Bits per sample uint8_t bps = 0; // Bits per sample
uint8_t decimation = 0; //How many to keep uint8_t decimation = 0; //How many to keep
@ -502,10 +486,8 @@ int CmdLFSetConfig(const char *Cmd)
uint8_t unsigned_trigg = 0; uint8_t unsigned_trigg = 0;
uint8_t cmdp = 0; uint8_t cmdp = 0;
while(param_getchar(Cmd, cmdp) != 0x00) while(param_getchar(Cmd, cmdp) != 0x00) {
{ switch(param_getchar(Cmd, cmdp)) {
switch(param_getchar(Cmd, cmdp))
{
case 'h': case 'h':
return usage_lf_config(); return usage_lf_config();
case 'H': case 'H':
@ -564,8 +546,7 @@ int CmdLFSetConfig(const char *Cmd)
return 0; return 0;
} }
int CmdLFRead(const char *Cmd) int CmdLFRead(const char *Cmd) {
{
bool arg1 = false; bool arg1 = false;
uint8_t cmdp = param_getchar(Cmd, 0); uint8_t cmdp = param_getchar(Cmd, 0);
@ -584,8 +565,7 @@ int CmdLFRead(const char *Cmd)
return 0; return 0;
} }
int CmdLFSnoop(const char *Cmd) int CmdLFSnoop(const char *Cmd) {
{
uint8_t cmdp = param_getchar(Cmd, 0); uint8_t cmdp = param_getchar(Cmd, 0);
if(cmdp == 'h' || cmdp == 'H') return usage_lf_snoop(); if(cmdp == 'h' || cmdp == 'H') return usage_lf_snoop();
@ -596,22 +576,18 @@ int CmdLFSnoop(const char *Cmd)
return 0; return 0;
} }
static void ChkBitstream(const char *str) static void ChkBitstream(const char *str) {
{ // convert to bitstream if necessary
int i; for (int i = 0; i < (int)(GraphTraceLen / 2); i++){
/* convert to bitstream if necessary */
for (i = 0; i < (int)(GraphTraceLen / 2); i++){
if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0) { if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0) {
CmdGetBitStream(""); CmdGetBitStream("");
break; break;
} }
} }
} }
//Attempt to simulate any wave in buffer (one bit per output sample) //Attempt to simulate any wave in buffer (one bit per output sample)
// converts GraphBuffer to bitstream (based on zero crossings) if needed. // converts GraphBuffer to bitstream (based on zero crossings) if needed.
int CmdLFSim(const char *Cmd) int CmdLFSim(const char *Cmd) {
{
int i,j; int i,j;
static int gap; static int gap;
@ -655,10 +631,8 @@ int CmdLFfskSim(const char *Cmd)
int dataLen = 0; int dataLen = 0;
uint8_t cmdp = 0; uint8_t cmdp = 0;
while(param_getchar(Cmd, cmdp) != 0x00) while(param_getchar(Cmd, cmdp) != 0x00) {
{ switch(param_getchar(Cmd, cmdp)){
switch(param_getchar(Cmd, cmdp))
{
case 'h': case 'h':
return usage_lf_simfsk(); return usage_lf_simfsk();
case 'i': case 'i':
@ -838,197 +812,191 @@ int CmdLFaskSim(const char *Cmd)
// by marshmellow - sim psk data given carrier, clock, invert // by marshmellow - sim psk data given carrier, clock, invert
// - allow pull data from DemodBuffer or parameters // - allow pull data from DemodBuffer or parameters
int CmdLFpskSim(const char *Cmd) int CmdLFpskSim(const char *Cmd) {
{ //might be able to autodetect FC and clock from Graphbuffer if using demod buffer
//might be able to autodetect FC and clock from Graphbuffer if using demod buffer //will need carrier, Clock, and bitstream
//will need carrier, Clock, and bitstream uint8_t carrier=0, clk=0;
uint8_t carrier=0, clk=0; uint8_t invert=0;
uint8_t invert=0; bool errors = FALSE;
bool errors = FALSE; char hexData[32] = {0x00}; // store entered hex data
char hexData[32] = {0x00}; // store entered hex data uint8_t data[255] = {0x00};
uint8_t data[255] = {0x00}; int dataLen = 0;
int dataLen = 0; uint8_t cmdp = 0;
uint8_t cmdp = 0; uint8_t pskType = 1;
uint8_t pskType = 1;
while(param_getchar(Cmd, cmdp) != 0x00) while(param_getchar(Cmd, cmdp) != 0x00) {
{ switch(param_getchar(Cmd, cmdp)) {
switch(param_getchar(Cmd, cmdp)) case 'h':
{ return usage_lf_simpsk();
case 'h': case 'i':
return usage_lf_simpsk(); invert = 1;
case 'i': cmdp++;
invert = 1; break;
cmdp++; case 'c':
break; errors |= param_getdec(Cmd,cmdp+1,&clk);
case 'c': cmdp +=2;
errors |= param_getdec(Cmd,cmdp+1,&clk); break;
cmdp+=2; case 'r':
break; errors |= param_getdec(Cmd,cmdp+1,&carrier);
case 'r': cmdp += 2;
errors |= param_getdec(Cmd,cmdp+1,&carrier); break;
cmdp+=2; case '1':
break; pskType = 1;
case '1': cmdp++;
pskType=1; break;
cmdp++; case '2':
break; pskType = 2;
case '2': cmdp++;
pskType=2; break;
cmdp++; case '3':
break; pskType = 3;
case '3': cmdp++;
pskType=3; break;
cmdp++; case 'd':
break; dataLen = param_getstr(Cmd, cmdp+1, hexData);
case 'd': if (dataLen == 0)
dataLen = param_getstr(Cmd, cmdp+1, hexData); errors = TRUE;
if (dataLen==0) { else
errors=TRUE; dataLen = hextobinarray((char *)data, hexData);
} else {
dataLen = hextobinarray((char *)data, hexData); if (dataLen == 0) errors = TRUE;
} if (errors) PrintAndLog ("Error getting hex data");
if (dataLen==0) errors=TRUE; cmdp+=2;
if (errors) PrintAndLog ("Error getting hex data"); break;
cmdp+=2; default:
break; PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
default: errors = TRUE;
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); break;
errors = TRUE; }
break; if (errors) break;
} }
if (errors) break; // No args
} if (cmdp == 0 && DemodBufferLen == 0)
if (cmdp == 0 && DemodBufferLen == 0) errors = TRUE;
{
errors = TRUE;// No args
}
//Validations //Validations
if (errors) if (errors) return usage_lf_simpsk();
{
return usage_lf_simpsk();
}
if (dataLen == 0){ //using DemodBuffer
PrintAndLog("Getting Clocks");
if (clk==0) clk = GetPskClock("", FALSE, FALSE);
PrintAndLog("clk: %d",clk);
if (!carrier) carrier = GetPskCarrier("", FALSE, FALSE);
PrintAndLog("carrier: %d", carrier);
} else {
setDemodBuf(data, dataLen, 0);
}
if (clk <= 0) clk = 32; if (dataLen == 0){ //using DemodBuffer
if (carrier == 0) carrier = 2; PrintAndLog("Getting Clocks");
if (pskType != 1){
if (pskType == 2){ if (clk==0) clk = GetPskClock("", FALSE, FALSE);
//need to convert psk2 to psk1 data before sim PrintAndLog("clk: %d",clk);
psk2TOpsk1(DemodBuffer, DemodBufferLen);
} else { if (!carrier) carrier = GetPskCarrier("", FALSE, FALSE);
PrintAndLog("Sorry, PSK3 not yet available"); PrintAndLog("carrier: %d", carrier);
}
} } else {
uint16_t arg1, arg2; setDemodBuf(data, dataLen, 0);
arg1 = clk << 8 | carrier; }
arg2 = invert;
size_t size=DemodBufferLen; if (clk <= 0) clk = 32;
if (size > USB_CMD_DATA_SIZE) {
PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE); if (carrier == 0) carrier = 2;
size=USB_CMD_DATA_SIZE;
}
UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}};
PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size);
memcpy(c.d.asBytes, DemodBuffer, size);
clearCommandBuffer();
SendCommand(&c);
return 0; if (pskType != 1){
if (pskType == 2){
//need to convert psk2 to psk1 data before sim
psk2TOpsk1(DemodBuffer, DemodBufferLen);
} else {
PrintAndLog("Sorry, PSK3 not yet available");
}
}
uint16_t arg1, arg2;
arg1 = clk << 8 | carrier;
arg2 = invert;
size_t size = DemodBufferLen;
if (size > USB_CMD_DATA_SIZE) {
PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
size = USB_CMD_DATA_SIZE;
}
UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}};
PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size);
memcpy(c.d.asBytes, DemodBuffer, size);
clearCommandBuffer();
SendCommand(&c);
return 0;
} }
int CmdLFSimBidir(const char *Cmd) int CmdLFSimBidir(const char *Cmd) {
{ // Set ADC to twice the carrier for a slight supersampling
// Set ADC to twice the carrier for a slight supersampling // HACK: not implemented in ARMSRC.
// HACK: not implemented in ARMSRC. PrintAndLog("Not implemented yet.");
PrintAndLog("Not implemented yet."); UsbCommand c = {CMD_LF_SIMULATE_BIDIR, {47, 384, 0}};
UsbCommand c = {CMD_LF_SIMULATE_BIDIR, {47, 384, 0}}; SendCommand(&c);
SendCommand(&c); return 0;
return 0;
} }
int CmdVchDemod(const char *Cmd) int CmdVchDemod(const char *Cmd) {
{ // Is this the entire sync pattern, or does this also include some
// Is this the entire sync pattern, or does this also include some // data bits that happen to be the same everywhere? That would be
// data bits that happen to be the same everywhere? That would be // lovely to know.
// lovely to know. static const int SyncPattern[] = {
static const int SyncPattern[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
};
// So first, we correlate for the sync pattern, and mark that. // So first, we correlate for the sync pattern, and mark that.
int bestCorrel = 0, bestPos = 0; int bestCorrel = 0, bestPos = 0;
int i; int i, j, sum = 0;
// It does us no good to find the sync pattern, with fewer than
// 2048 samples after it...
for (i = 0; i < (GraphTraceLen-2048); i++) {
int sum = 0;
int j;
for (j = 0; j < ARRAYLEN(SyncPattern); j++) {
sum += GraphBuffer[i+j]*SyncPattern[j];
}
if (sum > bestCorrel) {
bestCorrel = sum;
bestPos = i;
}
}
PrintAndLog("best sync at %d [metric %d]", bestPos, bestCorrel);
char bits[257]; // It does us no good to find the sync pattern, with fewer than 2048 samples after it.
bits[256] = '\0';
int worst = INT_MAX; for (i = 0; i < (GraphTraceLen - 2048); i++) {
int worstPos = 0; for (j = 0; j < ARRAYLEN(SyncPattern); j++) {
sum += GraphBuffer[i+j] * SyncPattern[j];
}
if (sum > bestCorrel) {
bestCorrel = sum;
bestPos = i;
}
}
PrintAndLog("best sync at %d [metric %d]", bestPos, bestCorrel);
for (i = 0; i < 2048; i += 8) { char bits[257];
int sum = 0; bits[256] = '\0';
int j;
for (j = 0; j < 8; j++) {
sum += GraphBuffer[bestPos+i+j];
}
if (sum < 0) {
bits[i/8] = '.';
} else {
bits[i/8] = '1';
}
if(abs(sum) < worst) {
worst = abs(sum);
worstPos = i;
}
}
PrintAndLog("bits:");
PrintAndLog("%s", bits);
PrintAndLog("worst metric: %d at pos %d", worst, worstPos);
if (strcmp(Cmd, "clone")==0) { int worst = INT_MAX, worstPos = 0;
GraphTraceLen = 0;
char *s; for (i = 0; i < 2048; i += 8) {
for(s = bits; *s; s++) { sum = 0;
int j; for (j = 0; j < 8; j++)
for(j = 0; j < 16; j++) { sum += GraphBuffer[bestPos+i+j];
GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;
} if (sum < 0)
} bits[i/8] = '.';
RepaintGraphWindow(); else
} bits[i/8] = '1';
return 0;
if(abs(sum) < worst) {
worst = abs(sum);
worstPos = i;
}
}
PrintAndLog("bits:");
PrintAndLog("%s", bits);
PrintAndLog("worst metric: %d at pos %d", worst, worstPos);
// clone
if (strcmp(Cmd, "clone")==0) {
GraphTraceLen = 0;
char *s;
for(s = bits; *s; s++) {
for(j = 0; j < 16; j++) {
GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;
}
}
RepaintGraphWindow();
}
return 0;
} }
//by marshmellow //by marshmellow