# 1 "proba.c"

# 52 "C:\PROGRA~1\HI-TEC~1\PICC\9.83\include\pic10f222.h"
volatile control unsigned char OPTION @ 0x000;


volatile unsigned char INDF @ 0x000;



volatile unsigned char TMR0 @ 0x001;



volatile unsigned char PCL @ 0x002;



volatile unsigned char STATUS @ 0x003;

volatile bit CARRY @ ((unsigned)&STATUS*8)+0;
volatile bit DC @ ((unsigned)&STATUS*8)+1;
volatile bit ZERO @ ((unsigned)&STATUS*8)+2;
volatile bit nPD @ ((unsigned)&STATUS*8)+3;
volatile bit nTO @ ((unsigned)&STATUS*8)+4;
volatile bit GPWUF @ ((unsigned)&STATUS*8)+7;

volatile union {
struct {
unsigned C : 1;
unsigned DC : 1;
unsigned Z : 1;
unsigned nPD : 1;
unsigned nTO : 1;
unsigned : 2;
unsigned GPWUF : 1;
};
} STATUSbits @ 0x003;



volatile unsigned char FSR @ 0x004;



volatile unsigned char OSCCAL @ 0x005;

volatile bit FOSC4 @ ((unsigned)&OSCCAL*8)+0;
volatile bit CAL0 @ ((unsigned)&OSCCAL*8)+1;
volatile bit CAL1 @ ((unsigned)&OSCCAL*8)+2;
volatile bit CAL2 @ ((unsigned)&OSCCAL*8)+3;
volatile bit CAL3 @ ((unsigned)&OSCCAL*8)+4;
volatile bit CAL4 @ ((unsigned)&OSCCAL*8)+5;
volatile bit CAL5 @ ((unsigned)&OSCCAL*8)+6;
volatile bit CAL6 @ ((unsigned)&OSCCAL*8)+7;

volatile union {
struct {
unsigned FOSC4 : 1;
unsigned CAL : 7;
};
struct {
unsigned : 1;
unsigned CAL0 : 1;
unsigned CAL1 : 1;
unsigned CAL2 : 1;
unsigned CAL3 : 1;
unsigned CAL4 : 1;
unsigned CAL5 : 1;
unsigned CAL6 : 1;
};
} OSCCALbits @ 0x005;



volatile unsigned char GPIO @ 0x006;
volatile control unsigned char TRIS @ 0x006;
volatile control unsigned char TRISGPIO @ 0x006;

volatile bit GP0 @ ((unsigned)&GPIO*8)+0;
volatile bit GP1 @ ((unsigned)&GPIO*8)+1;
volatile bit GP2 @ ((unsigned)&GPIO*8)+2;
volatile bit GP3 @ ((unsigned)&GPIO*8)+3;

volatile union {
struct {
unsigned GP0 : 1;
unsigned GP1 : 1;
unsigned GP2 : 1;
unsigned GP3 : 1;
};
} GPIObits @ 0x006;



volatile unsigned char ADCON0 @ 0x007;

volatile bit ADON @ ((unsigned)&ADCON0*8)+0;
volatile bit GO_nDONE @ ((unsigned)&ADCON0*8)+1;
volatile bit GO @ ((unsigned)&ADCON0*8)+1;
volatile bit CHS0 @ ((unsigned)&ADCON0*8)+2;
volatile bit CHS1 @ ((unsigned)&ADCON0*8)+3;
volatile bit ANS0 @ ((unsigned)&ADCON0*8)+6;
volatile bit ANS1 @ ((unsigned)&ADCON0*8)+7;
volatile bit nDONE @ ((unsigned)&ADCON0*8)+1;

volatile union {
struct {
unsigned ADON : 1;
unsigned GO_nDONE : 1;
unsigned CHS : 2;
unsigned : 2;
unsigned ANS : 2;
};
struct {
unsigned : 1;
unsigned GO : 1;
unsigned CHS0 : 1;
unsigned CHS1 : 1;
unsigned : 2;
unsigned ANS0 : 1;
unsigned ANS1 : 1;
};
struct {
unsigned : 1;
unsigned nDONE : 1;
};
} ADCON0bits @ 0x007;



volatile unsigned char ADRES @ 0x008;

