WebSVN – svnkaklik – Blame – /programy/C/PIC/hack/hack.LST

Rev	Author	Line No.	Line
6	kaklik	1	`CCS PCM C Compiler, Version 3.221, 27853 12-III-06 16:36`
		2
		3	`Filename: D:\KAKLIK\programy\PIC_C\hack\hack.LST`
		4
		5	`ROM used: 1587 words (41%)`
		6	`Largest free fragment is 1792`
		7	`RAM used: 41 (11%) at main() level`
		8	`51 (14%) worst case`
		9	`Stack: 3 worst case (2 in main + 1 for interrupts)`
		10
		11	`*`
		12	`0000: NOP`
		13	`0001: MOVLW 00`
		14	`0002: MOVWF 0A`
		15	`0003: GOTO 342`
		16	`0004: MOVWF 7F`
		17	`0005: SWAPF 03,W`
		18	`0006: CLRF 03`
		19	`0007: MOVWF 21`
		20	`0008: MOVF 7F,W`
		21	`0009: MOVWF 20`
		22	`000A: MOVF 0A,W`
		23	`000B: MOVWF 28`
		24	`000C: CLRF 0A`
		25	`000D: SWAPF 20,F`
		26	`000E: MOVF 04,W`
		27	`000F: MOVWF 22`
		28	`0010: MOVF 77,W`
		29	`0011: MOVWF 23`
		30	`0012: MOVF 78,W`
		31	`0013: MOVWF 24`
		32	`0014: MOVF 79,W`
		33	`0015: MOVWF 25`
		34	`0016: MOVF 7A,W`
		35	`0017: MOVWF 26`
		36	`0018: MOVF 7B,W`
		37	`0019: MOVWF 27`
		38	`001A: BCF 03.7`
		39	`001B: BCF 03.5`
		40	`001C: MOVLW 8C`
		41	`001D: MOVWF 04`
		42	`001E: BTFSS 00.0`
		43	`001F: GOTO 022`
		44	`0020: BTFSC 0C.0`
		45	`0021: GOTO 03B`
		46	`0022: MOVLW 8C`
		47	`0023: MOVWF 04`
		48	`0024: BTFSS 00.1`
		49	`0025: GOTO 028`
		50	`0026: BTFSC 0C.1`
		51	`0027: GOTO 03D`
		52	`0028: MOVF 22,W`
		53	`0029: MOVWF 04`
		54	`002A: MOVF 23,W`
		55	`002B: MOVWF 77`
		56	`002C: MOVF 24,W`
		57	`002D: MOVWF 78`
		58	`002E: MOVF 25,W`
		59	`002F: MOVWF 79`
		60	`0030: MOVF 26,W`
		61	`0031: MOVWF 7A`
		62	`0032: MOVF 27,W`
		63	`0033: MOVWF 7B`
		64	`0034: MOVF 28,W`
		65	`0035: MOVWF 0A`
		66	`0036: SWAPF 21,W`
		67	`0037: MOVWF 03`
		68	`0038: SWAPF 7F,F`
		69	`0039: SWAPF 7F,W`
		70	`003A: RETFIE`
		71	`003B: BCF 0A.3`
		72	`003C: GOTO 0E0`
		73	`003D: BCF 0A.3`
		74	`003E: GOTO 0E3`
		75	`.................... #include ".\hack.h"`
		76	`.................... #include <16F88.h>`
		77	`.................... //////// Standard Header file for the PIC16F88 device ////////////////`
		78	`.................... #device PIC16F88`
		79	`.................... #list`
		80	`....................`
		81	`.................... #device *=16`
		82	`.................... #device ICD=TRUE`
		83	`.................... #device adc=8`
		84	`.................... #fuses NOWDT,INTRC , NOPUT, MCLR, NOBROWNOUT, NOLVP, NOCPD, NOWRT, DEBUG, NOPROTECT, NOFCMEN, NOIESO`
		85	`.................... //#fuses NOWDT,INTRC_IO, NOPUT, MCLR, NOBROWNOUT, NOLVP, NOCPD, NOWRT, DEBUG, NOPROTECT, NOFCMEN, NOIESO`
		86	`.................... #use delay(clock=4000000,RESTART_WDT)`
		87	`*`
		88	`00E6: MOVLW 42`
		89	`00E7: MOVWF 04`
		90	`00E8: BCF 03.7`
		91	`00E9: MOVF 00,W`
		92	`00EA: BTFSC 03.2`
		93	`00EB: GOTO 0FD`
		94	`00EC: MOVLW 01`
		95	`00ED: MOVWF 78`
		96	`00EE: MOVLW BF`
		97	`00EF: MOVWF 77`
		98	`00F0: CLRWDT`
		99	`00F1: DECFSZ 77,F`
		100	`00F2: GOTO 0F0`
		101	`00F3: DECFSZ 78,F`
		102	`00F4: GOTO 0EE`
		103	`00F5: MOVLW 4A`
		104	`00F6: MOVWF 77`
		105	`00F7: DECFSZ 77,F`
		106	`00F8: GOTO 0F7`
		107	`00F9: NOP`
		108	`00FA: CLRWDT`
		109	`00FB: DECFSZ 00,F`
		110	`00FC: GOTO 0EC`
		111	`00FD: RETLW 00`
		112	`.................... //#use rs232(baud=2400,xmit=PIN_B3)`
		113	`.................... //#use rs232(DEBUGGER)`
		114	`.................... #use rs232(baud=1200,parity=N,xmit=PIN_B3,rcv=PIN_B2,bits=8)`
		115	`00FE: BSF 03.5`
		116	`00FF: BCF 06.3`
		117	`0100: BCF 03.5`
		118	`0101: BCF 06.3`
		119	`0102: MOVLW 08`
		120	`0103: MOVWF 78`
		121	`0104: NOP`
		122	`0105: NOP`
		123	`0106: NOP`
		124	`0107: BSF 78.7`
		125	`0108: GOTO 118`
		126	`0109: BCF 78.7`
		127	`010A: RRF 4C,F`
		128	`010B: BTFSC 03.0`
		129	`010C: BSF 06.3`
		130	`010D: BTFSS 03.0`
		131	`010E: BCF 06.3`
		132	`010F: BSF 78.6`
		133	`0110: GOTO 118`
		134	`0111: BCF 78.6`
		135	`0112: DECFSZ 78,F`
		136	`0113: GOTO 10A`
		137	`0114: NOP`
		138	`0115: NOP`
		139	`0116: NOP`
		140	`0117: BSF 06.3`
		141	`0118: MOVLW 01`
		142	`0119: MOVWF 77`
		143	`011A: CLRF 04`
		144	`011B: DECFSZ 04,F`
		145	`011C: GOTO 11B`
		146	`011D: DECFSZ 77,F`
		147	`011E: GOTO 11A`
		148	`011F: MOVLW 0D`
		149	`0120: MOVWF 04`
		150	`0121: DECFSZ 04,F`
		151	`0122: GOTO 121`
		152	`0123: NOP`
		153	`0124: NOP`
		154	`0125: BTFSC 78.7`
		155	`0126: GOTO 109`
		156	`0127: BTFSC 78.6`
		157	`0128: GOTO 111`
		158	`0129: RETLW 00`
		159	`012A: MOVF 04,W`
		160	`012B: MOVWF 78`
		161	`012C: MOVLW 08`
		162	`012D: MOVWF 77`
		163	`012E: BSF 03.5`
		164	`012F: BSF 06.2`
		165	`0130: BCF 03.5`
		166	`0131: BTFSS 06.2`
		167	`0132: GOTO 135`
		168	`0133: BSF 03.5`
		169	`0134: GOTO 130`
		170	`0135: CLRF 41`
		171	`0136: BSF 77.7`
		172	`0137: GOTO 148`
		173	`0138: BCF 77.7`
		174	`0139: GOTO 148`
		175	`013A: BCF 03.0`
		176	`013B: BTFSC 06.2`
		177	`013C: BSF 03.0`
		178	`013D: RRF 41,F`
		179	`013E: BSF 77.6`
		180	`013F: GOTO 148`
		181	`0140: BCF 77.6`
		182	`0141: DECFSZ 77,F`
		183	`0142: GOTO 13A`
		184	`0143: MOVF 78,W`
		185	`0144: MOVWF 04`
		186	`0145: MOVF 41,W`
		187	`0146: MOVWF 78`
		188	`0147: GOTO 15D`
		189	`0148: MOVLW 01`
		190	`0149: MOVWF 04`
		191	`014A: MOVLW 00`
		192	`014B: BTFSC 77.7`
		193	`014C: MOVLW 55`
		194	`014D: MOVWF 78`
		195	`014E: DECFSZ 78,F`
		196	`014F: GOTO 14E`
		197	`0150: DECFSZ 04,F`
		198	`0151: GOTO 14A`
		199	`0152: MOVLW 0D`
		200	`0153: BTFSC 77.7`
		201	`0154: MOVLW 03`
		202	`0155: MOVWF 78`
		203	`0156: DECFSZ 78,F`
		204	`0157: GOTO 156`
		205	`0158: BTFSC 77.7`
		206	`0159: GOTO 138`
		207	`015A: BTFSC 77.6`
		208	`015B: GOTO 140`
		209	`015C: GOTO 13A`
		210	`015D: BCF 0A.3`
		211	`015E: GOTO 3C1 (RETURN)`
		212	`....................`
		213	`....................`
		214	`.................... #include <stdlib.h>`
		215	`.................... ///////////////////////////////////////////////////////////////////////////`
		216	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		217	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		218	`.................... //// compiler. This source code may only be distributed to other ////`
		219	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		220	`.................... //// or distribution is permitted without written permission. ////`
		221	`.................... //// Derivative programs created using this software in object code ////`
		222	`.................... //// form are not restricted in any way. ////`
		223	`.................... ///////////////////////////////////////////////////////////////////////////`
		224	`....................`
		225	`.................... #ifndef _STDLIB`
		226	`.................... #define _STDLIB`
		227	`....................`
		228	`.................... //---------------------------------------------------------------------------`
		229	`.................... // Definitions and types`
		230	`.................... //---------------------------------------------------------------------------`
		231	`....................`
		232	`.................... #ifndef RAND_MAX`
		233	`.................... #define RAND_MAX 32767 // The value of which is the maximum value`
		234	`.................... // ... returned by the rand function`
		235	`.................... #endif`
		236	`....................`
		237	`.................... typedef struct {`
		238	`.................... signed int quot;`
		239	`.................... signed int rem;`
		240	`.................... } div_t;`
		241	`....................`
		242	`.................... typedef struct {`
		243	`.................... signed long quot;`
		244	`.................... signed long rem;`
		245	`.................... } ldiv_t;`
		246	`....................`
		247	`.................... #include <stddef.h>`
		248	`.................... ///////////////////////////////////////////////////////////////////////////`
		249	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		250	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		251	`.................... //// compiler. This source code may only be distributed to other ////`
		252	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		253	`.................... //// or distribution is permitted without written permission. ////`
		254	`.................... //// Derivative programs created using this software in object code ////`
		255	`.................... //// form are not restricted in any way. ////`
		256	`.................... ///////////////////////////////////////////////////////////////////////////`
		257	`....................`
		258	`.................... #ifndef _STDDEF`
		259	`....................`
		260	`.................... #define _STDDEF`
		261	`....................`
		262	`.................... #if sizeof(int *)==1`
		263	`.................... #define ptrdiff_t int`
		264	`.................... #else`
		265	`.................... #define ptrdiff_t long`
		266	`.................... #endif`
		267	`....................`
		268	`.................... #define size_t int`
		269	`.................... #define wchar_t char`
		270	`.................... #define NULL 0`
		271	`....................`
		272	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
		273	`....................`
		274	`.................... #endif`
		275	`....................`
		276	`....................`
		277	`.................... //---------------------------------------------------------------------------`
		278	`.................... // String conversion functions`
		279	`.................... //---------------------------------------------------------------------------`
		280	`....................`
		281	`.................... /* Standard template: float atof(char * s)`
		282	`.................... * converts the initial portion of the string s to a float.`
		283	`.................... * returns the converted value if any, 0 otherwise`
		284	`.................... */`
		285	`.................... float atof(char * s);`
		286	`....................`
		287	`.................... /* Standard template: signed int atoi(char * s)`
		288	`.................... * converts the initial portion of the string s to a signed int`
		289	`.................... * returns the converted value if any, 0 otherwise`
		290	`.................... */`
		291	`.................... signed int atoi(char *s);`
		292	`....................`
		293	`.................... /* Syntax: signed int32 atoi32(char * s)`
		294	`.................... converts the initial portion of the string s to a signed int32`
		295	`.................... returns the converted value if any, 0 otherwise*/`
		296	`.................... signed int32 atoi32(char *s);`
		297	`....................`
		298	`.................... /* Standard template: signed long atol(char * s)`
		299	`.................... * converts the initial portion of the string s to a signed long`
		300	`.................... * returns the converted value if any, 0 otherwise`
		301	`.................... */`
		302	`.................... signed long atol(char *s);`
		303	`....................`
		304	`.................... /* Standard template: float strtol(char * s,char *endptr)`
		305	`.................... * converts the initial portion of the string s to a float`
		306	`.................... * returns the converted value if any, 0 otherwise`
		307	`.................... * the final string is returned in the endptr, if endptr is not null`
		308	`.................... */`
		309	`.................... float strtod(char s,char endptr);`
		310	`....................`
		311	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`
		312	`.................... * converts the initial portion of the string s, represented as an`
		313	`.................... * integral value of radix base to a signed long.`
		314	`.................... * Returns the converted value if any, 0 otherwise`
		315	`.................... * the final string is returned in the endptr, if endptr is not null`
		316	`.................... */`
		317	`.................... signed long strtol(char s,char endptr,signed int base);`
		318	`....................`
		319	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`
		320	`.................... * converts the initial portion of the string s, represented as an`
		321	`.................... * integral value of radix base to a unsigned long.`
		322	`.................... * returns the converted value if any, 0 otherwise`
		323	`.................... * the final string is returned in the endptr, if endptr is not null`
		324	`.................... */`
		325	`.................... long strtoul(char s,char endptr,signed int base);`
		326	`....................`
		327	`.................... //---------------------------------------------------------------------------`
		328	`.................... // Pseudo-random sequence generation functions`
		329	`.................... //---------------------------------------------------------------------------`
		330	`....................`
		331	`.................... /* The rand function computes a sequence of pseudo-random integers in`
		332	`.................... * the range 0 to RAND_MAX`
		333	`.................... *`
		334	`.................... * Parameters:`
		335	`.................... * (none)`
		336	`.................... *`
		337	`.................... * Returns:`
		338	`.................... * The pseudo-random integer`
		339	`.................... */`
		340	`.................... long rand(void);`
		341	`....................`
		342	`.................... /* The srand function uses the argument as a seed for a new sequence of`
		343	`.................... * pseudo-random numbers to be returned by subsequent calls to rand.`
		344	`.................... *`
		345	`.................... * Parameters:`
		346	`.................... * [in] seed: The seed value to start from. You might need to pass`
		347	`.................... *`
		348	`.................... * Returns:`
		349	`.................... * (none)`
		350	`.................... *`
		351	`.................... * Remarks`
		352	`.................... * The srand function sets the starting point for generating`
		353	`.................... * a series of pseudorandom integers. To reinitialize the`
		354	`.................... * generator, use 1 as the seed argument. Any other value for`
		355	`.................... * seed sets the generator to a random starting point. rand`
		356	`.................... * retrieves the pseudorandom numbers that are generated.`
		357	`.................... * Calling rand before any call to srand generates the same`
		358	`.................... * sequence as calling srand with seed passed as 1.`
		359	`.................... * Usually, you need to pass a time here from outer source`
		360	`.................... * so that the numbers will be different every time you run.`
		361	`.................... */`
		362	`.................... void srand(unsigned int32 seed);`
		363	`....................`
		364	`.................... //---------------------------------------------------------------------------`
		365	`.................... // Memory management functions`
		366	`.................... //---------------------------------------------------------------------------`
		367	`....................`
		368	`.................... // Comming soon`
		369	`....................`
		370	`.................... //---------------------------------------------------------------------------`
		371	`.................... // Communication with the environment`
		372	`.................... //---------------------------------------------------------------------------`
		373	`....................`
		374	`.................... /* The function returns 0 always`
		375	`.................... */`
		376	`.................... signed int system(char *string);`
		377	`....................`
		378	`.................... //---------------------------------------------------------------------------`
		379	`.................... // Searching and sorting utilities`
		380	`.................... //---------------------------------------------------------------------------`
		381	`....................`
		382	`.................... /* Performs a binary search of a sorted array..`
		383	`.................... *`
		384	`.................... * Parameters:`
		385	`.................... * [in] key: Object to search for`
		386	`.................... * [in] base: Pointer to base of search data`
		387	`.................... * [in] num: Number of elements`
		388	`.................... * [in] width: Width of elements`
		389	`.................... * [in] compare: Function that compares two elements`
		390	`.................... *`
		391	`.................... * Returns:`
		392	`.................... * bsearch returns a pointer to an occurrence of key in the array pointed`
		393	`.................... * to by base. If key is not found, the function returns NULL. If the`
		394	`.................... * array is not in order or contains duplicate records with identical keys,`
		395	`.................... * the result is unpredictable.`
		396	`.................... */`
		397	`.................... //void bsearch(const void key, const void *base, size_t num, size_t width,`
		398	`.................... // int (compare)(const void , const void *));`
		399	`....................`
		400	`.................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents`
		401	`.................... * of the array are sorted into ascending order according to a comparison`
		402	`.................... * function pointed to by compar.`
		403	`.................... *`
		404	`.................... * Parameters:`
		405	`.................... * [in] base: Pointer to base of search data`
		406	`.................... * [in] num: Number of elements`
		407	`.................... * [in] width: Width of elements`
		408	`.................... * [in] compare: Function that compares two elements`
		409	`.................... *`
		410	`.................... * Returns:`
		411	`.................... * (none)`
		412	`.................... */`
		413	`.................... //void qsort(const void base, size_t num, size_t width,`
		414	`.................... // int (compare)(const void , const void *));`
		415	`....................`
		416	`.................... //---------------------------------------------------------------------------`
		417	`.................... // Integer arithmetic functions`
		418	`.................... //---------------------------------------------------------------------------`
		419	`....................`
		420	`.................... #define labs abs`
		421	`....................`
		422	`.................... div_t div(signed int numer,signed int denom);`
		423	`.................... ldiv_t ldiv(signed long numer,signed long denom);`
		424	`....................`
		425	`.................... //---------------------------------------------------------------------------`
		426	`.................... // Multibyte character functions`
		427	`.................... //---------------------------------------------------------------------------`
		428	`....................`
		429	`.................... // Not supported`
		430	`....................`
		431	`.................... //---------------------------------------------------------------------------`
		432	`.................... // Multibyte string functions`
		433	`.................... //---------------------------------------------------------------------------`
		434	`....................`
		435	`.................... // Not supported`
		436	`....................`
		437	`....................`
		438	`.................... //---------------------------------------------------------------------------`
		439	`.................... // Internal implementation`
		440	`.................... //---------------------------------------------------------------------------`
		441	`....................`
		442	`.................... #include <stddef.h>`
		443	`.................... ///////////////////////////////////////////////////////////////////////////`
		444	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		445	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		446	`.................... //// compiler. This source code may only be distributed to other ////`
		447	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		448	`.................... //// or distribution is permitted without written permission. ////`
		449	`.................... //// Derivative programs created using this software in object code ////`
		450	`.................... //// form are not restricted in any way. ////`
		451	`.................... ///////////////////////////////////////////////////////////////////////////`
		452	`....................`
		453	`.................... #ifndef _STDDEF`
		454	`....................`
		455	`.................... #define _STDDEF`
		456	`....................`
		457	`.................... #if sizeof(int *)==1`
		458	`.................... #define ptrdiff_t int`
		459	`.................... #else`
		460	`.................... #define ptrdiff_t long`
		461	`.................... #endif`
		462	`....................`
		463	`.................... #define size_t int`
		464	`.................... #define wchar_t char`
		465	`.................... #define NULL 0`
		466	`....................`
		467	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
		468	`....................`
		469	`.................... #endif`
		470	`....................`
		471	`.................... #include <string.h>`
		472	`.................... ////////////////////////////////////////////////////////////////////////////`
		473	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		474	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		475	`.................... //// compiler. This source code may only be distributed to other ////`
		476	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		477	`.................... //// or distribution is permitted without written permission. ////`
		478	`.................... //// Derivative programs created using this software in object code ////`
		479	`.................... //// form are not restricted in any way. ////`
		480	`.................... ////////////////////////////////////////////////////////////////////////////`
		481	`....................`
		482	`.................... #ifndef _STRING`
		483	`.................... #define _STRING`
		484	`.................... #include <stddef.h>`
		485	`.................... ///////////////////////////////////////////////////////////////////////////`
		486	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		487	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		488	`.................... //// compiler. This source code may only be distributed to other ////`
		489	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		490	`.................... //// or distribution is permitted without written permission. ////`
		491	`.................... //// Derivative programs created using this software in object code ////`
		492	`.................... //// form are not restricted in any way. ////`
		493	`.................... ///////////////////////////////////////////////////////////////////////////`
		494	`....................`
		495	`.................... #ifndef _STDDEF`
		496	`....................`
		497	`.................... #define _STDDEF`
		498	`....................`
		499	`.................... #if sizeof(int *)==1`
		500	`.................... #define ptrdiff_t int`
		501	`.................... #else`
		502	`.................... #define ptrdiff_t long`
		503	`.................... #endif`
		504	`....................`
		505	`.................... #define size_t int`
		506	`.................... #define wchar_t char`
		507	`.................... #define NULL 0`
		508	`....................`
		509	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
		510	`....................`
		511	`.................... #endif`
		512	`....................`
		513	`.................... #include <ctype.h>`
		514	`.................... ////////////////////////////////////////////////////////////////////////////`
		515	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
		516	`.................... //// This source code may only be used by licensed users of the CCS C ////`
		517	`.................... //// compiler. This source code may only be distributed to other ////`
		518	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
		519	`.................... //// or distribution is permitted without written permission. ////`
		520	`.................... //// Derivative programs created using this software in object code ////`
		521	`.................... //// form are not restricted in any way. ////`
		522	`.................... ////////////////////////////////////////////////////////////////////////////`
		523	`....................`
		524	`.................... #ifndef _CTYPE`
		525	`.................... #define _CTYPE`
		526	`....................`
		527	`.................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz")`
		528	`.................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ")`
		529	`.................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`
		530	`.................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`
		531	`.................... #define isdigit(x) isamong(x,"0123456789")`
		532	`.................... #define isspace(x) (x==' ')`
		533	`.................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef")`
		534	`.................... #define iscntrl(x) (x<' ')`
		535	`.................... #define isprint(x) (x>=' ')`
		536	`.................... #define isgraph(x) (x>' ')`
		537	`.................... #define ispunct(x) ((x>' ')&&!isalnum(x))`
		538	`....................`
		539	`.................... #endif`
		540	`....................`
		541	`....................`
		542	`....................`
		543	`....................`
		544	`....................`
		545	`.................... //////////////////////////////////////////////`
		546	`.................... //// Uncomment the following define to ////`
		547	`.................... //// allow some functions to use a ////`
		548	`.................... //// quicker algorithm, but use more ROM ////`
		549	`.................... //// ////`
		550	`.................... //// #define FASTER_BUT_MORE_ROM ////`
		551	`.................... //////////////////////////////////////////////`
		552	`....................`
		553	`....................`
		554	`....................`
		555	`.................... /Copying functions/`
		556	`.................... /* standard template:`
		557	`.................... void memmove(void s1, void *s2, size_t n).`
		558	`.................... Copies max of n characters safely (not following ending '\0')`
		559	`.................... from s2 in s1; if s2 has less than n characters, appends 0 */`
		560	`....................`
		561	`.................... char memmove(void s1,char *s2,size_t n)`
		562	`.................... {`
		563	`.................... char *sc1;`
		564	`.................... char *sc2;`
		565	`.................... sc1=s1;`
		566	`.................... sc2=s2;`
		567	`.................... if(sc2<sc1 && sc1 <sc2 +n)`
		568	`.................... for(sc1+=n,sc2+=n;0<n;--n)`
		569	`.................... --sc1=--sc2;`
		570	`.................... else`
		571	`.................... for(;0<n;--n)`
		572	`.................... sc1++=sc2++;`
		573	`.................... return s1;`
		574	`.................... }`
		575	`....................`
		576	`.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?`
		577	`.................... Standard template: char strcpy(char s1, const char *s2)`
		578	`.................... copies the string s2 including the null character to s1*/`
		579	`....................`
		580	`.................... char strcopy(char s1, char *s2)`
		581	`.................... {`
		582	`.................... char *s;`
		583	`....................`
		584	`.................... for (s = s1; *s2 != 0; s++, s2++) {`
		585	`.................... s = s2;`
		586	`.................... }`
		587	`.................... s = s2;`
		588	`.................... return(s1);`
		589	`.................... }`
		590	`....................`
		591	`.................... /* standard template:`
		592	`.................... char strncpy(char s1, const char *s2, size_t n).`
		593	`.................... Copies max of n characters (not following ending '\0')`
		594	`.................... from s2 in s1; if s2 has less than n characters, appends 0 */`
		595	`....................`
		596	`.................... char strncpy(char s1, char *s2, size_t n)`
		597	`.................... {`
		598	`.................... char *s;`
		599	`....................`
		600	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`
		601	`.................... s++ = s2++;`
		602	`.................... for (; n > 0; n--)`
		603	`.................... *s++ = '\0';`
		604	`....................`
		605	`.................... return(s1);`
		606	`.................... }`
		607	`.................... /***********************************************************/`
		608	`....................`
		609	`.................... /concatenation functions/`
		610	`.................... /* standard template: char strcat(char s1, const char *s2)`
		611	`.................... appends s2 to s1*/`
		612	`....................`
		613	`.................... char strcat(char s1, char *s2)`
		614	`.................... {`
		615	`.................... char *s;`
		616	`....................`
		617	`.................... for (s = s1; *s != '\0'; ++s);`
		618	`.................... while(*s2 != '\0')`
		619	`.................... {`
		620	`.................... s = s2;`
		621	`.................... ++s;`
		622	`.................... ++s2;`
		623	`.................... }`
		624	`....................`
		625	`.................... *s = '\0';`
		626	`.................... return(s1);`
		627	`.................... }`
		628	`.................... /* standard template: char strncat(char s1, char *s2,size_t n)`
		629	`.................... appends not more than n characters from s2 to s1*/`
		630	`....................`
		631	`.................... char strncat(char s1, char *s2, size_t n)`
		632	`.................... {`
		633	`.................... char *s;`
		634	`....................`
		635	`.................... for (s = s1; *s != '\0'; ++s);`
		636	`.................... while(*s2 != '\0' && 0<n)`
		637	`.................... {`
		638	`.................... s = s2;`
		639	`.................... ++s;`
		640	`.................... ++s2;`
		641	`.................... --n;`
		642	`.................... }`
		643	`....................`
		644	`.................... *s = '\0';`
		645	`.................... return(s1);`
		646	`.................... }`
		647	`....................`
		648	`.................... /***********************************************************/`
		649	`....................`
		650	`....................`
		651	`.................... /comparison functions/`
		652	`.................... /* standard template: signed int memcmp(void s1, void s2).`
		653	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
		654	`....................`
		655	`.................... signed int memcmp(void * s1,char *s2,size_t n)`
		656	`.................... {`
		657	`.................... char su1, su2;`
		658	`.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)`
		659	`.................... {`
		660	`.................... if(su1!=su2)`
		661	`.................... return ((su1<su2)?1:+1);`
		662	`.................... }`
		663	`.................... return 0;`
		664	`.................... }`
		665	`....................`
		666	`.................... /* standard template: int strcmp(const char s1, const char s2).`
		667	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
		668	`....................`
		669	`.................... signed int strcmp(char s1, char s2)`
		670	`.................... {`
		671	`.................... for (; s1 == s2; s1++, s2++)`
		672	`.................... if (*s1 == '\0')`
		673	`.................... return(0);`
		674	`.................... return((s1 < s2) ?-1: 1);`
		675	`.................... }`
		676	`.................... /* standard template: int strcoll(const char s1, const char s2).`
		677	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
		678	`....................`
		679	`.................... signed int strcoll(char s1, char s2)`
		680	`.................... {`
		681	`.................... for (; s1 == s2; s1++, s2++)`
		682	`.................... if (*s1 == '\0')`
		683	`.................... return(0);`
		684	`.................... return((s1 < s2) ?-1: 1);`
		685	`.................... }`
		686	`....................`
		687	`.................... /* standard template:`
		688	`.................... int strncmp(const char s1, const char s2, size_t n).`
		689	`.................... Compares max of n characters (not following 0) from s1 to s2;`
		690	`.................... returns same as strcmp */`
		691	`....................`
		692	`.................... signed int strncmp(char s1, char s2, size_t n)`
		693	`.................... {`
		694	`.................... for (; n > 0; s1++, s2++, n--)`
		695	`.................... if (s1 != s2)`
		696	`.................... return((s1 <s2) ?-1: 1);`
		697	`.................... else if (*s1 == '\0')`
		698	`.................... return(0);`
		699	`.................... return(0);`
		700	`.................... }`
		701	`.................... /* standard template:`
		702	`.................... int strxfrm(const char s1, const char s2, size_t n).`
		703	`.................... transforms maximum of n characters from s2 and places them into s1*/`
		704	`.................... size_t strxfrm(char s1, char s2, size_t n)`
		705	`.................... {`
		706	`.................... char *s;`
		707	`.................... int n1;`
		708	`.................... n1=n;`
		709	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`
		710	`.................... s++ = s2++;`
		711	`.................... for (; n > 0; n--)`
		712	`.................... *s++ = '\0';`
		713	`....................`
		714	`.................... return(n1);`
		715	`.................... }`
		716	`....................`
		717	`....................`
		718	`....................`
		719	`....................`
		720	`....................`
		721	`.................... /***********************************************************/`
		722	`.................... /Search functions/`
		723	`.................... /* standard template: void memchr(const char s, int c).`
		724	`.................... Finds first occurrence of c in n characters of s */`
		725	`....................`
		726	`.................... char memchr(void s,int c,size_t n)`
		727	`.................... {`
		728	`.................... char uc;`
		729	`.................... char *su;`
		730	`.................... uc=c;`
		731	`.................... for(su=s;0<n;++su,--n)`
		732	`.................... if(*su==uc)`
		733	`.................... return su;`
		734	`.................... return NULL;`
		735	`.................... }`
		736	`....................`
		737	`.................... /* standard template: char strchr(const char s, int c).`
		738	`.................... Finds first occurrence of c in s */`
		739	`....................`
		740	`.................... char strchr(char s, int c)`
		741	`.................... {`
		742	`.................... for (; *s != c; s++)`
		743	`.................... if (*s == '\0')`
		744	`.................... return(0);`
		745	`.................... return(s);`
		746	`.................... }`
		747	`.................... /* standard template:`
		748	`.................... size_t strcspn(const char s1, const char s2).`
		749	`.................... Computes length of max initial segment of s1 that`
		750	`.................... consists entirely of characters NOT from s2*/`
		751	`....................`
		752	`.................... int strcspn(char s1, char *s2)`
		753	`.................... {`
		754	`.................... char sc1, sc2;`
		755	`....................`
		756	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
		757	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`
		758	`.................... if (sc1 == sc2)`
		759	`.................... return(sc1 - s1);`
		760	`.................... return(sc1 - s1);`
		761	`.................... }`
		762	`.................... /* standard template:`
		763	`.................... char strpbrk(const char s1, const char *s2).`
		764	`.................... Locates first occurence of any character from s2 in s1;`
		765	`.................... returns s1 if s2 is empty string */`
		766	`....................`
		767	`.................... char strpbrk(char s1, char *s2)`
		768	`.................... {`
		769	`.................... char sc1, sc2;`
		770	`....................`
		771	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
		772	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`
		773	`.................... if (sc1 == sc2)`
		774	`.................... return(sc1);`
		775	`.................... return(0);`
		776	`.................... }`
		777	`....................`
		778	`....................`
		779	`.................... /* standard template: char strrchr(const char s, int c).`
		780	`.................... Finds last occurrence of c in s */`
		781	`....................`
		782	`.................... char strrchr(char s, int c)`
		783	`.................... {`
		784	`.................... char *p;`
		785	`....................`
		786	`.................... for (p = 0; ; s++)`
		787	`.................... {`
		788	`.................... if (*s == c)`
		789	`.................... p = s;`
		790	`.................... if (*s == '\0')`
		791	`.................... return(p);`
		792	`.................... }`
		793	`.................... }`
		794	`.................... /* computes length of max initial segment of s1 consisting`
		795	`.................... entirely of characters from s2 */`
		796	`....................`
		797	`.................... int strspn(char s1, char *s2)`
		798	`.................... {`
		799	`.................... char sc1, sc2;`
		800	`....................`
		801	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
		802	`.................... for (sc2 = s2; ; sc2++)`
		803	`.................... if (*sc2 == '\0')`
		804	`.................... return(sc1 - s1);`
		805	`.................... else if (sc1 == sc2)`
		806	`.................... break;`
		807	`.................... return(sc1 - s1);`
		808	`.................... }`
		809	`.................... /* standard template:`
		810	`.................... char strstr(const char s1, const char *s2);`
		811	`.................... Locates first occurence of character sequence s2 in s1;`
		812	`.................... returns 0 if s2 is empty string`
		813	`....................`
		814	`.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the`
		815	`.................... file to use the faster algorithm */`
		816	`.................... char strstr(char s1, char *s2)`
		817	`.................... {`
		818	`.................... char s, t;`
		819	`....................`
		820	`.................... #ifdef FASTER_BUT_MORE_ROM`
		821	`.................... if (*s2 == '\0')`
		822	`.................... return(s1);`
		823	`.................... #endif`
		824	`....................`
		825	`.................... while (*s1)`
		826	`.................... {`
		827	`.................... for(s = s1, t = s2; t && s == *t; ++s, ++t);`
		828	`....................`
		829	`.................... if (*t == '\0')`
		830	`.................... return s1;`
		831	`.................... ++s1;`
		832	`.................... #ifdef FASTER_BUT_MORE_ROM`
		833	`.................... while(s1 != '\0' && s1 != *s2)`
		834	`.................... ++s1;`
		835	`.................... #endif`
		836	`.................... }`
		837	`.................... return 0;`
		838	`.................... }`
		839	`....................`
		840	`.................... /* standard template: char strtok(char s1, const char *s2).`
		841	`....................`
		842	`.................... Finds next token in s1 delimited by a character from separator`
		843	`.................... string s2 (which can be different from call to call). First call`
		844	`.................... starts at beginning of s1 searching for first character NOT`
		845	`.................... contained in s2; returns 0 if none is found.`
		846	`.................... If one is found, it is the start of first token (return value).`
		847	`.................... Function then searches from there for a character contained in s2.`
		848	`.................... If none is found, current token extends to end of s1, and subsequent`
		849	`.................... searches for a token will return 0. If one is found, it is`
		850	`.................... overwritten by '\0', which terminates current token. Function saves`
		851	`.................... pointer to following character from which next search will start.`
		852	`.................... Each subsequent call, with 0 as first argument, starts searching`
		853	`.................... from saved pointer */`
		854	`....................`
		855	`.................... char strtok(char s1, char *s2)`
		856	`.................... {`
		857	`.................... char beg, end;`
		858	`.................... static char *save;`
		859	`*`
		860	`0359: CLRF 29`
		861	`035A: CLRF 2A`
		862	`....................`
		863	`.................... beg = (s1)?s1: save;`
		864	`.................... beg += strspn(beg, s2);`
		865	`.................... if (*beg == '\0')`
		866	`.................... {`
		867	`.................... *save = ' ';`
		868	`.................... return(0);`
		869	`.................... }`
		870	`.................... end = strpbrk(beg, s2);`
		871	`.................... if (*end != '\0')`
		872	`.................... {`
		873	`.................... *end = '\0';`
		874	`.................... end++;`
		875	`.................... }`
		876	`.................... save = end;`
		877	`.................... return(beg);`
		878	`.................... }`
		879	`....................`
		880	`.................... /*****************************************************************/`
		881	`.................... /Miscellaneous functions/`
		882	`.................... /* standard template`
		883	`.................... maps error number in errnum to an error message string`
		884	`.................... Returns: Pointer to string`
		885	`.................... */`
		886	`.................... #ifdef _ERRNO`
		887	`.................... char * strerror(int errnum)`
		888	`.................... {`
		889	`.................... char s[15];`
		890	`.................... switch( errnum)`
		891	`.................... {`
		892	`.................... case 0:`
		893	`.................... strcpy(s,"no errors");`
		894	`.................... return s;`
		895	`.................... case EDOM :`
		896	`.................... strcpy(s,"domain error");`
		897	`.................... return s;`
		898	`.................... case ERANGE:`
		899	`.................... strcpy(s,"range error");`
		900	`.................... return s;`
		901	`.................... }`
		902	`.................... }`
		903	`.................... #ENDIF`
		904	`.................... /* standard template: size_t strlen(const char *s).`
		905	`.................... Computes length of s1 (preceding terminating 0) */`
		906	`....................`
		907	`.................... int strlen(char s)`
		908	`.................... {`
		909	`.................... char *sc;`
		910	`....................`
		911	`.................... for (sc = s; *sc != 0; sc++);`
		912	`.................... return(sc - s);`
		913	`.................... }`
		914	`....................`
		915	`.................... /* standard template: size_t stricmp(const char s1, const char s2).`
		916	`.................... Compares s1 to s2 ignoring case (upper vs. lower) */`
		917	`....................`
		918	`.................... signed int stricmp(char s1, char s2)`
		919	`.................... {`
		920	`.................... for(; s1==s2\|\|(isalpha(s1)&&isalpha(s2)&&(s1==s2+32\|\|s2==s1+32));`
		921	`.................... s1++, s2++)`
		922	`.................... if (*s1 == '\0')`
		923	`.................... return(0);`
		924	`.................... return((s1 < s2) ?-1: 1);`
		925	`.................... }`
		926	`....................`
		927	`....................`
		928	`.................... /* standard template: char strlwr(char s).`
		929	`.................... Replaces uppercase letters by lowercase;`
		930	`.................... returns pointer to new string s */`
		931	`....................`
		932	`.................... char strlwr(char s)`
		933	`.................... {`
		934	`.................... char *p;`
		935	`....................`
		936	`.................... for (p = s; *p != '\0'; p++)`
		937	`.................... if (p >= 'A' && p <='Z')`
		938	`.................... *p += 'a' - 'A';`
		939	`.................... return(s);`
		940	`.................... }`
		941	`....................`
		942	`....................`
		943	`.................... /************************************************************/`
		944	`....................`
		945	`....................`
		946	`.................... #endif`
		947	`....................`
		948	`....................`
		949	`.................... div_t div(signed int numer,signed int denom)`
		950	`.................... {`
		951	`.................... div_t val;`
		952	`.................... val.quot = numer / denom;`
		953	`.................... val.rem = numer - (denom * val.quot);`
		954	`.................... return (val);`
		955	`.................... }`
		956	`....................`
		957	`.................... ldiv_t ldiv(signed long numer,signed long denom)`
		958	`.................... {`
		959	`.................... ldiv_t val;`
		960	`.................... val.quot = numer / denom;`
		961	`.................... val.rem = numer - (denom * val.quot);`
		962	`.................... return (val);`
		963	`.................... }`
		964	`....................`
		965	`.................... float atof(char * s)`
		966	`.................... {`
		967	`.................... float pow10 = 1.0;`
		968	`.................... float result = 0.0;`
		969	`.................... int sign = 0;`
		970	`.................... char c;`
		971	`.................... int ptr = 0;`
		972	`....................`
		973	`.................... c = s[ptr++];`
		974	`....................`
		975	`.................... if ((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`
		976	`.................... if(c == '-') {`
		977	`.................... sign = 1;`
		978	`.................... c = s[ptr++];`
		979	`.................... }`
		980	`.................... if(c == '+')`
		981	`.................... c = s[ptr++];`
		982	`....................`
		983	`.................... while((c >= '0' && c <= '9')) {`
		984	`.................... result = 10*result + c - '0';`
		985	`.................... c = s[ptr++];`
		986	`.................... }`
		987	`....................`
		988	`.................... if (c == '.') {`
		989	`.................... c = s[ptr++];`
		990	`.................... while((c >= '0' && c <= '9')) {`
		991	`.................... pow10 = pow10*10;`
		992	`.................... result += (c - '0')/pow10;`
		993	`.................... c = s[ptr++];`
		994	`.................... }`
		995	`.................... }`
		996	`....................`
		997	`.................... }`
		998	`....................`
		999	`.................... if (sign == 1)`
		1000	`.................... result = -1*result;`
		1001	`.................... return(result);`
		1002	`.................... }`
		1003	`....................`
		1004	`.................... signed int atoi(char *s)`
		1005	`.................... {`
		1006	`.................... signed int result;`
		1007	`.................... int sign, base, index;`
		1008	`.................... char c;`
		1009	`....................`
		1010	`.................... index = 0;`
		1011	`.................... sign = 0;`
		1012	`.................... base = 10;`
		1013	`.................... result = 0;`
		1014	`....................`
		1015	`.................... if (!s)`
		1016	`.................... return 0;`
		1017	`.................... // Omit all preceeding alpha characters`
		1018	`.................... c = s[index++];`
		1019	`....................`
		1020	`.................... // increase index if either positive or negative sign is detected`
		1021	`.................... if (c == '-')`
		1022	`.................... {`
		1023	`.................... sign = 1; // Set the sign to negative`
		1024	`.................... c = s[index++];`
		1025	`.................... }`
		1026	`.................... else if (c == '+')`
		1027	`.................... {`
		1028	`.................... c = s[index++];`
		1029	`.................... }`
		1030	`....................`
		1031	`.................... if (c >= '0' && c <= '9')`
		1032	`.................... {`
		1033	`....................`
		1034	`.................... // Check for hexa number`
		1035	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
		1036	`.................... {`
		1037	`.................... base = 16;`
		1038	`.................... index++;`
		1039	`.................... c = s[index++];`
		1040	`.................... }`
		1041	`....................`
		1042	`.................... // The number is a decimal number`
		1043	`.................... if (base == 10)`
		1044	`.................... {`
		1045	`.................... while (c >= '0' && c <= '9')`
		1046	`.................... {`
		1047	`.................... result = 10*result + (c - '0');`
		1048	`.................... c = s[index++];`
		1049	`.................... }`
		1050	`.................... }`
		1051	`.................... else if (base == 16) // The number is a hexa number`
		1052	`.................... {`
		1053	`.................... c = toupper(c);`
		1054	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c<='F'))`
		1055	`.................... {`
		1056	`.................... if (c >= '0' && c <= '9')`
		1057	`.................... result = (result << 4) + (c - '0');`
		1058	`.................... else`
		1059	`.................... result = (result << 4) + (c - 'A' + 10);`
		1060	`....................`
		1061	`.................... c = s[index++];`
		1062	`.................... c = toupper(c);`
		1063	`.................... }`
		1064	`.................... }`
		1065	`.................... }`
		1066	`....................`
		1067	`.................... if (sign == 1 && base == 10)`
		1068	`.................... result = -result;`
		1069	`....................`
		1070	`.................... return(result);`
		1071	`.................... }`
		1072	`....................`
		1073	`.................... signed long atol(char *s)`
		1074	`.................... {`
		1075	`.................... signed long result;`
		1076	`.................... int sign, base, index;`
		1077	`.................... char c;`
		1078	`....................`
		1079	`.................... index = 0;`
		1080	`*`
		1081	`0242: CLRF 47`
		1082	`.................... sign = 0;`
		1083	`0243: CLRF 45`
		1084	`.................... base = 10;`
		1085	`0244: MOVLW 0A`
		1086	`0245: MOVWF 46`
		1087	`.................... result = 0;`
		1088	`0246: CLRF 44`
		1089	`0247: CLRF 43`
		1090	`....................`
		1091	`.................... if (!s)`
		1092	`0248: MOVF 41,W`
		1093	`0249: IORWF 42,W`
		1094	`024A: BTFSS 03.2`
		1095	`024B: GOTO 250`
		1096	`.................... return 0;`
		1097	`024C: MOVLW 00`
		1098	`024D: MOVWF 78`
		1099	`024E: MOVWF 79`
		1100	`024F: GOTO 341`
		1101	`.................... c = s[index++];`
		1102	`0250: MOVF 47,W`
		1103	`0251: INCF 47,F`
		1104	`0252: ADDWF 41,W`
		1105	`0253: MOVWF 04`
		1106	`0254: BCF 03.7`
		1107	`0255: BTFSC 42.0`
		1108	`0256: BSF 03.7`
		1109	`0257: MOVF 00,W`
		1110	`0258: MOVWF 48`
		1111	`....................`
		1112	`.................... // increase index if either positive or negative sign is detected`
		1113	`.................... if (c == '-')`
		1114	`0259: MOVF 48,W`
		1115	`025A: SUBLW 2D`
		1116	`025B: BTFSS 03.2`
		1117	`025C: GOTO 269`
		1118	`.................... {`
		1119	`.................... sign = 1; // Set the sign to negative`
		1120	`025D: MOVLW 01`
		1121	`025E: MOVWF 45`
		1122	`.................... c = s[index++];`
		1123	`025F: MOVF 47,W`
		1124	`0260: INCF 47,F`
		1125	`0261: ADDWF 41,W`
		1126	`0262: MOVWF 04`
		1127	`0263: BCF 03.7`
		1128	`0264: BTFSC 42.0`
		1129	`0265: BSF 03.7`
		1130	`0266: MOVF 00,W`
		1131	`0267: MOVWF 48`
		1132	`.................... }`
		1133	`.................... else if (c == '+')`
		1134	`0268: GOTO 276`
		1135	`0269: MOVF 48,W`
		1136	`026A: SUBLW 2B`
		1137	`026B: BTFSS 03.2`
		1138	`026C: GOTO 276`
		1139	`.................... {`
		1140	`.................... c = s[index++];`
		1141	`026D: MOVF 47,W`
		1142	`026E: INCF 47,F`
		1143	`026F: ADDWF 41,W`
		1144	`0270: MOVWF 04`
		1145	`0271: BCF 03.7`
		1146	`0272: BTFSC 42.0`
		1147	`0273: BSF 03.7`
		1148	`0274: MOVF 00,W`
		1149	`0275: MOVWF 48`
		1150	`.................... }`
		1151	`....................`
		1152	`.................... if (c >= '0' && c <= '9')`
		1153	`0276: MOVF 48,W`
		1154	`0277: SUBLW 2F`
		1155	`0278: BTFSC 03.0`
		1156	`0279: GOTO 332`
		1157	`027A: MOVF 48,W`
		1158	`027B: SUBLW 39`
		1159	`027C: BTFSS 03.0`
		1160	`027D: GOTO 332`
		1161	`.................... {`
		1162	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
		1163	`027E: MOVF 48,W`
		1164	`027F: SUBLW 30`
		1165	`0280: BTFSS 03.2`
		1166	`0281: GOTO 2A2`
		1167	`0282: MOVF 47,W`
		1168	`0283: ADDWF 41,W`
		1169	`0284: MOVWF 04`
		1170	`0285: BCF 03.7`
		1171	`0286: BTFSC 42.0`
		1172	`0287: BSF 03.7`
		1173	`0288: MOVF 00,W`
		1174	`0289: SUBLW 78`
		1175	`028A: BTFSC 03.2`
		1176	`028B: GOTO 296`
		1177	`028C: MOVF 47,W`
		1178	`028D: ADDWF 41,W`
		1179	`028E: MOVWF 04`
		1180	`028F: BCF 03.7`
		1181	`0290: BTFSC 42.0`
		1182	`0291: BSF 03.7`
		1183	`0292: MOVF 00,W`
		1184	`0293: SUBLW 58`
		1185	`0294: BTFSS 03.2`
		1186	`0295: GOTO 2A2`
		1187	`.................... {`
		1188	`.................... base = 16;`
		1189	`0296: MOVLW 10`
		1190	`0297: MOVWF 46`
		1191	`.................... index++;`
		1192	`0298: INCF 47,F`
		1193	`.................... c = s[index++];`
		1194	`0299: MOVF 47,W`
		1195	`029A: INCF 47,F`
		1196	`029B: ADDWF 41,W`
		1197	`029C: MOVWF 04`
		1198	`029D: BCF 03.7`
		1199	`029E: BTFSC 42.0`
		1200	`029F: BSF 03.7`
		1201	`02A0: MOVF 00,W`
		1202	`02A1: MOVWF 48`
		1203	`.................... }`
		1204	`....................`
		1205	`.................... // The number is a decimal number`
		1206	`.................... if (base == 10)`
		1207	`02A2: MOVF 46,W`
		1208	`02A3: SUBLW 0A`
		1209	`02A4: BTFSS 03.2`
		1210	`02A5: GOTO 2C9`
		1211	`.................... {`
		1212	`.................... while (c >= '0' && c <= '9')`
		1213	`.................... {`
		1214	`02A6: MOVF 48,W`
		1215	`02A7: SUBLW 2F`
		1216	`02A8: BTFSC 03.0`
		1217	`02A9: GOTO 2C8`
		1218	`02AA: MOVF 48,W`
		1219	`02AB: SUBLW 39`
		1220	`02AC: BTFSS 03.0`
		1221	`02AD: GOTO 2C8`
		1222	`.................... result = 10*result + (c - '0');`
		1223	`02AE: CLRF 4A`
		1224	`02AF: MOVLW 0A`
		1225	`02B0: MOVWF 49`
		1226	`02B1: MOVF 44,W`
		1227	`02B2: MOVWF 4C`
		1228	`02B3: MOVF 43,W`
		1229	`02B4: MOVWF 4B`
		1230	`02B5: GOTO 22C`
		1231	`02B6: MOVLW 30`
		1232	`02B7: SUBWF 48,W`
		1233	`02B8: ADDWF 78,W`
		1234	`02B9: MOVWF 43`
		1235	`02BA: MOVF 79,W`
		1236	`02BB: MOVWF 44`
		1237	`02BC: BTFSC 03.0`
		1238	`02BD: INCF 44,F`
		1239	`.................... c = s[index++];`
		1240	`02BE: MOVF 47,W`
		1241	`02BF: INCF 47,F`
		1242	`02C0: ADDWF 41,W`
		1243	`02C1: MOVWF 04`
		1244	`02C2: BCF 03.7`
		1245	`02C3: BTFSC 42.0`
		1246	`02C4: BSF 03.7`
		1247	`02C5: MOVF 00,W`
		1248	`02C6: MOVWF 48`
		1249	`.................... }`
		1250	`02C7: GOTO 2A6`
		1251	`.................... }`
		1252	`.................... else if (base == 16) // The number is a hexa number`
		1253	`02C8: GOTO 332`
		1254	`02C9: MOVF 46,W`
		1255	`02CA: SUBLW 10`
		1256	`02CB: BTFSS 03.2`
		1257	`02CC: GOTO 332`
		1258	`.................... {`
		1259	`.................... c = toupper(c);`
		1260	`02CD: MOVF 48,W`
		1261	`02CE: SUBLW 60`
		1262	`02CF: BTFSC 03.0`
		1263	`02D0: GOTO 2D8`
		1264	`02D1: MOVF 48,W`
		1265	`02D2: SUBLW 7A`
		1266	`02D3: BTFSS 03.0`
		1267	`02D4: GOTO 2D8`
		1268	`02D5: MOVF 48,W`
		1269	`02D6: ANDLW DF`
		1270	`02D7: GOTO 2D9`
		1271	`02D8: MOVF 48,W`
		1272	`02D9: MOVWF 48`
		1273	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`
		1274	`.................... {`
		1275	`02DA: MOVF 48,W`
		1276	`02DB: SUBLW 2F`
		1277	`02DC: BTFSC 03.0`
		1278	`02DD: GOTO 2E2`
		1279	`02DE: MOVF 48,W`
		1280	`02DF: SUBLW 39`
		1281	`02E0: BTFSC 03.0`
		1282	`02E1: GOTO 2EA`
		1283	`02E2: MOVF 48,W`
		1284	`02E3: SUBLW 40`
		1285	`02E4: BTFSC 03.0`
		1286	`02E5: GOTO 332`
		1287	`02E6: MOVF 48,W`
		1288	`02E7: SUBLW 46`
		1289	`02E8: BTFSS 03.0`
		1290	`02E9: GOTO 332`
		1291	`.................... if (c >= '0' && c <= '9')`
		1292	`02EA: MOVF 48,W`
		1293	`02EB: SUBLW 2F`
		1294	`02EC: BTFSC 03.0`
		1295	`02ED: GOTO 307`
		1296	`02EE: MOVF 48,W`
		1297	`02EF: SUBLW 39`
		1298	`02F0: BTFSS 03.0`
		1299	`02F1: GOTO 307`
		1300	`.................... result = (result << 4) + (c - '0');`
		1301	`02F2: RLF 43,W`
		1302	`02F3: MOVWF 49`
		1303	`02F4: RLF 44,W`
		1304	`02F5: MOVWF 4A`
		1305	`02F6: RLF 49,F`
		1306	`02F7: RLF 4A,F`
		1307	`02F8: RLF 49,F`
		1308	`02F9: RLF 4A,F`
		1309	`02FA: RLF 49,F`
		1310	`02FB: RLF 4A,F`
		1311	`02FC: MOVLW F0`
		1312	`02FD: ANDWF 49,F`
		1313	`02FE: MOVLW 30`
		1314	`02FF: SUBWF 48,W`
		1315	`0300: ADDWF 49,W`
		1316	`0301: MOVWF 43`
		1317	`0302: MOVF 4A,W`
		1318	`0303: MOVWF 44`
		1319	`0304: BTFSC 03.0`
		1320	`0305: INCF 44,F`
		1321	`.................... else`
		1322	`0306: GOTO 31C`
		1323	`.................... result = (result << 4) + (c - 'A' + 10);`
		1324	`0307: RLF 43,W`
		1325	`0308: MOVWF 49`
		1326	`0309: RLF 44,W`
		1327	`030A: MOVWF 4A`
		1328	`030B: RLF 49,F`
		1329	`030C: RLF 4A,F`
		1330	`030D: RLF 49,F`
		1331	`030E: RLF 4A,F`
		1332	`030F: RLF 49,F`
		1333	`0310: RLF 4A,F`
		1334	`0311: MOVLW F0`
		1335	`0312: ANDWF 49,F`
		1336	`0313: MOVLW 41`
		1337	`0314: SUBWF 48,W`
		1338	`0315: ADDLW 0A`
		1339	`0316: ADDWF 49,W`
		1340	`0317: MOVWF 43`
		1341	`0318: MOVF 4A,W`
		1342	`0319: MOVWF 44`
		1343	`031A: BTFSC 03.0`
		1344	`031B: INCF 44,F`
		1345	`....................`
		1346	`.................... c = s[index++];c = toupper(c);`
		1347	`031C: MOVF 47,W`
		1348	`031D: INCF 47,F`
		1349	`031E: ADDWF 41,W`
		1350	`031F: MOVWF 04`
		1351	`0320: BCF 03.7`
		1352	`0321: BTFSC 42.0`
		1353	`0322: BSF 03.7`
		1354	`0323: MOVF 00,W`
		1355	`0324: MOVWF 48`
		1356	`0325: SUBLW 60`
		1357	`0326: BTFSC 03.0`
		1358	`0327: GOTO 32F`
		1359	`0328: MOVF 48,W`
		1360	`0329: SUBLW 7A`
		1361	`032A: BTFSS 03.0`
		1362	`032B: GOTO 32F`
		1363	`032C: MOVF 48,W`
		1364	`032D: ANDLW DF`
		1365	`032E: GOTO 330`
		1366	`032F: MOVF 48,W`
		1367	`0330: MOVWF 48`
		1368	`.................... }`
		1369	`0331: GOTO 2DA`
		1370	`.................... }`
		1371	`.................... }`
		1372	`....................`
		1373	`.................... if (base == 10 && sign == 1)`
		1374	`0332: MOVF 46,W`
		1375	`0333: SUBLW 0A`
		1376	`0334: BTFSS 03.2`
		1377	`0335: GOTO 33D`
		1378	`0336: DECFSZ 45,W`
		1379	`0337: GOTO 33D`
		1380	`.................... result = -result;`
		1381	`0338: COMF 43,F`
		1382	`0339: COMF 44,F`
		1383	`033A: INCF 43,F`
		1384	`033B: BTFSC 03.2`
		1385	`033C: INCF 44,F`
		1386	`....................`
		1387	`.................... return(result);`
		1388	`033D: MOVF 43,W`
		1389	`033E: MOVWF 78`
		1390	`033F: MOVF 44,W`
		1391	`0340: MOVWF 79`
		1392	`.................... }`
		1393	`0341: RETLW 00`
		1394	`....................`
		1395	`.................... /* A fast routine to multiply by 10`
		1396	`.................... */`
		1397	`.................... signed int32 mult_with10(int32 num)`
		1398	`.................... {`
		1399	`.................... return ( (num << 1) + (num << 3) );`
		1400	`.................... }`
		1401	`....................`
		1402	`.................... signed int32 atoi32(char *s)`
		1403	`.................... {`
		1404	`.................... signed int32 result;`
		1405	`.................... int sign, base, index;`
		1406	`.................... char c;`
		1407	`....................`
		1408	`.................... index = 0;`
		1409	`.................... sign = 0;`
		1410	`.................... base = 10;`
		1411	`.................... result = 0;`
		1412	`....................`
		1413	`.................... if (!s)`
		1414	`.................... return 0;`
		1415	`.................... c = s[index++];`
		1416	`....................`
		1417	`.................... // increase index if either positive or negative sign is detected`
		1418	`.................... if (c == '-')`
		1419	`.................... {`
		1420	`.................... sign = 1; // Set the sign to negative`
		1421	`.................... c = s[index++];`
		1422	`.................... }`
		1423	`.................... else if (c == '+')`
		1424	`.................... {`
		1425	`.................... c = s[index++];`
		1426	`.................... }`
		1427	`....................`
		1428	`.................... if (c >= '0' && c <= '9')`
		1429	`.................... {`
		1430	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
		1431	`.................... {`
		1432	`.................... base = 16;`
		1433	`.................... index++;`
		1434	`.................... c = s[index++];`
		1435	`.................... }`
		1436	`....................`
		1437	`.................... // The number is a decimal number`
		1438	`.................... if (base == 10)`
		1439	`.................... {`
		1440	`.................... while (c >= '0' && c <= '9') {`
		1441	`.................... result = (result << 1) + (result << 3); // result *= 10;`
		1442	`.................... result += (c - '0');`
		1443	`.................... c = s[index++];`
		1444	`.................... }`
		1445	`.................... }`
		1446	`.................... else if (base == 16) // The number is a hexa number`
		1447	`.................... {`
		1448	`.................... c = toupper(c);`
		1449	`.................... while ((c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`
		1450	`.................... {`
		1451	`.................... if (c >= '0' && c <= '9')`
		1452	`.................... result = (result << 4) + (c - '0');`
		1453	`.................... else`
		1454	`.................... result = (result << 4) + (c - 'A' + 10);`
		1455	`....................`
		1456	`.................... c = s[index++];c = toupper(c);`
		1457	`.................... }`
		1458	`.................... }`
		1459	`.................... }`
		1460	`....................`
		1461	`.................... if (base == 10 && sign == 1)`
		1462	`.................... result = -result;`
		1463	`....................`
		1464	`.................... return(result);`
		1465	`.................... }`
		1466	`....................`
		1467	`.................... float strtod(char s,char endptr) {`
		1468	`.................... float pow10 = 1.0;`
		1469	`.................... float result = 0.0;`
		1470	`.................... int sign = 0, point = 0;`
		1471	`.................... char c;`
		1472	`.................... int ptr = 0;`
		1473	`....................`
		1474	`.................... if (!s)`
		1475	`.................... return 0;`
		1476	`.................... c=s[ptr++];`
		1477	`....................`
		1478	`....................`
		1479	`.................... while((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`
		1480	`.................... if(c == '-') {`
		1481	`.................... sign = 1;`
		1482	`.................... c = s[ptr++];`
		1483	`.................... }`
		1484	`....................`
		1485	`.................... while((c >= '0' && c <= '9') && point == 0) {`
		1486	`.................... result = 10*result + c - '0';`
		1487	`.................... c = s[ptr++];`
		1488	`.................... }`
		1489	`....................`
		1490	`.................... if (c == '.') {`
		1491	`.................... point = 1;`
		1492	`.................... c = s[ptr++];`
		1493	`.................... }`
		1494	`....................`
		1495	`.................... while((c >= '0' && c <= '9') && point == 1) {`
		1496	`.................... pow10 = pow10*10;`
		1497	`.................... result += (c - '0')/pow10;`
		1498	`.................... c = s[ptr++];`
		1499	`.................... }`
		1500	`....................`
		1501	`.................... if (c == '+') {`
		1502	`.................... c = s[ptr++];`
		1503	`.................... }`
		1504	`.................... }`
		1505	`....................`
		1506	`.................... if (sign == 1)`
		1507	`.................... result = -1*result;`
		1508	`.................... if(endptr)`
		1509	`.................... {`
		1510	`.................... if (ptr) {`
		1511	`.................... ptr--;`
		1512	`.................... ((char )endptr)=s+ptr;`
		1513	`.................... }`
		1514	`.................... else`
		1515	`.................... ((char )endptr)=s;`
		1516	`.................... }`
		1517	`....................`
		1518	`.................... return(result);`
		1519	`.................... }`
		1520	`....................`
		1521	`.................... long strtoul(char s,char endptr,signed int base)`
		1522	`.................... {`
		1523	`.................... char sc,s1,*sd;`
		1524	`.................... unsigned long x=0;`
		1525	`.................... char sign;`
		1526	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`
		1527	`.................... for(sc=s;isspace(*sc);++sc);`
		1528	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`
		1529	`.................... if(sign=='-')`
		1530	`.................... {`
		1531	`.................... if (endptr)`
		1532	`.................... {`
		1533	`.................... ((char )endptr)=s;`
		1534	`.................... }`
		1535	`.................... return 0;`
		1536	`.................... }`
		1537	`....................`
		1538	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`
		1539	`.................... {`
		1540	`.................... if (endptr)`
		1541	`.................... {`
		1542	`.................... ((char )endptr)=s;`
		1543	`.................... }`
		1544	`.................... return 0;`
		1545	`.................... }`
		1546	`.................... else if (base)`
		1547	`.................... {`
		1548	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`
		1549	`.................... sc+=2;`
		1550	`.................... if(base==8 && *sc =='0')`
		1551	`.................... sc+=1;`
		1552	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`
		1553	`.................... sc+=2;`
		1554	`....................`
		1555	`.................... }`
		1556	`.................... else if(*sc!='0') // base is 0, find base`
		1557	`.................... base=10;`
		1558	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`
		1559	`.................... base =16,sc+=2;`
		1560	`.................... else if(sc[1]=='b')`
		1561	`.................... base=2,sc+=2;`
		1562	`.................... else`
		1563	`.................... base=8;`
		1564	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`
		1565	`.................... sd=memchr(digits,tolower(*sc),base);`
		1566	`.................... for(; sd!=0; )`
		1567	`.................... {`
		1568	`.................... x=x*base+(int16)(sd-digits);`
		1569	`.................... ++sc;`
		1570	`.................... sd=memchr(digits,tolower(*sc),base);`
		1571	`.................... }`
		1572	`.................... if(s1==sc)`
		1573	`.................... {`
		1574	`.................... if (endptr)`
		1575	`.................... {`
		1576	`.................... ((char )endptr)=s;`
		1577	`.................... }`
		1578	`.................... return 0;`
		1579	`.................... }`
		1580	`.................... if (endptr)`
		1581	`.................... ((char )endptr)=sc;`
		1582	`.................... return x;`
		1583	`.................... }`
		1584	`....................`
		1585	`....................`
		1586	`.................... signed long strtol(char s,char endptr,signed int base)`
		1587	`.................... {`
		1588	`.................... char sc,s1,*sd;`
		1589	`.................... signed long x=0;`
		1590	`.................... char sign;`
		1591	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`
		1592	`.................... for(sc=s;isspace(*sc);++sc);`
		1593	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`
		1594	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`
		1595	`.................... {`
		1596	`.................... if (endptr)`
		1597	`.................... {`
		1598	`.................... ((char )endptr)=s;`
		1599	`.................... }`
		1600	`.................... return 0;`
		1601	`.................... }`
		1602	`.................... else if (base)`
		1603	`.................... {`
		1604	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`
		1605	`.................... sc+=2;`
		1606	`.................... if(base==8 && *sc =='0')`
		1607	`.................... sc+=1;`
		1608	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`
		1609	`.................... sc+=2;`
		1610	`....................`
		1611	`.................... }`
		1612	`.................... else if(*sc!='0') // base is 0, find base`
		1613	`.................... base=10;`
		1614	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`
		1615	`.................... base =16,sc+=2;`
		1616	`.................... else if(sc[1]=='b')`
		1617	`.................... base=2,sc+=2;`
		1618	`.................... else`
		1619	`.................... base=8;`
		1620	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`
		1621	`....................`
		1622	`.................... sd=memchr(digits,tolower(*sc),base);`
		1623	`.................... for(;sd!=0;)`
		1624	`.................... {`
		1625	`.................... x=x*base+(int16)(sd-digits);`
		1626	`.................... ++sc;`
		1627	`.................... sd=memchr(digits,tolower(*sc),base);`
		1628	`.................... }`
		1629	`.................... if(s1==sc)`
		1630	`.................... {`
		1631	`.................... if (endptr)`
		1632	`.................... {`
		1633	`.................... ((char )endptr)=s;`
		1634	`.................... }`
		1635	`.................... return 0;`
		1636	`.................... }`
		1637	`.................... if(sign=='-')`
		1638	`.................... x =-x;`
		1639	`.................... if (endptr)`
		1640	`.................... ((char )endptr)=sc;`
		1641	`.................... return x;`
		1642	`.................... }`
		1643	`....................`
		1644	`.................... signed int system(char *string)`
		1645	`.................... {`
		1646	`.................... return 0;`
		1647	`.................... }`
		1648	`....................`
		1649	`.................... int mblen(char *s,size_t n)`
		1650	`.................... {`
		1651	`.................... return strlen(s);`
		1652	`.................... }`
		1653	`....................`
		1654	`.................... int mbtowc(wchar_t pwc,char s,size_t n)`
		1655	`.................... {`
		1656	`.................... pwc=s;`
		1657	`.................... return 1;`
		1658	`.................... }`
		1659	`....................`
		1660	`.................... int wctomb(char *s,wchar_t wchar)`
		1661	`.................... {`
		1662	`.................... *s=wchar;`
		1663	`.................... return 1;`
		1664	`.................... }`
		1665	`....................`
		1666	`.................... size_t mbstowcs(wchar_t pwcs,char s,size_t n)`
		1667	`.................... {`
		1668	`.................... strncpy(pwcs,s,n);`
		1669	`.................... return strlen(pwcs);`
		1670	`.................... }`
		1671	`....................`
		1672	`.................... size_t wcstombs(char s,wchar_t pwcs,size_t n)`
		1673	`.................... {`
		1674	`.................... strncpy(s,pwcs,n);`
		1675	`.................... return strlen(s);`
		1676	`.................... }`
		1677	`....................`
		1678	`.................... //---------------------------------------------------------------------------`
		1679	`.................... // The random number implementation`
		1680	`.................... //---------------------------------------------------------------------------`
		1681	`....................`
		1682	`.................... unsigned int32 _Randseed = 1;`
		1683	`*`
		1684	`035B: MOVLW 01`
		1685	`035C: MOVWF 2B`
		1686	`035D: CLRF 2C`
		1687	`035E: CLRF 2D`
		1688	`035F: CLRF 2E`
		1689	`....................`
		1690	`.................... long rand(void)`
		1691	`.................... {`
		1692	`.................... _Randseed = _Randseed * 1103515245 + 12345;`
		1693	`.................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX);`
		1694	`.................... }`
		1695	`....................`
		1696	`.................... void srand(unsigned int32 seed)`
		1697	`.................... {`
		1698	`.................... _Randseed = seed;`
		1699	`.................... }`
		1700	`....................`
		1701	`.................... //---------------------------------------------------------------------------`
		1702	`.................... // Searching and sorting utilities implementation`
		1703	`.................... //---------------------------------------------------------------------------`
		1704	`....................`
		1705	`.................... typedef signed int (_Cmpfun)(char p1,char * p2);`
		1706	`....................`
		1707	`.................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) {`
		1708	`.................... int m,j,i,l;`
		1709	`.................... short done;`
		1710	`.................... BYTE t[16];`
		1711	`....................`
		1712	`.................... m = qitems/2;`
		1713	`.................... while( m > 0 ) {`
		1714	`.................... for(j=0; j<(qitems-m); ++j) {`
		1715	`.................... i = j;`
		1716	`.................... do`
		1717	`.................... {`
		1718	`.................... done=TRUE;`
		1719	`.................... l = i+m;`
		1720	`.................... if( (cmp)(qdata+iqsize, qdata+l*qsize) > 0 ) {`
		1721	`.................... memcpy(t, qdata+i*qsize, qsize);`
		1722	`.................... memcpy(qdata+iqsize, qdata+lqsize, qsize);`
		1723	`.................... memcpy(qdata+l*qsize, t, qsize);`
		1724	`.................... if(m <= i)`
		1725	`.................... i -= m;`
		1726	`.................... done = FALSE;`
		1727	`.................... }`
		1728	`.................... } while(!done);`
		1729	`.................... }`
		1730	`.................... m = m/2;`
		1731	`.................... }`
		1732	`.................... }`
		1733	`....................`
		1734	`....................`
		1735	`.................... char bsearch(char key, char *base, size_t num, size_t width,_Cmpfun cmp)`
		1736	`.................... {`
		1737	`.................... char p, q;`
		1738	`.................... size_t n;`
		1739	`.................... size_t pivot;`
		1740	`.................... signed int val;`
		1741	`....................`
		1742	`.................... p = base;`
		1743	`.................... n = num;`
		1744	`....................`
		1745	`.................... while (n > 0)`
		1746	`.................... {`
		1747	`.................... pivot = n >> 1;`
		1748	`.................... q = p + width * pivot;`
		1749	`....................`
		1750	`.................... val = (*cmp)(key, q);`
		1751	`....................`
		1752	`.................... if (val < 0)`
		1753	`.................... n = pivot;`
		1754	`.................... else if (val == 0)`
		1755	`.................... return ((char *)q);`
		1756	`.................... else {`
		1757	`.................... p = q + width;`
		1758	`.................... n -= pivot + 1;`
		1759	`.................... }`
		1760	`.................... }`
		1761	`....................`
		1762	`.................... return NULL; // There's no match`
		1763	`.................... }`
		1764	`....................`
		1765	`....................`
		1766	`.................... #endif`
		1767	`....................`
		1768	`....................`
		1769	`.................... #define SYNC PIN_B4 // Spousteni oscyloskopu`
		1770	`.................... #define HACK PIN_B5 // Zkratovani napajeni SmartCard`
		1771	`.................... #define CLOCK PIN_B6 // Hodiny ze SmartCard`
		1772	`....................`
		1773	`.................... #int_TIMER1`
		1774	`.................... TIMER1_isr()`
		1775	`.................... {`
		1776	`....................`
		1777	`.................... }`
		1778	`....................`
		1779	`*`
		1780	`00E0: BCF 0C.0`
		1781	`00E1: BCF 0A.3`
		1782	`00E2: GOTO 028`
		1783	`.................... #int_TIMER2`
		1784	`.................... TIMER2_isr()`
		1785	`.................... {`
		1786	`....................`
		1787	`.................... }`
		1788	`....................`
		1789	`00E3: BCF 0C.1`
		1790	`00E4: BCF 0A.3`
		1791	`00E5: GOTO 028`
		1792	`.................... void main()`
		1793	`.................... {`
		1794	`*`
		1795	`0342: CLRF 04`
		1796	`0343: BCF 03.7`
		1797	`0344: MOVLW 1F`
		1798	`0345: ANDWF 03,F`
		1799	`0346: BSF 03.5`
		1800	`0347: BCF 1F.4`
		1801	`0348: BCF 1F.5`
		1802	`0349: MOVF 1B,W`
		1803	`034A: ANDLW 80`
		1804	`034B: MOVWF 1B`
		1805	`034C: MOVLW 07`
		1806	`034D: MOVWF 1C`
		1807	`034E: MOVF 05,W`
		1808	`034F: CLRWDT`
		1809	`0350: MOVF 1C,W`
		1810	`0351: BCF 03.5`
		1811	`0352: BCF 0D.6`
		1812	`0353: MOVLW 60`
		1813	`0354: BSF 03.5`
		1814	`0355: MOVWF 0F`
		1815	`0356: BCF 06.3`
		1816	`0357: BCF 03.5`
		1817	`0358: BSF 06.3`
		1818	`.................... unsigned int16 i;`
		1819	`.................... char ch;`
		1820	`.................... char string[10];`
		1821	`.................... const char ver[]={"HACK v1.0\0"};`
		1822	`.................... unsigned int16 prescale;`
		1823	`.................... unsigned int16 ticks;`
		1824	`.................... int n;`
		1825	`....................`
		1826	`.................... setup_adc_ports(NO_ANALOGS\|VSS_VDD);`
		1827	`*`
		1828	`0360: BSF 03.5`
		1829	`0361: BCF 1F.4`
		1830	`0362: BCF 1F.5`
		1831	`0363: MOVF 1B,W`
		1832	`0364: ANDLW 80`
		1833	`0365: MOVWF 1B`
		1834	`.................... setup_adc(ADC_OFF);`
		1835	`0366: BCF 03.5`
		1836	`0367: BCF 1F.0`
		1837	`.................... setup_spi(FALSE);`
		1838	`0368: BCF 14.5`
		1839	`0369: BSF 03.5`
		1840	`036A: BCF 06.2`
		1841	`036B: BSF 06.1`
		1842	`036C: BCF 06.4`
		1843	`036D: MOVLW 00`
		1844	`036E: BCF 03.5`
		1845	`036F: MOVWF 14`
		1846	`0370: BSF 03.5`
		1847	`0371: MOVWF 14`
		1848	`.................... setup_timer_0(RTCC_EXT_L_TO_H\|RTCC_DIV_1);`
		1849	`0372: MOVF 01,W`
		1850	`0373: ANDLW C7`
		1851	`0374: IORLW 28`
		1852	`0375: MOVWF 01`
		1853	`.................... setup_timer_1(T1_EXTERNAL\|T1_DIV_BY_1);`
		1854	`0376: MOVLW 87`
		1855	`0377: BCF 03.5`
		1856	`0378: MOVWF 10`
		1857	`.................... // setup_timer_1(T1_INTERNAL\|T1_DIV_BY_8);`
		1858	`.................... setup_timer_2(T2_DISABLED,0,1);`
		1859	`0379: MOVLW 00`
		1860	`037A: MOVWF 78`
		1861	`037B: MOVWF 12`
		1862	`037C: MOVLW 00`
		1863	`037D: BSF 03.5`
		1864	`037E: MOVWF 12`
		1865	`.................... setup_comparator(NC_NC_NC_NC);`
		1866	`037F: MOVLW 07`
		1867	`0380: MOVWF 1C`
		1868	`0381: MOVF 05,W`
		1869	`0382: CLRWDT`
		1870	`0383: MOVLW 02`
		1871	`0384: MOVWF 77`
		1872	`0385: DECFSZ 77,F`
		1873	`0386: GOTO 385`
		1874	`0387: NOP`
		1875	`0388: NOP`
		1876	`0389: MOVF 1C,W`
		1877	`038A: BCF 03.5`
		1878	`038B: BCF 0D.6`
		1879	`.................... setup_vref(FALSE);`
		1880	`038C: BSF 03.5`
		1881	`038D: CLRF 1D`
		1882	`.................... // enable_interrupts(INT_TIMER1);`
		1883	`.................... // enable_interrupts(INT_TIMER2);`
		1884	`.................... // enable_interrupts(GLOBAL);`
		1885	`....................`
		1886	`.................... setup_oscillator(OSC_4MHZ\|OSC_INTRC); // 4 MHz interni RC oscilator`
		1887	`038E: MOVLW 62`
		1888	`038F: MOVWF 0F`
		1889	`....................`
		1890	`.................... delay_ms(100);`
		1891	`0390: MOVLW 64`
		1892	`0391: BCF 03.5`
		1893	`0392: MOVWF 42`
		1894	`0393: CALL 0E6`
		1895	`.................... printf("\n\r\n\r%s", ver);`
		1896	`0394: CLRF 41`
		1897	`0395: MOVF 41,W`
		1898	`0396: CALL 04E`
		1899	`0397: INCF 41,F`
		1900	`0398: MOVWF 77`
		1901	`0399: MOVWF 4C`
		1902	`039A: CALL 0FE`
		1903	`039B: MOVLW 04`
		1904	`039C: SUBWF 41,W`
		1905	`039D: BTFSS 03.2`
		1906	`039E: GOTO 395`
		1907	`039F: CLRF 42`
		1908	`03A0: MOVF 42,W`
		1909	`03A1: CALL 03F`
		1910	`03A2: IORLW 00`
		1911	`03A3: BTFSC 03.2`
		1912	`03A4: GOTO 3A9`
		1913	`03A5: INCF 42,F`
		1914	`03A6: MOVWF 4C`
		1915	`03A7: CALL 0FE`
		1916	`03A8: GOTO 3A0`
		1917	`.................... output_low(SYNC);`
		1918	`03A9: BSF 03.5`
		1919	`03AA: BCF 06.4`
		1920	`03AB: BCF 03.5`
		1921	`03AC: BCF 06.4`
		1922	`.................... output_low(HACK);`
		1923	`03AD: BSF 03.5`
		1924	`03AE: BCF 06.5`
		1925	`03AF: BCF 03.5`
		1926	`03B0: BCF 06.5`
		1927	`.................... ticks=1;`
		1928	`03B1: CLRF 3F`
		1929	`03B2: MOVLW 01`
		1930	`03B3: MOVWF 3E`
		1931	`.................... prescale=0;`
		1932	`03B4: CLRF 3D`
		1933	`03B5: CLRF 3C`
		1934	`....................`
		1935	`.................... while(true)`
		1936	`.................... {`
		1937	`.................... printf("\n\r>");`
		1938	`03B6: MOVLW 0A`
		1939	`03B7: MOVWF 4C`
		1940	`03B8: CALL 0FE`
		1941	`03B9: MOVLW 0D`
		1942	`03BA: MOVWF 4C`
		1943	`03BB: CALL 0FE`
		1944	`03BC: MOVLW 3E`
		1945	`03BD: MOVWF 4C`
		1946	`03BE: CALL 0FE`
		1947	`.................... n=0;`
		1948	`03BF: CLRF 40`
		1949	`.................... do`
		1950	`.................... {`
		1951	`.................... ch=getchar();`
		1952	`03C0: GOTO 12A`
		1953	`03C1: MOVF 78,W`
		1954	`03C2: MOVWF 31`
		1955	`.................... printf("%c",ch);`
		1956	`03C3: MOVF 31,W`
		1957	`03C4: MOVWF 4C`
		1958	`03C5: CALL 0FE`
		1959	`.................... string[n++]=ch;`
		1960	`03C6: MOVF 40,W`
		1961	`03C7: INCF 40,F`
		1962	`03C8: ADDLW 32`
		1963	`03C9: MOVWF 04`
		1964	`03CA: BCF 03.7`
		1965	`03CB: MOVF 31,W`
		1966	`03CC: MOVWF 00`
		1967	`.................... } while((13 != ch) && (n < 10));`
		1968	`03CD: MOVF 31,W`
		1969	`03CE: SUBLW 0D`
		1970	`03CF: BTFSC 03.2`
		1971	`03D0: GOTO 3D5`
		1972	`03D1: MOVF 40,W`
		1973	`03D2: SUBLW 09`
		1974	`03D3: BTFSC 03.0`
		1975	`03D4: GOTO 3C0`
		1976	`.................... string[n]=0;`
		1977	`03D5: MOVLW 32`
		1978	`03D6: ADDWF 40,W`
		1979	`03D7: MOVWF 04`
		1980	`03D8: BCF 03.7`
		1981	`03D9: CLRF 00`
		1982	`.................... printf("\n\r");`
		1983	`03DA: MOVLW 0A`
		1984	`03DB: MOVWF 4C`
		1985	`03DC: CALL 0FE`
		1986	`03DD: MOVLW 0D`
		1987	`03DE: MOVWF 4C`
		1988	`03DF: CALL 0FE`
		1989	`.................... switch(string[0])`
		1990	`.................... {`
		1991	`03E0: MOVF 32,W`
		1992	`03E1: XORLW 67`
		1993	`03E2: BTFSC 03.2`
		1994	`03E3: GOTO 3F1`
		1995	`03E4: XORLW 15`
		1996	`03E5: BTFSC 03.2`
		1997	`03E6: GOTO 460`
		1998	`03E7: XORLW 1A`
		1999	`03E8: BTFSC 03.2`
		2000	`03E9: GOTO 4E9`
		2001	`03EA: XORLW 01`
		2002	`03EB: BTFSC 03.2`
		2003	`03EC: GOTO 571`
		2004	`03ED: XORLW 19`
		2005	`03EE: BTFSC 03.2`
		2006	`03EF: GOTO 5A8`
		2007	`03F0: GOTO 5EB`
		2008	`.................... case 'g': // GO`
		2009	`.................... printf("%Lue4 + %Lu GO", prescale, ticks);`
		2010	`03F1: MOVLW 10`
		2011	`03F2: MOVWF 04`
		2012	`03F3: MOVF 3D,W`
		2013	`03F4: MOVWF 44`
		2014	`03F5: MOVF 3C,W`
		2015	`03F6: MOVWF 43`
		2016	`03F7: CALL 15F`
		2017	`03F8: MOVLW 03`
		2018	`03F9: MOVWF 41`
		2019	`03FA: MOVF 41,W`
		2020	`03FB: CALL 059`
		2021	`03FC: INCF 41,F`
		2022	`03FD: MOVWF 77`
		2023	`03FE: MOVWF 4C`
		2024	`03FF: CALL 0FE`
		2025	`0400: MOVLW 08`
		2026	`0401: SUBWF 41,W`
		2027	`0402: BTFSS 03.2`
		2028	`0403: GOTO 3FA`
		2029	`0404: MOVLW 10`
		2030	`0405: MOVWF 04`
		2031	`0406: MOVF 3F,W`
		2032	`0407: MOVWF 44`
		2033	`0408: MOVF 3E,W`
		2034	`0409: MOVWF 43`
		2035	`040A: CALL 15F`
		2036	`040B: MOVLW 20`
		2037	`040C: MOVWF 4C`
		2038	`040D: CALL 0FE`
		2039	`040E: MOVLW 47`
		2040	`040F: MOVWF 4C`
		2041	`0410: CALL 0FE`
		2042	`0411: MOVLW 4F`
		2043	`0412: MOVWF 4C`
		2044	`0413: CALL 0FE`
		2045	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
		2046	`0414: CLRF 30`
		2047	`0415: CLRF 2F`
		2048	`0416: MOVF 30,W`
		2049	`0417: SUBWF 3D,W`
		2050	`0418: BTFSS 03.0`
		2051	`0419: GOTO 43C`
		2052	`041A: BTFSS 03.2`
		2053	`041B: GOTO 420`
		2054	`041C: MOVF 3C,W`
		2055	`041D: SUBWF 2F,W`
		2056	`041E: BTFSC 03.0`
		2057	`041F: GOTO 43C`
		2058	`0420: CLRF 0F`
		2059	`0421: CLRF 0E`
		2060	`0422: MOVF 0F,W`
		2061	`0423: MOVWF 7A`
		2062	`0424: MOVF 0E,W`
		2063	`0425: MOVWF 77`
		2064	`0426: MOVF 0F,W`
		2065	`0427: SUBWF 7A,W`
		2066	`0428: BTFSS 03.2`
		2067	`0429: GOTO 422`
		2068	`042A: MOVF 77,W`
		2069	`042B: MOVWF 41`
		2070	`042C: MOVF 7A,W`
		2071	`042D: MOVWF 42`
		2072	`042E: MOVF 42,W`
		2073	`042F: SUBLW 27`
		2074	`0430: BTFSS 03.0`
		2075	`0431: GOTO 438`
		2076	`0432: BTFSS 03.2`
		2077	`0433: GOTO 422`
		2078	`0434: MOVF 41,W`
		2079	`0435: SUBLW 0F`
		2080	`0436: BTFSC 03.0`
		2081	`0437: GOTO 422`
		2082	`0438: INCF 2F,F`
		2083	`0439: BTFSC 03.2`
		2084	`043A: INCF 30,F`
		2085	`043B: GOTO 416`
		2086	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
		2087	`043C: CLRF 0F`
		2088	`043D: CLRF 0E`
		2089	`043E: MOVF 0F,W`
		2090	`043F: MOVWF 7A`
		2091	`0440: MOVF 0E,W`
		2092	`0441: MOVWF 77`
		2093	`0442: MOVF 0F,W`
		2094	`0443: SUBWF 7A,W`
		2095	`0444: BTFSS 03.2`
		2096	`0445: GOTO 43E`
		2097	`0446: MOVF 77,W`
		2098	`0447: MOVWF 41`
		2099	`0448: MOVF 7A,W`
		2100	`0449: MOVWF 42`
		2101	`044A: MOVF 42,W`
		2102	`044B: SUBWF 3F,W`
		2103	`044C: BTFSS 03.0`
		2104	`044D: GOTO 454`
		2105	`044E: BTFSS 03.2`
		2106	`044F: GOTO 43E`
		2107	`0450: MOVF 3E,W`
		2108	`0451: SUBWF 41,W`
		2109	`0452: BTFSS 03.0`
		2110	`0453: GOTO 43E`
		2111	`.................... output_high(SYNC);`
		2112	`0454: BSF 03.5`
		2113	`0455: BCF 06.4`
		2114	`0456: BCF 03.5`
		2115	`0457: BSF 06.4`
		2116	`.................... delay_ms(1);`
		2117	`0458: MOVLW 01`
		2118	`0459: MOVWF 42`
		2119	`045A: CALL 0E6`
		2120	`.................... output_low(SYNC);`
		2121	`045B: BSF 03.5`
		2122	`045C: BCF 06.4`
		2123	`045D: BCF 03.5`
		2124	`045E: BCF 06.4`
		2125	`.................... break;`
		2126	`045F: GOTO 61A`
		2127	`....................`
		2128	`.................... case 'r': // REPEAT`
		2129	`.................... n=0;`
		2130	`0460: CLRF 40`
		2131	`.................... while(true)`
		2132	`.................... {`
		2133	`.................... printf("%Lue4 + %Lu REPEAT %u\n\r", prescale, ticks, n++);`
		2134	`0461: MOVF 40,W`
		2135	`0462: INCF 40,F`
		2136	`0463: MOVWF 41`
		2137	`0464: MOVLW 10`
		2138	`0465: MOVWF 04`
		2139	`0466: MOVF 3D,W`
		2140	`0467: MOVWF 44`
		2141	`0468: MOVF 3C,W`
		2142	`0469: MOVWF 43`
		2143	`046A: CALL 15F`
		2144	`046B: MOVLW 03`
		2145	`046C: MOVWF 42`
		2146	`046D: MOVF 42,W`
		2147	`046E: CALL 06C`
		2148	`046F: INCF 42,F`
		2149	`0470: MOVWF 77`
		2150	`0471: MOVWF 4C`
		2151	`0472: CALL 0FE`
		2152	`0473: MOVLW 08`
		2153	`0474: SUBWF 42,W`
		2154	`0475: BTFSS 03.2`
		2155	`0476: GOTO 46D`
		2156	`0477: MOVLW 10`
		2157	`0478: MOVWF 04`
		2158	`0479: MOVF 3F,W`
		2159	`047A: MOVWF 44`
		2160	`047B: MOVF 3E,W`
		2161	`047C: MOVWF 43`
		2162	`047D: CALL 15F`
		2163	`047E: MOVLW 0B`
		2164	`047F: MOVWF 43`
		2165	`0480: MOVF 43,W`
		2166	`0481: CALL 06C`
		2167	`0482: INCF 43,F`
		2168	`0483: MOVWF 77`
		2169	`0484: MOVWF 4C`
		2170	`0485: CALL 0FE`
		2171	`0486: MOVLW 13`
		2172	`0487: SUBWF 43,W`
		2173	`0488: BTFSS 03.2`
		2174	`0489: GOTO 480`
		2175	`048A: MOVF 41,W`
		2176	`048B: MOVWF 44`
		2177	`048C: MOVLW 18`
		2178	`048D: MOVWF 45`
		2179	`048E: GOTO 1DE`
		2180	`048F: MOVLW 0A`
		2181	`0490: MOVWF 4C`
		2182	`0491: CALL 0FE`
		2183	`0492: MOVLW 0D`
		2184	`0493: MOVWF 4C`
		2185	`0494: CALL 0FE`
		2186	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
		2187	`0495: CLRF 30`
		2188	`0496: CLRF 2F`
		2189	`0497: MOVF 30,W`
		2190	`0498: SUBWF 3D,W`
		2191	`0499: BTFSS 03.0`
		2192	`049A: GOTO 4BD`
		2193	`049B: BTFSS 03.2`
		2194	`049C: GOTO 4A1`
		2195	`049D: MOVF 3C,W`
		2196	`049E: SUBWF 2F,W`
		2197	`049F: BTFSC 03.0`
		2198	`04A0: GOTO 4BD`
		2199	`04A1: CLRF 0F`
		2200	`04A2: CLRF 0E`
		2201	`04A3: MOVF 0F,W`
		2202	`04A4: MOVWF 7A`
		2203	`04A5: MOVF 0E,W`
		2204	`04A6: MOVWF 77`
		2205	`04A7: MOVF 0F,W`
		2206	`04A8: SUBWF 7A,W`
		2207	`04A9: BTFSS 03.2`
		2208	`04AA: GOTO 4A3`
		2209	`04AB: MOVF 77,W`
		2210	`04AC: MOVWF 41`
		2211	`04AD: MOVF 7A,W`
		2212	`04AE: MOVWF 42`
		2213	`04AF: MOVF 42,W`
		2214	`04B0: SUBLW 27`
		2215	`04B1: BTFSS 03.0`
		2216	`04B2: GOTO 4B9`
		2217	`04B3: BTFSS 03.2`
		2218	`04B4: GOTO 4A3`
		2219	`04B5: MOVF 41,W`
		2220	`04B6: SUBLW 0F`
		2221	`04B7: BTFSC 03.0`
		2222	`04B8: GOTO 4A3`
		2223	`04B9: INCF 2F,F`
		2224	`04BA: BTFSC 03.2`
		2225	`04BB: INCF 30,F`
		2226	`04BC: GOTO 497`
		2227	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
		2228	`04BD: CLRF 0F`
		2229	`04BE: CLRF 0E`
		2230	`04BF: MOVF 0F,W`
		2231	`04C0: MOVWF 7A`
		2232	`04C1: MOVF 0E,W`
		2233	`04C2: MOVWF 77`
		2234	`04C3: MOVF 0F,W`
		2235	`04C4: SUBWF 7A,W`
		2236	`04C5: BTFSS 03.2`
		2237	`04C6: GOTO 4BF`
		2238	`04C7: MOVF 77,W`
		2239	`04C8: MOVWF 41`
		2240	`04C9: MOVF 7A,W`
		2241	`04CA: MOVWF 42`
		2242	`04CB: MOVF 42,W`
		2243	`04CC: SUBWF 3F,W`
		2244	`04CD: BTFSS 03.0`
		2245	`04CE: GOTO 4D5`
		2246	`04CF: BTFSS 03.2`
		2247	`04D0: GOTO 4BF`
		2248	`04D1: MOVF 3E,W`
		2249	`04D2: SUBWF 41,W`
		2250	`04D3: BTFSS 03.0`
		2251	`04D4: GOTO 4BF`
		2252	`.................... output_high(SYNC);`
		2253	`04D5: BSF 03.5`
		2254	`04D6: BCF 06.4`
		2255	`04D7: BCF 03.5`
		2256	`04D8: BSF 06.4`
		2257	`.................... delay_ms(20);`
		2258	`04D9: MOVLW 14`
		2259	`04DA: MOVWF 42`
		2260	`04DB: CALL 0E6`
		2261	`.................... output_low(SYNC);`
		2262	`04DC: BSF 03.5`
		2263	`04DD: BCF 06.4`
		2264	`04DE: BCF 03.5`
		2265	`04DF: BCF 06.4`
		2266	`.................... delay_ms(2000);`
		2267	`04E0: MOVLW 08`
		2268	`04E1: MOVWF 41`
		2269	`04E2: MOVLW FA`
		2270	`04E3: MOVWF 42`
		2271	`04E4: CALL 0E6`
		2272	`04E5: DECFSZ 41,F`
		2273	`04E6: GOTO 4E2`
		2274	`.................... };`
		2275	`04E7: GOTO 461`
		2276	`.................... break;`
		2277	`04E8: GOTO 61A`
		2278	`....................`
		2279	`.................... case 'h': // HACK`
		2280	`.................... printf("%Lue4 + %Lu HACK", prescale, ticks);`
		2281	`04E9: MOVLW 10`
		2282	`04EA: MOVWF 04`
		2283	`04EB: MOVF 3D,W`
		2284	`04EC: MOVWF 44`
		2285	`04ED: MOVF 3C,W`
		2286	`04EE: MOVWF 43`
		2287	`04EF: CALL 15F`
		2288	`04F0: MOVLW 03`
		2289	`04F1: MOVWF 41`
		2290	`04F2: MOVF 41,W`
		2291	`04F3: CALL 088`
		2292	`04F4: INCF 41,F`
		2293	`04F5: MOVWF 77`
		2294	`04F6: MOVWF 4C`
		2295	`04F7: CALL 0FE`
		2296	`04F8: MOVLW 08`
		2297	`04F9: SUBWF 41,W`
		2298	`04FA: BTFSS 03.2`
		2299	`04FB: GOTO 4F2`
		2300	`04FC: MOVLW 10`
		2301	`04FD: MOVWF 04`
		2302	`04FE: MOVF 3F,W`
		2303	`04FF: MOVWF 44`
		2304	`0500: MOVF 3E,W`
		2305	`0501: MOVWF 43`
		2306	`0502: CALL 15F`
		2307	`0503: MOVLW 0B`
		2308	`0504: MOVWF 42`
		2309	`0505: MOVF 42,W`
		2310	`0506: CALL 088`
		2311	`0507: INCF 42,F`
		2312	`0508: MOVWF 77`
		2313	`0509: MOVWF 4C`
		2314	`050A: CALL 0FE`
		2315	`050B: MOVLW 10`
		2316	`050C: SUBWF 42,W`
		2317	`050D: BTFSS 03.2`
		2318	`050E: GOTO 505`
		2319	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
		2320	`050F: CLRF 30`
		2321	`0510: CLRF 2F`
		2322	`0511: MOVF 30,W`
		2323	`0512: SUBWF 3D,W`
		2324	`0513: BTFSS 03.0`
		2325	`0514: GOTO 537`
		2326	`0515: BTFSS 03.2`
		2327	`0516: GOTO 51B`
		2328	`0517: MOVF 3C,W`
		2329	`0518: SUBWF 2F,W`
		2330	`0519: BTFSC 03.0`
		2331	`051A: GOTO 537`
		2332	`051B: CLRF 0F`
		2333	`051C: CLRF 0E`
		2334	`051D: MOVF 0F,W`
		2335	`051E: MOVWF 7A`
		2336	`051F: MOVF 0E,W`
		2337	`0520: MOVWF 77`
		2338	`0521: MOVF 0F,W`
		2339	`0522: SUBWF 7A,W`
		2340	`0523: BTFSS 03.2`
		2341	`0524: GOTO 51D`
		2342	`0525: MOVF 77,W`
		2343	`0526: MOVWF 41`
		2344	`0527: MOVF 7A,W`
		2345	`0528: MOVWF 42`
		2346	`0529: MOVF 42,W`
		2347	`052A: SUBLW 27`
		2348	`052B: BTFSS 03.0`
		2349	`052C: GOTO 533`
		2350	`052D: BTFSS 03.2`
		2351	`052E: GOTO 51D`
		2352	`052F: MOVF 41,W`
		2353	`0530: SUBLW 0F`
		2354	`0531: BTFSC 03.0`
		2355	`0532: GOTO 51D`
		2356	`0533: INCF 2F,F`
		2357	`0534: BTFSC 03.2`
		2358	`0535: INCF 30,F`
		2359	`0536: GOTO 511`
		2360	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
		2361	`0537: CLRF 0F`
		2362	`0538: CLRF 0E`
		2363	`0539: MOVF 0F,W`
		2364	`053A: MOVWF 7A`
		2365	`053B: MOVF 0E,W`
		2366	`053C: MOVWF 77`
		2367	`053D: MOVF 0F,W`
		2368	`053E: SUBWF 7A,W`
		2369	`053F: BTFSS 03.2`
		2370	`0540: GOTO 539`
		2371	`0541: MOVF 77,W`
		2372	`0542: MOVWF 41`
		2373	`0543: MOVF 7A,W`
		2374	`0544: MOVWF 42`
		2375	`0545: MOVF 42,W`
		2376	`0546: SUBWF 3F,W`
		2377	`0547: BTFSS 03.0`
		2378	`0548: GOTO 54F`
		2379	`0549: BTFSS 03.2`
		2380	`054A: GOTO 539`
		2381	`054B: MOVF 3E,W`
		2382	`054C: SUBWF 41,W`
		2383	`054D: BTFSS 03.0`
		2384	`054E: GOTO 539`
		2385	`.................... output_high(SYNC);`
		2386	`054F: BSF 03.5`
		2387	`0550: BCF 06.4`
		2388	`0551: BCF 03.5`
		2389	`0552: BSF 06.4`
		2390	`.................... output_low(CLOCK);`
		2391	`0553: BSF 03.5`
		2392	`0554: BCF 06.6`
		2393	`0555: BCF 03.5`
		2394	`0556: BCF 06.6`
		2395	`.................... delay_ms(10);`
		2396	`0557: MOVLW 0A`
		2397	`0558: MOVWF 42`
		2398	`0559: CALL 0E6`
		2399	`.................... output_high(HACK);`
		2400	`055A: BSF 03.5`
		2401	`055B: BCF 06.5`
		2402	`055C: BCF 03.5`
		2403	`055D: BSF 06.5`
		2404	`.................... delay_ms(10000);`
		2405	`055E: MOVLW 28`
		2406	`055F: MOVWF 41`
		2407	`0560: MOVLW FA`
		2408	`0561: MOVWF 42`
		2409	`0562: CALL 0E6`
		2410	`0563: DECFSZ 41,F`
		2411	`0564: GOTO 560`
		2412	`.................... output_low(HACK);`
		2413	`0565: BSF 03.5`
		2414	`0566: BCF 06.5`
		2415	`0567: BCF 03.5`
		2416	`0568: BCF 06.5`
		2417	`.................... output_low(SYNC);`
		2418	`0569: BSF 03.5`
		2419	`056A: BCF 06.4`
		2420	`056B: BCF 03.5`
		2421	`056C: BCF 06.4`
		2422	`.................... input(CLOCK);`
		2423	`056D: BSF 03.5`
		2424	`056E: BSF 06.6`
		2425	`.................... break;`
		2426	`056F: BCF 03.5`
		2427	`0570: GOTO 61A`
		2428	`....................`
		2429	`.................... case 'i': // Info`
		2430	`.................... printf("%s\n\r", ver);`
		2431	`0571: CLRF 41`
		2432	`0572: MOVF 41,W`
		2433	`0573: CALL 03F`
		2434	`0574: IORLW 00`
		2435	`0575: BTFSC 03.2`
		2436	`0576: GOTO 57B`
		2437	`0577: INCF 41,F`
		2438	`0578: MOVWF 4C`
		2439	`0579: CALL 0FE`
		2440	`057A: GOTO 572`
		2441	`057B: MOVLW 0A`
		2442	`057C: MOVWF 4C`
		2443	`057D: CALL 0FE`
		2444	`057E: MOVLW 0D`
		2445	`057F: MOVWF 4C`
		2446	`0580: CALL 0FE`
		2447	`.................... printf("%Lue4 + %Lu ticks", prescale, ticks);`
		2448	`0581: MOVLW 10`
		2449	`0582: MOVWF 04`
		2450	`0583: MOVF 3D,W`
		2451	`0584: MOVWF 44`
		2452	`0585: MOVF 3C,W`
		2453	`0586: MOVWF 43`
		2454	`0587: CALL 15F`
		2455	`0588: MOVLW 03`
		2456	`0589: MOVWF 41`
		2457	`058A: MOVF 41,W`
		2458	`058B: CALL 09D`
		2459	`058C: INCF 41,F`
		2460	`058D: MOVWF 77`
		2461	`058E: MOVWF 4C`
		2462	`058F: CALL 0FE`
		2463	`0590: MOVLW 08`
		2464	`0591: SUBWF 41,W`
		2465	`0592: BTFSS 03.2`
		2466	`0593: GOTO 58A`
		2467	`0594: MOVLW 10`
		2468	`0595: MOVWF 04`
		2469	`0596: MOVF 3F,W`
		2470	`0597: MOVWF 44`
		2471	`0598: MOVF 3E,W`
		2472	`0599: MOVWF 43`
		2473	`059A: CALL 15F`
		2474	`059B: MOVLW 0B`
		2475	`059C: MOVWF 42`
		2476	`059D: MOVF 42,W`
		2477	`059E: CALL 09D`
		2478	`059F: INCF 42,F`
		2479	`05A0: MOVWF 77`
		2480	`05A1: MOVWF 4C`
		2481	`05A2: CALL 0FE`
		2482	`05A3: MOVLW 11`
		2483	`05A4: SUBWF 42,W`
		2484	`05A5: BTFSS 03.2`
		2485	`05A6: GOTO 59D`
		2486	`.................... break;`
		2487	`05A7: GOTO 61A`
		2488	`....................`
		2489	`.................... case 'p':`
		2490	`.................... if (isdigit(string[1]))`
		2491	`05A8: MOVF 33,W`
		2492	`05A9: SUBLW 2F`
		2493	`05AA: BTFSC 03.0`
		2494	`05AB: GOTO 5DF`
		2495	`05AC: MOVF 33,W`
		2496	`05AD: SUBLW 39`
		2497	`05AE: BTFSS 03.0`
		2498	`05AF: GOTO 5DF`
		2499	`.................... {`
		2500	`.................... prescale=atol(string+1);`
		2501	`05B0: CLRF 42`
		2502	`05B1: MOVLW 33`
		2503	`05B2: MOVWF 41`
		2504	`05B3: CALL 242`
		2505	`05B4: MOVF 79,W`
		2506	`05B5: MOVWF 3D`
		2507	`05B6: MOVF 78,W`
		2508	`05B7: MOVWF 3C`
		2509	`.................... printf("%Lu x 10000 prescale", prescale);`
		2510	`05B8: MOVLW 10`
		2511	`05B9: MOVWF 04`
		2512	`05BA: MOVF 3D,W`
		2513	`05BB: MOVWF 44`
		2514	`05BC: MOVF 3C,W`
		2515	`05BD: MOVWF 43`
		2516	`05BE: CALL 15F`
		2517	`05BF: MOVLW 03`
		2518	`05C0: MOVWF 41`
		2519	`05C1: MOVF 41,W`
		2520	`05C2: CALL 0B3`
		2521	`05C3: INCF 41,F`
		2522	`05C4: MOVWF 77`
		2523	`05C5: MOVWF 4C`
		2524	`05C6: CALL 0FE`
		2525	`05C7: MOVLW 07`
		2526	`05C8: SUBWF 41,W`
		2527	`05C9: BTFSS 03.2`
		2528	`05CA: GOTO 5C1`
		2529	`05CB: MOVLW 04`
		2530	`05CC: MOVWF 42`
		2531	`05CD: MOVLW 30`
		2532	`05CE: MOVWF 4C`
		2533	`05CF: CALL 0FE`
		2534	`05D0: DECFSZ 42,F`
		2535	`05D1: GOTO 5CD`
		2536	`05D2: MOVLW 07`
		2537	`05D3: MOVWF 43`
		2538	`05D4: MOVF 43,W`
		2539	`05D5: CALL 0B3`
		2540	`05D6: INCF 43,F`
		2541	`05D7: MOVWF 77`
		2542	`05D8: MOVWF 4C`
		2543	`05D9: CALL 0FE`
		2544	`05DA: MOVLW 10`
		2545	`05DB: SUBWF 43,W`
		2546	`05DC: BTFSS 03.2`
		2547	`05DD: GOTO 5D4`
		2548	`.................... }`
		2549	`.................... else`
		2550	`05DE: GOTO 5EA`
		2551	`.................... printf("Error");`
		2552	`05DF: CLRF 41`
		2553	`05E0: MOVF 41,W`
		2554	`05E1: CALL 0C8`
		2555	`05E2: INCF 41,F`
		2556	`05E3: MOVWF 77`
		2557	`05E4: MOVWF 4C`
		2558	`05E5: CALL 0FE`
		2559	`05E6: MOVLW 05`
		2560	`05E7: SUBWF 41,W`
		2561	`05E8: BTFSS 03.2`
		2562	`05E9: GOTO 5E0`
		2563	`.................... break;`
		2564	`05EA: GOTO 61A`
		2565	`....................`
		2566	`.................... default: // fine ticks number`
		2567	`.................... if (isdigit(string[0]))`
		2568	`05EB: MOVF 32,W`
		2569	`05EC: SUBLW 2F`
		2570	`05ED: BTFSC 03.0`
		2571	`05EE: GOTO 60F`
		2572	`05EF: MOVF 32,W`
		2573	`05F0: SUBLW 39`
		2574	`05F1: BTFSS 03.0`
		2575	`05F2: GOTO 60F`
		2576	`.................... {`
		2577	`.................... ticks=atol(string);`
		2578	`05F3: CLRF 42`
		2579	`05F4: MOVLW 32`
		2580	`05F5: MOVWF 41`
		2581	`05F6: CALL 242`
		2582	`05F7: MOVF 79,W`
		2583	`05F8: MOVWF 3F`
		2584	`05F9: MOVF 78,W`
		2585	`05FA: MOVWF 3E`
		2586	`.................... printf("%Lu ticks", ticks);`
		2587	`05FB: MOVLW 10`
		2588	`05FC: MOVWF 04`
		2589	`05FD: MOVF 3F,W`
		2590	`05FE: MOVWF 44`
		2591	`05FF: MOVF 3E,W`
		2592	`0600: MOVWF 43`
		2593	`0601: CALL 15F`
		2594	`0602: MOVLW 03`
		2595	`0603: MOVWF 41`
		2596	`0604: MOVF 41,W`
		2597	`0605: CALL 0D2`
		2598	`0606: INCF 41,F`
		2599	`0607: MOVWF 77`
		2600	`0608: MOVWF 4C`
		2601	`0609: CALL 0FE`
		2602	`060A: MOVLW 09`
		2603	`060B: SUBWF 41,W`
		2604	`060C: BTFSS 03.2`
		2605	`060D: GOTO 604`
		2606	`.................... }`
		2607	`.................... else`
		2608	`060E: GOTO 61A`
		2609	`.................... printf("Error");`
		2610	`060F: CLRF 41`
		2611	`0610: MOVF 41,W`
		2612	`0611: CALL 0C8`
		2613	`0612: INCF 41,F`
		2614	`0613: MOVWF 77`
		2615	`0614: MOVWF 4C`
		2616	`0615: CALL 0FE`
		2617	`0616: MOVLW 05`
		2618	`0617: SUBWF 41,W`
		2619	`0618: BTFSS 03.2`
		2620	`0619: GOTO 610`
		2621	`.................... };`
		2622	`....................`
		2623	`.................... };`
		2624	`061A: GOTO 3B6`
		2625	`....................`
		2626	`.................... while(true)`
		2627	`.................... {`
		2628	`.................... output_low(PIN_B4);`
		2629	`061B: BSF 03.5`
		2630	`061C: BCF 06.4`
		2631	`061D: BCF 03.5`
		2632	`061E: BCF 06.4`
		2633	`.................... delay_ms(300);`
		2634	`061F: MOVLW 02`
		2635	`0620: MOVWF 41`
		2636	`0621: MOVLW 96`
		2637	`0622: MOVWF 42`
		2638	`0623: CALL 0E6`
		2639	`0624: DECFSZ 41,F`
		2640	`0625: GOTO 621`
		2641	`.................... output_high(PIN_B4);`
		2642	`0626: BSF 03.5`
		2643	`0627: BCF 06.4`
		2644	`0628: BCF 03.5`
		2645	`0629: BSF 06.4`
		2646	`.................... delay_ms(300);`
		2647	`062A: MOVLW 02`
		2648	`062B: MOVWF 41`
		2649	`062C: MOVLW 96`
		2650	`062D: MOVWF 42`
		2651	`062E: CALL 0E6`
		2652	`062F: DECFSZ 41,F`
		2653	`0630: GOTO 62C`
		2654	`.................... }`
		2655	`0631: GOTO 61B`
		2656	`.................... }`
		2657	`....................`
		2658	`0632: GOTO 632`
		2659
		2660	`Configuration Fuses:`
		2661	`Word 1: 3731 NOWDT PUT MCLR NOBROWNOUT NOLVP NOCPD NOWRT DEBUG CCPB0 NOPROTECT INTRC`
		2662	`Word 2: 3FFC NOFCMEN NOIESO`

Subversion Repositories svnkaklik

(root)/programy/C/PIC/hack/hack.LST – Rev 6