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

Rev 6		Rev 410
1	`CCS PCM C Compiler, Version 3.221, 27853 12-III-06 16:36`	1	`CCS PCM C Compiler, Version 3.221, 27853 12-III-06 16:36`
2		2
3	`Filename: D:\KAKLIK\programy\PIC_C\hack\hack.LST`	3	`Filename: D:\KAKLIK\programy\PIC_C\hack\hack.LST`
4		4
5	`ROM used: 1587 words (41%)`	5	`ROM used: 1587 words (41%)`
6	`Largest free fragment is 1792`	6	`Largest free fragment is 1792`
7	`RAM used: 41 (11%) at main() level`	7	`RAM used: 41 (11%) at main() level`
8	`51 (14%) worst case`	8	`51 (14%) worst case`
9	`Stack: 3 worst case (2 in main + 1 for interrupts)`	9	`Stack: 3 worst case (2 in main + 1 for interrupts)`
10		10
11	`*`	11	`*`
12	`0000: NOP`	12	`0000: NOP`
13	`0001: MOVLW 00`	13	`0001: MOVLW 00`
14	`0002: MOVWF 0A`	14	`0002: MOVWF 0A`
15	`0003: GOTO 342`	15	`0003: GOTO 342`
16	`0004: MOVWF 7F`	16	`0004: MOVWF 7F`
17	`0005: SWAPF 03,W`	17	`0005: SWAPF 03,W`
18	`0006: CLRF 03`	18	`0006: CLRF 03`
19	`0007: MOVWF 21`	19	`0007: MOVWF 21`
20	`0008: MOVF 7F,W`	20	`0008: MOVF 7F,W`
21	`0009: MOVWF 20`	21	`0009: MOVWF 20`
22	`000A: MOVF 0A,W`	22	`000A: MOVF 0A,W`
23	`000B: MOVWF 28`	23	`000B: MOVWF 28`
24	`000C: CLRF 0A`	24	`000C: CLRF 0A`
25	`000D: SWAPF 20,F`	25	`000D: SWAPF 20,F`
26	`000E: MOVF 04,W`	26	`000E: MOVF 04,W`
27	`000F: MOVWF 22`	27	`000F: MOVWF 22`
28	`0010: MOVF 77,W`	28	`0010: MOVF 77,W`
29	`0011: MOVWF 23`	29	`0011: MOVWF 23`
30	`0012: MOVF 78,W`	30	`0012: MOVF 78,W`
31	`0013: MOVWF 24`	31	`0013: MOVWF 24`
32	`0014: MOVF 79,W`	32	`0014: MOVF 79,W`
33	`0015: MOVWF 25`	33	`0015: MOVWF 25`
34	`0016: MOVF 7A,W`	34	`0016: MOVF 7A,W`
35	`0017: MOVWF 26`	35	`0017: MOVWF 26`
36	`0018: MOVF 7B,W`	36	`0018: MOVF 7B,W`
37	`0019: MOVWF 27`	37	`0019: MOVWF 27`
38	`001A: BCF 03.7`	38	`001A: BCF 03.7`
39	`001B: BCF 03.5`	39	`001B: BCF 03.5`
40	`001C: MOVLW 8C`	40	`001C: MOVLW 8C`
41	`001D: MOVWF 04`	41	`001D: MOVWF 04`
42	`001E: BTFSS 00.0`	42	`001E: BTFSS 00.0`
43	`001F: GOTO 022`	43	`001F: GOTO 022`
44	`0020: BTFSC 0C.0`	44	`0020: BTFSC 0C.0`
45	`0021: GOTO 03B`	45	`0021: GOTO 03B`
46	`0022: MOVLW 8C`	46	`0022: MOVLW 8C`
47	`0023: MOVWF 04`	47	`0023: MOVWF 04`
48	`0024: BTFSS 00.1`	48	`0024: BTFSS 00.1`
49	`0025: GOTO 028`	49	`0025: GOTO 028`
50	`0026: BTFSC 0C.1`	50	`0026: BTFSC 0C.1`
51	`0027: GOTO 03D`	51	`0027: GOTO 03D`
52	`0028: MOVF 22,W`	52	`0028: MOVF 22,W`
53	`0029: MOVWF 04`	53	`0029: MOVWF 04`
54	`002A: MOVF 23,W`	54	`002A: MOVF 23,W`
55	`002B: MOVWF 77`	55	`002B: MOVWF 77`
56	`002C: MOVF 24,W`	56	`002C: MOVF 24,W`
57	`002D: MOVWF 78`	57	`002D: MOVWF 78`
58	`002E: MOVF 25,W`	58	`002E: MOVF 25,W`
59	`002F: MOVWF 79`	59	`002F: MOVWF 79`
60	`0030: MOVF 26,W`	60	`0030: MOVF 26,W`
61	`0031: MOVWF 7A`	61	`0031: MOVWF 7A`
62	`0032: MOVF 27,W`	62	`0032: MOVF 27,W`
63	`0033: MOVWF 7B`	63	`0033: MOVWF 7B`
64	`0034: MOVF 28,W`	64	`0034: MOVF 28,W`
65	`0035: MOVWF 0A`	65	`0035: MOVWF 0A`
66	`0036: SWAPF 21,W`	66	`0036: SWAPF 21,W`
67	`0037: MOVWF 03`	67	`0037: MOVWF 03`
68	`0038: SWAPF 7F,F`	68	`0038: SWAPF 7F,F`
69	`0039: SWAPF 7F,W`	69	`0039: SWAPF 7F,W`
70	`003A: RETFIE`	70	`003A: RETFIE`
71	`003B: BCF 0A.3`	71	`003B: BCF 0A.3`
72	`003C: GOTO 0E0`	72	`003C: GOTO 0E0`
73	`003D: BCF 0A.3`	73	`003D: BCF 0A.3`
74	`003E: GOTO 0E3`	74	`003E: GOTO 0E3`
75	`.................... #include ".\hack.h"`	75	`.................... #include ".\hack.h"`
76	`.................... #include <16F88.h>`	76	`.................... #include <16F88.h>`
77	`.................... //////// Standard Header file for the PIC16F88 device ////////////////`	77	`.................... //////// Standard Header file for the PIC16F88 device ////////////////`
78	`.................... #device PIC16F88`	78	`.................... #device PIC16F88`
79	`.................... #list`	79	`.................... #list`
80	`....................`	80	`....................`
81	`.................... #device *=16`	81	`.................... #device *=16`
82	`.................... #device ICD=TRUE`	82	`.................... #device ICD=TRUE`
83	`.................... #device adc=8`	83	`.................... #device adc=8`
84	`.................... #fuses NOWDT,INTRC , NOPUT, MCLR, NOBROWNOUT, NOLVP, NOCPD, NOWRT, DEBUG, NOPROTECT, NOFCMEN, NOIESO`	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`	85	`.................... //#fuses NOWDT,INTRC_IO, NOPUT, MCLR, NOBROWNOUT, NOLVP, NOCPD, NOWRT, DEBUG, NOPROTECT, NOFCMEN, NOIESO`
86	`.................... #use delay(clock=4000000,RESTART_WDT)`	86	`.................... #use delay(clock=4000000,RESTART_WDT)`
87	`*`	87	`*`
88	`00E6: MOVLW 42`	88	`00E6: MOVLW 42`
89	`00E7: MOVWF 04`	89	`00E7: MOVWF 04`
90	`00E8: BCF 03.7`	90	`00E8: BCF 03.7`
91	`00E9: MOVF 00,W`	91	`00E9: MOVF 00,W`
92	`00EA: BTFSC 03.2`	92	`00EA: BTFSC 03.2`
93	`00EB: GOTO 0FD`	93	`00EB: GOTO 0FD`
94	`00EC: MOVLW 01`	94	`00EC: MOVLW 01`
95	`00ED: MOVWF 78`	95	`00ED: MOVWF 78`
96	`00EE: MOVLW BF`	96	`00EE: MOVLW BF`
97	`00EF: MOVWF 77`	97	`00EF: MOVWF 77`
98	`00F0: CLRWDT`	98	`00F0: CLRWDT`
99	`00F1: DECFSZ 77,F`	99	`00F1: DECFSZ 77,F`
100	`00F2: GOTO 0F0`	100	`00F2: GOTO 0F0`
101	`00F3: DECFSZ 78,F`	101	`00F3: DECFSZ 78,F`
102	`00F4: GOTO 0EE`	102	`00F4: GOTO 0EE`
103	`00F5: MOVLW 4A`	103	`00F5: MOVLW 4A`
104	`00F6: MOVWF 77`	104	`00F6: MOVWF 77`
105	`00F7: DECFSZ 77,F`	105	`00F7: DECFSZ 77,F`
106	`00F8: GOTO 0F7`	106	`00F8: GOTO 0F7`
107	`00F9: NOP`	107	`00F9: NOP`
108	`00FA: CLRWDT`	108	`00FA: CLRWDT`
109	`00FB: DECFSZ 00,F`	109	`00FB: DECFSZ 00,F`
110	`00FC: GOTO 0EC`	110	`00FC: GOTO 0EC`
111	`00FD: RETLW 00`	111	`00FD: RETLW 00`
112	`.................... //#use rs232(baud=2400,xmit=PIN_B3)`	112	`.................... //#use rs232(baud=2400,xmit=PIN_B3)`
113	`.................... //#use rs232(DEBUGGER)`	113	`.................... //#use rs232(DEBUGGER)`
114	`.................... #use rs232(baud=1200,parity=N,xmit=PIN_B3,rcv=PIN_B2,bits=8)`	114	`.................... #use rs232(baud=1200,parity=N,xmit=PIN_B3,rcv=PIN_B2,bits=8)`
115	`00FE: BSF 03.5`	115	`00FE: BSF 03.5`
116	`00FF: BCF 06.3`	116	`00FF: BCF 06.3`
117	`0100: BCF 03.5`	117	`0100: BCF 03.5`
118	`0101: BCF 06.3`	118	`0101: BCF 06.3`
119	`0102: MOVLW 08`	119	`0102: MOVLW 08`
120	`0103: MOVWF 78`	120	`0103: MOVWF 78`
121	`0104: NOP`	121	`0104: NOP`
122	`0105: NOP`	122	`0105: NOP`
123	`0106: NOP`	123	`0106: NOP`
124	`0107: BSF 78.7`	124	`0107: BSF 78.7`
125	`0108: GOTO 118`	125	`0108: GOTO 118`
126	`0109: BCF 78.7`	126	`0109: BCF 78.7`
127	`010A: RRF 4C,F`	127	`010A: RRF 4C,F`
128	`010B: BTFSC 03.0`	128	`010B: BTFSC 03.0`
129	`010C: BSF 06.3`	129	`010C: BSF 06.3`
130	`010D: BTFSS 03.0`	130	`010D: BTFSS 03.0`
131	`010E: BCF 06.3`	131	`010E: BCF 06.3`
132	`010F: BSF 78.6`	132	`010F: BSF 78.6`
133	`0110: GOTO 118`	133	`0110: GOTO 118`
134	`0111: BCF 78.6`	134	`0111: BCF 78.6`
135	`0112: DECFSZ 78,F`	135	`0112: DECFSZ 78,F`
136	`0113: GOTO 10A`	136	`0113: GOTO 10A`
137	`0114: NOP`	137	`0114: NOP`
138	`0115: NOP`	138	`0115: NOP`
139	`0116: NOP`	139	`0116: NOP`
140	`0117: BSF 06.3`	140	`0117: BSF 06.3`
141	`0118: MOVLW 01`	141	`0118: MOVLW 01`
142	`0119: MOVWF 77`	142	`0119: MOVWF 77`
143	`011A: CLRF 04`	143	`011A: CLRF 04`
144	`011B: DECFSZ 04,F`	144	`011B: DECFSZ 04,F`
145	`011C: GOTO 11B`	145	`011C: GOTO 11B`
146	`011D: DECFSZ 77,F`	146	`011D: DECFSZ 77,F`
147	`011E: GOTO 11A`	147	`011E: GOTO 11A`
148	`011F: MOVLW 0D`	148	`011F: MOVLW 0D`
149	`0120: MOVWF 04`	149	`0120: MOVWF 04`
150	`0121: DECFSZ 04,F`	150	`0121: DECFSZ 04,F`
151	`0122: GOTO 121`	151	`0122: GOTO 121`
152	`0123: NOP`	152	`0123: NOP`
153	`0124: NOP`	153	`0124: NOP`
154	`0125: BTFSC 78.7`	154	`0125: BTFSC 78.7`
155	`0126: GOTO 109`	155	`0126: GOTO 109`
156	`0127: BTFSC 78.6`	156	`0127: BTFSC 78.6`
157	`0128: GOTO 111`	157	`0128: GOTO 111`
158	`0129: RETLW 00`	158	`0129: RETLW 00`
159	`012A: MOVF 04,W`	159	`012A: MOVF 04,W`
160	`012B: MOVWF 78`	160	`012B: MOVWF 78`
161	`012C: MOVLW 08`	161	`012C: MOVLW 08`
162	`012D: MOVWF 77`	162	`012D: MOVWF 77`
163	`012E: BSF 03.5`	163	`012E: BSF 03.5`
164	`012F: BSF 06.2`	164	`012F: BSF 06.2`
165	`0130: BCF 03.5`	165	`0130: BCF 03.5`
166	`0131: BTFSS 06.2`	166	`0131: BTFSS 06.2`
167	`0132: GOTO 135`	167	`0132: GOTO 135`
168	`0133: BSF 03.5`	168	`0133: BSF 03.5`
169	`0134: GOTO 130`	169	`0134: GOTO 130`
170	`0135: CLRF 41`	170	`0135: CLRF 41`
171	`0136: BSF 77.7`	171	`0136: BSF 77.7`
172	`0137: GOTO 148`	172	`0137: GOTO 148`
173	`0138: BCF 77.7`	173	`0138: BCF 77.7`
174	`0139: GOTO 148`	174	`0139: GOTO 148`
175	`013A: BCF 03.0`	175	`013A: BCF 03.0`
176	`013B: BTFSC 06.2`	176	`013B: BTFSC 06.2`
177	`013C: BSF 03.0`	177	`013C: BSF 03.0`
178	`013D: RRF 41,F`	178	`013D: RRF 41,F`
179	`013E: BSF 77.6`	179	`013E: BSF 77.6`
180	`013F: GOTO 148`	180	`013F: GOTO 148`
181	`0140: BCF 77.6`	181	`0140: BCF 77.6`
182	`0141: DECFSZ 77,F`	182	`0141: DECFSZ 77,F`
183	`0142: GOTO 13A`	183	`0142: GOTO 13A`
184	`0143: MOVF 78,W`	184	`0143: MOVF 78,W`
185	`0144: MOVWF 04`	185	`0144: MOVWF 04`
186	`0145: MOVF 41,W`	186	`0145: MOVF 41,W`
187	`0146: MOVWF 78`	187	`0146: MOVWF 78`
188	`0147: GOTO 15D`	188	`0147: GOTO 15D`
189	`0148: MOVLW 01`	189	`0148: MOVLW 01`
190	`0149: MOVWF 04`	190	`0149: MOVWF 04`
191	`014A: MOVLW 00`	191	`014A: MOVLW 00`
192	`014B: BTFSC 77.7`	192	`014B: BTFSC 77.7`
193	`014C: MOVLW 55`	193	`014C: MOVLW 55`
194	`014D: MOVWF 78`	194	`014D: MOVWF 78`
195	`014E: DECFSZ 78,F`	195	`014E: DECFSZ 78,F`
196	`014F: GOTO 14E`	196	`014F: GOTO 14E`
197	`0150: DECFSZ 04,F`	197	`0150: DECFSZ 04,F`
198	`0151: GOTO 14A`	198	`0151: GOTO 14A`
199	`0152: MOVLW 0D`	199	`0152: MOVLW 0D`
200	`0153: BTFSC 77.7`	200	`0153: BTFSC 77.7`
201	`0154: MOVLW 03`	201	`0154: MOVLW 03`
202	`0155: MOVWF 78`	202	`0155: MOVWF 78`
203	`0156: DECFSZ 78,F`	203	`0156: DECFSZ 78,F`
204	`0157: GOTO 156`	204	`0157: GOTO 156`
205	`0158: BTFSC 77.7`	205	`0158: BTFSC 77.7`
206	`0159: GOTO 138`	206	`0159: GOTO 138`
207	`015A: BTFSC 77.6`	207	`015A: BTFSC 77.6`
208	`015B: GOTO 140`	208	`015B: GOTO 140`
209	`015C: GOTO 13A`	209	`015C: GOTO 13A`
210	`015D: BCF 0A.3`	210	`015D: BCF 0A.3`
211	`015E: GOTO 3C1 (RETURN)`	211	`015E: GOTO 3C1 (RETURN)`
212	`....................`	212	`....................`
213	`....................`	213	`....................`
214	`.................... #include <stdlib.h>`	214	`.................... #include <stdlib.h>`
215	`.................... ///////////////////////////////////////////////////////////////////////////`	215	`.................... ///////////////////////////////////////////////////////////////////////////`
216	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	216	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
217	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	218	`.................... //// compiler. This source code may only be distributed to other ////`
219	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	219	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
220	`.................... //// or distribution is permitted without written permission. ////`	220	`.................... //// or distribution is permitted without written permission. ////`
221	`.................... //// Derivative programs created using this software in object code ////`	221	`.................... //// Derivative programs created using this software in object code ////`
222	`.................... //// form are not restricted in any way. ////`	222	`.................... //// form are not restricted in any way. ////`
223	`.................... ///////////////////////////////////////////////////////////////////////////`	223	`.................... ///////////////////////////////////////////////////////////////////////////`
224	`....................`	224	`....................`
225	`.................... #ifndef _STDLIB`	225	`.................... #ifndef _STDLIB`
226	`.................... #define _STDLIB`	226	`.................... #define _STDLIB`
227	`....................`	227	`....................`
228	`.................... //---------------------------------------------------------------------------`	228	`.................... //---------------------------------------------------------------------------`
229	`.................... // Definitions and types`	229	`.................... // Definitions and types`
230	`.................... //---------------------------------------------------------------------------`	230	`.................... //---------------------------------------------------------------------------`
231	`....................`	231	`....................`
232	`.................... #ifndef RAND_MAX`	232	`.................... #ifndef RAND_MAX`
233	`.................... #define RAND_MAX 32767 // The value of which is the maximum value`	233	`.................... #define RAND_MAX 32767 // The value of which is the maximum value`
234	`.................... // ... returned by the rand function`	234	`.................... // ... returned by the rand function`
235	`.................... #endif`	235	`.................... #endif`
236	`....................`	236	`....................`
237	`.................... typedef struct {`	237	`.................... typedef struct {`
238	`.................... signed int quot;`	238	`.................... signed int quot;`
239	`.................... signed int rem;`	239	`.................... signed int rem;`
240	`.................... } div_t;`	240	`.................... } div_t;`
241	`....................`	241	`....................`
242	`.................... typedef struct {`	242	`.................... typedef struct {`
243	`.................... signed long quot;`	243	`.................... signed long quot;`
244	`.................... signed long rem;`	244	`.................... signed long rem;`
245	`.................... } ldiv_t;`	245	`.................... } ldiv_t;`
246	`....................`	246	`....................`
247	`.................... #include <stddef.h>`	247	`.................... #include <stddef.h>`
248	`.................... ///////////////////////////////////////////////////////////////////////////`	248	`.................... ///////////////////////////////////////////////////////////////////////////`
249	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	249	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
250	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	251	`.................... //// compiler. This source code may only be distributed to other ////`
252	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	252	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
253	`.................... //// or distribution is permitted without written permission. ////`	253	`.................... //// or distribution is permitted without written permission. ////`
254	`.................... //// Derivative programs created using this software in object code ////`	254	`.................... //// Derivative programs created using this software in object code ////`
255	`.................... //// form are not restricted in any way. ////`	255	`.................... //// form are not restricted in any way. ////`
256	`.................... ///////////////////////////////////////////////////////////////////////////`	256	`.................... ///////////////////////////////////////////////////////////////////////////`
257	`....................`	257	`....................`
258	`.................... #ifndef _STDDEF`	258	`.................... #ifndef _STDDEF`
259	`....................`	259	`....................`
260	`.................... #define _STDDEF`	260	`.................... #define _STDDEF`
261	`....................`	261	`....................`
262	`.................... #if sizeof(int *)==1`	262	`.................... #if sizeof(int *)==1`
263	`.................... #define ptrdiff_t int`	263	`.................... #define ptrdiff_t int`
264	`.................... #else`	264	`.................... #else`
265	`.................... #define ptrdiff_t long`	265	`.................... #define ptrdiff_t long`
266	`.................... #endif`	266	`.................... #endif`
267	`....................`	267	`....................`
268	`.................... #define size_t int`	268	`.................... #define size_t int`
269	`.................... #define wchar_t char`	269	`.................... #define wchar_t char`
270	`.................... #define NULL 0`	270	`.................... #define NULL 0`
271	`....................`	271	`....................`
272	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`	272	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
273	`....................`	273	`....................`
274	`.................... #endif`	274	`.................... #endif`
275	`....................`	275	`....................`
276	`....................`	276	`....................`
277	`.................... //---------------------------------------------------------------------------`	277	`.................... //---------------------------------------------------------------------------`
278	`.................... // String conversion functions`	278	`.................... // String conversion functions`
279	`.................... //---------------------------------------------------------------------------`	279	`.................... //---------------------------------------------------------------------------`
280	`....................`	280	`....................`
281	`.................... /* Standard template: float atof(char * s)`	281	`.................... /* Standard template: float atof(char * s)`
282	`.................... * converts the initial portion of the string s to a float.`	282	`.................... * converts the initial portion of the string s to a float.`
283	`.................... * returns the converted value if any, 0 otherwise`	283	`.................... * returns the converted value if any, 0 otherwise`
284	`.................... */`	284	`.................... */`
285	`.................... float atof(char * s);`	285	`.................... float atof(char * s);`
286	`....................`	286	`....................`
287	`.................... /* Standard template: signed int atoi(char * s)`	287	`.................... /* Standard template: signed int atoi(char * s)`
288	`.................... * converts the initial portion of the string s to a signed int`	288	`.................... * converts the initial portion of the string s to a signed int`
289	`.................... * returns the converted value if any, 0 otherwise`	289	`.................... * returns the converted value if any, 0 otherwise`
290	`.................... */`	290	`.................... */`
291	`.................... signed int atoi(char *s);`	291	`.................... signed int atoi(char *s);`
292	`....................`	292	`....................`
293	`.................... /* Syntax: signed int32 atoi32(char * s)`	293	`.................... /* Syntax: signed int32 atoi32(char * s)`
294	`.................... converts the initial portion of the string s to a signed int32`	294	`.................... converts the initial portion of the string s to a signed int32`
295	`.................... returns the converted value if any, 0 otherwise*/`	295	`.................... returns the converted value if any, 0 otherwise*/`
296	`.................... signed int32 atoi32(char *s);`	296	`.................... signed int32 atoi32(char *s);`
297	`....................`	297	`....................`
298	`.................... /* Standard template: signed long atol(char * s)`	298	`.................... /* Standard template: signed long atol(char * s)`
299	`.................... * converts the initial portion of the string s to a signed long`	299	`.................... * converts the initial portion of the string s to a signed long`
300	`.................... * returns the converted value if any, 0 otherwise`	300	`.................... * returns the converted value if any, 0 otherwise`
301	`.................... */`	301	`.................... */`
302	`.................... signed long atol(char *s);`	302	`.................... signed long atol(char *s);`
303	`....................`	303	`....................`
304	`.................... /* Standard template: float strtol(char * s,char *endptr)`	304	`.................... /* Standard template: float strtol(char * s,char *endptr)`
305	`.................... * converts the initial portion of the string s to a float`	305	`.................... * converts the initial portion of the string s to a float`
306	`.................... * returns the converted value if any, 0 otherwise`	306	`.................... * returns the converted value if any, 0 otherwise`
307	`.................... * the final string is returned in the endptr, if endptr is not null`	307	`.................... * the final string is returned in the endptr, if endptr is not null`
308	`.................... */`	308	`.................... */`
309	`.................... float strtod(char s,char endptr);`	309	`.................... float strtod(char s,char endptr);`
310	`....................`	310	`....................`
311	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`	311	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`
312	`.................... * converts the initial portion of the string s, represented as an`	312	`.................... * converts the initial portion of the string s, represented as an`
313	`.................... * integral value of radix base to a signed long.`	313	`.................... * integral value of radix base to a signed long.`
314	`.................... * Returns the converted value if any, 0 otherwise`	314	`.................... * Returns the converted value if any, 0 otherwise`
315	`.................... * the final string is returned in the endptr, if endptr is not null`	315	`.................... * the final string is returned in the endptr, if endptr is not null`
316	`.................... */`	316	`.................... */`
317	`.................... signed long strtol(char s,char endptr,signed int base);`	317	`.................... signed long strtol(char s,char endptr,signed int base);`
318	`....................`	318	`....................`
319	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`	319	`.................... /* Standard template: long strtoul(char * s,char *endptr,signed int base)`
320	`.................... * converts the initial portion of the string s, represented as an`	320	`.................... * converts the initial portion of the string s, represented as an`
321	`.................... * integral value of radix base to a unsigned long.`	321	`.................... * integral value of radix base to a unsigned long.`
322	`.................... * returns the converted value if any, 0 otherwise`	322	`.................... * returns the converted value if any, 0 otherwise`
323	`.................... * the final string is returned in the endptr, if endptr is not null`	323	`.................... * the final string is returned in the endptr, if endptr is not null`
324	`.................... */`	324	`.................... */`
325	`.................... long strtoul(char s,char endptr,signed int base);`	325	`.................... long strtoul(char s,char endptr,signed int base);`
326	`....................`	326	`....................`
327	`.................... //---------------------------------------------------------------------------`	327	`.................... //---------------------------------------------------------------------------`
328	`.................... // Pseudo-random sequence generation functions`	328	`.................... // Pseudo-random sequence generation functions`
329	`.................... //---------------------------------------------------------------------------`	329	`.................... //---------------------------------------------------------------------------`
330	`....................`	330	`....................`
331	`.................... /* The rand function computes a sequence of pseudo-random integers in`	331	`.................... /* The rand function computes a sequence of pseudo-random integers in`
332	`.................... * the range 0 to RAND_MAX`	332	`.................... * the range 0 to RAND_MAX`
333	`.................... *`	333	`.................... *`
334	`.................... * Parameters:`	334	`.................... * Parameters:`
335	`.................... * (none)`	335	`.................... * (none)`
336	`.................... *`	336	`.................... *`
337	`.................... * Returns:`	337	`.................... * Returns:`
338	`.................... * The pseudo-random integer`	338	`.................... * The pseudo-random integer`
339	`.................... */`	339	`.................... */`
340	`.................... long rand(void);`	340	`.................... long rand(void);`
341	`....................`	341	`....................`
342	`.................... /* The srand function uses the argument as a seed for a new sequence of`	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.`	343	`.................... * pseudo-random numbers to be returned by subsequent calls to rand.`
344	`.................... *`	344	`.................... *`
345	`.................... * Parameters:`	345	`.................... * Parameters:`
346	`.................... * [in] seed: The seed value to start from. You might need to pass`	346	`.................... * [in] seed: The seed value to start from. You might need to pass`
347	`.................... *`	347	`.................... *`
348	`.................... * Returns:`	348	`.................... * Returns:`
349	`.................... * (none)`	349	`.................... * (none)`
350	`.................... *`	350	`.................... *`
351	`.................... * Remarks`	351	`.................... * Remarks`
352	`.................... * The srand function sets the starting point for generating`	352	`.................... * The srand function sets the starting point for generating`
353	`.................... * a series of pseudorandom integers. To reinitialize the`	353	`.................... * a series of pseudorandom integers. To reinitialize the`
354	`.................... * generator, use 1 as the seed argument. Any other value for`	354	`.................... * generator, use 1 as the seed argument. Any other value for`
355	`.................... * seed sets the generator to a random starting point. rand`	355	`.................... * seed sets the generator to a random starting point. rand`
356	`.................... * retrieves the pseudorandom numbers that are generated.`	356	`.................... * retrieves the pseudorandom numbers that are generated.`
357	`.................... * Calling rand before any call to srand generates the same`	357	`.................... * Calling rand before any call to srand generates the same`
358	`.................... * sequence as calling srand with seed passed as 1.`	358	`.................... * sequence as calling srand with seed passed as 1.`
359	`.................... * Usually, you need to pass a time here from outer source`	359	`.................... * Usually, you need to pass a time here from outer source`
360	`.................... * so that the numbers will be different every time you run.`	360	`.................... * so that the numbers will be different every time you run.`
361	`.................... */`	361	`.................... */`
362	`.................... void srand(unsigned int32 seed);`	362	`.................... void srand(unsigned int32 seed);`
363	`....................`	363	`....................`
364	`.................... //---------------------------------------------------------------------------`	364	`.................... //---------------------------------------------------------------------------`
365	`.................... // Memory management functions`	365	`.................... // Memory management functions`
366	`.................... //---------------------------------------------------------------------------`	366	`.................... //---------------------------------------------------------------------------`
367	`....................`	367	`....................`
368	`.................... // Comming soon`	368	`.................... // Comming soon`
369	`....................`	369	`....................`
370	`.................... //---------------------------------------------------------------------------`	370	`.................... //---------------------------------------------------------------------------`
371	`.................... // Communication with the environment`	371	`.................... // Communication with the environment`
372	`.................... //---------------------------------------------------------------------------`	372	`.................... //---------------------------------------------------------------------------`
373	`....................`	373	`....................`
374	`.................... /* The function returns 0 always`	374	`.................... /* The function returns 0 always`
375	`.................... */`	375	`.................... */`
376	`.................... signed int system(char *string);`	376	`.................... signed int system(char *string);`
377	`....................`	377	`....................`
378	`.................... //---------------------------------------------------------------------------`	378	`.................... //---------------------------------------------------------------------------`
379	`.................... // Searching and sorting utilities`	379	`.................... // Searching and sorting utilities`
380	`.................... //---------------------------------------------------------------------------`	380	`.................... //---------------------------------------------------------------------------`
381	`....................`	381	`....................`
382	`.................... /* Performs a binary search of a sorted array..`	382	`.................... /* Performs a binary search of a sorted array..`
383	`.................... *`	383	`.................... *`
384	`.................... * Parameters:`	384	`.................... * Parameters:`
385	`.................... * [in] key: Object to search for`	385	`.................... * [in] key: Object to search for`
386	`.................... * [in] base: Pointer to base of search data`	386	`.................... * [in] base: Pointer to base of search data`
387	`.................... * [in] num: Number of elements`	387	`.................... * [in] num: Number of elements`
388	`.................... * [in] width: Width of elements`	388	`.................... * [in] width: Width of elements`
389	`.................... * [in] compare: Function that compares two elements`	389	`.................... * [in] compare: Function that compares two elements`
390	`.................... *`	390	`.................... *`
391	`.................... * Returns:`	391	`.................... * Returns:`
392	`.................... * bsearch returns a pointer to an occurrence of key in the array pointed`	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`	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,`	394	`.................... * array is not in order or contains duplicate records with identical keys,`
395	`.................... * the result is unpredictable.`	395	`.................... * the result is unpredictable.`
396	`.................... */`	396	`.................... */`
397	`.................... //void bsearch(const void key, const void *base, size_t num, size_t width,`	397	`.................... //void bsearch(const void key, const void *base, size_t num, size_t width,`
398	`.................... // int (compare)(const void , const void *));`	398	`.................... // int (compare)(const void , const void *));`
399	`....................`	399	`....................`
400	`.................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents`	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`	401	`.................... * of the array are sorted into ascending order according to a comparison`
402	`.................... * function pointed to by compar.`	402	`.................... * function pointed to by compar.`
403	`.................... *`	403	`.................... *`
404	`.................... * Parameters:`	404	`.................... * Parameters:`
405	`.................... * [in] base: Pointer to base of search data`	405	`.................... * [in] base: Pointer to base of search data`
406	`.................... * [in] num: Number of elements`	406	`.................... * [in] num: Number of elements`
407	`.................... * [in] width: Width of elements`	407	`.................... * [in] width: Width of elements`
408	`.................... * [in] compare: Function that compares two elements`	408	`.................... * [in] compare: Function that compares two elements`
409	`.................... *`	409	`.................... *`
410	`.................... * Returns:`	410	`.................... * Returns:`
411	`.................... * (none)`	411	`.................... * (none)`
412	`.................... */`	412	`.................... */`
413	`.................... //void qsort(const void base, size_t num, size_t width,`	413	`.................... //void qsort(const void base, size_t num, size_t width,`
414	`.................... // int (compare)(const void , const void *));`	414	`.................... // int (compare)(const void , const void *));`
415	`....................`	415	`....................`
416	`.................... //---------------------------------------------------------------------------`	416	`.................... //---------------------------------------------------------------------------`
417	`.................... // Integer arithmetic functions`	417	`.................... // Integer arithmetic functions`
418	`.................... //---------------------------------------------------------------------------`	418	`.................... //---------------------------------------------------------------------------`
419	`....................`	419	`....................`
420	`.................... #define labs abs`	420	`.................... #define labs abs`
421	`....................`	421	`....................`
422	`.................... div_t div(signed int numer,signed int denom);`	422	`.................... div_t div(signed int numer,signed int denom);`
423	`.................... ldiv_t ldiv(signed long numer,signed long denom);`	423	`.................... ldiv_t ldiv(signed long numer,signed long denom);`
424	`....................`	424	`....................`
425	`.................... //---------------------------------------------------------------------------`	425	`.................... //---------------------------------------------------------------------------`
426	`.................... // Multibyte character functions`	426	`.................... // Multibyte character functions`
427	`.................... //---------------------------------------------------------------------------`	427	`.................... //---------------------------------------------------------------------------`
428	`....................`	428	`....................`
429	`.................... // Not supported`	429	`.................... // Not supported`
430	`....................`	430	`....................`
431	`.................... //---------------------------------------------------------------------------`	431	`.................... //---------------------------------------------------------------------------`
432	`.................... // Multibyte string functions`	432	`.................... // Multibyte string functions`
433	`.................... //---------------------------------------------------------------------------`	433	`.................... //---------------------------------------------------------------------------`
434	`....................`	434	`....................`
435	`.................... // Not supported`	435	`.................... // Not supported`
436	`....................`	436	`....................`
437	`....................`	437	`....................`
438	`.................... //---------------------------------------------------------------------------`	438	`.................... //---------------------------------------------------------------------------`
439	`.................... // Internal implementation`	439	`.................... // Internal implementation`
440	`.................... //---------------------------------------------------------------------------`	440	`.................... //---------------------------------------------------------------------------`
441	`....................`	441	`....................`
442	`.................... #include <stddef.h>`	442	`.................... #include <stddef.h>`
443	`.................... ///////////////////////////////////////////////////////////////////////////`	443	`.................... ///////////////////////////////////////////////////////////////////////////`
444	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	444	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
445	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	446	`.................... //// compiler. This source code may only be distributed to other ////`
447	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	447	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
448	`.................... //// or distribution is permitted without written permission. ////`	448	`.................... //// or distribution is permitted without written permission. ////`
449	`.................... //// Derivative programs created using this software in object code ////`	449	`.................... //// Derivative programs created using this software in object code ////`
450	`.................... //// form are not restricted in any way. ////`	450	`.................... //// form are not restricted in any way. ////`
451	`.................... ///////////////////////////////////////////////////////////////////////////`	451	`.................... ///////////////////////////////////////////////////////////////////////////`
452	`....................`	452	`....................`
453	`.................... #ifndef _STDDEF`	453	`.................... #ifndef _STDDEF`
454	`....................`	454	`....................`
455	`.................... #define _STDDEF`	455	`.................... #define _STDDEF`
456	`....................`	456	`....................`
457	`.................... #if sizeof(int *)==1`	457	`.................... #if sizeof(int *)==1`
458	`.................... #define ptrdiff_t int`	458	`.................... #define ptrdiff_t int`
459	`.................... #else`	459	`.................... #else`
460	`.................... #define ptrdiff_t long`	460	`.................... #define ptrdiff_t long`
461	`.................... #endif`	461	`.................... #endif`
462	`....................`	462	`....................`
463	`.................... #define size_t int`	463	`.................... #define size_t int`
464	`.................... #define wchar_t char`	464	`.................... #define wchar_t char`
465	`.................... #define NULL 0`	465	`.................... #define NULL 0`
466	`....................`	466	`....................`
467	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`	467	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
468	`....................`	468	`....................`
469	`.................... #endif`	469	`.................... #endif`
470	`....................`	470	`....................`
471	`.................... #include <string.h>`	471	`.................... #include <string.h>`
472	`.................... ////////////////////////////////////////////////////////////////////////////`	472	`.................... ////////////////////////////////////////////////////////////////////////////`
473	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	473	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
474	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	475	`.................... //// compiler. This source code may only be distributed to other ////`
476	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	476	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
477	`.................... //// or distribution is permitted without written permission. ////`	477	`.................... //// or distribution is permitted without written permission. ////`
478	`.................... //// Derivative programs created using this software in object code ////`	478	`.................... //// Derivative programs created using this software in object code ////`
479	`.................... //// form are not restricted in any way. ////`	479	`.................... //// form are not restricted in any way. ////`
480	`.................... ////////////////////////////////////////////////////////////////////////////`	480	`.................... ////////////////////////////////////////////////////////////////////////////`
481	`....................`	481	`....................`
482	`.................... #ifndef _STRING`	482	`.................... #ifndef _STRING`
483	`.................... #define _STRING`	483	`.................... #define _STRING`
484	`.................... #include <stddef.h>`	484	`.................... #include <stddef.h>`
485	`.................... ///////////////////////////////////////////////////////////////////////////`	485	`.................... ///////////////////////////////////////////////////////////////////////////`
486	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	486	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
487	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	488	`.................... //// compiler. This source code may only be distributed to other ////`
489	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	489	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
490	`.................... //// or distribution is permitted without written permission. ////`	490	`.................... //// or distribution is permitted without written permission. ////`
491	`.................... //// Derivative programs created using this software in object code ////`	491	`.................... //// Derivative programs created using this software in object code ////`
492	`.................... //// form are not restricted in any way. ////`	492	`.................... //// form are not restricted in any way. ////`
493	`.................... ///////////////////////////////////////////////////////////////////////////`	493	`.................... ///////////////////////////////////////////////////////////////////////////`
494	`....................`	494	`....................`
495	`.................... #ifndef _STDDEF`	495	`.................... #ifndef _STDDEF`
496	`....................`	496	`....................`
497	`.................... #define _STDDEF`	497	`.................... #define _STDDEF`
498	`....................`	498	`....................`
499	`.................... #if sizeof(int *)==1`	499	`.................... #if sizeof(int *)==1`
500	`.................... #define ptrdiff_t int`	500	`.................... #define ptrdiff_t int`
501	`.................... #else`	501	`.................... #else`
502	`.................... #define ptrdiff_t long`	502	`.................... #define ptrdiff_t long`
503	`.................... #endif`	503	`.................... #endif`
504	`....................`	504	`....................`
505	`.................... #define size_t int`	505	`.................... #define size_t int`
506	`.................... #define wchar_t char`	506	`.................... #define wchar_t char`
507	`.................... #define NULL 0`	507	`.................... #define NULL 0`
508	`....................`	508	`....................`
509	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`	509	`.................... #define offsetof(s,f) (offsetofbit(s,f)/8)`
510	`....................`	510	`....................`
511	`.................... #endif`	511	`.................... #endif`
512	`....................`	512	`....................`
513	`.................... #include <ctype.h>`	513	`.................... #include <ctype.h>`
514	`.................... ////////////////////////////////////////////////////////////////////////////`	514	`.................... ////////////////////////////////////////////////////////////////////////////`
515	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`	515	`.................... //// (C) Copyright 1996,2003 Custom Computer Services ////`
516	`.................... //// This source code may only be used by licensed users of the CCS C ////`	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 ////`	517	`.................... //// compiler. This source code may only be distributed to other ////`
518	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`	518	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
519	`.................... //// or distribution is permitted without written permission. ////`	519	`.................... //// or distribution is permitted without written permission. ////`
520	`.................... //// Derivative programs created using this software in object code ////`	520	`.................... //// Derivative programs created using this software in object code ////`
521	`.................... //// form are not restricted in any way. ////`	521	`.................... //// form are not restricted in any way. ////`
522	`.................... ////////////////////////////////////////////////////////////////////////////`	522	`.................... ////////////////////////////////////////////////////////////////////////////`
523	`....................`	523	`....................`
524	`.................... #ifndef _CTYPE`	524	`.................... #ifndef _CTYPE`
525	`.................... #define _CTYPE`	525	`.................... #define _CTYPE`
526	`....................`	526	`....................`
527	`.................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz")`	527	`.................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz")`
528	`.................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ")`	528	`.................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ")`
529	`.................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`	529	`.................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`
530	`.................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`	530	`.................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")`
531	`.................... #define isdigit(x) isamong(x,"0123456789")`	531	`.................... #define isdigit(x) isamong(x,"0123456789")`
532	`.................... #define isspace(x) (x==' ')`	532	`.................... #define isspace(x) (x==' ')`
533	`.................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef")`	533	`.................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef")`
534	`.................... #define iscntrl(x) (x<' ')`	534	`.................... #define iscntrl(x) (x<' ')`
535	`.................... #define isprint(x) (x>=' ')`	535	`.................... #define isprint(x) (x>=' ')`
536	`.................... #define isgraph(x) (x>' ')`	536	`.................... #define isgraph(x) (x>' ')`
537	`.................... #define ispunct(x) ((x>' ')&&!isalnum(x))`	537	`.................... #define ispunct(x) ((x>' ')&&!isalnum(x))`
538	`....................`	538	`....................`
539	`.................... #endif`	539	`.................... #endif`
540	`....................`	540	`....................`
541	`....................`	541	`....................`
542	`....................`	542	`....................`
543	`....................`	543	`....................`
544	`....................`	544	`....................`
545	`.................... //////////////////////////////////////////////`	545	`.................... //////////////////////////////////////////////`
546	`.................... //// Uncomment the following define to ////`	546	`.................... //// Uncomment the following define to ////`
547	`.................... //// allow some functions to use a ////`	547	`.................... //// allow some functions to use a ////`
548	`.................... //// quicker algorithm, but use more ROM ////`	548	`.................... //// quicker algorithm, but use more ROM ////`
549	`.................... //// ////`	549	`.................... //// ////`
550	`.................... //// #define FASTER_BUT_MORE_ROM ////`	550	`.................... //// #define FASTER_BUT_MORE_ROM ////`
551	`.................... //////////////////////////////////////////////`	551	`.................... //////////////////////////////////////////////`
552	`....................`	552	`....................`
553	`....................`	553	`....................`
554	`....................`	554	`....................`
555	`.................... /Copying functions/`	555	`.................... /Copying functions/`
556	`.................... /* standard template:`	556	`.................... /* standard template:`
557	`.................... void memmove(void s1, void *s2, size_t n).`	557	`.................... void memmove(void s1, void *s2, size_t n).`
558	`.................... Copies max of n characters safely (not following ending '\0')`	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 */`	559	`.................... from s2 in s1; if s2 has less than n characters, appends 0 */`
560	`....................`	560	`....................`
561	`.................... char memmove(void s1,char *s2,size_t n)`	561	`.................... char memmove(void s1,char *s2,size_t n)`
562	`.................... {`	562	`.................... {`
563	`.................... char *sc1;`	563	`.................... char *sc1;`
564	`.................... char *sc2;`	564	`.................... char *sc2;`
565	`.................... sc1=s1;`	565	`.................... sc1=s1;`
566	`.................... sc2=s2;`	566	`.................... sc2=s2;`
567	`.................... if(sc2<sc1 && sc1 <sc2 +n)`	567	`.................... if(sc2<sc1 && sc1 <sc2 +n)`
568	`.................... for(sc1+=n,sc2+=n;0<n;--n)`	568	`.................... for(sc1+=n,sc2+=n;0<n;--n)`
569	`.................... --sc1=--sc2;`	569	`.................... --sc1=--sc2;`
570	`.................... else`	570	`.................... else`
571	`.................... for(;0<n;--n)`	571	`.................... for(;0<n;--n)`
572	`.................... sc1++=sc2++;`	572	`.................... sc1++=sc2++;`
573	`.................... return s1;`	573	`.................... return s1;`
574	`.................... }`	574	`.................... }`
575	`....................`	575	`....................`
576	`.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?`	576	`.................... /* compiler ignored the name 'strcpy()'; perhaps, it's reserved?`
577	`.................... Standard template: char strcpy(char s1, const char *s2)`	577	`.................... Standard template: char strcpy(char s1, const char *s2)`
578	`.................... copies the string s2 including the null character to s1*/`	578	`.................... copies the string s2 including the null character to s1*/`
579	`....................`	579	`....................`
580	`.................... char strcopy(char s1, char *s2)`	580	`.................... char strcopy(char s1, char *s2)`
581	`.................... {`	581	`.................... {`
582	`.................... char *s;`	582	`.................... char *s;`
583	`....................`	583	`....................`
584	`.................... for (s = s1; *s2 != 0; s++, s2++) {`	584	`.................... for (s = s1; *s2 != 0; s++, s2++) {`
585	`.................... s = s2;`	585	`.................... s = s2;`
586	`.................... }`	586	`.................... }`
587	`.................... s = s2;`	587	`.................... s = s2;`
588	`.................... return(s1);`	588	`.................... return(s1);`
589	`.................... }`	589	`.................... }`
590	`....................`	590	`....................`
591	`.................... /* standard template:`	591	`.................... /* standard template:`
592	`.................... char strncpy(char s1, const char *s2, size_t n).`	592	`.................... char strncpy(char s1, const char *s2, size_t n).`
593	`.................... Copies max of n characters (not following ending '\0')`	593	`.................... Copies max of n characters (not following ending '\0')`
594	`.................... from s2 in s1; if s2 has less than n characters, appends 0 */`	594	`.................... from s2 in s1; if s2 has less than n characters, appends 0 */`
595	`....................`	595	`....................`
596	`.................... char strncpy(char s1, char *s2, size_t n)`	596	`.................... char strncpy(char s1, char *s2, size_t n)`
597	`.................... {`	597	`.................... {`
598	`.................... char *s;`	598	`.................... char *s;`
599	`....................`	599	`....................`
600	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`	600	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`
601	`.................... s++ = s2++;`	601	`.................... s++ = s2++;`
602	`.................... for (; n > 0; n--)`	602	`.................... for (; n > 0; n--)`
603	`.................... *s++ = '\0';`	603	`.................... *s++ = '\0';`
604	`....................`	604	`....................`
605	`.................... return(s1);`	605	`.................... return(s1);`
606	`.................... }`	606	`.................... }`
607	`.................... /***********************************************************/`	607	`.................... /***********************************************************/`
608	`....................`	608	`....................`
609	`.................... /concatenation functions/`	609	`.................... /concatenation functions/`
610	`.................... /* standard template: char strcat(char s1, const char *s2)`	610	`.................... /* standard template: char strcat(char s1, const char *s2)`
611	`.................... appends s2 to s1*/`	611	`.................... appends s2 to s1*/`
612	`....................`	612	`....................`
613	`.................... char strcat(char s1, char *s2)`	613	`.................... char strcat(char s1, char *s2)`
614	`.................... {`	614	`.................... {`
615	`.................... char *s;`	615	`.................... char *s;`
616	`....................`	616	`....................`
617	`.................... for (s = s1; *s != '\0'; ++s);`	617	`.................... for (s = s1; *s != '\0'; ++s);`
618	`.................... while(*s2 != '\0')`	618	`.................... while(*s2 != '\0')`
619	`.................... {`	619	`.................... {`
620	`.................... s = s2;`	620	`.................... s = s2;`
621	`.................... ++s;`	621	`.................... ++s;`
622	`.................... ++s2;`	622	`.................... ++s2;`
623	`.................... }`	623	`.................... }`
624	`....................`	624	`....................`
625	`.................... *s = '\0';`	625	`.................... *s = '\0';`
626	`.................... return(s1);`	626	`.................... return(s1);`
627	`.................... }`	627	`.................... }`
628	`.................... /* standard template: char strncat(char s1, char *s2,size_t n)`	628	`.................... /* standard template: char strncat(char s1, char *s2,size_t n)`
629	`.................... appends not more than n characters from s2 to s1*/`	629	`.................... appends not more than n characters from s2 to s1*/`
630	`....................`	630	`....................`
631	`.................... char strncat(char s1, char *s2, size_t n)`	631	`.................... char strncat(char s1, char *s2, size_t n)`
632	`.................... {`	632	`.................... {`
633	`.................... char *s;`	633	`.................... char *s;`
634	`....................`	634	`....................`
635	`.................... for (s = s1; *s != '\0'; ++s);`	635	`.................... for (s = s1; *s != '\0'; ++s);`
636	`.................... while(*s2 != '\0' && 0<n)`	636	`.................... while(*s2 != '\0' && 0<n)`
637	`.................... {`	637	`.................... {`
638	`.................... s = s2;`	638	`.................... s = s2;`
639	`.................... ++s;`	639	`.................... ++s;`
640	`.................... ++s2;`	640	`.................... ++s2;`
641	`.................... --n;`	641	`.................... --n;`
642	`.................... }`	642	`.................... }`
643	`....................`	643	`....................`
644	`.................... *s = '\0';`	644	`.................... *s = '\0';`
645	`.................... return(s1);`	645	`.................... return(s1);`
646	`.................... }`	646	`.................... }`
647	`....................`	647	`....................`
648	`.................... /***********************************************************/`	648	`.................... /***********************************************************/`
649	`....................`	649	`....................`
650	`....................`	650	`....................`
651	`.................... /comparison functions/`	651	`.................... /comparison functions/`
652	`.................... /* standard template: signed int memcmp(void s1, void s2).`	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 */`	653	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
654	`....................`	654	`....................`
655	`.................... signed int memcmp(void * s1,char *s2,size_t n)`	655	`.................... signed int memcmp(void * s1,char *s2,size_t n)`
656	`.................... {`	656	`.................... {`
657	`.................... char su1, su2;`	657	`.................... char su1, su2;`
658	`.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)`	658	`.................... for(su1=s1, su2=s2; 0<n; ++su1, ++su2, --n)`
659	`.................... {`	659	`.................... {`
660	`.................... if(su1!=su2)`	660	`.................... if(su1!=su2)`
661	`.................... return ((su1<su2)?1:+1);`	661	`.................... return ((su1<su2)?1:+1);`
662	`.................... }`	662	`.................... }`
663	`.................... return 0;`	663	`.................... return 0;`
664	`.................... }`	664	`.................... }`
665	`....................`	665	`....................`
666	`.................... /* standard template: int strcmp(const char s1, const char s2).`	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 */`	667	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
668	`....................`	668	`....................`
669	`.................... signed int strcmp(char s1, char s2)`	669	`.................... signed int strcmp(char s1, char s2)`
670	`.................... {`	670	`.................... {`
671	`.................... for (; s1 == s2; s1++, s2++)`	671	`.................... for (; s1 == s2; s1++, s2++)`
672	`.................... if (*s1 == '\0')`	672	`.................... if (*s1 == '\0')`
673	`.................... return(0);`	673	`.................... return(0);`
674	`.................... return((s1 < s2) ?-1: 1);`	674	`.................... return((s1 < s2) ?-1: 1);`
675	`.................... }`	675	`.................... }`
676	`.................... /* standard template: int strcoll(const char s1, const char s2).`	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 */`	677	`.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */`
678	`....................`	678	`....................`
679	`.................... signed int strcoll(char s1, char s2)`	679	`.................... signed int strcoll(char s1, char s2)`
680	`.................... {`	680	`.................... {`
681	`.................... for (; s1 == s2; s1++, s2++)`	681	`.................... for (; s1 == s2; s1++, s2++)`
682	`.................... if (*s1 == '\0')`	682	`.................... if (*s1 == '\0')`
683	`.................... return(0);`	683	`.................... return(0);`
684	`.................... return((s1 < s2) ?-1: 1);`	684	`.................... return((s1 < s2) ?-1: 1);`
685	`.................... }`	685	`.................... }`
686	`....................`	686	`....................`
687	`.................... /* standard template:`	687	`.................... /* standard template:`
688	`.................... int strncmp(const char s1, const char s2, size_t n).`	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;`	689	`.................... Compares max of n characters (not following 0) from s1 to s2;`
690	`.................... returns same as strcmp */`	690	`.................... returns same as strcmp */`
691	`....................`	691	`....................`
692	`.................... signed int strncmp(char s1, char s2, size_t n)`	692	`.................... signed int strncmp(char s1, char s2, size_t n)`
693	`.................... {`	693	`.................... {`
694	`.................... for (; n > 0; s1++, s2++, n--)`	694	`.................... for (; n > 0; s1++, s2++, n--)`
695	`.................... if (s1 != s2)`	695	`.................... if (s1 != s2)`
696	`.................... return((s1 <s2) ?-1: 1);`	696	`.................... return((s1 <s2) ?-1: 1);`
697	`.................... else if (*s1 == '\0')`	697	`.................... else if (*s1 == '\0')`
698	`.................... return(0);`	698	`.................... return(0);`
699	`.................... return(0);`	699	`.................... return(0);`
700	`.................... }`	700	`.................... }`
701	`.................... /* standard template:`	701	`.................... /* standard template:`
702	`.................... int strxfrm(const char s1, const char s2, size_t n).`	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*/`	703	`.................... transforms maximum of n characters from s2 and places them into s1*/`
704	`.................... size_t strxfrm(char s1, char s2, size_t n)`	704	`.................... size_t strxfrm(char s1, char s2, size_t n)`
705	`.................... {`	705	`.................... {`
706	`.................... char *s;`	706	`.................... char *s;`
707	`.................... int n1;`	707	`.................... int n1;`
708	`.................... n1=n;`	708	`.................... n1=n;`
709	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`	709	`.................... for (s = s1; n > 0 && *s2 != '\0'; n--)`
710	`.................... s++ = s2++;`	710	`.................... s++ = s2++;`
711	`.................... for (; n > 0; n--)`	711	`.................... for (; n > 0; n--)`
712	`.................... *s++ = '\0';`	712	`.................... *s++ = '\0';`
713	`....................`	713	`....................`
714	`.................... return(n1);`	714	`.................... return(n1);`
715	`.................... }`	715	`.................... }`
716	`....................`	716	`....................`
717	`....................`	717	`....................`
718	`....................`	718	`....................`
719	`....................`	719	`....................`
720	`....................`	720	`....................`
721	`.................... /***********************************************************/`	721	`.................... /***********************************************************/`
722	`.................... /Search functions/`	722	`.................... /Search functions/`
723	`.................... /* standard template: void memchr(const char s, int c).`	723	`.................... /* standard template: void memchr(const char s, int c).`
724	`.................... Finds first occurrence of c in n characters of s */`	724	`.................... Finds first occurrence of c in n characters of s */`
725	`....................`	725	`....................`
726	`.................... char memchr(void s,int c,size_t n)`	726	`.................... char memchr(void s,int c,size_t n)`
727	`.................... {`	727	`.................... {`
728	`.................... char uc;`	728	`.................... char uc;`
729	`.................... char *su;`	729	`.................... char *su;`
730	`.................... uc=c;`	730	`.................... uc=c;`
731	`.................... for(su=s;0<n;++su,--n)`	731	`.................... for(su=s;0<n;++su,--n)`
732	`.................... if(*su==uc)`	732	`.................... if(*su==uc)`
733	`.................... return su;`	733	`.................... return su;`
734	`.................... return NULL;`	734	`.................... return NULL;`
735	`.................... }`	735	`.................... }`
736	`....................`	736	`....................`
737	`.................... /* standard template: char strchr(const char s, int c).`	737	`.................... /* standard template: char strchr(const char s, int c).`
738	`.................... Finds first occurrence of c in s */`	738	`.................... Finds first occurrence of c in s */`
739	`....................`	739	`....................`
740	`.................... char strchr(char s, int c)`	740	`.................... char strchr(char s, int c)`
741	`.................... {`	741	`.................... {`
742	`.................... for (; *s != c; s++)`	742	`.................... for (; *s != c; s++)`
743	`.................... if (*s == '\0')`	743	`.................... if (*s == '\0')`
744	`.................... return(0);`	744	`.................... return(0);`
745	`.................... return(s);`	745	`.................... return(s);`
746	`.................... }`	746	`.................... }`
747	`.................... /* standard template:`	747	`.................... /* standard template:`
748	`.................... size_t strcspn(const char s1, const char s2).`	748	`.................... size_t strcspn(const char s1, const char s2).`
749	`.................... Computes length of max initial segment of s1 that`	749	`.................... Computes length of max initial segment of s1 that`
750	`.................... consists entirely of characters NOT from s2*/`	750	`.................... consists entirely of characters NOT from s2*/`
751	`....................`	751	`....................`
752	`.................... int strcspn(char s1, char *s2)`	752	`.................... int strcspn(char s1, char *s2)`
753	`.................... {`	753	`.................... {`
754	`.................... char sc1, sc2;`	754	`.................... char sc1, sc2;`
755	`....................`	755	`....................`
756	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`	756	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
757	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`	757	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`
758	`.................... if (sc1 == sc2)`	758	`.................... if (sc1 == sc2)`
759	`.................... return(sc1 - s1);`	759	`.................... return(sc1 - s1);`
760	`.................... return(sc1 - s1);`	760	`.................... return(sc1 - s1);`
761	`.................... }`	761	`.................... }`
762	`.................... /* standard template:`	762	`.................... /* standard template:`
763	`.................... char strpbrk(const char s1, const char *s2).`	763	`.................... char strpbrk(const char s1, const char *s2).`
764	`.................... Locates first occurence of any character from s2 in s1;`	764	`.................... Locates first occurence of any character from s2 in s1;`
765	`.................... returns s1 if s2 is empty string */`	765	`.................... returns s1 if s2 is empty string */`
766	`....................`	766	`....................`
767	`.................... char strpbrk(char s1, char *s2)`	767	`.................... char strpbrk(char s1, char *s2)`
768	`.................... {`	768	`.................... {`
769	`.................... char sc1, sc2;`	769	`.................... char sc1, sc2;`
770	`....................`	770	`....................`
771	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`	771	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
772	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`	772	`.................... for (sc2 = s2; *sc2 != 0; sc2++)`
773	`.................... if (sc1 == sc2)`	773	`.................... if (sc1 == sc2)`
774	`.................... return(sc1);`	774	`.................... return(sc1);`
775	`.................... return(0);`	775	`.................... return(0);`
776	`.................... }`	776	`.................... }`
777	`....................`	777	`....................`
778	`....................`	778	`....................`
779	`.................... /* standard template: char strrchr(const char s, int c).`	779	`.................... /* standard template: char strrchr(const char s, int c).`
780	`.................... Finds last occurrence of c in s */`	780	`.................... Finds last occurrence of c in s */`
781	`....................`	781	`....................`
782	`.................... char strrchr(char s, int c)`	782	`.................... char strrchr(char s, int c)`
783	`.................... {`	783	`.................... {`
784	`.................... char *p;`	784	`.................... char *p;`
785	`....................`	785	`....................`
786	`.................... for (p = 0; ; s++)`	786	`.................... for (p = 0; ; s++)`
787	`.................... {`	787	`.................... {`
788	`.................... if (*s == c)`	788	`.................... if (*s == c)`
789	`.................... p = s;`	789	`.................... p = s;`
790	`.................... if (*s == '\0')`	790	`.................... if (*s == '\0')`
791	`.................... return(p);`	791	`.................... return(p);`
792	`.................... }`	792	`.................... }`
793	`.................... }`	793	`.................... }`
794	`.................... /* computes length of max initial segment of s1 consisting`	794	`.................... /* computes length of max initial segment of s1 consisting`
795	`.................... entirely of characters from s2 */`	795	`.................... entirely of characters from s2 */`
796	`....................`	796	`....................`
797	`.................... int strspn(char s1, char *s2)`	797	`.................... int strspn(char s1, char *s2)`
798	`.................... {`	798	`.................... {`
799	`.................... char sc1, sc2;`	799	`.................... char sc1, sc2;`
800	`....................`	800	`....................`
801	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`	801	`.................... for (sc1 = s1; *sc1 != 0; sc1++)`
802	`.................... for (sc2 = s2; ; sc2++)`	802	`.................... for (sc2 = s2; ; sc2++)`
803	`.................... if (*sc2 == '\0')`	803	`.................... if (*sc2 == '\0')`
804	`.................... return(sc1 - s1);`	804	`.................... return(sc1 - s1);`
805	`.................... else if (sc1 == sc2)`	805	`.................... else if (sc1 == sc2)`
806	`.................... break;`	806	`.................... break;`
807	`.................... return(sc1 - s1);`	807	`.................... return(sc1 - s1);`
808	`.................... }`	808	`.................... }`
809	`.................... /* standard template:`	809	`.................... /* standard template:`
810	`.................... char strstr(const char s1, const char *s2);`	810	`.................... char strstr(const char s1, const char *s2);`
811	`.................... Locates first occurence of character sequence s2 in s1;`	811	`.................... Locates first occurence of character sequence s2 in s1;`
812	`.................... returns 0 if s2 is empty string`	812	`.................... returns 0 if s2 is empty string`
813	`....................`	813	`....................`
814	`.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the`	814	`.................... Uncomment #define FASTER_BUT_MORE_ROM at the top of the`
815	`.................... file to use the faster algorithm */`	815	`.................... file to use the faster algorithm */`
816	`.................... char strstr(char s1, char *s2)`	816	`.................... char strstr(char s1, char *s2)`
817	`.................... {`	817	`.................... {`
818	`.................... char s, t;`	818	`.................... char s, t;`
819	`....................`	819	`....................`
820	`.................... #ifdef FASTER_BUT_MORE_ROM`	820	`.................... #ifdef FASTER_BUT_MORE_ROM`
821	`.................... if (*s2 == '\0')`	821	`.................... if (*s2 == '\0')`
822	`.................... return(s1);`	822	`.................... return(s1);`
823	`.................... #endif`	823	`.................... #endif`
824	`....................`	824	`....................`
825	`.................... while (*s1)`	825	`.................... while (*s1)`
826	`.................... {`	826	`.................... {`
827	`.................... for(s = s1, t = s2; t && s == *t; ++s, ++t);`	827	`.................... for(s = s1, t = s2; t && s == *t; ++s, ++t);`
828	`....................`	828	`....................`
829	`.................... if (*t == '\0')`	829	`.................... if (*t == '\0')`
830	`.................... return s1;`	830	`.................... return s1;`
831	`.................... ++s1;`	831	`.................... ++s1;`
832	`.................... #ifdef FASTER_BUT_MORE_ROM`	832	`.................... #ifdef FASTER_BUT_MORE_ROM`
833	`.................... while(s1 != '\0' && s1 != *s2)`	833	`.................... while(s1 != '\0' && s1 != *s2)`
834	`.................... ++s1;`	834	`.................... ++s1;`
835	`.................... #endif`	835	`.................... #endif`
836	`.................... }`	836	`.................... }`
837	`.................... return 0;`	837	`.................... return 0;`
838	`.................... }`	838	`.................... }`
839	`....................`	839	`....................`
840	`.................... /* standard template: char strtok(char s1, const char *s2).`	840	`.................... /* standard template: char strtok(char s1, const char *s2).`
841	`....................`	841	`....................`
842	`.................... Finds next token in s1 delimited by a character from separator`	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`	843	`.................... string s2 (which can be different from call to call). First call`
844	`.................... starts at beginning of s1 searching for first character NOT`	844	`.................... starts at beginning of s1 searching for first character NOT`
845	`.................... contained in s2; returns 0 if none is found.`	845	`.................... contained in s2; returns 0 if none is found.`
846	`.................... If one is found, it is the start of first token (return value).`	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.`	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`	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`	849	`.................... searches for a token will return 0. If one is found, it is`
850	`.................... overwritten by '\0', which terminates current token. Function saves`	850	`.................... overwritten by '\0', which terminates current token. Function saves`
851	`.................... pointer to following character from which next search will start.`	851	`.................... pointer to following character from which next search will start.`
852	`.................... Each subsequent call, with 0 as first argument, starts searching`	852	`.................... Each subsequent call, with 0 as first argument, starts searching`
853	`.................... from saved pointer */`	853	`.................... from saved pointer */`
854	`....................`	854	`....................`
855	`.................... char strtok(char s1, char *s2)`	855	`.................... char strtok(char s1, char *s2)`
856	`.................... {`	856	`.................... {`
857	`.................... char beg, end;`	857	`.................... char beg, end;`
858	`.................... static char *save;`	858	`.................... static char *save;`
859	`*`	859	`*`
860	`0359: CLRF 29`	860	`0359: CLRF 29`
861	`035A: CLRF 2A`	861	`035A: CLRF 2A`
862	`....................`	862	`....................`
863	`.................... beg = (s1)?s1: save;`	863	`.................... beg = (s1)?s1: save;`
864	`.................... beg += strspn(beg, s2);`	864	`.................... beg += strspn(beg, s2);`
865	`.................... if (*beg == '\0')`	865	`.................... if (*beg == '\0')`
866	`.................... {`	866	`.................... {`
867	`.................... *save = ' ';`	867	`.................... *save = ' ';`
868	`.................... return(0);`	868	`.................... return(0);`
869	`.................... }`	869	`.................... }`
870	`.................... end = strpbrk(beg, s2);`	870	`.................... end = strpbrk(beg, s2);`
871	`.................... if (*end != '\0')`	871	`.................... if (*end != '\0')`
872	`.................... {`	872	`.................... {`
873	`.................... *end = '\0';`	873	`.................... *end = '\0';`
874	`.................... end++;`	874	`.................... end++;`
875	`.................... }`	875	`.................... }`
876	`.................... save = end;`	876	`.................... save = end;`
877	`.................... return(beg);`	877	`.................... return(beg);`
878	`.................... }`	878	`.................... }`
879	`....................`	879	`....................`
880	`.................... /*****************************************************************/`	880	`.................... /*****************************************************************/`
881	`.................... /Miscellaneous functions/`	881	`.................... /Miscellaneous functions/`
882	`.................... /* standard template`	882	`.................... /* standard template`
883	`.................... maps error number in errnum to an error message string`	883	`.................... maps error number in errnum to an error message string`
884	`.................... Returns: Pointer to string`	884	`.................... Returns: Pointer to string`
885	`.................... */`	885	`.................... */`
886	`.................... #ifdef _ERRNO`	886	`.................... #ifdef _ERRNO`
887	`.................... char * strerror(int errnum)`	887	`.................... char * strerror(int errnum)`
888	`.................... {`	888	`.................... {`
889	`.................... char s[15];`	889	`.................... char s[15];`
890	`.................... switch( errnum)`	890	`.................... switch( errnum)`
891	`.................... {`	891	`.................... {`
892	`.................... case 0:`	892	`.................... case 0:`
893	`.................... strcpy(s,"no errors");`	893	`.................... strcpy(s,"no errors");`
894	`.................... return s;`	894	`.................... return s;`
895	`.................... case EDOM :`	895	`.................... case EDOM :`
896	`.................... strcpy(s,"domain error");`	896	`.................... strcpy(s,"domain error");`
897	`.................... return s;`	897	`.................... return s;`
898	`.................... case ERANGE:`	898	`.................... case ERANGE:`
899	`.................... strcpy(s,"range error");`	899	`.................... strcpy(s,"range error");`
900	`.................... return s;`	900	`.................... return s;`
901	`.................... }`	901	`.................... }`
902	`.................... }`	902	`.................... }`
903	`.................... #ENDIF`	903	`.................... #ENDIF`
904	`.................... /* standard template: size_t strlen(const char *s).`	904	`.................... /* standard template: size_t strlen(const char *s).`
905	`.................... Computes length of s1 (preceding terminating 0) */`	905	`.................... Computes length of s1 (preceding terminating 0) */`
906	`....................`	906	`....................`
907	`.................... int strlen(char s)`	907	`.................... int strlen(char s)`
908	`.................... {`	908	`.................... {`
909	`.................... char *sc;`	909	`.................... char *sc;`
910	`....................`	910	`....................`
911	`.................... for (sc = s; *sc != 0; sc++);`	911	`.................... for (sc = s; *sc != 0; sc++);`
912	`.................... return(sc - s);`	912	`.................... return(sc - s);`
913	`.................... }`	913	`.................... }`
914	`....................`	914	`....................`
915	`.................... /* standard template: size_t stricmp(const char s1, const char s2).`	915	`.................... /* standard template: size_t stricmp(const char s1, const char s2).`
916	`.................... Compares s1 to s2 ignoring case (upper vs. lower) */`	916	`.................... Compares s1 to s2 ignoring case (upper vs. lower) */`
917	`....................`	917	`....................`
918	`.................... signed int stricmp(char s1, char s2)`	918	`.................... signed int stricmp(char s1, char s2)`
919	`.................... {`	919	`.................... {`
920	`.................... for(; s1==s2\|\|(isalpha(s1)&&isalpha(s2)&&(s1==s2+32\|\|s2==s1+32));`	920	`.................... for(; s1==s2\|\|(isalpha(s1)&&isalpha(s2)&&(s1==s2+32\|\|s2==s1+32));`
921	`.................... s1++, s2++)`	921	`.................... s1++, s2++)`
922	`.................... if (*s1 == '\0')`	922	`.................... if (*s1 == '\0')`
923	`.................... return(0);`	923	`.................... return(0);`
924	`.................... return((s1 < s2) ?-1: 1);`	924	`.................... return((s1 < s2) ?-1: 1);`
925	`.................... }`	925	`.................... }`
926	`....................`	926	`....................`
927	`....................`	927	`....................`
928	`.................... /* standard template: char strlwr(char s).`	928	`.................... /* standard template: char strlwr(char s).`
929	`.................... Replaces uppercase letters by lowercase;`	929	`.................... Replaces uppercase letters by lowercase;`
930	`.................... returns pointer to new string s */`	930	`.................... returns pointer to new string s */`
931	`....................`	931	`....................`
932	`.................... char strlwr(char s)`	932	`.................... char strlwr(char s)`
933	`.................... {`	933	`.................... {`
934	`.................... char *p;`	934	`.................... char *p;`
935	`....................`	935	`....................`
936	`.................... for (p = s; *p != '\0'; p++)`	936	`.................... for (p = s; *p != '\0'; p++)`
937	`.................... if (p >= 'A' && p <='Z')`	937	`.................... if (p >= 'A' && p <='Z')`
938	`.................... *p += 'a' - 'A';`	938	`.................... *p += 'a' - 'A';`
939	`.................... return(s);`	939	`.................... return(s);`
940	`.................... }`	940	`.................... }`
941	`....................`	941	`....................`
942	`....................`	942	`....................`
943	`.................... /************************************************************/`	943	`.................... /************************************************************/`
944	`....................`	944	`....................`
945	`....................`	945	`....................`
946	`.................... #endif`	946	`.................... #endif`
947	`....................`	947	`....................`
948	`....................`	948	`....................`
949	`.................... div_t div(signed int numer,signed int denom)`	949	`.................... div_t div(signed int numer,signed int denom)`
950	`.................... {`	950	`.................... {`
951	`.................... div_t val;`	951	`.................... div_t val;`
952	`.................... val.quot = numer / denom;`	952	`.................... val.quot = numer / denom;`
953	`.................... val.rem = numer - (denom * val.quot);`	953	`.................... val.rem = numer - (denom * val.quot);`
954	`.................... return (val);`	954	`.................... return (val);`
955	`.................... }`	955	`.................... }`
956	`....................`	956	`....................`
957	`.................... ldiv_t ldiv(signed long numer,signed long denom)`	957	`.................... ldiv_t ldiv(signed long numer,signed long denom)`
958	`.................... {`	958	`.................... {`
959	`.................... ldiv_t val;`	959	`.................... ldiv_t val;`
960	`.................... val.quot = numer / denom;`	960	`.................... val.quot = numer / denom;`
961	`.................... val.rem = numer - (denom * val.quot);`	961	`.................... val.rem = numer - (denom * val.quot);`
962	`.................... return (val);`	962	`.................... return (val);`
963	`.................... }`	963	`.................... }`
964	`....................`	964	`....................`
965	`.................... float atof(char * s)`	965	`.................... float atof(char * s)`
966	`.................... {`	966	`.................... {`
967	`.................... float pow10 = 1.0;`	967	`.................... float pow10 = 1.0;`
968	`.................... float result = 0.0;`	968	`.................... float result = 0.0;`
969	`.................... int sign = 0;`	969	`.................... int sign = 0;`
970	`.................... char c;`	970	`.................... char c;`
971	`.................... int ptr = 0;`	971	`.................... int ptr = 0;`
972	`....................`	972	`....................`
973	`.................... c = s[ptr++];`	973	`.................... c = s[ptr++];`
974	`....................`	974	`....................`
975	`.................... if ((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`	975	`.................... if ((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`
976	`.................... if(c == '-') {`	976	`.................... if(c == '-') {`
977	`.................... sign = 1;`	977	`.................... sign = 1;`
978	`.................... c = s[ptr++];`	978	`.................... c = s[ptr++];`
979	`.................... }`	979	`.................... }`
980	`.................... if(c == '+')`	980	`.................... if(c == '+')`
981	`.................... c = s[ptr++];`	981	`.................... c = s[ptr++];`
982	`....................`	982	`....................`
983	`.................... while((c >= '0' && c <= '9')) {`	983	`.................... while((c >= '0' && c <= '9')) {`
984	`.................... result = 10*result + c - '0';`	984	`.................... result = 10*result + c - '0';`
985	`.................... c = s[ptr++];`	985	`.................... c = s[ptr++];`
986	`.................... }`	986	`.................... }`
987	`....................`	987	`....................`
988	`.................... if (c == '.') {`	988	`.................... if (c == '.') {`
989	`.................... c = s[ptr++];`	989	`.................... c = s[ptr++];`
990	`.................... while((c >= '0' && c <= '9')) {`	990	`.................... while((c >= '0' && c <= '9')) {`
991	`.................... pow10 = pow10*10;`	991	`.................... pow10 = pow10*10;`
992	`.................... result += (c - '0')/pow10;`	992	`.................... result += (c - '0')/pow10;`
993	`.................... c = s[ptr++];`	993	`.................... c = s[ptr++];`
994	`.................... }`	994	`.................... }`
995	`.................... }`	995	`.................... }`
996	`....................`	996	`....................`
997	`.................... }`	997	`.................... }`
998	`....................`	998	`....................`
999	`.................... if (sign == 1)`	999	`.................... if (sign == 1)`
1000	`.................... result = -1*result;`	1000	`.................... result = -1*result;`
1001	`.................... return(result);`	1001	`.................... return(result);`
1002	`.................... }`	1002	`.................... }`
1003	`....................`	1003	`....................`
1004	`.................... signed int atoi(char *s)`	1004	`.................... signed int atoi(char *s)`
1005	`.................... {`	1005	`.................... {`
1006	`.................... signed int result;`	1006	`.................... signed int result;`
1007	`.................... int sign, base, index;`	1007	`.................... int sign, base, index;`
1008	`.................... char c;`	1008	`.................... char c;`
1009	`....................`	1009	`....................`
1010	`.................... index = 0;`	1010	`.................... index = 0;`
1011	`.................... sign = 0;`	1011	`.................... sign = 0;`
1012	`.................... base = 10;`	1012	`.................... base = 10;`
1013	`.................... result = 0;`	1013	`.................... result = 0;`
1014	`....................`	1014	`....................`
1015	`.................... if (!s)`	1015	`.................... if (!s)`
1016	`.................... return 0;`	1016	`.................... return 0;`
1017	`.................... // Omit all preceeding alpha characters`	1017	`.................... // Omit all preceeding alpha characters`
1018	`.................... c = s[index++];`	1018	`.................... c = s[index++];`
1019	`....................`	1019	`....................`
1020	`.................... // increase index if either positive or negative sign is detected`	1020	`.................... // increase index if either positive or negative sign is detected`
1021	`.................... if (c == '-')`	1021	`.................... if (c == '-')`
1022	`.................... {`	1022	`.................... {`
1023	`.................... sign = 1; // Set the sign to negative`	1023	`.................... sign = 1; // Set the sign to negative`
1024	`.................... c = s[index++];`	1024	`.................... c = s[index++];`
1025	`.................... }`	1025	`.................... }`
1026	`.................... else if (c == '+')`	1026	`.................... else if (c == '+')`
1027	`.................... {`	1027	`.................... {`
1028	`.................... c = s[index++];`	1028	`.................... c = s[index++];`
1029	`.................... }`	1029	`.................... }`
1030	`....................`	1030	`....................`
1031	`.................... if (c >= '0' && c <= '9')`	1031	`.................... if (c >= '0' && c <= '9')`
1032	`.................... {`	1032	`.................... {`
1033	`....................`	1033	`....................`
1034	`.................... // Check for hexa number`	1034	`.................... // Check for hexa number`
1035	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`	1035	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
1036	`.................... {`	1036	`.................... {`
1037	`.................... base = 16;`	1037	`.................... base = 16;`
1038	`.................... index++;`	1038	`.................... index++;`
1039	`.................... c = s[index++];`	1039	`.................... c = s[index++];`
1040	`.................... }`	1040	`.................... }`
1041	`....................`	1041	`....................`
1042	`.................... // The number is a decimal number`	1042	`.................... // The number is a decimal number`
1043	`.................... if (base == 10)`	1043	`.................... if (base == 10)`
1044	`.................... {`	1044	`.................... {`
1045	`.................... while (c >= '0' && c <= '9')`	1045	`.................... while (c >= '0' && c <= '9')`
1046	`.................... {`	1046	`.................... {`
1047	`.................... result = 10*result + (c - '0');`	1047	`.................... result = 10*result + (c - '0');`
1048	`.................... c = s[index++];`	1048	`.................... c = s[index++];`
1049	`.................... }`	1049	`.................... }`
1050	`.................... }`	1050	`.................... }`
1051	`.................... else if (base == 16) // The number is a hexa number`	1051	`.................... else if (base == 16) // The number is a hexa number`
1052	`.................... {`	1052	`.................... {`
1053	`.................... c = toupper(c);`	1053	`.................... c = toupper(c);`
1054	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c<='F'))`	1054	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c<='F'))`
1055	`.................... {`	1055	`.................... {`
1056	`.................... if (c >= '0' && c <= '9')`	1056	`.................... if (c >= '0' && c <= '9')`
1057	`.................... result = (result << 4) + (c - '0');`	1057	`.................... result = (result << 4) + (c - '0');`
1058	`.................... else`	1058	`.................... else`
1059	`.................... result = (result << 4) + (c - 'A' + 10);`	1059	`.................... result = (result << 4) + (c - 'A' + 10);`
1060	`....................`	1060	`....................`
1061	`.................... c = s[index++];`	1061	`.................... c = s[index++];`
1062	`.................... c = toupper(c);`	1062	`.................... c = toupper(c);`
1063	`.................... }`	1063	`.................... }`
1064	`.................... }`	1064	`.................... }`
1065	`.................... }`	1065	`.................... }`
1066	`....................`	1066	`....................`
1067	`.................... if (sign == 1 && base == 10)`	1067	`.................... if (sign == 1 && base == 10)`
1068	`.................... result = -result;`	1068	`.................... result = -result;`
1069	`....................`	1069	`....................`
1070	`.................... return(result);`	1070	`.................... return(result);`
1071	`.................... }`	1071	`.................... }`
1072	`....................`	1072	`....................`
1073	`.................... signed long atol(char *s)`	1073	`.................... signed long atol(char *s)`
1074	`.................... {`	1074	`.................... {`
1075	`.................... signed long result;`	1075	`.................... signed long result;`
1076	`.................... int sign, base, index;`	1076	`.................... int sign, base, index;`
1077	`.................... char c;`	1077	`.................... char c;`
1078	`....................`	1078	`....................`
1079	`.................... index = 0;`	1079	`.................... index = 0;`
1080	`*`	1080	`*`
1081	`0242: CLRF 47`	1081	`0242: CLRF 47`
1082	`.................... sign = 0;`	1082	`.................... sign = 0;`
1083	`0243: CLRF 45`	1083	`0243: CLRF 45`
1084	`.................... base = 10;`	1084	`.................... base = 10;`
1085	`0244: MOVLW 0A`	1085	`0244: MOVLW 0A`
1086	`0245: MOVWF 46`	1086	`0245: MOVWF 46`
1087	`.................... result = 0;`	1087	`.................... result = 0;`
1088	`0246: CLRF 44`	1088	`0246: CLRF 44`
1089	`0247: CLRF 43`	1089	`0247: CLRF 43`
1090	`....................`	1090	`....................`
1091	`.................... if (!s)`	1091	`.................... if (!s)`
1092	`0248: MOVF 41,W`	1092	`0248: MOVF 41,W`
1093	`0249: IORWF 42,W`	1093	`0249: IORWF 42,W`
1094	`024A: BTFSS 03.2`	1094	`024A: BTFSS 03.2`
1095	`024B: GOTO 250`	1095	`024B: GOTO 250`
1096	`.................... return 0;`	1096	`.................... return 0;`
1097	`024C: MOVLW 00`	1097	`024C: MOVLW 00`
1098	`024D: MOVWF 78`	1098	`024D: MOVWF 78`
1099	`024E: MOVWF 79`	1099	`024E: MOVWF 79`
1100	`024F: GOTO 341`	1100	`024F: GOTO 341`
1101	`.................... c = s[index++];`	1101	`.................... c = s[index++];`
1102	`0250: MOVF 47,W`	1102	`0250: MOVF 47,W`
1103	`0251: INCF 47,F`	1103	`0251: INCF 47,F`
1104	`0252: ADDWF 41,W`	1104	`0252: ADDWF 41,W`
1105	`0253: MOVWF 04`	1105	`0253: MOVWF 04`
1106	`0254: BCF 03.7`	1106	`0254: BCF 03.7`
1107	`0255: BTFSC 42.0`	1107	`0255: BTFSC 42.0`
1108	`0256: BSF 03.7`	1108	`0256: BSF 03.7`
1109	`0257: MOVF 00,W`	1109	`0257: MOVF 00,W`
1110	`0258: MOVWF 48`	1110	`0258: MOVWF 48`
1111	`....................`	1111	`....................`
1112	`.................... // increase index if either positive or negative sign is detected`	1112	`.................... // increase index if either positive or negative sign is detected`
1113	`.................... if (c == '-')`	1113	`.................... if (c == '-')`
1114	`0259: MOVF 48,W`	1114	`0259: MOVF 48,W`
1115	`025A: SUBLW 2D`	1115	`025A: SUBLW 2D`
1116	`025B: BTFSS 03.2`	1116	`025B: BTFSS 03.2`
1117	`025C: GOTO 269`	1117	`025C: GOTO 269`
1118	`.................... {`	1118	`.................... {`
1119	`.................... sign = 1; // Set the sign to negative`	1119	`.................... sign = 1; // Set the sign to negative`
1120	`025D: MOVLW 01`	1120	`025D: MOVLW 01`
1121	`025E: MOVWF 45`	1121	`025E: MOVWF 45`
1122	`.................... c = s[index++];`	1122	`.................... c = s[index++];`
1123	`025F: MOVF 47,W`	1123	`025F: MOVF 47,W`
1124	`0260: INCF 47,F`	1124	`0260: INCF 47,F`
1125	`0261: ADDWF 41,W`	1125	`0261: ADDWF 41,W`
1126	`0262: MOVWF 04`	1126	`0262: MOVWF 04`
1127	`0263: BCF 03.7`	1127	`0263: BCF 03.7`
1128	`0264: BTFSC 42.0`	1128	`0264: BTFSC 42.0`
1129	`0265: BSF 03.7`	1129	`0265: BSF 03.7`
1130	`0266: MOVF 00,W`	1130	`0266: MOVF 00,W`
1131	`0267: MOVWF 48`	1131	`0267: MOVWF 48`
1132	`.................... }`	1132	`.................... }`
1133	`.................... else if (c == '+')`	1133	`.................... else if (c == '+')`
1134	`0268: GOTO 276`	1134	`0268: GOTO 276`
1135	`0269: MOVF 48,W`	1135	`0269: MOVF 48,W`
1136	`026A: SUBLW 2B`	1136	`026A: SUBLW 2B`
1137	`026B: BTFSS 03.2`	1137	`026B: BTFSS 03.2`
1138	`026C: GOTO 276`	1138	`026C: GOTO 276`
1139	`.................... {`	1139	`.................... {`
1140	`.................... c = s[index++];`	1140	`.................... c = s[index++];`
1141	`026D: MOVF 47,W`	1141	`026D: MOVF 47,W`
1142	`026E: INCF 47,F`	1142	`026E: INCF 47,F`
1143	`026F: ADDWF 41,W`	1143	`026F: ADDWF 41,W`
1144	`0270: MOVWF 04`	1144	`0270: MOVWF 04`
1145	`0271: BCF 03.7`	1145	`0271: BCF 03.7`
1146	`0272: BTFSC 42.0`	1146	`0272: BTFSC 42.0`
1147	`0273: BSF 03.7`	1147	`0273: BSF 03.7`
1148	`0274: MOVF 00,W`	1148	`0274: MOVF 00,W`
1149	`0275: MOVWF 48`	1149	`0275: MOVWF 48`
1150	`.................... }`	1150	`.................... }`
1151	`....................`	1151	`....................`
1152	`.................... if (c >= '0' && c <= '9')`	1152	`.................... if (c >= '0' && c <= '9')`
1153	`0276: MOVF 48,W`	1153	`0276: MOVF 48,W`
1154	`0277: SUBLW 2F`	1154	`0277: SUBLW 2F`
1155	`0278: BTFSC 03.0`	1155	`0278: BTFSC 03.0`
1156	`0279: GOTO 332`	1156	`0279: GOTO 332`
1157	`027A: MOVF 48,W`	1157	`027A: MOVF 48,W`
1158	`027B: SUBLW 39`	1158	`027B: SUBLW 39`
1159	`027C: BTFSS 03.0`	1159	`027C: BTFSS 03.0`
1160	`027D: GOTO 332`	1160	`027D: GOTO 332`
1161	`.................... {`	1161	`.................... {`
1162	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`	1162	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
1163	`027E: MOVF 48,W`	1163	`027E: MOVF 48,W`
1164	`027F: SUBLW 30`	1164	`027F: SUBLW 30`
1165	`0280: BTFSS 03.2`	1165	`0280: BTFSS 03.2`
1166	`0281: GOTO 2A2`	1166	`0281: GOTO 2A2`
1167	`0282: MOVF 47,W`	1167	`0282: MOVF 47,W`
1168	`0283: ADDWF 41,W`	1168	`0283: ADDWF 41,W`
1169	`0284: MOVWF 04`	1169	`0284: MOVWF 04`
1170	`0285: BCF 03.7`	1170	`0285: BCF 03.7`
1171	`0286: BTFSC 42.0`	1171	`0286: BTFSC 42.0`
1172	`0287: BSF 03.7`	1172	`0287: BSF 03.7`
1173	`0288: MOVF 00,W`	1173	`0288: MOVF 00,W`
1174	`0289: SUBLW 78`	1174	`0289: SUBLW 78`
1175	`028A: BTFSC 03.2`	1175	`028A: BTFSC 03.2`
1176	`028B: GOTO 296`	1176	`028B: GOTO 296`
1177	`028C: MOVF 47,W`	1177	`028C: MOVF 47,W`
1178	`028D: ADDWF 41,W`	1178	`028D: ADDWF 41,W`
1179	`028E: MOVWF 04`	1179	`028E: MOVWF 04`
1180	`028F: BCF 03.7`	1180	`028F: BCF 03.7`
1181	`0290: BTFSC 42.0`	1181	`0290: BTFSC 42.0`
1182	`0291: BSF 03.7`	1182	`0291: BSF 03.7`
1183	`0292: MOVF 00,W`	1183	`0292: MOVF 00,W`
1184	`0293: SUBLW 58`	1184	`0293: SUBLW 58`
1185	`0294: BTFSS 03.2`	1185	`0294: BTFSS 03.2`
1186	`0295: GOTO 2A2`	1186	`0295: GOTO 2A2`
1187	`.................... {`	1187	`.................... {`
1188	`.................... base = 16;`	1188	`.................... base = 16;`
1189	`0296: MOVLW 10`	1189	`0296: MOVLW 10`
1190	`0297: MOVWF 46`	1190	`0297: MOVWF 46`
1191	`.................... index++;`	1191	`.................... index++;`
1192	`0298: INCF 47,F`	1192	`0298: INCF 47,F`
1193	`.................... c = s[index++];`	1193	`.................... c = s[index++];`
1194	`0299: MOVF 47,W`	1194	`0299: MOVF 47,W`
1195	`029A: INCF 47,F`	1195	`029A: INCF 47,F`
1196	`029B: ADDWF 41,W`	1196	`029B: ADDWF 41,W`
1197	`029C: MOVWF 04`	1197	`029C: MOVWF 04`
1198	`029D: BCF 03.7`	1198	`029D: BCF 03.7`
1199	`029E: BTFSC 42.0`	1199	`029E: BTFSC 42.0`
1200	`029F: BSF 03.7`	1200	`029F: BSF 03.7`
1201	`02A0: MOVF 00,W`	1201	`02A0: MOVF 00,W`
1202	`02A1: MOVWF 48`	1202	`02A1: MOVWF 48`
1203	`.................... }`	1203	`.................... }`
1204	`....................`	1204	`....................`
1205	`.................... // The number is a decimal number`	1205	`.................... // The number is a decimal number`
1206	`.................... if (base == 10)`	1206	`.................... if (base == 10)`
1207	`02A2: MOVF 46,W`	1207	`02A2: MOVF 46,W`
1208	`02A3: SUBLW 0A`	1208	`02A3: SUBLW 0A`
1209	`02A4: BTFSS 03.2`	1209	`02A4: BTFSS 03.2`
1210	`02A5: GOTO 2C9`	1210	`02A5: GOTO 2C9`
1211	`.................... {`	1211	`.................... {`
1212	`.................... while (c >= '0' && c <= '9')`	1212	`.................... while (c >= '0' && c <= '9')`
1213	`.................... {`	1213	`.................... {`
1214	`02A6: MOVF 48,W`	1214	`02A6: MOVF 48,W`
1215	`02A7: SUBLW 2F`	1215	`02A7: SUBLW 2F`
1216	`02A8: BTFSC 03.0`	1216	`02A8: BTFSC 03.0`
1217	`02A9: GOTO 2C8`	1217	`02A9: GOTO 2C8`
1218	`02AA: MOVF 48,W`	1218	`02AA: MOVF 48,W`
1219	`02AB: SUBLW 39`	1219	`02AB: SUBLW 39`
1220	`02AC: BTFSS 03.0`	1220	`02AC: BTFSS 03.0`
1221	`02AD: GOTO 2C8`	1221	`02AD: GOTO 2C8`
1222	`.................... result = 10*result + (c - '0');`	1222	`.................... result = 10*result + (c - '0');`
1223	`02AE: CLRF 4A`	1223	`02AE: CLRF 4A`
1224	`02AF: MOVLW 0A`	1224	`02AF: MOVLW 0A`
1225	`02B0: MOVWF 49`	1225	`02B0: MOVWF 49`
1226	`02B1: MOVF 44,W`	1226	`02B1: MOVF 44,W`
1227	`02B2: MOVWF 4C`	1227	`02B2: MOVWF 4C`
1228	`02B3: MOVF 43,W`	1228	`02B3: MOVF 43,W`
1229	`02B4: MOVWF 4B`	1229	`02B4: MOVWF 4B`
1230	`02B5: GOTO 22C`	1230	`02B5: GOTO 22C`
1231	`02B6: MOVLW 30`	1231	`02B6: MOVLW 30`
1232	`02B7: SUBWF 48,W`	1232	`02B7: SUBWF 48,W`
1233	`02B8: ADDWF 78,W`	1233	`02B8: ADDWF 78,W`
1234	`02B9: MOVWF 43`	1234	`02B9: MOVWF 43`
1235	`02BA: MOVF 79,W`	1235	`02BA: MOVF 79,W`
1236	`02BB: MOVWF 44`	1236	`02BB: MOVWF 44`
1237	`02BC: BTFSC 03.0`	1237	`02BC: BTFSC 03.0`
1238	`02BD: INCF 44,F`	1238	`02BD: INCF 44,F`
1239	`.................... c = s[index++];`	1239	`.................... c = s[index++];`
1240	`02BE: MOVF 47,W`	1240	`02BE: MOVF 47,W`
1241	`02BF: INCF 47,F`	1241	`02BF: INCF 47,F`
1242	`02C0: ADDWF 41,W`	1242	`02C0: ADDWF 41,W`
1243	`02C1: MOVWF 04`	1243	`02C1: MOVWF 04`
1244	`02C2: BCF 03.7`	1244	`02C2: BCF 03.7`
1245	`02C3: BTFSC 42.0`	1245	`02C3: BTFSC 42.0`
1246	`02C4: BSF 03.7`	1246	`02C4: BSF 03.7`
1247	`02C5: MOVF 00,W`	1247	`02C5: MOVF 00,W`
1248	`02C6: MOVWF 48`	1248	`02C6: MOVWF 48`
1249	`.................... }`	1249	`.................... }`
1250	`02C7: GOTO 2A6`	1250	`02C7: GOTO 2A6`
1251	`.................... }`	1251	`.................... }`
1252	`.................... else if (base == 16) // The number is a hexa number`	1252	`.................... else if (base == 16) // The number is a hexa number`
1253	`02C8: GOTO 332`	1253	`02C8: GOTO 332`
1254	`02C9: MOVF 46,W`	1254	`02C9: MOVF 46,W`
1255	`02CA: SUBLW 10`	1255	`02CA: SUBLW 10`
1256	`02CB: BTFSS 03.2`	1256	`02CB: BTFSS 03.2`
1257	`02CC: GOTO 332`	1257	`02CC: GOTO 332`
1258	`.................... {`	1258	`.................... {`
1259	`.................... c = toupper(c);`	1259	`.................... c = toupper(c);`
1260	`02CD: MOVF 48,W`	1260	`02CD: MOVF 48,W`
1261	`02CE: SUBLW 60`	1261	`02CE: SUBLW 60`
1262	`02CF: BTFSC 03.0`	1262	`02CF: BTFSC 03.0`
1263	`02D0: GOTO 2D8`	1263	`02D0: GOTO 2D8`
1264	`02D1: MOVF 48,W`	1264	`02D1: MOVF 48,W`
1265	`02D2: SUBLW 7A`	1265	`02D2: SUBLW 7A`
1266	`02D3: BTFSS 03.0`	1266	`02D3: BTFSS 03.0`
1267	`02D4: GOTO 2D8`	1267	`02D4: GOTO 2D8`
1268	`02D5: MOVF 48,W`	1268	`02D5: MOVF 48,W`
1269	`02D6: ANDLW DF`	1269	`02D6: ANDLW DF`
1270	`02D7: GOTO 2D9`	1270	`02D7: GOTO 2D9`
1271	`02D8: MOVF 48,W`	1271	`02D8: MOVF 48,W`
1272	`02D9: MOVWF 48`	1272	`02D9: MOVWF 48`
1273	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`	1273	`.................... while ( (c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`
1274	`.................... {`	1274	`.................... {`
1275	`02DA: MOVF 48,W`	1275	`02DA: MOVF 48,W`
1276	`02DB: SUBLW 2F`	1276	`02DB: SUBLW 2F`
1277	`02DC: BTFSC 03.0`	1277	`02DC: BTFSC 03.0`
1278	`02DD: GOTO 2E2`	1278	`02DD: GOTO 2E2`
1279	`02DE: MOVF 48,W`	1279	`02DE: MOVF 48,W`
1280	`02DF: SUBLW 39`	1280	`02DF: SUBLW 39`
1281	`02E0: BTFSC 03.0`	1281	`02E0: BTFSC 03.0`
1282	`02E1: GOTO 2EA`	1282	`02E1: GOTO 2EA`
1283	`02E2: MOVF 48,W`	1283	`02E2: MOVF 48,W`
1284	`02E3: SUBLW 40`	1284	`02E3: SUBLW 40`
1285	`02E4: BTFSC 03.0`	1285	`02E4: BTFSC 03.0`
1286	`02E5: GOTO 332`	1286	`02E5: GOTO 332`
1287	`02E6: MOVF 48,W`	1287	`02E6: MOVF 48,W`
1288	`02E7: SUBLW 46`	1288	`02E7: SUBLW 46`
1289	`02E8: BTFSS 03.0`	1289	`02E8: BTFSS 03.0`
1290	`02E9: GOTO 332`	1290	`02E9: GOTO 332`
1291	`.................... if (c >= '0' && c <= '9')`	1291	`.................... if (c >= '0' && c <= '9')`
1292	`02EA: MOVF 48,W`	1292	`02EA: MOVF 48,W`
1293	`02EB: SUBLW 2F`	1293	`02EB: SUBLW 2F`
1294	`02EC: BTFSC 03.0`	1294	`02EC: BTFSC 03.0`
1295	`02ED: GOTO 307`	1295	`02ED: GOTO 307`
1296	`02EE: MOVF 48,W`	1296	`02EE: MOVF 48,W`
1297	`02EF: SUBLW 39`	1297	`02EF: SUBLW 39`
1298	`02F0: BTFSS 03.0`	1298	`02F0: BTFSS 03.0`
1299	`02F1: GOTO 307`	1299	`02F1: GOTO 307`
1300	`.................... result = (result << 4) + (c - '0');`	1300	`.................... result = (result << 4) + (c - '0');`
1301	`02F2: RLF 43,W`	1301	`02F2: RLF 43,W`
1302	`02F3: MOVWF 49`	1302	`02F3: MOVWF 49`
1303	`02F4: RLF 44,W`	1303	`02F4: RLF 44,W`
1304	`02F5: MOVWF 4A`	1304	`02F5: MOVWF 4A`
1305	`02F6: RLF 49,F`	1305	`02F6: RLF 49,F`
1306	`02F7: RLF 4A,F`	1306	`02F7: RLF 4A,F`
1307	`02F8: RLF 49,F`	1307	`02F8: RLF 49,F`
1308	`02F9: RLF 4A,F`	1308	`02F9: RLF 4A,F`
1309	`02FA: RLF 49,F`	1309	`02FA: RLF 49,F`
1310	`02FB: RLF 4A,F`	1310	`02FB: RLF 4A,F`
1311	`02FC: MOVLW F0`	1311	`02FC: MOVLW F0`
1312	`02FD: ANDWF 49,F`	1312	`02FD: ANDWF 49,F`
1313	`02FE: MOVLW 30`	1313	`02FE: MOVLW 30`
1314	`02FF: SUBWF 48,W`	1314	`02FF: SUBWF 48,W`
1315	`0300: ADDWF 49,W`	1315	`0300: ADDWF 49,W`
1316	`0301: MOVWF 43`	1316	`0301: MOVWF 43`
1317	`0302: MOVF 4A,W`	1317	`0302: MOVF 4A,W`
1318	`0303: MOVWF 44`	1318	`0303: MOVWF 44`
1319	`0304: BTFSC 03.0`	1319	`0304: BTFSC 03.0`
1320	`0305: INCF 44,F`	1320	`0305: INCF 44,F`
1321	`.................... else`	1321	`.................... else`
1322	`0306: GOTO 31C`	1322	`0306: GOTO 31C`
1323	`.................... result = (result << 4) + (c - 'A' + 10);`	1323	`.................... result = (result << 4) + (c - 'A' + 10);`
1324	`0307: RLF 43,W`	1324	`0307: RLF 43,W`
1325	`0308: MOVWF 49`	1325	`0308: MOVWF 49`
1326	`0309: RLF 44,W`	1326	`0309: RLF 44,W`
1327	`030A: MOVWF 4A`	1327	`030A: MOVWF 4A`
1328	`030B: RLF 49,F`	1328	`030B: RLF 49,F`
1329	`030C: RLF 4A,F`	1329	`030C: RLF 4A,F`
1330	`030D: RLF 49,F`	1330	`030D: RLF 49,F`
1331	`030E: RLF 4A,F`	1331	`030E: RLF 4A,F`
1332	`030F: RLF 49,F`	1332	`030F: RLF 49,F`
1333	`0310: RLF 4A,F`	1333	`0310: RLF 4A,F`
1334	`0311: MOVLW F0`	1334	`0311: MOVLW F0`
1335	`0312: ANDWF 49,F`	1335	`0312: ANDWF 49,F`
1336	`0313: MOVLW 41`	1336	`0313: MOVLW 41`
1337	`0314: SUBWF 48,W`	1337	`0314: SUBWF 48,W`
1338	`0315: ADDLW 0A`	1338	`0315: ADDLW 0A`
1339	`0316: ADDWF 49,W`	1339	`0316: ADDWF 49,W`
1340	`0317: MOVWF 43`	1340	`0317: MOVWF 43`
1341	`0318: MOVF 4A,W`	1341	`0318: MOVF 4A,W`
1342	`0319: MOVWF 44`	1342	`0319: MOVWF 44`
1343	`031A: BTFSC 03.0`	1343	`031A: BTFSC 03.0`
1344	`031B: INCF 44,F`	1344	`031B: INCF 44,F`
1345	`....................`	1345	`....................`
1346	`.................... c = s[index++];c = toupper(c);`	1346	`.................... c = s[index++];c = toupper(c);`
1347	`031C: MOVF 47,W`	1347	`031C: MOVF 47,W`
1348	`031D: INCF 47,F`	1348	`031D: INCF 47,F`
1349	`031E: ADDWF 41,W`	1349	`031E: ADDWF 41,W`
1350	`031F: MOVWF 04`	1350	`031F: MOVWF 04`
1351	`0320: BCF 03.7`	1351	`0320: BCF 03.7`
1352	`0321: BTFSC 42.0`	1352	`0321: BTFSC 42.0`
1353	`0322: BSF 03.7`	1353	`0322: BSF 03.7`
1354	`0323: MOVF 00,W`	1354	`0323: MOVF 00,W`
1355	`0324: MOVWF 48`	1355	`0324: MOVWF 48`
1356	`0325: SUBLW 60`	1356	`0325: SUBLW 60`
1357	`0326: BTFSC 03.0`	1357	`0326: BTFSC 03.0`
1358	`0327: GOTO 32F`	1358	`0327: GOTO 32F`
1359	`0328: MOVF 48,W`	1359	`0328: MOVF 48,W`
1360	`0329: SUBLW 7A`	1360	`0329: SUBLW 7A`
1361	`032A: BTFSS 03.0`	1361	`032A: BTFSS 03.0`
1362	`032B: GOTO 32F`	1362	`032B: GOTO 32F`
1363	`032C: MOVF 48,W`	1363	`032C: MOVF 48,W`
1364	`032D: ANDLW DF`	1364	`032D: ANDLW DF`
1365	`032E: GOTO 330`	1365	`032E: GOTO 330`
1366	`032F: MOVF 48,W`	1366	`032F: MOVF 48,W`
1367	`0330: MOVWF 48`	1367	`0330: MOVWF 48`
1368	`.................... }`	1368	`.................... }`
1369	`0331: GOTO 2DA`	1369	`0331: GOTO 2DA`
1370	`.................... }`	1370	`.................... }`
1371	`.................... }`	1371	`.................... }`
1372	`....................`	1372	`....................`
1373	`.................... if (base == 10 && sign == 1)`	1373	`.................... if (base == 10 && sign == 1)`
1374	`0332: MOVF 46,W`	1374	`0332: MOVF 46,W`
1375	`0333: SUBLW 0A`	1375	`0333: SUBLW 0A`
1376	`0334: BTFSS 03.2`	1376	`0334: BTFSS 03.2`
1377	`0335: GOTO 33D`	1377	`0335: GOTO 33D`
1378	`0336: DECFSZ 45,W`	1378	`0336: DECFSZ 45,W`
1379	`0337: GOTO 33D`	1379	`0337: GOTO 33D`
1380	`.................... result = -result;`	1380	`.................... result = -result;`
1381	`0338: COMF 43,F`	1381	`0338: COMF 43,F`
1382	`0339: COMF 44,F`	1382	`0339: COMF 44,F`
1383	`033A: INCF 43,F`	1383	`033A: INCF 43,F`
1384	`033B: BTFSC 03.2`	1384	`033B: BTFSC 03.2`
1385	`033C: INCF 44,F`	1385	`033C: INCF 44,F`
1386	`....................`	1386	`....................`
1387	`.................... return(result);`	1387	`.................... return(result);`
1388	`033D: MOVF 43,W`	1388	`033D: MOVF 43,W`
1389	`033E: MOVWF 78`	1389	`033E: MOVWF 78`
1390	`033F: MOVF 44,W`	1390	`033F: MOVF 44,W`
1391	`0340: MOVWF 79`	1391	`0340: MOVWF 79`
1392	`.................... }`	1392	`.................... }`
1393	`0341: RETLW 00`	1393	`0341: RETLW 00`
1394	`....................`	1394	`....................`
1395	`.................... /* A fast routine to multiply by 10`	1395	`.................... /* A fast routine to multiply by 10`
1396	`.................... */`	1396	`.................... */`
1397	`.................... signed int32 mult_with10(int32 num)`	1397	`.................... signed int32 mult_with10(int32 num)`
1398	`.................... {`	1398	`.................... {`
1399	`.................... return ( (num << 1) + (num << 3) );`	1399	`.................... return ( (num << 1) + (num << 3) );`
1400	`.................... }`	1400	`.................... }`
1401	`....................`	1401	`....................`
1402	`.................... signed int32 atoi32(char *s)`	1402	`.................... signed int32 atoi32(char *s)`
1403	`.................... {`	1403	`.................... {`
1404	`.................... signed int32 result;`	1404	`.................... signed int32 result;`
1405	`.................... int sign, base, index;`	1405	`.................... int sign, base, index;`
1406	`.................... char c;`	1406	`.................... char c;`
1407	`....................`	1407	`....................`
1408	`.................... index = 0;`	1408	`.................... index = 0;`
1409	`.................... sign = 0;`	1409	`.................... sign = 0;`
1410	`.................... base = 10;`	1410	`.................... base = 10;`
1411	`.................... result = 0;`	1411	`.................... result = 0;`
1412	`....................`	1412	`....................`
1413	`.................... if (!s)`	1413	`.................... if (!s)`
1414	`.................... return 0;`	1414	`.................... return 0;`
1415	`.................... c = s[index++];`	1415	`.................... c = s[index++];`
1416	`....................`	1416	`....................`
1417	`.................... // increase index if either positive or negative sign is detected`	1417	`.................... // increase index if either positive or negative sign is detected`
1418	`.................... if (c == '-')`	1418	`.................... if (c == '-')`
1419	`.................... {`	1419	`.................... {`
1420	`.................... sign = 1; // Set the sign to negative`	1420	`.................... sign = 1; // Set the sign to negative`
1421	`.................... c = s[index++];`	1421	`.................... c = s[index++];`
1422	`.................... }`	1422	`.................... }`
1423	`.................... else if (c == '+')`	1423	`.................... else if (c == '+')`
1424	`.................... {`	1424	`.................... {`
1425	`.................... c = s[index++];`	1425	`.................... c = s[index++];`
1426	`.................... }`	1426	`.................... }`
1427	`....................`	1427	`....................`
1428	`.................... if (c >= '0' && c <= '9')`	1428	`.................... if (c >= '0' && c <= '9')`
1429	`.................... {`	1429	`.................... {`
1430	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`	1430	`.................... if (c == '0' && (s[index] == 'x' \|\| s[index] == 'X'))`
1431	`.................... {`	1431	`.................... {`
1432	`.................... base = 16;`	1432	`.................... base = 16;`
1433	`.................... index++;`	1433	`.................... index++;`
1434	`.................... c = s[index++];`	1434	`.................... c = s[index++];`
1435	`.................... }`	1435	`.................... }`
1436	`....................`	1436	`....................`
1437	`.................... // The number is a decimal number`	1437	`.................... // The number is a decimal number`
1438	`.................... if (base == 10)`	1438	`.................... if (base == 10)`
1439	`.................... {`	1439	`.................... {`
1440	`.................... while (c >= '0' && c <= '9') {`	1440	`.................... while (c >= '0' && c <= '9') {`
1441	`.................... result = (result << 1) + (result << 3); // result *= 10;`	1441	`.................... result = (result << 1) + (result << 3); // result *= 10;`
1442	`.................... result += (c - '0');`	1442	`.................... result += (c - '0');`
1443	`.................... c = s[index++];`	1443	`.................... c = s[index++];`
1444	`.................... }`	1444	`.................... }`
1445	`.................... }`	1445	`.................... }`
1446	`.................... else if (base == 16) // The number is a hexa number`	1446	`.................... else if (base == 16) // The number is a hexa number`
1447	`.................... {`	1447	`.................... {`
1448	`.................... c = toupper(c);`	1448	`.................... c = toupper(c);`
1449	`.................... while ((c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`	1449	`.................... while ((c >= '0' && c <= '9') \|\| (c >= 'A' && c <='F'))`
1450	`.................... {`	1450	`.................... {`
1451	`.................... if (c >= '0' && c <= '9')`	1451	`.................... if (c >= '0' && c <= '9')`
1452	`.................... result = (result << 4) + (c - '0');`	1452	`.................... result = (result << 4) + (c - '0');`
1453	`.................... else`	1453	`.................... else`
1454	`.................... result = (result << 4) + (c - 'A' + 10);`	1454	`.................... result = (result << 4) + (c - 'A' + 10);`
1455	`....................`	1455	`....................`
1456	`.................... c = s[index++];c = toupper(c);`	1456	`.................... c = s[index++];c = toupper(c);`
1457	`.................... }`	1457	`.................... }`
1458	`.................... }`	1458	`.................... }`
1459	`.................... }`	1459	`.................... }`
1460	`....................`	1460	`....................`
1461	`.................... if (base == 10 && sign == 1)`	1461	`.................... if (base == 10 && sign == 1)`
1462	`.................... result = -result;`	1462	`.................... result = -result;`
1463	`....................`	1463	`....................`
1464	`.................... return(result);`	1464	`.................... return(result);`
1465	`.................... }`	1465	`.................... }`
1466	`....................`	1466	`....................`
1467	`.................... float strtod(char s,char endptr) {`	1467	`.................... float strtod(char s,char endptr) {`
1468	`.................... float pow10 = 1.0;`	1468	`.................... float pow10 = 1.0;`
1469	`.................... float result = 0.0;`	1469	`.................... float result = 0.0;`
1470	`.................... int sign = 0, point = 0;`	1470	`.................... int sign = 0, point = 0;`
1471	`.................... char c;`	1471	`.................... char c;`
1472	`.................... int ptr = 0;`	1472	`.................... int ptr = 0;`
1473	`....................`	1473	`....................`
1474	`.................... if (!s)`	1474	`.................... if (!s)`
1475	`.................... return 0;`	1475	`.................... return 0;`
1476	`.................... c=s[ptr++];`	1476	`.................... c=s[ptr++];`
1477	`....................`	1477	`....................`
1478	`....................`	1478	`....................`
1479	`.................... while((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`	1479	`.................... while((c>='0' && c<='9') \|\| c=='+' \|\| c=='-' \|\| c=='.') {`
1480	`.................... if(c == '-') {`	1480	`.................... if(c == '-') {`
1481	`.................... sign = 1;`	1481	`.................... sign = 1;`
1482	`.................... c = s[ptr++];`	1482	`.................... c = s[ptr++];`
1483	`.................... }`	1483	`.................... }`
1484	`....................`	1484	`....................`
1485	`.................... while((c >= '0' && c <= '9') && point == 0) {`	1485	`.................... while((c >= '0' && c <= '9') && point == 0) {`
1486	`.................... result = 10*result + c - '0';`	1486	`.................... result = 10*result + c - '0';`
1487	`.................... c = s[ptr++];`	1487	`.................... c = s[ptr++];`
1488	`.................... }`	1488	`.................... }`
1489	`....................`	1489	`....................`
1490	`.................... if (c == '.') {`	1490	`.................... if (c == '.') {`
1491	`.................... point = 1;`	1491	`.................... point = 1;`
1492	`.................... c = s[ptr++];`	1492	`.................... c = s[ptr++];`
1493	`.................... }`	1493	`.................... }`
1494	`....................`	1494	`....................`
1495	`.................... while((c >= '0' && c <= '9') && point == 1) {`	1495	`.................... while((c >= '0' && c <= '9') && point == 1) {`
1496	`.................... pow10 = pow10*10;`	1496	`.................... pow10 = pow10*10;`
1497	`.................... result += (c - '0')/pow10;`	1497	`.................... result += (c - '0')/pow10;`
1498	`.................... c = s[ptr++];`	1498	`.................... c = s[ptr++];`
1499	`.................... }`	1499	`.................... }`
1500	`....................`	1500	`....................`
1501	`.................... if (c == '+') {`	1501	`.................... if (c == '+') {`
1502	`.................... c = s[ptr++];`	1502	`.................... c = s[ptr++];`
1503	`.................... }`	1503	`.................... }`
1504	`.................... }`	1504	`.................... }`
1505	`....................`	1505	`....................`
1506	`.................... if (sign == 1)`	1506	`.................... if (sign == 1)`
1507	`.................... result = -1*result;`	1507	`.................... result = -1*result;`
1508	`.................... if(endptr)`	1508	`.................... if(endptr)`
1509	`.................... {`	1509	`.................... {`
1510	`.................... if (ptr) {`	1510	`.................... if (ptr) {`
1511	`.................... ptr--;`	1511	`.................... ptr--;`
1512	`.................... ((char )endptr)=s+ptr;`	1512	`.................... ((char )endptr)=s+ptr;`
1513	`.................... }`	1513	`.................... }`
1514	`.................... else`	1514	`.................... else`
1515	`.................... ((char )endptr)=s;`	1515	`.................... ((char )endptr)=s;`
1516	`.................... }`	1516	`.................... }`
1517	`....................`	1517	`....................`
1518	`.................... return(result);`	1518	`.................... return(result);`
1519	`.................... }`	1519	`.................... }`
1520	`....................`	1520	`....................`
1521	`.................... long strtoul(char s,char endptr,signed int base)`	1521	`.................... long strtoul(char s,char endptr,signed int base)`
1522	`.................... {`	1522	`.................... {`
1523	`.................... char sc,s1,*sd;`	1523	`.................... char sc,s1,*sd;`
1524	`.................... unsigned long x=0;`	1524	`.................... unsigned long x=0;`
1525	`.................... char sign;`	1525	`.................... char sign;`
1526	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`	1526	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`
1527	`.................... for(sc=s;isspace(*sc);++sc);`	1527	`.................... for(sc=s;isspace(*sc);++sc);`
1528	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`	1528	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`
1529	`.................... if(sign=='-')`	1529	`.................... if(sign=='-')`
1530	`.................... {`	1530	`.................... {`
1531	`.................... if (endptr)`	1531	`.................... if (endptr)`
1532	`.................... {`	1532	`.................... {`
1533	`.................... ((char )endptr)=s;`	1533	`.................... ((char )endptr)=s;`
1534	`.................... }`	1534	`.................... }`
1535	`.................... return 0;`	1535	`.................... return 0;`
1536	`.................... }`	1536	`.................... }`
1537	`....................`	1537	`....................`
1538	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`	1538	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`
1539	`.................... {`	1539	`.................... {`
1540	`.................... if (endptr)`	1540	`.................... if (endptr)`
1541	`.................... {`	1541	`.................... {`
1542	`.................... ((char )endptr)=s;`	1542	`.................... ((char )endptr)=s;`
1543	`.................... }`	1543	`.................... }`
1544	`.................... return 0;`	1544	`.................... return 0;`
1545	`.................... }`	1545	`.................... }`
1546	`.................... else if (base)`	1546	`.................... else if (base)`
1547	`.................... {`	1547	`.................... {`
1548	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`	1548	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`
1549	`.................... sc+=2;`	1549	`.................... sc+=2;`
1550	`.................... if(base==8 && *sc =='0')`	1550	`.................... if(base==8 && *sc =='0')`
1551	`.................... sc+=1;`	1551	`.................... sc+=1;`
1552	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`	1552	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`
1553	`.................... sc+=2;`	1553	`.................... sc+=2;`
1554	`....................`	1554	`....................`
1555	`.................... }`	1555	`.................... }`
1556	`.................... else if(*sc!='0') // base is 0, find base`	1556	`.................... else if(*sc!='0') // base is 0, find base`
1557	`.................... base=10;`	1557	`.................... base=10;`
1558	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`	1558	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`
1559	`.................... base =16,sc+=2;`	1559	`.................... base =16,sc+=2;`
1560	`.................... else if(sc[1]=='b')`	1560	`.................... else if(sc[1]=='b')`
1561	`.................... base=2,sc+=2;`	1561	`.................... base=2,sc+=2;`
1562	`.................... else`	1562	`.................... else`
1563	`.................... base=8;`	1563	`.................... base=8;`
1564	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`	1564	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`
1565	`.................... sd=memchr(digits,tolower(*sc),base);`	1565	`.................... sd=memchr(digits,tolower(*sc),base);`
1566	`.................... for(; sd!=0; )`	1566	`.................... for(; sd!=0; )`
1567	`.................... {`	1567	`.................... {`
1568	`.................... x=x*base+(int16)(sd-digits);`	1568	`.................... x=x*base+(int16)(sd-digits);`
1569	`.................... ++sc;`	1569	`.................... ++sc;`
1570	`.................... sd=memchr(digits,tolower(*sc),base);`	1570	`.................... sd=memchr(digits,tolower(*sc),base);`
1571	`.................... }`	1571	`.................... }`
1572	`.................... if(s1==sc)`	1572	`.................... if(s1==sc)`
1573	`.................... {`	1573	`.................... {`
1574	`.................... if (endptr)`	1574	`.................... if (endptr)`
1575	`.................... {`	1575	`.................... {`
1576	`.................... ((char )endptr)=s;`	1576	`.................... ((char )endptr)=s;`
1577	`.................... }`	1577	`.................... }`
1578	`.................... return 0;`	1578	`.................... return 0;`
1579	`.................... }`	1579	`.................... }`
1580	`.................... if (endptr)`	1580	`.................... if (endptr)`
1581	`.................... ((char )endptr)=sc;`	1581	`.................... ((char )endptr)=sc;`
1582	`.................... return x;`	1582	`.................... return x;`
1583	`.................... }`	1583	`.................... }`
1584	`....................`	1584	`....................`
1585	`....................`	1585	`....................`
1586	`.................... signed long strtol(char s,char endptr,signed int base)`	1586	`.................... signed long strtol(char s,char endptr,signed int base)`
1587	`.................... {`	1587	`.................... {`
1588	`.................... char sc,s1,*sd;`	1588	`.................... char sc,s1,*sd;`
1589	`.................... signed long x=0;`	1589	`.................... signed long x=0;`
1590	`.................... char sign;`	1590	`.................... char sign;`
1591	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`	1591	`.................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz";`
1592	`.................... for(sc=s;isspace(*sc);++sc);`	1592	`.................... for(sc=s;isspace(*sc);++sc);`
1593	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`	1593	`.................... sign=sc=='-'\|\|sc=='+'?sc++:'+';`
1594	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`	1594	`.................... if (base <0 \|\| base ==1\|\| base >36) // invalid base`
1595	`.................... {`	1595	`.................... {`
1596	`.................... if (endptr)`	1596	`.................... if (endptr)`
1597	`.................... {`	1597	`.................... {`
1598	`.................... ((char )endptr)=s;`	1598	`.................... ((char )endptr)=s;`
1599	`.................... }`	1599	`.................... }`
1600	`.................... return 0;`	1600	`.................... return 0;`
1601	`.................... }`	1601	`.................... }`
1602	`.................... else if (base)`	1602	`.................... else if (base)`
1603	`.................... {`	1603	`.................... {`
1604	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`	1604	`.................... if(base==16 && *sc =='0'&&(sc[1]=='x' \|\| sc[1]=='X'))`
1605	`.................... sc+=2;`	1605	`.................... sc+=2;`
1606	`.................... if(base==8 && *sc =='0')`	1606	`.................... if(base==8 && *sc =='0')`
1607	`.................... sc+=1;`	1607	`.................... sc+=1;`
1608	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`	1608	`.................... if(base==2 && *sc =='0'&&sc[1]=='b')`
1609	`.................... sc+=2;`	1609	`.................... sc+=2;`
1610	`....................`	1610	`....................`
1611	`.................... }`	1611	`.................... }`
1612	`.................... else if(*sc!='0') // base is 0, find base`	1612	`.................... else if(*sc!='0') // base is 0, find base`
1613	`.................... base=10;`	1613	`.................... base=10;`
1614	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`	1614	`.................... else if (sc[1]=='x' \|\| sc[1]=='X')`
1615	`.................... base =16,sc+=2;`	1615	`.................... base =16,sc+=2;`
1616	`.................... else if(sc[1]=='b')`	1616	`.................... else if(sc[1]=='b')`
1617	`.................... base=2,sc+=2;`	1617	`.................... base=2,sc+=2;`
1618	`.................... else`	1618	`.................... else`
1619	`.................... base=8;`	1619	`.................... base=8;`
1620	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`	1620	`.................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes`
1621	`....................`	1621	`....................`
1622	`.................... sd=memchr(digits,tolower(*sc),base);`	1622	`.................... sd=memchr(digits,tolower(*sc),base);`
1623	`.................... for(;sd!=0;)`	1623	`.................... for(;sd!=0;)`
1624	`.................... {`	1624	`.................... {`
1625	`.................... x=x*base+(int16)(sd-digits);`	1625	`.................... x=x*base+(int16)(sd-digits);`
1626	`.................... ++sc;`	1626	`.................... ++sc;`
1627	`.................... sd=memchr(digits,tolower(*sc),base);`	1627	`.................... sd=memchr(digits,tolower(*sc),base);`
1628	`.................... }`	1628	`.................... }`
1629	`.................... if(s1==sc)`	1629	`.................... if(s1==sc)`
1630	`.................... {`	1630	`.................... {`
1631	`.................... if (endptr)`	1631	`.................... if (endptr)`
1632	`.................... {`	1632	`.................... {`
1633	`.................... ((char )endptr)=s;`	1633	`.................... ((char )endptr)=s;`
1634	`.................... }`	1634	`.................... }`
1635	`.................... return 0;`	1635	`.................... return 0;`
1636	`.................... }`	1636	`.................... }`
1637	`.................... if(sign=='-')`	1637	`.................... if(sign=='-')`
1638	`.................... x =-x;`	1638	`.................... x =-x;`
1639	`.................... if (endptr)`	1639	`.................... if (endptr)`
1640	`.................... ((char )endptr)=sc;`	1640	`.................... ((char )endptr)=sc;`
1641	`.................... return x;`	1641	`.................... return x;`
1642	`.................... }`	1642	`.................... }`
1643	`....................`	1643	`....................`
1644	`.................... signed int system(char *string)`	1644	`.................... signed int system(char *string)`
1645	`.................... {`	1645	`.................... {`
1646	`.................... return 0;`	1646	`.................... return 0;`
1647	`.................... }`	1647	`.................... }`
1648	`....................`	1648	`....................`
1649	`.................... int mblen(char *s,size_t n)`	1649	`.................... int mblen(char *s,size_t n)`
1650	`.................... {`	1650	`.................... {`
1651	`.................... return strlen(s);`	1651	`.................... return strlen(s);`
1652	`.................... }`	1652	`.................... }`
1653	`....................`	1653	`....................`
1654	`.................... int mbtowc(wchar_t pwc,char s,size_t n)`	1654	`.................... int mbtowc(wchar_t pwc,char s,size_t n)`
1655	`.................... {`	1655	`.................... {`
1656	`.................... pwc=s;`	1656	`.................... pwc=s;`
1657	`.................... return 1;`	1657	`.................... return 1;`
1658	`.................... }`	1658	`.................... }`
1659	`....................`	1659	`....................`
1660	`.................... int wctomb(char *s,wchar_t wchar)`	1660	`.................... int wctomb(char *s,wchar_t wchar)`
1661	`.................... {`	1661	`.................... {`
1662	`.................... *s=wchar;`	1662	`.................... *s=wchar;`
1663	`.................... return 1;`	1663	`.................... return 1;`
1664	`.................... }`	1664	`.................... }`
1665	`....................`	1665	`....................`
1666	`.................... size_t mbstowcs(wchar_t pwcs,char s,size_t n)`	1666	`.................... size_t mbstowcs(wchar_t pwcs,char s,size_t n)`
1667	`.................... {`	1667	`.................... {`
1668	`.................... strncpy(pwcs,s,n);`	1668	`.................... strncpy(pwcs,s,n);`
1669	`.................... return strlen(pwcs);`	1669	`.................... return strlen(pwcs);`
1670	`.................... }`	1670	`.................... }`
1671	`....................`	1671	`....................`
1672	`.................... size_t wcstombs(char s,wchar_t pwcs,size_t n)`	1672	`.................... size_t wcstombs(char s,wchar_t pwcs,size_t n)`
1673	`.................... {`	1673	`.................... {`
1674	`.................... strncpy(s,pwcs,n);`	1674	`.................... strncpy(s,pwcs,n);`
1675	`.................... return strlen(s);`	1675	`.................... return strlen(s);`
1676	`.................... }`	1676	`.................... }`
1677	`....................`	1677	`....................`
1678	`.................... //---------------------------------------------------------------------------`	1678	`.................... //---------------------------------------------------------------------------`
1679	`.................... // The random number implementation`	1679	`.................... // The random number implementation`
1680	`.................... //---------------------------------------------------------------------------`	1680	`.................... //---------------------------------------------------------------------------`
1681	`....................`	1681	`....................`
1682	`.................... unsigned int32 _Randseed = 1;`	1682	`.................... unsigned int32 _Randseed = 1;`
1683	`*`	1683	`*`
1684	`035B: MOVLW 01`	1684	`035B: MOVLW 01`
1685	`035C: MOVWF 2B`	1685	`035C: MOVWF 2B`
1686	`035D: CLRF 2C`	1686	`035D: CLRF 2C`
1687	`035E: CLRF 2D`	1687	`035E: CLRF 2D`
1688	`035F: CLRF 2E`	1688	`035F: CLRF 2E`
1689	`....................`	1689	`....................`
1690	`.................... long rand(void)`	1690	`.................... long rand(void)`
1691	`.................... {`	1691	`.................... {`
1692	`.................... _Randseed = _Randseed * 1103515245 + 12345;`	1692	`.................... _Randseed = _Randseed * 1103515245 + 12345;`
1693	`.................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX);`	1693	`.................... return ((unsigned long)(_Randseed >> 16) % RAND_MAX);`
1694	`.................... }`	1694	`.................... }`
1695	`....................`	1695	`....................`
1696	`.................... void srand(unsigned int32 seed)`	1696	`.................... void srand(unsigned int32 seed)`
1697	`.................... {`	1697	`.................... {`
1698	`.................... _Randseed = seed;`	1698	`.................... _Randseed = seed;`
1699	`.................... }`	1699	`.................... }`
1700	`....................`	1700	`....................`
1701	`.................... //---------------------------------------------------------------------------`	1701	`.................... //---------------------------------------------------------------------------`
1702	`.................... // Searching and sorting utilities implementation`	1702	`.................... // Searching and sorting utilities implementation`
1703	`.................... //---------------------------------------------------------------------------`	1703	`.................... //---------------------------------------------------------------------------`
1704	`....................`	1704	`....................`
1705	`.................... typedef signed int (_Cmpfun)(char p1,char * p2);`	1705	`.................... typedef signed int (_Cmpfun)(char p1,char * p2);`
1706	`....................`	1706	`....................`
1707	`.................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) {`	1707	`.................... void qsort(char * qdata, int qitems, int qsize, _Cmpfun cmp) {`
1708	`.................... int m,j,i,l;`	1708	`.................... int m,j,i,l;`
1709	`.................... short done;`	1709	`.................... short done;`
1710	`.................... BYTE t[16];`	1710	`.................... BYTE t[16];`
1711	`....................`	1711	`....................`
1712	`.................... m = qitems/2;`	1712	`.................... m = qitems/2;`
1713	`.................... while( m > 0 ) {`	1713	`.................... while( m > 0 ) {`
1714	`.................... for(j=0; j<(qitems-m); ++j) {`	1714	`.................... for(j=0; j<(qitems-m); ++j) {`
1715	`.................... i = j;`	1715	`.................... i = j;`
1716	`.................... do`	1716	`.................... do`
1717	`.................... {`	1717	`.................... {`
1718	`.................... done=TRUE;`	1718	`.................... done=TRUE;`
1719	`.................... l = i+m;`	1719	`.................... l = i+m;`
1720	`.................... if( (cmp)(qdata+iqsize, qdata+l*qsize) > 0 ) {`	1720	`.................... if( (cmp)(qdata+iqsize, qdata+l*qsize) > 0 ) {`
1721	`.................... memcpy(t, qdata+i*qsize, qsize);`	1721	`.................... memcpy(t, qdata+i*qsize, qsize);`
1722	`.................... memcpy(qdata+iqsize, qdata+lqsize, qsize);`	1722	`.................... memcpy(qdata+iqsize, qdata+lqsize, qsize);`
1723	`.................... memcpy(qdata+l*qsize, t, qsize);`	1723	`.................... memcpy(qdata+l*qsize, t, qsize);`
1724	`.................... if(m <= i)`	1724	`.................... if(m <= i)`
1725	`.................... i -= m;`	1725	`.................... i -= m;`
1726	`.................... done = FALSE;`	1726	`.................... done = FALSE;`
1727	`.................... }`	1727	`.................... }`
1728	`.................... } while(!done);`	1728	`.................... } while(!done);`
1729	`.................... }`	1729	`.................... }`
1730	`.................... m = m/2;`	1730	`.................... m = m/2;`
1731	`.................... }`	1731	`.................... }`
1732	`.................... }`	1732	`.................... }`
1733	`....................`	1733	`....................`
1734	`....................`	1734	`....................`
1735	`.................... char bsearch(char key, char *base, size_t num, size_t width,_Cmpfun cmp)`	1735	`.................... char bsearch(char key, char *base, size_t num, size_t width,_Cmpfun cmp)`
1736	`.................... {`	1736	`.................... {`
1737	`.................... char p, q;`	1737	`.................... char p, q;`
1738	`.................... size_t n;`	1738	`.................... size_t n;`
1739	`.................... size_t pivot;`	1739	`.................... size_t pivot;`
1740	`.................... signed int val;`	1740	`.................... signed int val;`
1741	`....................`	1741	`....................`
1742	`.................... p = base;`	1742	`.................... p = base;`
1743	`.................... n = num;`	1743	`.................... n = num;`
1744	`....................`	1744	`....................`
1745	`.................... while (n > 0)`	1745	`.................... while (n > 0)`
1746	`.................... {`	1746	`.................... {`
1747	`.................... pivot = n >> 1;`	1747	`.................... pivot = n >> 1;`
1748	`.................... q = p + width * pivot;`	1748	`.................... q = p + width * pivot;`
1749	`....................`	1749	`....................`
1750	`.................... val = (*cmp)(key, q);`	1750	`.................... val = (*cmp)(key, q);`
1751	`....................`	1751	`....................`
1752	`.................... if (val < 0)`	1752	`.................... if (val < 0)`
1753	`.................... n = pivot;`	1753	`.................... n = pivot;`
1754	`.................... else if (val == 0)`	1754	`.................... else if (val == 0)`
1755	`.................... return ((char *)q);`	1755	`.................... return ((char *)q);`
1756	`.................... else {`	1756	`.................... else {`
1757	`.................... p = q + width;`	1757	`.................... p = q + width;`
1758	`.................... n -= pivot + 1;`	1758	`.................... n -= pivot + 1;`
1759	`.................... }`	1759	`.................... }`
1760	`.................... }`	1760	`.................... }`
1761	`....................`	1761	`....................`
1762	`.................... return NULL; // There's no match`	1762	`.................... return NULL; // There's no match`
1763	`.................... }`	1763	`.................... }`
1764	`....................`	1764	`....................`
1765	`....................`	1765	`....................`
1766	`.................... #endif`	1766	`.................... #endif`
1767	`....................`	1767	`....................`
1768	`....................`	1768	`....................`
1769	`.................... #define SYNC PIN_B4 // Spousteni oscyloskopu`	1769	`.................... #define SYNC PIN_B4 // Spousteni oscyloskopu`
1770	`.................... #define HACK PIN_B5 // Zkratovani napajeni SmartCard`	1770	`.................... #define HACK PIN_B5 // Zkratovani napajeni SmartCard`
1771	`.................... #define CLOCK PIN_B6 // Hodiny ze SmartCard`	1771	`.................... #define CLOCK PIN_B6 // Hodiny ze SmartCard`
1772	`....................`	1772	`....................`
1773	`.................... #int_TIMER1`	1773	`.................... #int_TIMER1`
1774	`.................... TIMER1_isr()`	1774	`.................... TIMER1_isr()`
1775	`.................... {`	1775	`.................... {`
1776	`....................`	1776	`....................`
1777	`.................... }`	1777	`.................... }`
1778	`....................`	1778	`....................`
1779	`*`	1779	`*`
1780	`00E0: BCF 0C.0`	1780	`00E0: BCF 0C.0`
1781	`00E1: BCF 0A.3`	1781	`00E1: BCF 0A.3`
1782	`00E2: GOTO 028`	1782	`00E2: GOTO 028`
1783	`.................... #int_TIMER2`	1783	`.................... #int_TIMER2`
1784	`.................... TIMER2_isr()`	1784	`.................... TIMER2_isr()`
1785	`.................... {`	1785	`.................... {`
1786	`....................`	1786	`....................`
1787	`.................... }`	1787	`.................... }`
1788	`....................`	1788	`....................`
1789	`00E3: BCF 0C.1`	1789	`00E3: BCF 0C.1`
1790	`00E4: BCF 0A.3`	1790	`00E4: BCF 0A.3`
1791	`00E5: GOTO 028`	1791	`00E5: GOTO 028`
1792	`.................... void main()`	1792	`.................... void main()`
1793	`.................... {`	1793	`.................... {`
1794	`*`	1794	`*`
1795	`0342: CLRF 04`	1795	`0342: CLRF 04`
1796	`0343: BCF 03.7`	1796	`0343: BCF 03.7`
1797	`0344: MOVLW 1F`	1797	`0344: MOVLW 1F`
1798	`0345: ANDWF 03,F`	1798	`0345: ANDWF 03,F`
1799	`0346: BSF 03.5`	1799	`0346: BSF 03.5`
1800	`0347: BCF 1F.4`	1800	`0347: BCF 1F.4`
1801	`0348: BCF 1F.5`	1801	`0348: BCF 1F.5`
1802	`0349: MOVF 1B,W`	1802	`0349: MOVF 1B,W`
1803	`034A: ANDLW 80`	1803	`034A: ANDLW 80`
1804	`034B: MOVWF 1B`	1804	`034B: MOVWF 1B`
1805	`034C: MOVLW 07`	1805	`034C: MOVLW 07`
1806	`034D: MOVWF 1C`	1806	`034D: MOVWF 1C`
1807	`034E: MOVF 05,W`	1807	`034E: MOVF 05,W`
1808	`034F: CLRWDT`	1808	`034F: CLRWDT`
1809	`0350: MOVF 1C,W`	1809	`0350: MOVF 1C,W`
1810	`0351: BCF 03.5`	1810	`0351: BCF 03.5`
1811	`0352: BCF 0D.6`	1811	`0352: BCF 0D.6`
1812	`0353: MOVLW 60`	1812	`0353: MOVLW 60`
1813	`0354: BSF 03.5`	1813	`0354: BSF 03.5`
1814	`0355: MOVWF 0F`	1814	`0355: MOVWF 0F`
1815	`0356: BCF 06.3`	1815	`0356: BCF 06.3`
1816	`0357: BCF 03.5`	1816	`0357: BCF 03.5`
1817	`0358: BSF 06.3`	1817	`0358: BSF 06.3`
1818	`.................... unsigned int16 i;`	1818	`.................... unsigned int16 i;`
1819	`.................... char ch;`	1819	`.................... char ch;`
1820	`.................... char string[10];`	1820	`.................... char string[10];`
1821	`.................... const char ver[]={"HACK v1.0\0"};`	1821	`.................... const char ver[]={"HACK v1.0\0"};`
1822	`.................... unsigned int16 prescale;`	1822	`.................... unsigned int16 prescale;`
1823	`.................... unsigned int16 ticks;`	1823	`.................... unsigned int16 ticks;`
1824	`.................... int n;`	1824	`.................... int n;`
1825	`....................`	1825	`....................`
1826	`.................... setup_adc_ports(NO_ANALOGS\|VSS_VDD);`	1826	`.................... setup_adc_ports(NO_ANALOGS\|VSS_VDD);`
1827	`*`	1827	`*`
1828	`0360: BSF 03.5`	1828	`0360: BSF 03.5`
1829	`0361: BCF 1F.4`	1829	`0361: BCF 1F.4`
1830	`0362: BCF 1F.5`	1830	`0362: BCF 1F.5`
1831	`0363: MOVF 1B,W`	1831	`0363: MOVF 1B,W`
1832	`0364: ANDLW 80`	1832	`0364: ANDLW 80`
1833	`0365: MOVWF 1B`	1833	`0365: MOVWF 1B`
1834	`.................... setup_adc(ADC_OFF);`	1834	`.................... setup_adc(ADC_OFF);`
1835	`0366: BCF 03.5`	1835	`0366: BCF 03.5`
1836	`0367: BCF 1F.0`	1836	`0367: BCF 1F.0`
1837	`.................... setup_spi(FALSE);`	1837	`.................... setup_spi(FALSE);`
1838	`0368: BCF 14.5`	1838	`0368: BCF 14.5`
1839	`0369: BSF 03.5`	1839	`0369: BSF 03.5`
1840	`036A: BCF 06.2`	1840	`036A: BCF 06.2`
1841	`036B: BSF 06.1`	1841	`036B: BSF 06.1`
1842	`036C: BCF 06.4`	1842	`036C: BCF 06.4`
1843	`036D: MOVLW 00`	1843	`036D: MOVLW 00`
1844	`036E: BCF 03.5`	1844	`036E: BCF 03.5`
1845	`036F: MOVWF 14`	1845	`036F: MOVWF 14`
1846	`0370: BSF 03.5`	1846	`0370: BSF 03.5`
1847	`0371: MOVWF 14`	1847	`0371: MOVWF 14`
1848	`.................... setup_timer_0(RTCC_EXT_L_TO_H\|RTCC_DIV_1);`	1848	`.................... setup_timer_0(RTCC_EXT_L_TO_H\|RTCC_DIV_1);`
1849	`0372: MOVF 01,W`	1849	`0372: MOVF 01,W`
1850	`0373: ANDLW C7`	1850	`0373: ANDLW C7`
1851	`0374: IORLW 28`	1851	`0374: IORLW 28`
1852	`0375: MOVWF 01`	1852	`0375: MOVWF 01`
1853	`.................... setup_timer_1(T1_EXTERNAL\|T1_DIV_BY_1);`	1853	`.................... setup_timer_1(T1_EXTERNAL\|T1_DIV_BY_1);`
1854	`0376: MOVLW 87`	1854	`0376: MOVLW 87`
1855	`0377: BCF 03.5`	1855	`0377: BCF 03.5`
1856	`0378: MOVWF 10`	1856	`0378: MOVWF 10`
1857	`.................... // setup_timer_1(T1_INTERNAL\|T1_DIV_BY_8);`	1857	`.................... // setup_timer_1(T1_INTERNAL\|T1_DIV_BY_8);`
1858	`.................... setup_timer_2(T2_DISABLED,0,1);`	1858	`.................... setup_timer_2(T2_DISABLED,0,1);`
1859	`0379: MOVLW 00`	1859	`0379: MOVLW 00`
1860	`037A: MOVWF 78`	1860	`037A: MOVWF 78`
1861	`037B: MOVWF 12`	1861	`037B: MOVWF 12`
1862	`037C: MOVLW 00`	1862	`037C: MOVLW 00`
1863	`037D: BSF 03.5`	1863	`037D: BSF 03.5`
1864	`037E: MOVWF 12`	1864	`037E: MOVWF 12`
1865	`.................... setup_comparator(NC_NC_NC_NC);`	1865	`.................... setup_comparator(NC_NC_NC_NC);`
1866	`037F: MOVLW 07`	1866	`037F: MOVLW 07`
1867	`0380: MOVWF 1C`	1867	`0380: MOVWF 1C`
1868	`0381: MOVF 05,W`	1868	`0381: MOVF 05,W`
1869	`0382: CLRWDT`	1869	`0382: CLRWDT`
1870	`0383: MOVLW 02`	1870	`0383: MOVLW 02`
1871	`0384: MOVWF 77`	1871	`0384: MOVWF 77`
1872	`0385: DECFSZ 77,F`	1872	`0385: DECFSZ 77,F`
1873	`0386: GOTO 385`	1873	`0386: GOTO 385`
1874	`0387: NOP`	1874	`0387: NOP`
1875	`0388: NOP`	1875	`0388: NOP`
1876	`0389: MOVF 1C,W`	1876	`0389: MOVF 1C,W`
1877	`038A: BCF 03.5`	1877	`038A: BCF 03.5`
1878	`038B: BCF 0D.6`	1878	`038B: BCF 0D.6`
1879	`.................... setup_vref(FALSE);`	1879	`.................... setup_vref(FALSE);`
1880	`038C: BSF 03.5`	1880	`038C: BSF 03.5`
1881	`038D: CLRF 1D`	1881	`038D: CLRF 1D`
1882	`.................... // enable_interrupts(INT_TIMER1);`	1882	`.................... // enable_interrupts(INT_TIMER1);`
1883	`.................... // enable_interrupts(INT_TIMER2);`	1883	`.................... // enable_interrupts(INT_TIMER2);`
1884	`.................... // enable_interrupts(GLOBAL);`	1884	`.................... // enable_interrupts(GLOBAL);`
1885	`....................`	1885	`....................`
1886	`.................... setup_oscillator(OSC_4MHZ\|OSC_INTRC); // 4 MHz interni RC oscilator`	1886	`.................... setup_oscillator(OSC_4MHZ\|OSC_INTRC); // 4 MHz interni RC oscilator`
1887	`038E: MOVLW 62`	1887	`038E: MOVLW 62`
1888	`038F: MOVWF 0F`	1888	`038F: MOVWF 0F`
1889	`....................`	1889	`....................`
1890	`.................... delay_ms(100);`	1890	`.................... delay_ms(100);`
1891	`0390: MOVLW 64`	1891	`0390: MOVLW 64`
1892	`0391: BCF 03.5`	1892	`0391: BCF 03.5`
1893	`0392: MOVWF 42`	1893	`0392: MOVWF 42`
1894	`0393: CALL 0E6`	1894	`0393: CALL 0E6`
1895	`.................... printf("\n\r\n\r%s", ver);`	1895	`.................... printf("\n\r\n\r%s", ver);`
1896	`0394: CLRF 41`	1896	`0394: CLRF 41`
1897	`0395: MOVF 41,W`	1897	`0395: MOVF 41,W`
1898	`0396: CALL 04E`	1898	`0396: CALL 04E`
1899	`0397: INCF 41,F`	1899	`0397: INCF 41,F`
1900	`0398: MOVWF 77`	1900	`0398: MOVWF 77`
1901	`0399: MOVWF 4C`	1901	`0399: MOVWF 4C`
1902	`039A: CALL 0FE`	1902	`039A: CALL 0FE`
1903	`039B: MOVLW 04`	1903	`039B: MOVLW 04`
1904	`039C: SUBWF 41,W`	1904	`039C: SUBWF 41,W`
1905	`039D: BTFSS 03.2`	1905	`039D: BTFSS 03.2`
1906	`039E: GOTO 395`	1906	`039E: GOTO 395`
1907	`039F: CLRF 42`	1907	`039F: CLRF 42`
1908	`03A0: MOVF 42,W`	1908	`03A0: MOVF 42,W`
1909	`03A1: CALL 03F`	1909	`03A1: CALL 03F`
1910	`03A2: IORLW 00`	1910	`03A2: IORLW 00`
1911	`03A3: BTFSC 03.2`	1911	`03A3: BTFSC 03.2`
1912	`03A4: GOTO 3A9`	1912	`03A4: GOTO 3A9`
1913	`03A5: INCF 42,F`	1913	`03A5: INCF 42,F`
1914	`03A6: MOVWF 4C`	1914	`03A6: MOVWF 4C`
1915	`03A7: CALL 0FE`	1915	`03A7: CALL 0FE`
1916	`03A8: GOTO 3A0`	1916	`03A8: GOTO 3A0`
1917	`.................... output_low(SYNC);`	1917	`.................... output_low(SYNC);`
1918	`03A9: BSF 03.5`	1918	`03A9: BSF 03.5`
1919	`03AA: BCF 06.4`	1919	`03AA: BCF 06.4`
1920	`03AB: BCF 03.5`	1920	`03AB: BCF 03.5`
1921	`03AC: BCF 06.4`	1921	`03AC: BCF 06.4`
1922	`.................... output_low(HACK);`	1922	`.................... output_low(HACK);`
1923	`03AD: BSF 03.5`	1923	`03AD: BSF 03.5`
1924	`03AE: BCF 06.5`	1924	`03AE: BCF 06.5`
1925	`03AF: BCF 03.5`	1925	`03AF: BCF 03.5`
1926	`03B0: BCF 06.5`	1926	`03B0: BCF 06.5`
1927	`.................... ticks=1;`	1927	`.................... ticks=1;`
1928	`03B1: CLRF 3F`	1928	`03B1: CLRF 3F`
1929	`03B2: MOVLW 01`	1929	`03B2: MOVLW 01`
1930	`03B3: MOVWF 3E`	1930	`03B3: MOVWF 3E`
1931	`.................... prescale=0;`	1931	`.................... prescale=0;`
1932	`03B4: CLRF 3D`	1932	`03B4: CLRF 3D`
1933	`03B5: CLRF 3C`	1933	`03B5: CLRF 3C`
1934	`....................`	1934	`....................`
1935	`.................... while(true)`	1935	`.................... while(true)`
1936	`.................... {`	1936	`.................... {`
1937	`.................... printf("\n\r>");`	1937	`.................... printf("\n\r>");`
1938	`03B6: MOVLW 0A`	1938	`03B6: MOVLW 0A`
1939	`03B7: MOVWF 4C`	1939	`03B7: MOVWF 4C`
1940	`03B8: CALL 0FE`	1940	`03B8: CALL 0FE`
1941	`03B9: MOVLW 0D`	1941	`03B9: MOVLW 0D`
1942	`03BA: MOVWF 4C`	1942	`03BA: MOVWF 4C`
1943	`03BB: CALL 0FE`	1943	`03BB: CALL 0FE`
1944	`03BC: MOVLW 3E`	1944	`03BC: MOVLW 3E`
1945	`03BD: MOVWF 4C`	1945	`03BD: MOVWF 4C`
1946	`03BE: CALL 0FE`	1946	`03BE: CALL 0FE`
1947	`.................... n=0;`	1947	`.................... n=0;`
1948	`03BF: CLRF 40`	1948	`03BF: CLRF 40`
1949	`.................... do`	1949	`.................... do`
1950	`.................... {`	1950	`.................... {`
1951	`.................... ch=getchar();`	1951	`.................... ch=getchar();`
1952	`03C0: GOTO 12A`	1952	`03C0: GOTO 12A`
1953	`03C1: MOVF 78,W`	1953	`03C1: MOVF 78,W`
1954	`03C2: MOVWF 31`	1954	`03C2: MOVWF 31`
1955	`.................... printf("%c",ch);`	1955	`.................... printf("%c",ch);`
1956	`03C3: MOVF 31,W`	1956	`03C3: MOVF 31,W`
1957	`03C4: MOVWF 4C`	1957	`03C4: MOVWF 4C`
1958	`03C5: CALL 0FE`	1958	`03C5: CALL 0FE`
1959	`.................... string[n++]=ch;`	1959	`.................... string[n++]=ch;`
1960	`03C6: MOVF 40,W`	1960	`03C6: MOVF 40,W`
1961	`03C7: INCF 40,F`	1961	`03C7: INCF 40,F`
1962	`03C8: ADDLW 32`	1962	`03C8: ADDLW 32`
1963	`03C9: MOVWF 04`	1963	`03C9: MOVWF 04`
1964	`03CA: BCF 03.7`	1964	`03CA: BCF 03.7`
1965	`03CB: MOVF 31,W`	1965	`03CB: MOVF 31,W`
1966	`03CC: MOVWF 00`	1966	`03CC: MOVWF 00`
1967	`.................... } while((13 != ch) && (n < 10));`	1967	`.................... } while((13 != ch) && (n < 10));`
1968	`03CD: MOVF 31,W`	1968	`03CD: MOVF 31,W`
1969	`03CE: SUBLW 0D`	1969	`03CE: SUBLW 0D`
1970	`03CF: BTFSC 03.2`	1970	`03CF: BTFSC 03.2`
1971	`03D0: GOTO 3D5`	1971	`03D0: GOTO 3D5`
1972	`03D1: MOVF 40,W`	1972	`03D1: MOVF 40,W`
1973	`03D2: SUBLW 09`	1973	`03D2: SUBLW 09`
1974	`03D3: BTFSC 03.0`	1974	`03D3: BTFSC 03.0`
1975	`03D4: GOTO 3C0`	1975	`03D4: GOTO 3C0`
1976	`.................... string[n]=0;`	1976	`.................... string[n]=0;`
1977	`03D5: MOVLW 32`	1977	`03D5: MOVLW 32`
1978	`03D6: ADDWF 40,W`	1978	`03D6: ADDWF 40,W`
1979	`03D7: MOVWF 04`	1979	`03D7: MOVWF 04`
1980	`03D8: BCF 03.7`	1980	`03D8: BCF 03.7`
1981	`03D9: CLRF 00`	1981	`03D9: CLRF 00`
1982	`.................... printf("\n\r");`	1982	`.................... printf("\n\r");`
1983	`03DA: MOVLW 0A`	1983	`03DA: MOVLW 0A`
1984	`03DB: MOVWF 4C`	1984	`03DB: MOVWF 4C`
1985	`03DC: CALL 0FE`	1985	`03DC: CALL 0FE`
1986	`03DD: MOVLW 0D`	1986	`03DD: MOVLW 0D`
1987	`03DE: MOVWF 4C`	1987	`03DE: MOVWF 4C`
1988	`03DF: CALL 0FE`	1988	`03DF: CALL 0FE`
1989	`.................... switch(string[0])`	1989	`.................... switch(string[0])`
1990	`.................... {`	1990	`.................... {`
1991	`03E0: MOVF 32,W`	1991	`03E0: MOVF 32,W`
1992	`03E1: XORLW 67`	1992	`03E1: XORLW 67`
1993	`03E2: BTFSC 03.2`	1993	`03E2: BTFSC 03.2`
1994	`03E3: GOTO 3F1`	1994	`03E3: GOTO 3F1`
1995	`03E4: XORLW 15`	1995	`03E4: XORLW 15`
1996	`03E5: BTFSC 03.2`	1996	`03E5: BTFSC 03.2`
1997	`03E6: GOTO 460`	1997	`03E6: GOTO 460`
1998	`03E7: XORLW 1A`	1998	`03E7: XORLW 1A`
1999	`03E8: BTFSC 03.2`	1999	`03E8: BTFSC 03.2`
2000	`03E9: GOTO 4E9`	2000	`03E9: GOTO 4E9`
2001	`03EA: XORLW 01`	2001	`03EA: XORLW 01`
2002	`03EB: BTFSC 03.2`	2002	`03EB: BTFSC 03.2`
2003	`03EC: GOTO 571`	2003	`03EC: GOTO 571`
2004	`03ED: XORLW 19`	2004	`03ED: XORLW 19`
2005	`03EE: BTFSC 03.2`	2005	`03EE: BTFSC 03.2`
2006	`03EF: GOTO 5A8`	2006	`03EF: GOTO 5A8`
2007	`03F0: GOTO 5EB`	2007	`03F0: GOTO 5EB`
2008	`.................... case 'g': // GO`	2008	`.................... case 'g': // GO`
2009	`.................... printf("%Lue4 + %Lu GO", prescale, ticks);`	2009	`.................... printf("%Lue4 + %Lu GO", prescale, ticks);`
2010	`03F1: MOVLW 10`	2010	`03F1: MOVLW 10`
2011	`03F2: MOVWF 04`	2011	`03F2: MOVWF 04`
2012	`03F3: MOVF 3D,W`	2012	`03F3: MOVF 3D,W`
2013	`03F4: MOVWF 44`	2013	`03F4: MOVWF 44`
2014	`03F5: MOVF 3C,W`	2014	`03F5: MOVF 3C,W`
2015	`03F6: MOVWF 43`	2015	`03F6: MOVWF 43`
2016	`03F7: CALL 15F`	2016	`03F7: CALL 15F`
2017	`03F8: MOVLW 03`	2017	`03F8: MOVLW 03`
2018	`03F9: MOVWF 41`	2018	`03F9: MOVWF 41`
2019	`03FA: MOVF 41,W`	2019	`03FA: MOVF 41,W`
2020	`03FB: CALL 059`	2020	`03FB: CALL 059`
2021	`03FC: INCF 41,F`	2021	`03FC: INCF 41,F`
2022	`03FD: MOVWF 77`	2022	`03FD: MOVWF 77`
2023	`03FE: MOVWF 4C`	2023	`03FE: MOVWF 4C`
2024	`03FF: CALL 0FE`	2024	`03FF: CALL 0FE`
2025	`0400: MOVLW 08`	2025	`0400: MOVLW 08`
2026	`0401: SUBWF 41,W`	2026	`0401: SUBWF 41,W`
2027	`0402: BTFSS 03.2`	2027	`0402: BTFSS 03.2`
2028	`0403: GOTO 3FA`	2028	`0403: GOTO 3FA`
2029	`0404: MOVLW 10`	2029	`0404: MOVLW 10`
2030	`0405: MOVWF 04`	2030	`0405: MOVWF 04`
2031	`0406: MOVF 3F,W`	2031	`0406: MOVF 3F,W`
2032	`0407: MOVWF 44`	2032	`0407: MOVWF 44`
2033	`0408: MOVF 3E,W`	2033	`0408: MOVF 3E,W`
2034	`0409: MOVWF 43`	2034	`0409: MOVWF 43`
2035	`040A: CALL 15F`	2035	`040A: CALL 15F`
2036	`040B: MOVLW 20`	2036	`040B: MOVLW 20`
2037	`040C: MOVWF 4C`	2037	`040C: MOVWF 4C`
2038	`040D: CALL 0FE`	2038	`040D: CALL 0FE`
2039	`040E: MOVLW 47`	2039	`040E: MOVLW 47`
2040	`040F: MOVWF 4C`	2040	`040F: MOVWF 4C`
2041	`0410: CALL 0FE`	2041	`0410: CALL 0FE`
2042	`0411: MOVLW 4F`	2042	`0411: MOVLW 4F`
2043	`0412: MOVWF 4C`	2043	`0412: MOVWF 4C`
2044	`0413: CALL 0FE`	2044	`0413: CALL 0FE`
2045	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`	2045	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
2046	`0414: CLRF 30`	2046	`0414: CLRF 30`
2047	`0415: CLRF 2F`	2047	`0415: CLRF 2F`
2048	`0416: MOVF 30,W`	2048	`0416: MOVF 30,W`
2049	`0417: SUBWF 3D,W`	2049	`0417: SUBWF 3D,W`
2050	`0418: BTFSS 03.0`	2050	`0418: BTFSS 03.0`
2051	`0419: GOTO 43C`	2051	`0419: GOTO 43C`
2052	`041A: BTFSS 03.2`	2052	`041A: BTFSS 03.2`
2053	`041B: GOTO 420`	2053	`041B: GOTO 420`
2054	`041C: MOVF 3C,W`	2054	`041C: MOVF 3C,W`
2055	`041D: SUBWF 2F,W`	2055	`041D: SUBWF 2F,W`
2056	`041E: BTFSC 03.0`	2056	`041E: BTFSC 03.0`
2057	`041F: GOTO 43C`	2057	`041F: GOTO 43C`
2058	`0420: CLRF 0F`	2058	`0420: CLRF 0F`
2059	`0421: CLRF 0E`	2059	`0421: CLRF 0E`
2060	`0422: MOVF 0F,W`	2060	`0422: MOVF 0F,W`
2061	`0423: MOVWF 7A`	2061	`0423: MOVWF 7A`
2062	`0424: MOVF 0E,W`	2062	`0424: MOVF 0E,W`
2063	`0425: MOVWF 77`	2063	`0425: MOVWF 77`
2064	`0426: MOVF 0F,W`	2064	`0426: MOVF 0F,W`
2065	`0427: SUBWF 7A,W`	2065	`0427: SUBWF 7A,W`
2066	`0428: BTFSS 03.2`	2066	`0428: BTFSS 03.2`
2067	`0429: GOTO 422`	2067	`0429: GOTO 422`
2068	`042A: MOVF 77,W`	2068	`042A: MOVF 77,W`
2069	`042B: MOVWF 41`	2069	`042B: MOVWF 41`
2070	`042C: MOVF 7A,W`	2070	`042C: MOVF 7A,W`
2071	`042D: MOVWF 42`	2071	`042D: MOVWF 42`
2072	`042E: MOVF 42,W`	2072	`042E: MOVF 42,W`
2073	`042F: SUBLW 27`	2073	`042F: SUBLW 27`
2074	`0430: BTFSS 03.0`	2074	`0430: BTFSS 03.0`
2075	`0431: GOTO 438`	2075	`0431: GOTO 438`
2076	`0432: BTFSS 03.2`	2076	`0432: BTFSS 03.2`
2077	`0433: GOTO 422`	2077	`0433: GOTO 422`
2078	`0434: MOVF 41,W`	2078	`0434: MOVF 41,W`
2079	`0435: SUBLW 0F`	2079	`0435: SUBLW 0F`
2080	`0436: BTFSC 03.0`	2080	`0436: BTFSC 03.0`
2081	`0437: GOTO 422`	2081	`0437: GOTO 422`
2082	`0438: INCF 2F,F`	2082	`0438: INCF 2F,F`
2083	`0439: BTFSC 03.2`	2083	`0439: BTFSC 03.2`
2084	`043A: INCF 30,F`	2084	`043A: INCF 30,F`
2085	`043B: GOTO 416`	2085	`043B: GOTO 416`
2086	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`	2086	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
2087	`043C: CLRF 0F`	2087	`043C: CLRF 0F`
2088	`043D: CLRF 0E`	2088	`043D: CLRF 0E`
2089	`043E: MOVF 0F,W`	2089	`043E: MOVF 0F,W`
2090	`043F: MOVWF 7A`	2090	`043F: MOVWF 7A`
2091	`0440: MOVF 0E,W`	2091	`0440: MOVF 0E,W`
2092	`0441: MOVWF 77`	2092	`0441: MOVWF 77`
2093	`0442: MOVF 0F,W`	2093	`0442: MOVF 0F,W`
2094	`0443: SUBWF 7A,W`	2094	`0443: SUBWF 7A,W`
2095	`0444: BTFSS 03.2`	2095	`0444: BTFSS 03.2`
2096	`0445: GOTO 43E`	2096	`0445: GOTO 43E`
2097	`0446: MOVF 77,W`	2097	`0446: MOVF 77,W`
2098	`0447: MOVWF 41`	2098	`0447: MOVWF 41`
2099	`0448: MOVF 7A,W`	2099	`0448: MOVF 7A,W`
2100	`0449: MOVWF 42`	2100	`0449: MOVWF 42`
2101	`044A: MOVF 42,W`	2101	`044A: MOVF 42,W`
2102	`044B: SUBWF 3F,W`	2102	`044B: SUBWF 3F,W`
2103	`044C: BTFSS 03.0`	2103	`044C: BTFSS 03.0`
2104	`044D: GOTO 454`	2104	`044D: GOTO 454`
2105	`044E: BTFSS 03.2`	2105	`044E: BTFSS 03.2`
2106	`044F: GOTO 43E`	2106	`044F: GOTO 43E`
2107	`0450: MOVF 3E,W`	2107	`0450: MOVF 3E,W`
2108	`0451: SUBWF 41,W`	2108	`0451: SUBWF 41,W`
2109	`0452: BTFSS 03.0`	2109	`0452: BTFSS 03.0`
2110	`0453: GOTO 43E`	2110	`0453: GOTO 43E`
2111	`.................... output_high(SYNC);`	2111	`.................... output_high(SYNC);`
2112	`0454: BSF 03.5`	2112	`0454: BSF 03.5`
2113	`0455: BCF 06.4`	2113	`0455: BCF 06.4`
2114	`0456: BCF 03.5`	2114	`0456: BCF 03.5`
2115	`0457: BSF 06.4`	2115	`0457: BSF 06.4`
2116	`.................... delay_ms(1);`	2116	`.................... delay_ms(1);`
2117	`0458: MOVLW 01`	2117	`0458: MOVLW 01`
2118	`0459: MOVWF 42`	2118	`0459: MOVWF 42`
2119	`045A: CALL 0E6`	2119	`045A: CALL 0E6`
2120	`.................... output_low(SYNC);`	2120	`.................... output_low(SYNC);`
2121	`045B: BSF 03.5`	2121	`045B: BSF 03.5`
2122	`045C: BCF 06.4`	2122	`045C: BCF 06.4`
2123	`045D: BCF 03.5`	2123	`045D: BCF 03.5`
2124	`045E: BCF 06.4`	2124	`045E: BCF 06.4`
2125	`.................... break;`	2125	`.................... break;`
2126	`045F: GOTO 61A`	2126	`045F: GOTO 61A`
2127	`....................`	2127	`....................`
2128	`.................... case 'r': // REPEAT`	2128	`.................... case 'r': // REPEAT`
2129	`.................... n=0;`	2129	`.................... n=0;`
2130	`0460: CLRF 40`	2130	`0460: CLRF 40`
2131	`.................... while(true)`	2131	`.................... while(true)`
2132	`.................... {`	2132	`.................... {`
2133	`.................... printf("%Lue4 + %Lu REPEAT %u\n\r", prescale, ticks, n++);`	2133	`.................... printf("%Lue4 + %Lu REPEAT %u\n\r", prescale, ticks, n++);`
2134	`0461: MOVF 40,W`	2134	`0461: MOVF 40,W`
2135	`0462: INCF 40,F`	2135	`0462: INCF 40,F`
2136	`0463: MOVWF 41`	2136	`0463: MOVWF 41`
2137	`0464: MOVLW 10`	2137	`0464: MOVLW 10`
2138	`0465: MOVWF 04`	2138	`0465: MOVWF 04`
2139	`0466: MOVF 3D,W`	2139	`0466: MOVF 3D,W`
2140	`0467: MOVWF 44`	2140	`0467: MOVWF 44`
2141	`0468: MOVF 3C,W`	2141	`0468: MOVF 3C,W`
2142	`0469: MOVWF 43`	2142	`0469: MOVWF 43`
2143	`046A: CALL 15F`	2143	`046A: CALL 15F`
2144	`046B: MOVLW 03`	2144	`046B: MOVLW 03`
2145	`046C: MOVWF 42`	2145	`046C: MOVWF 42`
2146	`046D: MOVF 42,W`	2146	`046D: MOVF 42,W`
2147	`046E: CALL 06C`	2147	`046E: CALL 06C`
2148	`046F: INCF 42,F`	2148	`046F: INCF 42,F`
2149	`0470: MOVWF 77`	2149	`0470: MOVWF 77`
2150	`0471: MOVWF 4C`	2150	`0471: MOVWF 4C`
2151	`0472: CALL 0FE`	2151	`0472: CALL 0FE`
2152	`0473: MOVLW 08`	2152	`0473: MOVLW 08`
2153	`0474: SUBWF 42,W`	2153	`0474: SUBWF 42,W`
2154	`0475: BTFSS 03.2`	2154	`0475: BTFSS 03.2`
2155	`0476: GOTO 46D`	2155	`0476: GOTO 46D`
2156	`0477: MOVLW 10`	2156	`0477: MOVLW 10`
2157	`0478: MOVWF 04`	2157	`0478: MOVWF 04`
2158	`0479: MOVF 3F,W`	2158	`0479: MOVF 3F,W`
2159	`047A: MOVWF 44`	2159	`047A: MOVWF 44`
2160	`047B: MOVF 3E,W`	2160	`047B: MOVF 3E,W`
2161	`047C: MOVWF 43`	2161	`047C: MOVWF 43`
2162	`047D: CALL 15F`	2162	`047D: CALL 15F`
2163	`047E: MOVLW 0B`	2163	`047E: MOVLW 0B`
2164	`047F: MOVWF 43`	2164	`047F: MOVWF 43`
2165	`0480: MOVF 43,W`	2165	`0480: MOVF 43,W`
2166	`0481: CALL 06C`	2166	`0481: CALL 06C`
2167	`0482: INCF 43,F`	2167	`0482: INCF 43,F`
2168	`0483: MOVWF 77`	2168	`0483: MOVWF 77`
2169	`0484: MOVWF 4C`	2169	`0484: MOVWF 4C`
2170	`0485: CALL 0FE`	2170	`0485: CALL 0FE`
2171	`0486: MOVLW 13`	2171	`0486: MOVLW 13`
2172	`0487: SUBWF 43,W`	2172	`0487: SUBWF 43,W`
2173	`0488: BTFSS 03.2`	2173	`0488: BTFSS 03.2`
2174	`0489: GOTO 480`	2174	`0489: GOTO 480`
2175	`048A: MOVF 41,W`	2175	`048A: MOVF 41,W`
2176	`048B: MOVWF 44`	2176	`048B: MOVWF 44`
2177	`048C: MOVLW 18`	2177	`048C: MOVLW 18`
2178	`048D: MOVWF 45`	2178	`048D: MOVWF 45`
2179	`048E: GOTO 1DE`	2179	`048E: GOTO 1DE`
2180	`048F: MOVLW 0A`	2180	`048F: MOVLW 0A`
2181	`0490: MOVWF 4C`	2181	`0490: MOVWF 4C`
2182	`0491: CALL 0FE`	2182	`0491: CALL 0FE`
2183	`0492: MOVLW 0D`	2183	`0492: MOVLW 0D`
2184	`0493: MOVWF 4C`	2184	`0493: MOVWF 4C`
2185	`0494: CALL 0FE`	2185	`0494: CALL 0FE`
2186	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`	2186	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
2187	`0495: CLRF 30`	2187	`0495: CLRF 30`
2188	`0496: CLRF 2F`	2188	`0496: CLRF 2F`
2189	`0497: MOVF 30,W`	2189	`0497: MOVF 30,W`
2190	`0498: SUBWF 3D,W`	2190	`0498: SUBWF 3D,W`
2191	`0499: BTFSS 03.0`	2191	`0499: BTFSS 03.0`
2192	`049A: GOTO 4BD`	2192	`049A: GOTO 4BD`
2193	`049B: BTFSS 03.2`	2193	`049B: BTFSS 03.2`
2194	`049C: GOTO 4A1`	2194	`049C: GOTO 4A1`
2195	`049D: MOVF 3C,W`	2195	`049D: MOVF 3C,W`
2196	`049E: SUBWF 2F,W`	2196	`049E: SUBWF 2F,W`
2197	`049F: BTFSC 03.0`	2197	`049F: BTFSC 03.0`
2198	`04A0: GOTO 4BD`	2198	`04A0: GOTO 4BD`
2199	`04A1: CLRF 0F`	2199	`04A1: CLRF 0F`
2200	`04A2: CLRF 0E`	2200	`04A2: CLRF 0E`
2201	`04A3: MOVF 0F,W`	2201	`04A3: MOVF 0F,W`
2202	`04A4: MOVWF 7A`	2202	`04A4: MOVWF 7A`
2203	`04A5: MOVF 0E,W`	2203	`04A5: MOVF 0E,W`
2204	`04A6: MOVWF 77`	2204	`04A6: MOVWF 77`
2205	`04A7: MOVF 0F,W`	2205	`04A7: MOVF 0F,W`
2206	`04A8: SUBWF 7A,W`	2206	`04A8: SUBWF 7A,W`
2207	`04A9: BTFSS 03.2`	2207	`04A9: BTFSS 03.2`
2208	`04AA: GOTO 4A3`	2208	`04AA: GOTO 4A3`
2209	`04AB: MOVF 77,W`	2209	`04AB: MOVF 77,W`
2210	`04AC: MOVWF 41`	2210	`04AC: MOVWF 41`
2211	`04AD: MOVF 7A,W`	2211	`04AD: MOVF 7A,W`
2212	`04AE: MOVWF 42`	2212	`04AE: MOVWF 42`
2213	`04AF: MOVF 42,W`	2213	`04AF: MOVF 42,W`
2214	`04B0: SUBLW 27`	2214	`04B0: SUBLW 27`
2215	`04B1: BTFSS 03.0`	2215	`04B1: BTFSS 03.0`
2216	`04B2: GOTO 4B9`	2216	`04B2: GOTO 4B9`
2217	`04B3: BTFSS 03.2`	2217	`04B3: BTFSS 03.2`
2218	`04B4: GOTO 4A3`	2218	`04B4: GOTO 4A3`
2219	`04B5: MOVF 41,W`	2219	`04B5: MOVF 41,W`
2220	`04B6: SUBLW 0F`	2220	`04B6: SUBLW 0F`
2221	`04B7: BTFSC 03.0`	2221	`04B7: BTFSC 03.0`
2222	`04B8: GOTO 4A3`	2222	`04B8: GOTO 4A3`
2223	`04B9: INCF 2F,F`	2223	`04B9: INCF 2F,F`
2224	`04BA: BTFSC 03.2`	2224	`04BA: BTFSC 03.2`
2225	`04BB: INCF 30,F`	2225	`04BB: INCF 30,F`
2226	`04BC: GOTO 497`	2226	`04BC: GOTO 497`
2227	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`	2227	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
2228	`04BD: CLRF 0F`	2228	`04BD: CLRF 0F`
2229	`04BE: CLRF 0E`	2229	`04BE: CLRF 0E`
2230	`04BF: MOVF 0F,W`	2230	`04BF: MOVF 0F,W`
2231	`04C0: MOVWF 7A`	2231	`04C0: MOVWF 7A`
2232	`04C1: MOVF 0E,W`	2232	`04C1: MOVF 0E,W`
2233	`04C2: MOVWF 77`	2233	`04C2: MOVWF 77`
2234	`04C3: MOVF 0F,W`	2234	`04C3: MOVF 0F,W`
2235	`04C4: SUBWF 7A,W`	2235	`04C4: SUBWF 7A,W`
2236	`04C5: BTFSS 03.2`	2236	`04C5: BTFSS 03.2`
2237	`04C6: GOTO 4BF`	2237	`04C6: GOTO 4BF`
2238	`04C7: MOVF 77,W`	2238	`04C7: MOVF 77,W`
2239	`04C8: MOVWF 41`	2239	`04C8: MOVWF 41`
2240	`04C9: MOVF 7A,W`	2240	`04C9: MOVF 7A,W`
2241	`04CA: MOVWF 42`	2241	`04CA: MOVWF 42`
2242	`04CB: MOVF 42,W`	2242	`04CB: MOVF 42,W`
2243	`04CC: SUBWF 3F,W`	2243	`04CC: SUBWF 3F,W`
2244	`04CD: BTFSS 03.0`	2244	`04CD: BTFSS 03.0`
2245	`04CE: GOTO 4D5`	2245	`04CE: GOTO 4D5`
2246	`04CF: BTFSS 03.2`	2246	`04CF: BTFSS 03.2`
2247	`04D0: GOTO 4BF`	2247	`04D0: GOTO 4BF`
2248	`04D1: MOVF 3E,W`	2248	`04D1: MOVF 3E,W`
2249	`04D2: SUBWF 41,W`	2249	`04D2: SUBWF 41,W`
2250	`04D3: BTFSS 03.0`	2250	`04D3: BTFSS 03.0`
2251	`04D4: GOTO 4BF`	2251	`04D4: GOTO 4BF`
2252	`.................... output_high(SYNC);`	2252	`.................... output_high(SYNC);`
2253	`04D5: BSF 03.5`	2253	`04D5: BSF 03.5`
2254	`04D6: BCF 06.4`	2254	`04D6: BCF 06.4`
2255	`04D7: BCF 03.5`	2255	`04D7: BCF 03.5`
2256	`04D8: BSF 06.4`	2256	`04D8: BSF 06.4`
2257	`.................... delay_ms(20);`	2257	`.................... delay_ms(20);`
2258	`04D9: MOVLW 14`	2258	`04D9: MOVLW 14`
2259	`04DA: MOVWF 42`	2259	`04DA: MOVWF 42`
2260	`04DB: CALL 0E6`	2260	`04DB: CALL 0E6`
2261	`.................... output_low(SYNC);`	2261	`.................... output_low(SYNC);`
2262	`04DC: BSF 03.5`	2262	`04DC: BSF 03.5`
2263	`04DD: BCF 06.4`	2263	`04DD: BCF 06.4`
2264	`04DE: BCF 03.5`	2264	`04DE: BCF 03.5`
2265	`04DF: BCF 06.4`	2265	`04DF: BCF 06.4`
2266	`.................... delay_ms(2000);`	2266	`.................... delay_ms(2000);`
2267	`04E0: MOVLW 08`	2267	`04E0: MOVLW 08`
2268	`04E1: MOVWF 41`	2268	`04E1: MOVWF 41`
2269	`04E2: MOVLW FA`	2269	`04E2: MOVLW FA`
2270	`04E3: MOVWF 42`	2270	`04E3: MOVWF 42`
2271	`04E4: CALL 0E6`	2271	`04E4: CALL 0E6`
2272	`04E5: DECFSZ 41,F`	2272	`04E5: DECFSZ 41,F`
2273	`04E6: GOTO 4E2`	2273	`04E6: GOTO 4E2`
2274	`.................... };`	2274	`.................... };`
2275	`04E7: GOTO 461`	2275	`04E7: GOTO 461`
2276	`.................... break;`	2276	`.................... break;`
2277	`04E8: GOTO 61A`	2277	`04E8: GOTO 61A`
2278	`....................`	2278	`....................`
2279	`.................... case 'h': // HACK`	2279	`.................... case 'h': // HACK`
2280	`.................... printf("%Lue4 + %Lu HACK", prescale, ticks);`	2280	`.................... printf("%Lue4 + %Lu HACK", prescale, ticks);`
2281	`04E9: MOVLW 10`	2281	`04E9: MOVLW 10`
2282	`04EA: MOVWF 04`	2282	`04EA: MOVWF 04`
2283	`04EB: MOVF 3D,W`	2283	`04EB: MOVF 3D,W`
2284	`04EC: MOVWF 44`	2284	`04EC: MOVWF 44`
2285	`04ED: MOVF 3C,W`	2285	`04ED: MOVF 3C,W`
2286	`04EE: MOVWF 43`	2286	`04EE: MOVWF 43`
2287	`04EF: CALL 15F`	2287	`04EF: CALL 15F`
2288	`04F0: MOVLW 03`	2288	`04F0: MOVLW 03`
2289	`04F1: MOVWF 41`	2289	`04F1: MOVWF 41`
2290	`04F2: MOVF 41,W`	2290	`04F2: MOVF 41,W`
2291	`04F3: CALL 088`	2291	`04F3: CALL 088`
2292	`04F4: INCF 41,F`	2292	`04F4: INCF 41,F`
2293	`04F5: MOVWF 77`	2293	`04F5: MOVWF 77`
2294	`04F6: MOVWF 4C`	2294	`04F6: MOVWF 4C`
2295	`04F7: CALL 0FE`	2295	`04F7: CALL 0FE`
2296	`04F8: MOVLW 08`	2296	`04F8: MOVLW 08`
2297	`04F9: SUBWF 41,W`	2297	`04F9: SUBWF 41,W`
2298	`04FA: BTFSS 03.2`	2298	`04FA: BTFSS 03.2`
2299	`04FB: GOTO 4F2`	2299	`04FB: GOTO 4F2`
2300	`04FC: MOVLW 10`	2300	`04FC: MOVLW 10`
2301	`04FD: MOVWF 04`	2301	`04FD: MOVWF 04`
2302	`04FE: MOVF 3F,W`	2302	`04FE: MOVF 3F,W`
2303	`04FF: MOVWF 44`	2303	`04FF: MOVWF 44`
2304	`0500: MOVF 3E,W`	2304	`0500: MOVF 3E,W`
2305	`0501: MOVWF 43`	2305	`0501: MOVWF 43`
2306	`0502: CALL 15F`	2306	`0502: CALL 15F`
2307	`0503: MOVLW 0B`	2307	`0503: MOVLW 0B`
2308	`0504: MOVWF 42`	2308	`0504: MOVWF 42`
2309	`0505: MOVF 42,W`	2309	`0505: MOVF 42,W`
2310	`0506: CALL 088`	2310	`0506: CALL 088`
2311	`0507: INCF 42,F`	2311	`0507: INCF 42,F`
2312	`0508: MOVWF 77`	2312	`0508: MOVWF 77`
2313	`0509: MOVWF 4C`	2313	`0509: MOVWF 4C`
2314	`050A: CALL 0FE`	2314	`050A: CALL 0FE`
2315	`050B: MOVLW 10`	2315	`050B: MOVLW 10`
2316	`050C: SUBWF 42,W`	2316	`050C: SUBWF 42,W`
2317	`050D: BTFSS 03.2`	2317	`050D: BTFSS 03.2`
2318	`050E: GOTO 505`	2318	`050E: GOTO 505`
2319	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`	2319	`.................... for(i=0; i<prescale; i++) { set_timer1(0); while ( get_timer1() < 10000 ) ; };`
2320	`050F: CLRF 30`	2320	`050F: CLRF 30`
2321	`0510: CLRF 2F`	2321	`0510: CLRF 2F`
2322	`0511: MOVF 30,W`	2322	`0511: MOVF 30,W`
2323	`0512: SUBWF 3D,W`	2323	`0512: SUBWF 3D,W`
2324	`0513: BTFSS 03.0`	2324	`0513: BTFSS 03.0`
2325	`0514: GOTO 537`	2325	`0514: GOTO 537`
2326	`0515: BTFSS 03.2`	2326	`0515: BTFSS 03.2`
2327	`0516: GOTO 51B`	2327	`0516: GOTO 51B`
2328	`0517: MOVF 3C,W`	2328	`0517: MOVF 3C,W`
2329	`0518: SUBWF 2F,W`	2329	`0518: SUBWF 2F,W`
2330	`0519: BTFSC 03.0`	2330	`0519: BTFSC 03.0`
2331	`051A: GOTO 537`	2331	`051A: GOTO 537`
2332	`051B: CLRF 0F`	2332	`051B: CLRF 0F`
2333	`051C: CLRF 0E`	2333	`051C: CLRF 0E`
2334	`051D: MOVF 0F,W`	2334	`051D: MOVF 0F,W`
2335	`051E: MOVWF 7A`	2335	`051E: MOVWF 7A`
2336	`051F: MOVF 0E,W`	2336	`051F: MOVF 0E,W`
2337	`0520: MOVWF 77`	2337	`0520: MOVWF 77`
2338	`0521: MOVF 0F,W`	2338	`0521: MOVF 0F,W`
2339	`0522: SUBWF 7A,W`	2339	`0522: SUBWF 7A,W`
2340	`0523: BTFSS 03.2`	2340	`0523: BTFSS 03.2`
2341	`0524: GOTO 51D`	2341	`0524: GOTO 51D`
2342	`0525: MOVF 77,W`	2342	`0525: MOVF 77,W`
2343	`0526: MOVWF 41`	2343	`0526: MOVWF 41`
2344	`0527: MOVF 7A,W`	2344	`0527: MOVF 7A,W`
2345	`0528: MOVWF 42`	2345	`0528: MOVWF 42`
2346	`0529: MOVF 42,W`	2346	`0529: MOVF 42,W`
2347	`052A: SUBLW 27`	2347	`052A: SUBLW 27`
2348	`052B: BTFSS 03.0`	2348	`052B: BTFSS 03.0`
2349	`052C: GOTO 533`	2349	`052C: GOTO 533`
2350	`052D: BTFSS 03.2`	2350	`052D: BTFSS 03.2`
2351	`052E: GOTO 51D`	2351	`052E: GOTO 51D`
2352	`052F: MOVF 41,W`	2352	`052F: MOVF 41,W`
2353	`0530: SUBLW 0F`	2353	`0530: SUBLW 0F`
2354	`0531: BTFSC 03.0`	2354	`0531: BTFSC 03.0`
2355	`0532: GOTO 51D`	2355	`0532: GOTO 51D`
2356	`0533: INCF 2F,F`	2356	`0533: INCF 2F,F`
2357	`0534: BTFSC 03.2`	2357	`0534: BTFSC 03.2`
2358	`0535: INCF 30,F`	2358	`0535: INCF 30,F`
2359	`0536: GOTO 511`	2359	`0536: GOTO 511`
2360	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`	2360	`.................... set_timer1(0); while ( get_timer1() < ticks ) ;`
2361	`0537: CLRF 0F`	2361	`0537: CLRF 0F`
2362	`0538: CLRF 0E`	2362	`0538: CLRF 0E`
2363	`0539: MOVF 0F,W`	2363	`0539: MOVF 0F,W`
2364	`053A: MOVWF 7A`	2364	`053A: MOVWF 7A`
2365	`053B: MOVF 0E,W`	2365	`053B: MOVF 0E,W`
2366	`053C: MOVWF 77`	2366	`053C: MOVWF 77`
2367	`053D: MOVF 0F,W`	2367	`053D: MOVF 0F,W`
2368	`053E: SUBWF 7A,W`	2368	`053E: SUBWF 7A,W`
2369	`053F: BTFSS 03.2`	2369	`053F: BTFSS 03.2`
2370	`0540: GOTO 539`	2370	`0540: GOTO 539`
2371	`0541: MOVF 77,W`	2371	`0541: MOVF 77,W`
2372	`0542: MOVWF 41`	2372	`0542: MOVWF 41`
2373	`0543: MOVF 7A,W`	2373	`0543: MOVF 7A,W`
2374	`0544: MOVWF 42`	2374	`0544: MOVWF 42`
2375	`0545: MOVF 42,W`	2375	`0545: MOVF 42,W`
2376	`0546: SUBWF 3F,W`	2376	`0546: SUBWF 3F,W`
2377	`0547: BTFSS 03.0`	2377	`0547: BTFSS 03.0`
2378	`0548: GOTO 54F`	2378	`0548: GOTO 54F`
2379	`0549: BTFSS 03.2`	2379	`0549: BTFSS 03.2`
2380	`054A: GOTO 539`	2380	`054A: GOTO 539`
2381	`054B: MOVF 3E,W`	2381	`054B: MOVF 3E,W`
2382	`054C: SUBWF 41,W`	2382	`054C: SUBWF 41,W`
2383	`054D: BTFSS 03.0`	2383	`054D: BTFSS 03.0`
2384	`054E: GOTO 539`	2384	`054E: GOTO 539`
2385	`.................... output_high(SYNC);`	2385	`.................... output_high(SYNC);`
2386	`054F: BSF 03.5`	2386	`054F: BSF 03.5`
2387	`0550: BCF 06.4`	2387	`0550: BCF 06.4`
2388	`0551: BCF 03.5`	2388	`0551: BCF 03.5`
2389	`0552: BSF 06.4`	2389	`0552: BSF 06.4`
2390	`.................... output_low(CLOCK);`	2390	`.................... output_low(CLOCK);`
2391	`0553: BSF 03.5`	2391	`0553: BSF 03.5`
2392	`0554: BCF 06.6`	2392	`0554: BCF 06.6`
2393	`0555: BCF 03.5`	2393	`0555: BCF 03.5`
2394	`0556: BCF 06.6`	2394	`0556: BCF 06.6`
2395	`.................... delay_ms(10);`	2395	`.................... delay_ms(10);`
2396	`0557: MOVLW 0A`	2396	`0557: MOVLW 0A`
2397	`0558: MOVWF 42`	2397	`0558: MOVWF 42`
2398	`0559: CALL 0E6`	2398	`0559: CALL 0E6`
2399	`.................... output_high(HACK);`	2399	`.................... output_high(HACK);`
2400	`055A: BSF 03.5`	2400	`055A: BSF 03.5`
2401	`055B: BCF 06.5`	2401	`055B: BCF 06.5`
2402	`055C: BCF 03.5`	2402	`055C: BCF 03.5`
2403	`055D: BSF 06.5`	2403	`055D: BSF 06.5`
2404	`.................... delay_ms(10000);`	2404	`.................... delay_ms(10000);`
2405	`055E: MOVLW 28`	2405	`055E: MOVLW 28`
2406	`055F: MOVWF 41`	2406	`055F: MOVWF 41`
2407	`0560: MOVLW FA`	2407	`0560: MOVLW FA`
2408	`0561: MOVWF 42`	2408	`0561: MOVWF 42`
2409	`0562: CALL 0E6`	2409	`0562: CALL 0E6`
2410	`0563: DECFSZ 41,F`	2410	`0563: DECFSZ 41,F`
2411	`0564: GOTO 560`	2411	`0564: GOTO 560`
2412	`.................... output_low(HACK);`	2412	`.................... output_low(HACK);`
2413	`0565: BSF 03.5`	2413	`0565: BSF 03.5`
2414	`0566: BCF 06.5`	2414	`0566: BCF 06.5`
2415	`0567: BCF 03.5`	2415	`0567: BCF 03.5`
2416	`0568: BCF 06.5`	2416	`0568: BCF 06.5`
2417	`.................... output_low(SYNC);`	2417	`.................... output_low(SYNC);`
2418	`0569: BSF 03.5`	2418	`0569: BSF 03.5`
2419	`056A: BCF 06.4`	2419	`056A: BCF 06.4`
2420	`056B: BCF 03.5`	2420	`056B: BCF 03.5`
2421	`056C: BCF 06.4`	2421	`056C: BCF 06.4`
2422	`.................... input(CLOCK);`	2422	`.................... input(CLOCK);`
2423	`056D: BSF 03.5`	2423	`056D: BSF 03.5`
2424	`056E: BSF 06.6`	2424	`056E: BSF 06.6`
2425	`.................... break;`	2425	`.................... break;`
2426	`056F: BCF 03.5`	2426	`056F: BCF 03.5`
2427	`0570: GOTO 61A`	2427	`0570: GOTO 61A`
2428	`....................`	2428	`....................`
2429	`.................... case 'i': // Info`	2429	`.................... case 'i': // Info`
2430	`.................... printf("%s\n\r", ver);`	2430	`.................... printf("%s\n\r", ver);`
2431	`0571: CLRF 41`	2431	`0571: CLRF 41`
2432	`0572: MOVF 41,W`	2432	`0572: MOVF 41,W`
2433	`0573: CALL 03F`	2433	`0573: CALL 03F`
2434	`0574: IORLW 00`	2434	`0574: IORLW 00`
2435	`0575: BTFSC 03.2`	2435	`0575: BTFSC 03.2`
2436	`0576: GOTO 57B`	2436	`0576: GOTO 57B`
2437	`0577: INCF 41,F`	2437	`0577: INCF 41,F`
2438	`0578: MOVWF 4C`	2438	`0578: MOVWF 4C`
2439	`0579: CALL 0FE`	2439	`0579: CALL 0FE`
2440	`057A: GOTO 572`	2440	`057A: GOTO 572`
2441	`057B: MOVLW 0A`	2441	`057B: MOVLW 0A`
2442	`057C: MOVWF 4C`	2442	`057C: MOVWF 4C`
2443	`057D: CALL 0FE`	2443	`057D: CALL 0FE`
2444	`057E: MOVLW 0D`	2444	`057E: MOVLW 0D`
2445	`057F: MOVWF 4C`	2445	`057F: MOVWF 4C`
2446	`0580: CALL 0FE`	2446	`0580: CALL 0FE`
2447	`.................... printf("%Lue4 + %Lu ticks", prescale, ticks);`	2447	`.................... printf("%Lue4 + %Lu ticks", prescale, ticks);`
2448	`0581: MOVLW 10`	2448	`0581: MOVLW 10`
2449	`0582: MOVWF 04`	2449	`0582: MOVWF 04`
2450	`0583: MOVF 3D,W`	2450	`0583: MOVF 3D,W`
2451	`0584: MOVWF 44`	2451	`0584: MOVWF 44`
2452	`0585: MOVF 3C,W`	2452	`0585: MOVF 3C,W`
2453	`0586: MOVWF 43`	2453	`0586: MOVWF 43`
2454	`0587: CALL 15F`	2454	`0587: CALL 15F`
2455	`0588: MOVLW 03`	2455	`0588: MOVLW 03`
2456	`0589: MOVWF 41`	2456	`0589: MOVWF 41`
2457	`058A: MOVF 41,W`	2457	`058A: MOVF 41,W`
2458	`058B: CALL 09D`	2458	`058B: CALL 09D`
2459	`058C: INCF 41,F`	2459	`058C: INCF 41,F`
2460	`058D: MOVWF 77`	2460	`058D: MOVWF 77`
2461	`058E: MOVWF 4C`	2461	`058E: MOVWF 4C`
2462	`058F: CALL 0FE`	2462	`058F: CALL 0FE`
2463	`0590: MOVLW 08`	2463	`0590: MOVLW 08`
2464	`0591: SUBWF 41,W`	2464	`0591: SUBWF 41,W`
2465	`0592: BTFSS 03.2`	2465	`0592: BTFSS 03.2`
2466	`0593: GOTO 58A`	2466	`0593: GOTO 58A`
2467	`0594: MOVLW 10`	2467	`0594: MOVLW 10`
2468	`0595: MOVWF 04`	2468	`0595: MOVWF 04`
2469	`0596: MOVF 3F,W`	2469	`0596: MOVF 3F,W`
2470	`0597: MOVWF 44`	2470	`0597: MOVWF 44`
2471	`0598: MOVF 3E,W`	2471	`0598: MOVF 3E,W`
2472	`0599: MOVWF 43`	2472	`0599: MOVWF 43`
2473	`059A: CALL 15F`	2473	`059A: CALL 15F`
2474	`059B: MOVLW 0B`	2474	`059B: MOVLW 0B`
2475	`059C: MOVWF 42`	2475	`059C: MOVWF 42`
2476	`059D: MOVF 42,W`	2476	`059D: MOVF 42,W`
2477	`059E: CALL 09D`	2477	`059E: CALL 09D`
2478	`059F: INCF 42,F`	2478	`059F: INCF 42,F`
2479	`05A0: MOVWF 77`	2479	`05A0: MOVWF 77`
2480	`05A1: MOVWF 4C`	2480	`05A1: MOVWF 4C`
2481	`05A2: CALL 0FE`	2481	`05A2: CALL 0FE`
2482	`05A3: MOVLW 11`	2482	`05A3: MOVLW 11`
2483	`05A4: SUBWF 42,W`	2483	`05A4: SUBWF 42,W`
2484	`05A5: BTFSS 03.2`	2484	`05A5: BTFSS 03.2`
2485	`05A6: GOTO 59D`	2485	`05A6: GOTO 59D`
2486	`.................... break;`	2486	`.................... break;`
2487	`05A7: GOTO 61A`	2487	`05A7: GOTO 61A`
2488	`....................`	2488	`....................`
2489	`.................... case 'p':`	2489	`.................... case 'p':`
2490	`.................... if (isdigit(string[1]))`	2490	`.................... if (isdigit(string[1]))`
2491	`05A8: MOVF 33,W`	2491	`05A8: MOVF 33,W`
2492	`05A9: SUBLW 2F`	2492	`05A9: SUBLW 2F`
2493	`05AA: BTFSC 03.0`	2493	`05AA: BTFSC 03.0`
2494	`05AB: GOTO 5DF`	2494	`05AB: GOTO 5DF`
2495	`05AC: MOVF 33,W`	2495	`05AC: MOVF 33,W`
2496	`05AD: SUBLW 39`	2496	`05AD: SUBLW 39`
2497	`05AE: BTFSS 03.0`	2497	`05AE: BTFSS 03.0`
2498	`05AF: GOTO 5DF`	2498	`05AF: GOTO 5DF`
2499	`.................... {`	2499	`.................... {`
2500	`.................... prescale=atol(string+1);`	2500	`.................... prescale=atol(string+1);`
2501	`05B0: CLRF 42`	2501	`05B0: CLRF 42`
2502	`05B1: MOVLW 33`	2502	`05B1: MOVLW 33`
2503	`05B2: MOVWF 41`	2503	`05B2: MOVWF 41`
2504	`05B3: CALL 242`	2504	`05B3: CALL 242`
2505	`05B4: MOVF 79,W`	2505	`05B4: MOVF 79,W`
2506	`05B5: MOVWF 3D`	2506	`05B5: MOVWF 3D`
2507	`05B6: MOVF 78,W`	2507	`05B6: MOVF 78,W`
2508	`05B7: MOVWF 3C`	2508	`05B7: MOVWF 3C`
2509	`.................... printf("%Lu x 10000 prescale", prescale);`	2509	`.................... printf("%Lu x 10000 prescale", prescale);`
2510	`05B8: MOVLW 10`	2510	`05B8: MOVLW 10`
2511	`05B9: MOVWF 04`	2511	`05B9: MOVWF 04`
2512	`05BA: MOVF 3D,W`	2512	`05BA: MOVF 3D,W`
2513	`05BB: MOVWF 44`	2513	`05BB: MOVWF 44`
2514	`05BC: MOVF 3C,W`	2514	`05BC: MOVF 3C,W`
2515	`05BD: MOVWF 43`	2515	`05BD: MOVWF 43`
2516	`05BE: CALL 15F`	2516	`05BE: CALL 15F`
2517	`05BF: MOVLW 03`	2517	`05BF: MOVLW 03`
2518	`05C0: MOVWF 41`	2518	`05C0: MOVWF 41`
2519	`05C1: MOVF 41,W`	2519	`05C1: MOVF 41,W`
2520	`05C2: CALL 0B3`	2520	`05C2: CALL 0B3`
2521	`05C3: INCF 41,F`	2521	`05C3: INCF 41,F`
2522	`05C4: MOVWF 77`	2522	`05C4: MOVWF 77`
2523	`05C5: MOVWF 4C`	2523	`05C5: MOVWF 4C`
2524	`05C6: CALL 0FE`	2524	`05C6: CALL 0FE`
2525	`05C7: MOVLW 07`	2525	`05C7: MOVLW 07`
2526	`05C8: SUBWF 41,W`	2526	`05C8: SUBWF 41,W`
2527	`05C9: BTFSS 03.2`	2527	`05C9: BTFSS 03.2`
2528	`05CA: GOTO 5C1`	2528	`05CA: GOTO 5C1`
2529	`05CB: MOVLW 04`	2529	`05CB: MOVLW 04`
2530	`05CC: MOVWF 42`	2530	`05CC: MOVWF 42`
2531	`05CD: MOVLW 30`	2531	`05CD: MOVLW 30`
2532	`05CE: MOVWF 4C`	2532	`05CE: MOVWF 4C`
2533	`05CF: CALL 0FE`	2533	`05CF: CALL 0FE`
2534	`05D0: DECFSZ 42,F`	2534	`05D0: DECFSZ 42,F`
2535	`05D1: GOTO 5CD`	2535	`05D1: GOTO 5CD`
2536	`05D2: MOVLW 07`	2536	`05D2: MOVLW 07`
2537	`05D3: MOVWF 43`	2537	`05D3: MOVWF 43`
2538	`05D4: MOVF 43,W`	2538	`05D4: MOVF 43,W`
2539	`05D5: CALL 0B3`	2539	`05D5: CALL 0B3`
2540	`05D6: INCF 43,F`	2540	`05D6: INCF 43,F`
2541	`05D7: MOVWF 77`	2541	`05D7: MOVWF 77`
2542	`05D8: MOVWF 4C`	2542	`05D8: MOVWF 4C`
2543	`05D9: CALL 0FE`	2543	`05D9: CALL 0FE`
2544	`05DA: MOVLW 10`	2544	`05DA: MOVLW 10`
2545	`05DB: SUBWF 43,W`	2545	`05DB: SUBWF 43,W`
2546	`05DC: BTFSS 03.2`	2546	`05DC: BTFSS 03.2`
2547	`05DD: GOTO 5D4`	2547	`05DD: GOTO 5D4`
2548	`.................... }`	2548	`.................... }`
2549	`.................... else`	2549	`.................... else`
2550	`05DE: GOTO 5EA`	2550	`05DE: GOTO 5EA`
2551	`.................... printf("Error");`	2551	`.................... printf("Error");`
2552	`05DF: CLRF 41`	2552	`05DF: CLRF 41`
2553	`05E0: MOVF 41,W`	2553	`05E0: MOVF 41,W`
2554	`05E1: CALL 0C8`	2554	`05E1: CALL 0C8`
2555	`05E2: INCF 41,F`	2555	`05E2: INCF 41,F`
2556	`05E3: MOVWF 77`	2556	`05E3: MOVWF 77`
2557	`05E4: MOVWF 4C`	2557	`05E4: MOVWF 4C`
2558	`05E5: CALL 0FE`	2558	`05E5: CALL 0FE`
2559	`05E6: MOVLW 05`	2559	`05E6: MOVLW 05`
2560	`05E7: SUBWF 41,W`	2560	`05E7: SUBWF 41,W`
2561	`05E8: BTFSS 03.2`	2561	`05E8: BTFSS 03.2`
2562	`05E9: GOTO 5E0`	2562	`05E9: GOTO 5E0`
2563	`.................... break;`	2563	`.................... break;`
2564	`05EA: GOTO 61A`	2564	`05EA: GOTO 61A`
2565	`....................`	2565	`....................`
2566	`.................... default: // fine ticks number`	2566	`.................... default: // fine ticks number`
2567	`.................... if (isdigit(string[0]))`	2567	`.................... if (isdigit(string[0]))`
2568	`05EB: MOVF 32,W`	2568	`05EB: MOVF 32,W`
2569	`05EC: SUBLW 2F`	2569	`05EC: SUBLW 2F`
2570	`05ED: BTFSC 03.0`	2570	`05ED: BTFSC 03.0`
2571	`05EE: GOTO 60F`	2571	`05EE: GOTO 60F`
2572	`05EF: MOVF 32,W`	2572	`05EF: MOVF 32,W`
2573	`05F0: SUBLW 39`	2573	`05F0: SUBLW 39`
2574	`05F1: BTFSS 03.0`	2574	`05F1: BTFSS 03.0`
2575	`05F2: GOTO 60F`	2575	`05F2: GOTO 60F`
2576	`.................... {`	2576	`.................... {`
2577	`.................... ticks=atol(string);`	2577	`.................... ticks=atol(string);`
2578	`05F3: CLRF 42`	2578	`05F3: CLRF 42`
2579	`05F4: MOVLW 32`	2579	`05F4: MOVLW 32`
2580	`05F5: MOVWF 41`	2580	`05F5: MOVWF 41`
2581	`05F6: CALL 242`	2581	`05F6: CALL 242`
2582	`05F7: MOVF 79,W`	2582	`05F7: MOVF 79,W`
2583	`05F8: MOVWF 3F`	2583	`05F8: MOVWF 3F`
2584	`05F9: MOVF 78,W`	2584	`05F9: MOVF 78,W`
2585	`05FA: MOVWF 3E`	2585	`05FA: MOVWF 3E`
2586	`.................... printf("%Lu ticks", ticks);`	2586	`.................... printf("%Lu ticks", ticks);`
2587	`05FB: MOVLW 10`	2587	`05FB: MOVLW 10`
2588	`05FC: MOVWF 04`	2588	`05FC: MOVWF 04`
2589	`05FD: MOVF 3F,W`	2589	`05FD: MOVF 3F,W`
2590	`05FE: MOVWF 44`	2590	`05FE: MOVWF 44`
2591	`05FF: MOVF 3E,W`	2591	`05FF: MOVF 3E,W`
2592	`0600: MOVWF 43`	2592	`0600: MOVWF 43`
2593	`0601: CALL 15F`	2593	`0601: CALL 15F`
2594	`0602: MOVLW 03`	2594	`0602: MOVLW 03`
2595	`0603: MOVWF 41`	2595	`0603: MOVWF 41`
2596	`0604: MOVF 41,W`	2596	`0604: MOVF 41,W`
2597	`0605: CALL 0D2`	2597	`0605: CALL 0D2`
2598	`0606: INCF 41,F`	2598	`0606: INCF 41,F`
2599	`0607: MOVWF 77`	2599	`0607: MOVWF 77`
2600	`0608: MOVWF 4C`	2600	`0608: MOVWF 4C`
2601	`0609: CALL 0FE`	2601	`0609: CALL 0FE`
2602	`060A: MOVLW 09`	2602	`060A: MOVLW 09`
2603	`060B: SUBWF 41,W`	2603	`060B: SUBWF 41,W`
2604	`060C: BTFSS 03.2`	2604	`060C: BTFSS 03.2`
2605	`060D: GOTO 604`	2605	`060D: GOTO 604`
2606	`.................... }`	2606	`.................... }`
2607	`.................... else`	2607	`.................... else`
2608	`060E: GOTO 61A`	2608	`060E: GOTO 61A`
2609	`.................... printf("Error");`	2609	`.................... printf("Error");`
2610	`060F: CLRF 41`	2610	`060F: CLRF 41`
2611	`0610: MOVF 41,W`	2611	`0610: MOVF 41,W`
2612	`0611: CALL 0C8`	2612	`0611: CALL 0C8`
2613	`0612: INCF 41,F`	2613	`0612: INCF 41,F`
2614	`0613: MOVWF 77`	2614	`0613: MOVWF 77`
2615	`0614: MOVWF 4C`	2615	`0614: MOVWF 4C`
2616	`0615: CALL 0FE`	2616	`0615: CALL 0FE`
2617	`0616: MOVLW 05`	2617	`0616: MOVLW 05`
2618	`0617: SUBWF 41,W`	2618	`0617: SUBWF 41,W`
2619	`0618: BTFSS 03.2`	2619	`0618: BTFSS 03.2`
2620	`0619: GOTO 610`	2620	`0619: GOTO 610`
2621	`.................... };`	2621	`.................... };`
2622	`....................`	2622	`....................`
2623	`.................... };`	2623	`.................... };`
2624	`061A: GOTO 3B6`	2624	`061A: GOTO 3B6`
2625	`....................`	2625	`....................`
2626	`.................... while(true)`	2626	`.................... while(true)`
2627	`.................... {`	2627	`.................... {`
2628	`.................... output_low(PIN_B4);`	2628	`.................... output_low(PIN_B4);`
2629	`061B: BSF 03.5`	2629	`061B: BSF 03.5`
2630	`061C: BCF 06.4`	2630	`061C: BCF 06.4`
2631	`061D: BCF 03.5`	2631	`061D: BCF 03.5`
2632	`061E: BCF 06.4`	2632	`061E: BCF 06.4`
2633	`.................... delay_ms(300);`	2633	`.................... delay_ms(300);`
2634	`061F: MOVLW 02`	2634	`061F: MOVLW 02`
2635	`0620: MOVWF 41`	2635	`0620: MOVWF 41`
2636	`0621: MOVLW 96`	2636	`0621: MOVLW 96`
2637	`0622: MOVWF 42`	2637	`0622: MOVWF 42`
2638	`0623: CALL 0E6`	2638	`0623: CALL 0E6`
2639	`0624: DECFSZ 41,F`	2639	`0624: DECFSZ 41,F`
2640	`0625: GOTO 621`	2640	`0625: GOTO 621`
2641	`.................... output_high(PIN_B4);`	2641	`.................... output_high(PIN_B4);`
2642	`0626: BSF 03.5`	2642	`0626: BSF 03.5`
2643	`0627: BCF 06.4`	2643	`0627: BCF 06.4`
2644	`0628: BCF 03.5`	2644	`0628: BCF 03.5`
2645	`0629: BSF 06.4`	2645	`0629: BSF 06.4`
2646	`.................... delay_ms(300);`	2646	`.................... delay_ms(300);`
2647	`062A: MOVLW 02`	2647	`062A: MOVLW 02`
2648	`062B: MOVWF 41`	2648	`062B: MOVWF 41`
2649	`062C: MOVLW 96`	2649	`062C: MOVLW 96`
2650	`062D: MOVWF 42`	2650	`062D: MOVWF 42`
2651	`062E: CALL 0E6`	2651	`062E: CALL 0E6`
2652	`062F: DECFSZ 41,F`	2652	`062F: DECFSZ 41,F`
2653	`0630: GOTO 62C`	2653	`0630: GOTO 62C`
2654	`.................... }`	2654	`.................... }`
2655	`0631: GOTO 61B`	2655	`0631: GOTO 61B`
2656	`.................... }`	2656	`.................... }`
2657	`....................`	2657	`....................`
2658	`0632: GOTO 632`	2658	`0632: GOTO 632`
2659		2659
2660	`Configuration Fuses:`	2660	`Configuration Fuses:`
2661	`Word 1: 3731 NOWDT PUT MCLR NOBROWNOUT NOLVP NOCPD NOWRT DEBUG CCPB0 NOPROTECT INTRC`	2661	`Word 1: 3731 NOWDT PUT MCLR NOBROWNOUT NOLVP NOCPD NOWRT DEBUG CCPB0 NOPROTECT INTRC`
2662	`Word 2: 3FFC NOFCMEN NOIESO`	2662	`Word 2: 3FFC NOFCMEN NOIESO`

Subversion Repositories svnkaklik

(root)/programy/C/PIC/hack/hack.LST @ 661 – Rev 6 → 410