volatile bit ADRES0 @ ((unsigned)&ADRES*8)+0;
volatile bit ADRES1 @ ((unsigned)&ADRES*8)+1;
volatile bit ADRES2 @ ((unsigned)&ADRES*8)+2;
volatile bit ADRES3 @ ((unsigned)&ADRES*8)+3;
volatile bit ADRES4 @ ((unsigned)&ADRES*8)+4;
volatile bit ADRES5 @ ((unsigned)&ADRES*8)+5;
volatile bit ADRES6 @ ((unsigned)&ADRES*8)+6;
volatile bit ADRES7 @ ((unsigned)&ADRES*8)+7;

volatile union {
struct {
unsigned ADRES0 : 1;
unsigned ADRES1 : 1;
unsigned ADRES2 : 1;
unsigned ADRES3 : 1;
unsigned ADRES4 : 1;
unsigned ADRES5 : 1;
unsigned ADRES6 : 1;
unsigned ADRES7 : 1;
};
} ADRESbits @ 0x008;


# 27 "C:\PROGRA~1\HI-TEC~1\PICC\9.83\include\pic.h"
#pragma inline(_nop)
extern void _nop(void);


# 153
#pragma inline(_delay)
extern void _delay(unsigned long);

# 34 "proba.c"
asm("\tpsect config,class=CONFIG,delta=2"); asm("\tdw ""0xfeb");

# 62 "C:\Program Files\Matrix Multimedia\Flowcode V4\FCD\internals.h"
char FCI_GETCHAR(char* sStr1, char iStr1_len, char iPos);
char FCI_GETLENGTH(char* sStr1, char iStr1_len);
char FCI_MIDSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iStart, char iCount);
char FCI_LEFTSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iCount);
char FCI_RIGHTSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iCount);
char FCI_CONCATENATE(char* sSrc1, char iSrc1_len, char* sSrc2, char iSrc2_len, char* sDst, char iDst_len);
char FCI_TOSTRING(int iSrc1, char* sDst, char iDst_len);
void FCI_TOLOWER(char* sSrc, char iSrc_len, char* sDst, char iDst_len);
void FCI_TOUPPER(char* sSrc, char iSrc_len, char* sDst, char iDst_len);
char FCI_COMPARE(char* sSrc1, char iSrc1_len, char* sSrc2, char iSrc2_len, char iNoCase);
char FCI_FLOAT_TO_STRING(float Number, char Precision, char* String, char MSZ_String);
char FCI_NUMBER_TO_HEX(short Number, char* String, char MSZ_String);
short FCI_STRING_TO_INT(char* String, char MSZ_String);
float FCI_STRING_TO_FLOAT(char* String, char MSZ_String);
void Wdt_msDelay(void);
void Wdt_Delay_S(short delay);
void Wdt_Delay_Ms(short delay);
char isinf(float f);

# 3 "C:\PROGRA~1\HI-TEC~1\PICC\9.83\include\math.h"
extern double fabs(double);
extern double floor(double);
extern double ceil(double);
extern double modf(double, double *);
extern double sqrt(double);
extern double atof(const char *);
extern double sin(double);
extern double cos(double);
extern double tan(double);
extern double asin(double);
extern double acos(double);
extern double atan(double);
extern double atan2(double, double);
extern double log(double);
extern double log10(double);
extern double pow(double, double);
extern double exp(double);
extern double sinh(double);
extern double cosh(double);
extern double tanh(double);
extern double eval_poly(double, const double *, int);
extern double frexp(double, int *);
extern double ldexp(double, int);
extern double fmod(double, double);
extern double trunc(double);
extern double round(double);

# 107 "C:\Program Files\Matrix Multimedia\Flowcode V4\FCD\internals.h"
char ts_bit(char reg, char bt);
char test_bit(char reg, char bt);
void delay_10us(char del);
void delay_us(char del);
void delay_ms(char del);
void delay_s(char del);
void nop(void);
float float32_add(float a, float b);
float float32_sub(float a, float b);
float float32_mul(float a, float b);
float float32_div(float a, float b);
float float32_rem(float a, float b);
char float32_is_signaling_nan(float a);
char float32_eq(float a, float b);
char float32_ge(float a, float b);
char float32_gt(float a, float b);
char float32_le(float a, float b);
char float32_lt(float a, float b);
short float32_to_int32 (float a);
float float32_from_int32 (short a);

# 136
char ts_bit(char reg, char bt)
{
if (bt)
return 1;
return 0;
}

char test_bit(char reg, char bt)
{
if (reg & (1 << bt))
return (1 << bt);
return 0;
}

void delay_10us(char del)
{
char count;
for(count=0; count<10; count++)
{
delay_us(del);
}
}

void delay_us(char del)
{
while (del > 1)
{
_delay((unsigned long)((1)*(8000000/4000000.0)));
del = del - 1;
}
}

void delay_ms(char del)
{
while (del > 1)
{
_delay((unsigned long)((1)*(8000000/4000.0)));
del = del - 1;
}
}

void delay_s(char del)
{
char i;
for(i=0; i<del; i++)
{
delay_ms(250);
delay_ms(250);
delay_ms(250);
delay_ms(250);
}
}

void nop()
{
asm("NOP");
}

float float32_add(float a, float b)
{
return (a + b);
}

float float32_sub(float a, float b)
{
return (a - b);
}

float float32_mul(float a, float b)
{
return (a * b);
}

float float32_div(float a, float b)
{
return (a / b);
}

float float32_rem(float a, float b)
{
return (fmod(a, b));
}

char float32_is_signaling_nan(float a)
{
return isinf(a);
}

char float32_eq(float a, float b)
{
return (a == b);
}

char float32_ge(float a, float b)
{
return (a >= b);
}

char float32_gt(float a, float b)
{
return (a > b);
}

char float32_le(float a, float b)
{
return (a <= b);
}

char float32_lt(float a, float b)
{
return (a < b);
}

short float32_to_int32 (float a)
{
return ((int)a);
}

float float32_from_int32 (short a)
{
return ((float)a);
}

char FCI_GETCHAR(char* sStr1, char iStr1_len, char iPos)
{
char tmp;
for (tmp = 0; tmp < iStr1_len; tmp++)
{
if (*sStr1 == 0)
break;
sStr1++;
}

if(iPos < tmp)
tmp = *sStr1;
else tmp = 0;
return (tmp);
}

char FCI_GETLENGTH(char* sStr1, char iStr1_len)
{
char tmp;
for (tmp = 0; tmp < iStr1_len; tmp++)
{
if (*sStr1 == 0)
break;
sStr1++;
}
return (tmp);
}

char FCI_MIDSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iStart, char iCount)
{
char idx;
for (idx = 0; idx < iSrc_len; idx++)
{
if (*sSrc == 0)
break;
sSrc++;
}

if (iStart >= idx)
{
*sDst = 0;
}
else
{
if ((iStart + iCount) >= idx)
iCount = idx - iStart;

sSrc = 0;

for (idx = 0; idx < iStart; idx++)
sSrc++;

for (idx = 0; idx < iCount; idx++)
{
if (idx < iDst_len)
{
*sDst = *sSrc;
sDst++;
sSrc++;
}
else break;
}

if (idx < iDst_len)
*sDst = 0;
}
return (idx);
}

char FCI_LEFTSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iCount)
{
char idx = 0;
for (idx = 0; idx < iSrc_len; idx++)
{
if (*sSrc == 0)
break;
sSrc++;
}

if (iCount > idx)
iCount = idx;

sSrc = 0;

for (idx = 0; idx < iCount; idx++)
{
if (idx < iDst_len)
{
*sDst = *sSrc;
sDst++;
sSrc++;
}
else break;
}

if (idx < iDst_len)
*sDst = 0;

return (idx);
}

char FCI_RIGHTSTRING(char* sSrc, char iSrc_len, char* sDst, char iDst_len, char iCount)
{
char idx = 0;
char delta;

for (idx = 0; idx < iSrc_len; idx++)
{
if (*sSrc == 0)
break;
sSrc++;
}

if (iCount > idx)
iCount = idx;

delta = idx - iCount;

sSrc = 0;
for (idx = 0; idx < delta; idx++)
sSrc++;

for(idx = 0; idx < iCount; idx++)
{
if (idx < iDst_len)
{
*sDst = *sSrc;
sDst++;
sSrc++;
}
else break;
}

if (idx < iDst_len)
*sDst = 0;

return (idx);
}

char FCI_CONCATENATE(char* sSrc1, char iSrc1_len, char* sSrc2, char iSrc2_len, char* sDst, char iDst_len)
{
char tmp;
char idx = 0;

for (tmp=0; tmp<iSrc1_len; tmp++)
{
if (idx < iDst_len)
{
*sDst = *sSrc1;
sDst++;
sSrc1++;

if (*sSrc1 != 0)
idx++;
else break;
}
}

for (tmp=0; tmp<iSrc2_len; tmp++)
{
if (idx < iDst_len)
{
*sDst = *sSrc2;
sDst++;
sSrc2++;

if (*sSrc2 != 0)
idx++;
else break;
}
}

if (idx < iDst_len)
*sDst = 0;

return (idx);
}

char FCI_TOSTRING(int iSrc1, char* sDst, char iDst_len)
{
char tmp1;
short tmp2;
char idx = 0;



if (iSrc1 < 0)
{
sDst[0] = '-';
idx++;
iSrc1 = 0 - iSrc1;
}

tmp2 = iSrc1;
if (iSrc1 >= 10000)
{
if (idx < iDst_len)
{
tmp1 = tmp2 / 10000;
sDst[idx] = '0' + tmp1;
idx++;
}

while (tmp1 > 0)
{
tmp2 = tmp2 - 10000;
tmp1--;
}
}

if (iSrc1 >= 1000)
{
if (idx < iDst_len)
{
tmp1 = tmp2 / 1000;
sDst[idx] = '0' + tmp1;
idx++;
}

while (tmp1 > 0)
{
tmp2 = tmp2 - 1000;
tmp1--;
}
}

if (iSrc1 >= 100)
{
if (idx < iDst_len)
{
tmp1 = tmp2 / 100;
sDst[idx] = '0' + tmp1;
idx++;
}

while (tmp1 > 0)
{
tmp2 = tmp2 - 100;
tmp1--;
}
}

if (iSrc1 >= 10)
{
if (idx < iDst_len)
{
tmp1 = tmp2 / 10;
sDst[idx] = '0' + tmp1;
idx++;
}

while (tmp1 > 0)
{
tmp2 = tmp2 - 10;
tmp1--;
}
}

if (idx < iDst_len)
{
sDst[idx] = '0' + tmp2;
idx++;
}


if (idx < iDst_len)
{
sDst[idx] = 0;
}

return (idx);
}

void FCI_TOLOWER(char* sSrc, char iSrc_len, char* sDst, char iDst_len)
{
char idx;
char ch;


for (idx=0; idx<iSrc_len; idx++)
{
if (idx < iDst_len)
{
ch = sSrc[idx];
sDst[idx] = ch;
if (ch != 0)
{
if ((ch >= 'A') && (ch <= 'Z'))
{
sDst[idx] = (ch | 0x20);
}
} else {
break;
}
}
}
}

void FCI_TOUPPER(char* sSrc, char iSrc_len, char* sDst, char iDst_len)
{
char idx;
char ch;


for (idx=0; idx<iSrc_len; idx++)
{
if (idx < iDst_len)
{
ch = sSrc[idx];
sDst[idx] = ch;
if (ch != 0)
{
if ((ch >= 'a') && (ch <= 'z'))
{
sDst[idx] = (ch & 0xDF);
}
} else {
break;
}
}
}
}

char FCI_COMPARE(char* sSrc1, char iSrc1_len, char* sSrc2, char iSrc2_len, char iNoCase)
{
char iRetVal = 0;
char idx;
char ch1, ch2;

for (idx=0; idx < iSrc1_len; idx++)
{
if (idx < iSrc2_len)
{
ch1 = *sSrc1;
ch2 = *sSrc2;

if (iNoCase)
{
if ((ch1 >= 'a') && (ch1 <= 'z'))
ch1 = (ch1 & 0xDF);

if ((ch2 >= 'a') && (ch2 <= 'z'))
ch2 = (ch2 & 0xDF);

}

if (ch1 < ch2)
{
return(255);
}
else if (ch1 > ch2)
{
return(1);
}

sSrc1++;
sSrc2++;
}
else
{
if (*sSrc1 == 0)
return (0);
else
return (1);
}
}

if (iSrc1_len == iSrc2_len)
return (0);
else
{
if (*sSrc2 == 0)
return (0);
else
return (255);
}
}

# 1260
void Wdt_msDelay(void)
{
char i;
for (i=0; i<75; i++)
{
asm("clrwdt");
delay_us(10);
}
}


void Wdt_Delay_S(short delay)
{
short i, j;
for (i=0; i<delay; i++)
{
for (j=0; j<1000; j++)
Wdt_msDelay();
}
}


void Wdt_Delay_Ms(short delay)
{
short i;
for (i=0; i<delay; i++)
Wdt_msDelay();
}


char FCI_FLOAT_TO_STRING(float Number, char Precision, char* String, char MSZ_String)
{
int whole;
char str_length;
char idx;
char stringidx = 0;
float real, temp;
char old;
char temp_string[10];

# 1324
whole = (int)Number;
temp = whole;

if (Number >= 0)
{
real = Number - temp;
}
else
{
if (whole == 0)
{
String[stringidx] = '-';
stringidx = stringidx + 1;
}

real = temp - Number;
}


str_length = FCI_TOSTRING(whole, temp_string, 5);

for (idx=0; idx<str_length; idx++)
{
if(stringidx < MSZ_String)
{
String[stringidx] = temp_string[idx];
stringidx = stringidx + 1;
}
}

if(stringidx < MSZ_String)
{
String[stringidx] = '.';
stringidx = stringidx + 1;
}

for (idx = 0; idx < Precision; idx++)
{
if (stringidx >= MSZ_String)
break;

# 1372
real = real * 10;
whole = (int)real;
temp = whole;
real = real - temp;


String[stringidx] = '0' + whole;
stringidx = stringidx + 1;
}

if(stringidx < MSZ_String)
{
String[stringidx] = 0;
}

return stringidx;
}


char FCI_NUMBER_TO_HEX(short Number, char* String, char MSZ_String)
{
char stringidx;
char idx = 0;
char temp;
char digit[4] = {0,0,0,0};
unsigned int num;


if(Number < 256 && MSZ_String < 4)
return 0;

if(Number > 255 && MSZ_String < 6)
return 0;


String[0] = '0';
String[1] = 'x';


if(Number < 0)
{
num = 0 - Number;
num = 0xFFFF - (num - 1);
}
else
num = Number;


while (num > 0)
{
temp = num % 16;
num = num / 16;

if(temp > 9)
{
temp = temp - 10;
digit[idx] = temp + 'A';
}
else
digit[idx] = temp + '0';

idx = idx + 1;
}


for (stringidx = 2; stringidx < (idx + 2); stringidx++)
String[stringidx] = digit[idx - (stringidx - 1)];


if(stringidx < MSZ_String)
{
String[stringidx] = 0;
}

return stringidx;
}


short FCI_STRING_TO_INT(char* String, char MSZ_String)
{
char bNegative = 0;
char idx = 0;
short RetVal = 0;


if(String[0] == '-')
{
bNegative = 1;
idx = 1;
}


while (idx < MSZ_String && String[idx] >= '0' && String[idx] <= '9')
{

RetVal = RetVal * 10;
RetVal = RetVal + (String[idx] - '0');
idx = idx + 1;
}

if (bNegative)
RetVal = 0 - RetVal;

return RetVal;
}


float FCI_STRING_TO_FLOAT(char* String, char MSZ_String)
{
float RetVal = 0;
float real_divider = 1;
int whole, real;
char idx = 0;
char idx2 = 0;
char offset = 0;
char bNegative = 0;
char Comp_String[8];


if(String[0] == '-')
{
bNegative = 1;
offset = 1;
}


for(idx=offset; idx<MSZ_String; idx++)
{
if(String[idx] == '.')
break;
}


whole = FCI_STRING_TO_INT (String, idx);


if(idx == MSZ_String)
{

# 1514
RetVal = (int)whole;

return RetVal;
}


offset = idx + 1;
for(idx=offset; idx<MSZ_String; idx++)
{
if(String[idx] >= '0' && String[idx] <= '9')
{
Comp_String[idx - offset] = String[idx];

# 1530
real_divider = real_divider * 0.1;

}
else
break;
}


real = FCI_STRING_TO_INT (Comp_String, (idx - offset));

# 1554
RetVal = (float)real;
RetVal = RetVal * real_divider;
real_divider = (float)whole;
RetVal = RetVal + real_divider;

if (bNegative)
RetVal = 0 - RetVal;


return RetVal;
}


char isinf(float f)
{
char* b;
b = (char*)&f;
if ((b[0] == 0) &&
(b[1] == 0) &&
(b[2] == 128) &&
((b[3] & 127) == 127))
{
return (255);
}
return (0);
}

# 49 "proba.c"
void main()
{


osccal = osccal & 0xFE;
ADCON0 = 0x00;
asm("movlw 0xDF");
asm("option");
char tvar;

# 64
while (1)
{


asm nop


}


mainendloop: goto mainendloop;
}