WebSVN – MLAB – Rev 2988 and 2985 – Diff – /Modules/Sensors/MAG01A/SW/PIC16F887/main.lst

Rev 2985		Rev 2988
Line 1...		Line 1...
1	`CCS PCM C Compiler, Version 4.106, 47914 15-V-13 18:53`	1	`CCS PCM C Compiler, Version 4.106, 47914 15-V-13 20:34`
2		2
3	`Filename: Z:\home\kaklik\svnMLAB\Modules\Sensors\MAG01A\SW\PIC16F887\main.lst`	3	`Filename: Z:\home\kaklik\svnMLAB\Modules\Sensors\MAG01A\SW\PIC16F887\main.lst`
4		4
5	`ROM used: 821 words (10%)`	5	`ROM used: 775 words (9%)`
6	`Largest free fragment is 2048`	6	`Largest free fragment is 2048`
7	`RAM used: 18 (5%) at main() level`	7	`RAM used: 28 (8%) at main() level`
8	`27 (7%) worst case`	8	`38 (10%) worst case`
9	`Stack: 2 locations`	9	`Stack: 2 locations`
10		10
11	`*`	11	`*`
12	`0000: MOVLW 02`	12	`0000: MOVLW 02`
13	`0001: MOVWF 0A`	13	`0001: MOVWF 0A`
14	`0002: GOTO 250`	14	`0002: GOTO 24F`
15	`0003: NOP`	15	`0003: NOP`
16	`.................... #include "main.h"`	16	`.................... #include "main.h"`
17	`.................... #include <16F887.h>`	17	`.................... #include <16F887.h>`
18	`.................... //////// Standard Header file for the PIC16F887 device ////////////////`	18	`.................... //////// Standard Header file for the PIC16F887 device ////////////////`
19	`.................... #device PIC16F887`	19	`.................... #device PIC16F887`
Line 46...		Line 46...
46	`0024: MOVF 20,W`	46	`0024: MOVF 20,W`
47	`0025: BSF 03.5`	47	`0025: BSF 03.5`
48	`0026: MOVWF 07`	48	`0026: MOVWF 07`
49	`0027: NOP`	49	`0027: NOP`
50	`0028: BCF 03.5`	50	`0028: BCF 03.5`
51	`0029: RLF 32,F`	51	`0029: RLF 3D,F`
52	`002A: BCF 07.4`	52	`002A: BCF 07.4`
53	`002B: BTFSS 03.0`	53	`002B: BTFSS 03.0`
54	`002C: GOTO 033`	54	`002C: GOTO 033`
55	`002D: BSF 20.4`	55	`002D: BSF 20.4`
56	`002E: MOVF 20,W`	56	`002E: MOVF 20,W`
Line 111...		Line 111...
111	`0065: BSF 03.5`	111	`0065: BSF 03.5`
112	`0066: MOVWF 07`	112	`0066: MOVWF 07`
113	`0067: BCF 03.5`	113	`0067: BCF 03.5`
114	`0068: RETURN`	114	`0068: RETURN`
115	`*`	115	`*`
116	`010C: MOVLW 08`	116	`010B: MOVLW 08`
117	`010D: MOVWF 33`	117	`010C: MOVWF 3E`
118	`010E: MOVF 77,W`	118	`010D: MOVF 77,W`
119	`010F: MOVWF 34`	119	`010E: MOVWF 3F`
120	`0110: BSF 20.4`	120	`010F: BSF 20.4`
121	`0111: MOVF 20,W`	121	`0110: MOVF 20,W`
122	`0112: BSF 03.5`	122	`0111: BSF 03.5`
123	`0113: MOVWF 07`	123	`0112: MOVWF 07`
124	`0114: NOP`	124	`0113: NOP`
125	`0115: BCF 03.5`	125	`0114: BCF 03.5`
126	`0116: BSF 20.3`	126	`0115: BSF 20.3`
127	`0117: MOVF 20,W`	127	`0116: MOVF 20,W`
128	`0118: BSF 03.5`	128	`0117: BSF 03.5`
129	`0119: MOVWF 07`	129	`0118: MOVWF 07`
130	`011A: BCF 03.5`	130	`0119: BCF 03.5`
131	`011B: BTFSS 07.3`	131	`011A: BTFSS 07.3`
132	`011C: GOTO 11B`	132	`011B: GOTO 11A`
133	`011D: BTFSC 07.4`	133	`011C: BTFSC 07.4`
134	`011E: BSF 03.0`	134	`011D: BSF 03.0`
135	`011F: BTFSS 07.4`	135	`011E: BTFSS 07.4`
136	`0120: BCF 03.0`	136	`011F: BCF 03.0`
137	`0121: RLF 78,F`	137	`0120: RLF 78,F`
138	`0122: NOP`	138	`0121: NOP`
139	`0123: BCF 20.3`	139	`0122: BCF 20.3`
140	`0124: MOVF 20,W`	140	`0123: MOVF 20,W`
141	`0125: BSF 03.5`	141	`0124: BSF 03.5`
142	`0126: MOVWF 07`	142	`0125: MOVWF 07`
143	`0127: BCF 03.5`	143	`0126: BCF 03.5`
144	`0128: BCF 07.3`	144	`0127: BCF 07.3`
145	`0129: DECFSZ 33,F`	145	`0128: DECFSZ 3E,F`
146	`012A: GOTO 110`	146	`0129: GOTO 10F`
147	`012B: BSF 20.4`	147	`012A: BSF 20.4`
148	`012C: MOVF 20,W`	148	`012B: MOVF 20,W`
149	`012D: BSF 03.5`	149	`012C: BSF 03.5`
150	`012E: MOVWF 07`	150	`012D: MOVWF 07`
151	`012F: NOP`	151	`012E: NOP`
152	`0130: BCF 03.5`	152	`012F: BCF 03.5`
153	`0131: BCF 07.4`	153	`0130: BCF 07.4`
154	`0132: MOVF 34,W`	154	`0131: MOVF 3F,W`
155	`0133: BTFSC 03.2`	155	`0132: BTFSC 03.2`
156	`0134: GOTO 13A`	156	`0133: GOTO 139`
157	`0135: BCF 20.4`	157	`0134: BCF 20.4`
158	`0136: MOVF 20,W`	158	`0135: MOVF 20,W`
159	`0137: BSF 03.5`	159	`0136: BSF 03.5`
160	`0138: MOVWF 07`	160	`0137: MOVWF 07`
161	`0139: BCF 03.5`	161	`0138: BCF 03.5`
162	`013A: NOP`	162	`0139: NOP`
163	`013B: BSF 20.3`	163	`013A: BSF 20.3`
164	`013C: MOVF 20,W`	164	`013B: MOVF 20,W`
165	`013D: BSF 03.5`	165	`013C: BSF 03.5`
166	`013E: MOVWF 07`	166	`013D: MOVWF 07`
167	`013F: BCF 03.5`	167	`013E: BCF 03.5`
168	`0140: BTFSS 07.3`	168	`013F: BTFSS 07.3`
169	`0141: GOTO 140`	169	`0140: GOTO 13F`
170	`0142: NOP`	170	`0141: NOP`
171	`0143: BCF 07.3`	171	`0142: BCF 07.3`
172	`0144: BCF 20.3`	172	`0143: BCF 20.3`
173	`0145: MOVF 20,W`	173	`0144: MOVF 20,W`
174	`0146: BSF 03.5`	174	`0145: BSF 03.5`
175	`0147: MOVWF 07`	175	`0146: MOVWF 07`
176	`0148: NOP`	176	`0147: NOP`
177	`0149: BCF 03.5`	177	`0148: BCF 03.5`
178	`014A: BCF 07.4`	178	`0149: BCF 07.4`
179	`014B: BCF 20.4`	179	`014A: BCF 20.4`
180	`014C: MOVF 20,W`	180	`014B: MOVF 20,W`
181	`014D: BSF 03.5`	181	`014C: BSF 03.5`
182	`014E: MOVWF 07`	182	`014D: MOVWF 07`
183	`014F: BCF 03.5`	183	`014E: BCF 03.5`
184	`0150: RETURN`	184	`014F: RETURN`
185	`.................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD`	185	`.................... #use rs232(baud=115200,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD`
186	`*`	186	`*`
187	`00A2: BCF 20.7`	187	`00A2: BCF 20.7`
188	`00A3: MOVF 20,W`	188	`00A3: MOVF 20,W`
189	`00A4: BSF 03.5`	189	`00A4: BSF 03.5`
190	`00A5: MOVWF 07`	190	`00A5: MOVWF 07`
Line 193...		Line 193...
193	`00A8: MOVLW 08`	193	`00A8: MOVLW 08`
194	`00A9: MOVWF 78`	194	`00A9: MOVWF 78`
195	`00AA: GOTO 0AB`	195	`00AA: GOTO 0AB`
196	`00AB: NOP`	196	`00AB: NOP`
197	`00AC: BSF 78.7`	197	`00AC: BSF 78.7`
198	`00AD: GOTO 0BC`	198	`00AD: GOTO 0C0`
199	`00AE: BCF 78.7`	199	`00AE: BCF 78.7`
200	`00AF: RRF 35,F`	200	`00AF: MOVF 40,W`
201	`00B0: BTFSC 03.0`	201	`00B0: MOVWF 79`
202	`00B1: BSF 07.7`	202	`00B1: RRF 79,F`
203	`00B2: BTFSS 03.0`	203	`00B2: BTFSC 03.0`
204	`00B3: BCF 07.7`	204	`00B3: BSF 07.7`
205	`00B4: BSF 78.6`	205	`00B4: BTFSS 03.0`
206	`00B5: GOTO 0BC`	206	`00B5: BCF 07.7`
207	`00B6: BCF 78.6`	207	`00B6: BSF 78.6`
208	`00B7: DECFSZ 78,F`	208	`00B7: GOTO 0C0`
209	`00B8: GOTO 0AF`	209	`00B8: BCF 78.6`
210	`00B9: GOTO 0BA`	210	`00B9: DECFSZ 78,F`
211	`00BA: NOP`	211	`00BA: GOTO 0B1`
212	`00BB: BSF 07.7`	212	`00BB: MOVF 79,W`
213	`00BC: MOVLW 3F`	213	`00BC: MOVWF 40`
214	`00BD: MOVWF 04`	214	`00BD: GOTO 0BE`
215	`00BE: DECFSZ 04,F`	215	`00BE: NOP`
216	`00BF: GOTO 0BE`	216	`00BF: BSF 07.7`
217	`00C0: NOP`	-
218	`00C1: BTFSC 78.7`	217	`00C0: BTFSC 78.7`
219	`00C2: GOTO 0AE`	218	`00C1: GOTO 0AE`
220	`00C3: BTFSC 78.6`	219	`00C2: BTFSC 78.6`
221	`00C4: GOTO 0B6`	220	`00C3: GOTO 0B8`
222	`00C5: RETURN`	221	`00C4: RETURN`
223	`....................`	222	`....................`
224	`....................`	223	`....................`
225	`.................... #include "HMC5883L.h"`	224	`.................... #include "HMC5883L.h"`
226	`.................... #define MAG_ADDR_R 0x3D //addresa pro cteni`	225	`.................... #define MAG_ADDR_R 0x3D //addresa pro cteni`
227	`.................... #define MAG_ADDR_W 0x3C`	226	`.................... #define MAG_ADDR_W 0x3C`
Line 282...		Line 281...
282	`007F: BSF 03.5`	281	`007F: BSF 03.5`
283	`0080: MOVWF 07`	282	`0080: MOVWF 07`
284	`.................... i2c_write(HMC5883L_WRT_ADDR);`	283	`.................... i2c_write(HMC5883L_WRT_ADDR);`
285	`0081: MOVLW 3C`	284	`0081: MOVLW 3C`
286	`0082: BCF 03.5`	285	`0082: BCF 03.5`
287	`0083: MOVWF 32`	286	`0083: MOVWF 3D`
288	`0084: CALL 01F`	287	`0084: CALL 01F`
289	`.................... i2c_write(reg);`	288	`.................... i2c_write(reg);`
290	`0085: MOVF 2C,W`	289	`0085: MOVF 37,W`
291	`0086: MOVWF 32`	290	`0086: MOVWF 3D`
292	`0087: CALL 01F`	291	`0087: CALL 01F`
293	`.................... i2c_write(data);`	292	`.................... i2c_write(data);`
294	`0088: MOVF 2D,W`	293	`0088: MOVF 38,W`
295	`0089: MOVWF 32`	294	`0089: MOVWF 3D`
296	`008A: CALL 01F`	295	`008A: CALL 01F`
297	`.................... i2c_stop();`	296	`.................... i2c_stop();`
298	`008B: BCF 20.4`	297	`008B: BCF 20.4`
299	`008C: MOVF 20,W`	298	`008C: MOVF 20,W`
300	`008D: BSF 03.5`	299	`008D: BSF 03.5`
Line 346...		Line 345...
346	`....................`	345	`....................`
347	`.................... // This global structure holds the values read`	346	`.................... // This global structure holds the values read`
348	`.................... // from the HMC5883L x,y,z registers.`	347	`.................... // from the HMC5883L x,y,z registers.`
349	`.................... hmc5883l_result compass = {0,0,0};`	348	`.................... hmc5883l_result compass = {0,0,0};`
350	`*`	349	`*`
351	`0271: CLRF 21`	350	`0270: CLRF 21`
352	`0272: CLRF 22`	351	`0271: CLRF 22`
353	`0273: CLRF 23`	352	`0272: CLRF 23`
354	`0274: CLRF 24`	353	`0273: CLRF 24`
355	`0275: CLRF 25`	354	`0274: CLRF 25`
356	`0276: CLRF 26`	355	`0275: CLRF 26`
357	`....................`	356	`....................`
358	`.................... //------------------------------`	357	`.................... //------------------------------`
359	`.................... void hmc5883l_read_data(void)`	358	`.................... void hmc5883l_read_data(void)`
360	`.................... {`	359	`.................... {`
361	`.................... unsigned int8 x_lsb;`	360	`.................... unsigned int8 x_lsb;`
Line 367...		Line 366...
367	`.................... unsigned int8 z_lsb;`	366	`.................... unsigned int8 z_lsb;`
368	`.................... unsigned int8 z_msb;`	367	`.................... unsigned int8 z_msb;`
369	`....................`	368	`....................`
370	`.................... i2c_start();`	369	`.................... i2c_start();`
371	`*`	370	`*`
372	`0151: BSF 20.4`	371	`0150: BSF 20.4`
373	`0152: MOVF 20,W`	372	`0151: MOVF 20,W`
374	`0153: BSF 03.5`	373	`0152: BSF 03.5`
375	`0154: MOVWF 07`	374	`0153: MOVWF 07`
376	`0155: NOP`	375	`0154: NOP`
377	`0156: BCF 03.5`	376	`0155: BCF 03.5`
378	`0157: BSF 20.3`	377	`0156: BSF 20.3`
379	`0158: MOVF 20,W`	378	`0157: MOVF 20,W`
380	`0159: BSF 03.5`	379	`0158: BSF 03.5`
381	`015A: MOVWF 07`	380	`0159: MOVWF 07`
382	`015B: NOP`	381	`015A: NOP`
383	`015C: BCF 03.5`	382	`015B: BCF 03.5`
384	`015D: BCF 07.4`	383	`015C: BCF 07.4`
385	`015E: BCF 20.4`	384	`015D: BCF 20.4`
386	`015F: MOVF 20,W`	385	`015E: MOVF 20,W`
387	`0160: BSF 03.5`	386	`015F: BSF 03.5`
388	`0161: MOVWF 07`	387	`0160: MOVWF 07`
389	`0162: NOP`	388	`0161: NOP`
390	`0163: BCF 03.5`	389	`0162: BCF 03.5`
391	`0164: BCF 07.3`	390	`0163: BCF 07.3`
392	`0165: BCF 20.3`	391	`0164: BCF 20.3`
393	`0166: MOVF 20,W`	392	`0165: MOVF 20,W`
394	`0167: BSF 03.5`	393	`0166: BSF 03.5`
395	`0168: MOVWF 07`	394	`0167: MOVWF 07`
396	`.................... i2c_write(HMC5883L_WRT_ADDR);`	395	`.................... i2c_write(HMC5883L_WRT_ADDR);`
397	`0169: MOVLW 3C`	396	`0168: MOVLW 3C`
398	`016A: BCF 03.5`	397	`0169: BCF 03.5`
399	`016B: MOVWF 32`	398	`016A: MOVWF 3D`
400	`016C: CALL 01F`	399	`016B: CALL 01F`
401	`.................... i2c_write(HMC5883L_X_MSB_REG); // Point to X-msb register`	400	`.................... i2c_write(HMC5883L_X_MSB_REG); // Point to X-msb register`
402	`016D: MOVLW 03`	401	`016C: MOVLW 03`
403	`016E: MOVWF 32`	402	`016D: MOVWF 3D`
404	`016F: CALL 01F`	403	`016E: CALL 01F`
405	`.................... i2c_start();`	404	`.................... i2c_start();`
406	`0170: BSF 20.4`	405	`016F: BSF 20.4`
407	`0171: MOVF 20,W`	406	`0170: MOVF 20,W`
408	`0172: BSF 03.5`	407	`0171: BSF 03.5`
409	`0173: MOVWF 07`	408	`0172: MOVWF 07`
410	`0174: NOP`	409	`0173: NOP`
411	`0175: BCF 03.5`	410	`0174: BCF 03.5`
412	`0176: BSF 20.3`	411	`0175: BSF 20.3`
413	`0177: MOVF 20,W`	412	`0176: MOVF 20,W`
414	`0178: BSF 03.5`	413	`0177: BSF 03.5`
415	`0179: MOVWF 07`	414	`0178: MOVWF 07`
416	`017A: NOP`	415	`0179: NOP`
417	`017B: BCF 03.5`	416	`017A: BCF 03.5`
418	`017C: BTFSS 07.3`	417	`017B: BTFSS 07.3`
419	`017D: GOTO 17C`	418	`017C: GOTO 17B`
420	`017E: BCF 07.4`	419	`017D: BCF 07.4`
421	`017F: BCF 20.4`	420	`017E: BCF 20.4`
422	`0180: MOVF 20,W`	421	`017F: MOVF 20,W`
423	`0181: BSF 03.5`	422	`0180: BSF 03.5`
424	`0182: MOVWF 07`	423	`0181: MOVWF 07`
425	`0183: NOP`	424	`0182: NOP`
426	`0184: BCF 03.5`	425	`0183: BCF 03.5`
427	`0185: BCF 07.3`	426	`0184: BCF 07.3`
428	`0186: BCF 20.3`	427	`0185: BCF 20.3`
429	`0187: MOVF 20,W`	428	`0186: MOVF 20,W`
430	`0188: BSF 03.5`	429	`0187: BSF 03.5`
431	`0189: MOVWF 07`	430	`0188: MOVWF 07`
432	`.................... i2c_write(HMC5883L_READ_ADDR);`	431	`.................... i2c_write(HMC5883L_READ_ADDR);`
433	`018A: MOVLW 3D`	432	`0189: MOVLW 3D`
434	`018B: BCF 03.5`	433	`018A: BCF 03.5`
435	`018C: MOVWF 32`	434	`018B: MOVWF 3D`
436	`018D: CALL 01F`	435	`018C: CALL 01F`
437	`....................`	436	`....................`
438	`.................... x_msb = i2c_read();`	437	`.................... x_msb = i2c_read();`
439	`018E: MOVLW 01`	438	`018D: MOVLW 01`
440	`018F: MOVWF 77`	439	`018E: MOVWF 77`
441	`0190: CALL 10C`	440	`018F: CALL 10B`
442	`0191: MOVF 78,W`	441	`0190: MOVF 78,W`
443	`0192: MOVWF 2D`	442	`0191: MOVWF 38`
444	`.................... x_lsb = i2c_read();`	443	`.................... x_lsb = i2c_read();`
445	`0193: MOVLW 01`	444	`0192: MOVLW 01`
446	`0194: MOVWF 77`	445	`0193: MOVWF 77`
447	`0195: CALL 10C`	446	`0194: CALL 10B`
448	`0196: MOVF 78,W`	447	`0195: MOVF 78,W`
449	`0197: MOVWF 2C`	448	`0196: MOVWF 37`
450	`....................`	449	`....................`
451	`.................... z_msb = i2c_read();`	450	`.................... z_msb = i2c_read();`
452	`0198: MOVLW 01`	451	`0197: MOVLW 01`
453	`0199: MOVWF 77`	452	`0198: MOVWF 77`
454	`019A: CALL 10C`	453	`0199: CALL 10B`
455	`019B: MOVF 78,W`	454	`019A: MOVF 78,W`
456	`019C: MOVWF 31`	455	`019B: MOVWF 3C`
457	`.................... z_lsb = i2c_read();`	456	`.................... z_lsb = i2c_read();`
458	`019D: MOVLW 01`	457	`019C: MOVLW 01`
459	`019E: MOVWF 77`	458	`019D: MOVWF 77`
460	`019F: CALL 10C`	459	`019E: CALL 10B`
461	`01A0: MOVF 78,W`	460	`019F: MOVF 78,W`
462	`01A1: MOVWF 30`	461	`01A0: MOVWF 3B`
463	`....................`	462	`....................`
464	`.................... y_msb = i2c_read();`	463	`.................... y_msb = i2c_read();`
465	`01A2: MOVLW 01`	464	`01A1: MOVLW 01`
466	`01A3: MOVWF 77`	465	`01A2: MOVWF 77`
467	`01A4: CALL 10C`	466	`01A3: CALL 10B`
468	`01A5: MOVF 78,W`	467	`01A4: MOVF 78,W`
469	`01A6: MOVWF 2F`	468	`01A5: MOVWF 3A`
470	`.................... y_lsb = i2c_read(0); // do a NACK on last read`	469	`.................... y_lsb = i2c_read(0); // do a NACK on last read`
471	`01A7: CLRF 77`	470	`01A6: CLRF 77`
472	`01A8: CALL 10C`	471	`01A7: CALL 10B`
473	`01A9: MOVF 78,W`	472	`01A8: MOVF 78,W`
474	`01AA: MOVWF 2E`	473	`01A9: MOVWF 39`
475	`....................`	474	`....................`
476	`.................... i2c_stop();`	475	`.................... i2c_stop();`
477	`01AB: BCF 20.4`	476	`01AA: BCF 20.4`
478	`01AC: MOVF 20,W`	477	`01AB: MOVF 20,W`
479	`01AD: BSF 03.5`	478	`01AC: BSF 03.5`
480	`01AE: MOVWF 07`	479	`01AD: MOVWF 07`
481	`01AF: NOP`	480	`01AE: NOP`
482	`01B0: BCF 03.5`	481	`01AF: BCF 03.5`
483	`01B1: BSF 20.3`	482	`01B0: BSF 20.3`
484	`01B2: MOVF 20,W`	483	`01B1: MOVF 20,W`
485	`01B3: BSF 03.5`	484	`01B2: BSF 03.5`
486	`01B4: MOVWF 07`	485	`01B3: MOVWF 07`
487	`01B5: BCF 03.5`	486	`01B4: BCF 03.5`
488	`01B6: BTFSS 07.3`	487	`01B5: BTFSS 07.3`
489	`01B7: GOTO 1B6`	488	`01B6: GOTO 1B5`
490	`01B8: NOP`	489	`01B7: NOP`
491	`01B9: GOTO 1BA`	490	`01B8: GOTO 1B9`
492	`01BA: NOP`	491	`01B9: NOP`
493	`01BB: BSF 20.4`	492	`01BA: BSF 20.4`
494	`01BC: MOVF 20,W`	493	`01BB: MOVF 20,W`
495	`01BD: BSF 03.5`	494	`01BC: BSF 03.5`
496	`01BE: MOVWF 07`	495	`01BD: MOVWF 07`
497	`01BF: NOP`	496	`01BE: NOP`
498	`....................`	497	`....................`
499	`.................... // Combine high and low bytes into 16-bit values.`	498	`.................... // Combine high and low bytes into 16-bit values.`
500	`.................... compass.x = make16(x_msb, x_lsb);`	499	`.................... compass.x = make16(x_msb, x_lsb);`
501	`01C0: BCF 03.5`	500	`01BF: BCF 03.5`
502	`01C1: MOVF 2D,W`	501	`01C0: MOVF 38,W`
503	`01C2: MOVWF 22`	502	`01C1: MOVWF 22`
504	`01C3: MOVF 2C,W`	503	`01C2: MOVF 37,W`
505	`01C4: MOVWF 21`	504	`01C3: MOVWF 21`
506	`.................... compass.y = make16(y_msb, y_lsb);`	505	`.................... compass.y = make16(y_msb, y_lsb);`
507	`01C5: MOVF 2F,W`	506	`01C4: MOVF 3A,W`
508	`01C6: MOVWF 24`	507	`01C5: MOVWF 24`
509	`01C7: MOVF 2E,W`	508	`01C6: MOVF 39,W`
510	`01C8: MOVWF 23`	509	`01C7: MOVWF 23`
511	`.................... compass.z = make16(z_msb, z_lsb);`	510	`.................... compass.z = make16(z_msb, z_lsb);`
512	`01C9: MOVF 31,W`	511	`01C8: MOVF 3C,W`
513	`01CA: MOVWF 26`	512	`01C9: MOVWF 26`
514	`01CB: MOVF 30,W`	513	`01CA: MOVF 3B,W`
515	`01CC: MOVWF 25`	514	`01CB: MOVWF 25`
516	`.................... }`	515	`.................... }`
517	`01CD: BCF 0A.3`	516	`01CC: BCF 0A.3`
518	`01CE: BCF 0A.4`	517	`01CD: BCF 0A.4`
519	`01CF: GOTO 2EE (RETURN)`	518	`01CE: GOTO 2E1 (RETURN)`
-		519	`....................`
-		520	`....................`
-		521	`....................`
-		522	`....................`
-		523	`.................... #include <math.h>`
-		524	`.................... ////////////////////////////////////////////////////////////////////////////`
-		525	`.................... //// (C) Copyright 1996,2008 Custom Computer Services ////`
-		526	`.................... //// This source code may only be used by licensed users of the CCS C ////`
-		527	`.................... //// compiler. This source code may only be distributed to other ////`
-		528	`.................... //// licensed users of the CCS C compiler. No other use, reproduction ////`
-		529	`.................... //// or distribution is permitted without written permission. ////`
-		530	`.................... //// Derivative programs created using this software in object code ////`
-		531	`.................... //// form are not restricted in any way. ////`
-		532	`.................... ////////////////////////////////////////////////////////////////////////////`
-		533	`.................... //// ////`
-		534	`.................... //// History: ////`
-		535	`.................... //// * 9/20/2001 : Improvments are made to sin/cos code. ////`
-		536	`.................... //// The code now is small, much faster, ////`
-		537	`.................... //// and more accurate. ////`
-		538	`.................... //// * 2/21/2007 : Compiler handles & operator differently and does`
-		539	`.................... //// not return generic (int8 *) so type cast is done ////`
-		540	`.................... //// ////`
-		541	`.................... ////////////////////////////////////////////////////////////////////////////`
-		542	`....................`
-		543	`.................... #ifndef MATH_H`
-		544	`.................... #define MATH_H`
-		545	`....................`
-		546	`.................... #ifdef PI`
-		547	`.................... #undef PI`
-		548	`.................... #endif`
-		549	`.................... #define PI 3.1415926535897932`
-		550	`....................`
-		551	`....................`
-		552	`.................... #define SQRT2 1.4142135623730950`
-		553	`....................`
-		554	`.................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};`
-		555	`.................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};`
-		556	`....................`
-		557	`.................... ///////////////////////////// Round Functions //////////////////////////////`
-		558	`....................`
-		559	`.................... float32 CEIL_FLOOR(float32 x, unsigned int8 n)`
-		560	`.................... {`
-		561	`.................... float32 y, res;`
-		562	`.................... unsigned int16 l;`
-		563	`.................... int1 s;`
-		564	`....................`
-		565	`.................... s = 0;`
-		566	`.................... y = x;`
-		567	`....................`
-		568	`.................... if (x < 0)`
-		569	`.................... {`
-		570	`.................... s = 1;`
-		571	`.................... y = -y;`
-		572	`.................... }`
-		573	`....................`
-		574	`.................... if (y <= 32768.0)`
-		575	`.................... res = (float32)(unsigned int16)y;`
-		576	`....................`
-		577	`.................... else if (y < 10000000.0)`
-		578	`.................... {`
-		579	`.................... l = (unsigned int16)(y/32768.0);`
-		580	`.................... y = 32768.0*(y/32768.0 - (float32)l);`
-		581	`.................... res = 32768.0*(float32)l;`
-		582	`.................... res += (float32)(unsigned int16)y;`
-		583	`.................... }`
-		584	`....................`
-		585	`.................... else`
-		586	`.................... res = y;`
-		587	`....................`
-		588	`.................... y = y - (float32)(unsigned int16)y;`
-		589	`....................`
-		590	`.................... if (s)`
-		591	`.................... res = -res;`
-		592	`....................`
-		593	`.................... if (y != 0)`
-		594	`.................... {`
-		595	`.................... if (s == 1 && n == 0)`
-		596	`.................... res -= 1.0;`
-		597	`....................`
-		598	`.................... if (s == 0 && n == 1)`
-		599	`.................... res += 1.0;`
-		600	`.................... }`
-		601	`.................... if (x == 0)`
-		602	`.................... res = 0;`
-		603	`....................`
-		604	`.................... return (res);`
-		605	`.................... }`
-		606	`....................`
-		607	`.................... // Overloaded Functions to take care for new Data types in PCD`
-		608	`.................... // Overloaded function CEIL_FLOOR() for data type - Float48`
-		609	`.................... #if defined(__PCD__)`
-		610	`.................... float48 CEIL_FLOOR(float48 x, unsigned int8 n)`
-		611	`.................... {`
-		612	`.................... float48 y, res;`
-		613	`.................... unsigned int16 l;`
-		614	`.................... int1 s;`
-		615	`....................`
-		616	`.................... s = 0;`
-		617	`.................... y = x;`
-		618	`....................`
-		619	`.................... if (x < 0)`
-		620	`.................... {`
-		621	`.................... s = 1;`
-		622	`.................... y = -y;`
-		623	`.................... }`
-		624	`....................`
-		625	`.................... if (y <= 32768.0)`
-		626	`.................... res = (float48)(unsigned int16)y;`
-		627	`....................`
-		628	`.................... else if (y < 10000000.0)`
-		629	`.................... {`
-		630	`.................... l = (unsigned int16)(y/32768.0);`
-		631	`.................... y = 32768.0*(y/32768.0 - (float48)l);`
-		632	`.................... res = 32768.0*(float32)l;`
-		633	`.................... res += (float48)(unsigned int16)y;`
-		634	`.................... }`
-		635	`....................`
-		636	`.................... else`
-		637	`.................... res = y;`
-		638	`....................`
-		639	`.................... y = y - (float48)(unsigned int16)y;`
-		640	`....................`
-		641	`.................... if (s)`
-		642	`.................... res = -res;`
-		643	`....................`
-		644	`.................... if (y != 0)`
-		645	`.................... {`
-		646	`.................... if (s == 1 && n == 0)`
-		647	`.................... res -= 1.0;`
-		648	`....................`
-		649	`.................... if (s == 0 && n == 1)`
-		650	`.................... res += 1.0;`
-		651	`.................... }`
-		652	`.................... if (x == 0)`
-		653	`.................... res = 0;`
-		654	`....................`
-		655	`.................... return (res);`
-		656	`.................... }`
-		657	`....................`
-		658	`....................`
-		659	`.................... // Overloaded function CEIL_FLOOR() for data type - Float64`
-		660	`.................... float64 CEIL_FLOOR(float64 x, unsigned int8 n)`
-		661	`.................... {`
-		662	`.................... float64 y, res;`
-		663	`.................... unsigned int16 l;`
-		664	`.................... int1 s;`
-		665	`....................`
-		666	`.................... s = 0;`
-		667	`.................... y = x;`
-		668	`....................`
-		669	`.................... if (x < 0)`
-		670	`.................... {`
-		671	`.................... s = 1;`
-		672	`.................... y = -y;`
-		673	`.................... }`
-		674	`....................`
-		675	`.................... if (y <= 32768.0)`
-		676	`.................... res = (float64)(unsigned int16)y;`
-		677	`....................`
-		678	`.................... else if (y < 10000000.0)`
-		679	`.................... {`
-		680	`.................... l = (unsigned int16)(y/32768.0);`
-		681	`.................... y = 32768.0*(y/32768.0 - (float64)l);`
-		682	`.................... res = 32768.0*(float64)l;`
-		683	`.................... res += (float64)(unsigned int16)y;`
-		684	`.................... }`
-		685	`....................`
-		686	`.................... else`
-		687	`.................... res = y;`
-		688	`....................`
-		689	`.................... y = y - (float64)(unsigned int16)y;`
-		690	`....................`
-		691	`.................... if (s)`
-		692	`.................... res = -res;`
-		693	`....................`
-		694	`.................... if (y != 0)`
-		695	`.................... {`
-		696	`.................... if (s == 1 && n == 0)`
-		697	`.................... res -= 1.0;`
-		698	`....................`
-		699	`.................... if (s == 0 && n == 1)`
-		700	`.................... res += 1.0;`
-		701	`.................... }`
-		702	`.................... if (x == 0)`
-		703	`.................... res = 0;`
-		704	`....................`
-		705	`.................... return (res);`
-		706	`.................... }`
-		707	`.................... #endif`
-		708	`....................`
-		709	`.................... ////////////////////////////////////////////////////////////////////////////`
-		710	`.................... // float floor(float x)`
-		711	`.................... ////////////////////////////////////////////////////////////////////////////`
-		712	`.................... // Description : rounds down the number x.`
-		713	`.................... // Date : N/A`
-		714	`.................... //`
-		715	`.................... float32 floor(float32 x)`
-		716	`.................... {`
-		717	`.................... return CEIL_FLOOR(x, 0);`
-		718	`.................... }`
-		719	`.................... // Following 2 functions are overloaded functions of floor() for PCD`
-		720	`.................... // Overloaded function floor() for data type - Float48`
-		721	`.................... #if defined(__PCD__)`
-		722	`.................... float48 floor(float48 x)`
-		723	`.................... {`
-		724	`.................... return CEIL_FLOOR(x, 0);`
-		725	`.................... }`
-		726	`....................`
-		727	`.................... // Overloaded function floor() for data type - Float64`
-		728	`.................... float64 floor(float64 x)`
-		729	`.................... {`
-		730	`.................... return CEIL_FLOOR(x, 0);`
-		731	`.................... }`
-		732	`.................... #endif`
-		733	`....................`
-		734	`....................`
-		735	`.................... ////////////////////////////////////////////////////////////////////////////`
-		736	`.................... // float ceil(float x)`
-		737	`.................... ////////////////////////////////////////////////////////////////////////////`
-		738	`.................... // Description : rounds up the number x.`
-		739	`.................... // Date : N/A`
-		740	`.................... //`
-		741	`.................... float32 ceil(float32 x)`
-		742	`.................... {`
-		743	`.................... return CEIL_FLOOR(x, 1);`
-		744	`.................... }`
-		745	`.................... // Following 2 functions are overloaded functions of ceil() for PCD`
-		746	`.................... // Overloaded function ceil() for data type - Float48`
-		747	`.................... #if defined(__PCD__)`
-		748	`.................... float48 ceil(float48 x)`
-		749	`.................... {`
-		750	`.................... return CEIL_FLOOR(x, 1);`
-		751	`.................... }`
-		752	`....................`
-		753	`.................... // Overloaded function ceil() for data type - Float64`
-		754	`.................... float64 ceil(float64 x)`
-		755	`.................... {`
-		756	`.................... return CEIL_FLOOR(x, 1);`
-		757	`.................... }`
-		758	`.................... #endif`
-		759	`....................`
-		760	`.................... ////////////////////////////////////////////////////////////////////////////`
-		761	`.................... // float fabs(float x)`
-		762	`.................... ////////////////////////////////////////////////////////////////////////////`
-		763	`.................... // Description : Computes the absolute value of floating point number x`
-		764	`.................... // Returns : returns the absolute value of x`
-		765	`.................... // Date : N/A`
-		766	`.................... //`
-		767	`.................... #define fabs abs`
-		768	`....................`
-		769	`.................... ////////////////////////////////////////////////////////////////////////////`
-		770	`.................... // float fmod(float x)`
-		771	`.................... ////////////////////////////////////////////////////////////////////////////`
-		772	`.................... // Description : Computes the floating point remainder of x/y`
-		773	`.................... // Returns : returns the value of x= i*y, for some integer i such that, if y`
-		774	`.................... // is non zero, the result has the same isgn of x na dmagnitude less than the`
-		775	`.................... // magnitude of y. If y is zero then a domain error occurs.`
-		776	`.................... // Date : N/A`
-		777	`.................... //`
-		778	`....................`
-		779	`.................... float fmod(float32 x,float32 y)`
-		780	`.................... {`
-		781	`.................... float32 i;`
-		782	`.................... if (y!=0.0)`
-		783	`.................... {`
-		784	`.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);`
-		785	`.................... return(x-(i*y));`
-		786	`.................... }`
-		787	`.................... else`
-		788	`.................... {`
-		789	`.................... #ifdef _ERRNO`
-		790	`.................... {`
-		791	`.................... errno=EDOM;`
-		792	`.................... }`
-		793	`.................... #endif`
-		794	`.................... }`
-		795	`.................... }`
-		796	`.................... //Overloaded function for fmod() for PCD`
-		797	`.................... // Overloaded function fmod() for data type - Float48`
-		798	`.................... #if defined(__PCD__)`
-		799	`.................... float48 fmod(float48 x,float48 y)`
-		800	`.................... {`
-		801	`.................... float48 i;`
-		802	`.................... if (y!=0.0)`
-		803	`.................... {`
-		804	`.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);`
-		805	`.................... return(x-(i*y));`
-		806	`.................... }`
-		807	`.................... else`
-		808	`.................... {`
-		809	`.................... #ifdef _ERRNO`
-		810	`.................... {`
-		811	`.................... errno=EDOM;`
-		812	`.................... }`
-		813	`.................... #endif`
-		814	`.................... }`
-		815	`.................... }`
-		816	`.................... // Overloaded function fmod() for data type - Float64`
-		817	`.................... float64 fmod(float64 x,float64 y)`
-		818	`.................... {`
-		819	`.................... float64 i;`
-		820	`.................... if (y!=0.0)`
-		821	`.................... {`
-		822	`.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);`
-		823	`.................... return(x-(i*y));`
-		824	`.................... }`
-		825	`.................... else`
-		826	`.................... {`
-		827	`.................... #ifdef _ERRNO`
-		828	`.................... {`
-		829	`.................... errno=EDOM;`
-		830	`.................... }`
-		831	`.................... #endif`
-		832	`.................... }`
-		833	`.................... }`
-		834	`.................... #endif`
-		835	`.................... //////////////////// Exponential and logarithmic functions ////////////////////`
-		836	`.................... ////////////////////////////////////////////////////////////////////////////`
-		837	`.................... // float exp(float x)`
-		838	`.................... ////////////////////////////////////////////////////////////////////////////`
-		839	`.................... // Description : returns the value (e^x)`
-		840	`.................... // Date : N/A`
-		841	`.................... //`
-		842	`.................... #define LN2 0.6931471805599453`
-		843	`....................`
-		844	`.................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,`
-		845	`.................... 0.0554965651, 0.240227138, 0.693147172};`
-		846	`....................`
-		847	`....................`
-		848	`.................... float32 exp(float32 x)`
-		849	`.................... {`
-		850	`.................... float32 y, res, r;`
-		851	`.................... #if defined(__PCD__)`
-		852	`.................... int8 data1;`
-		853	`.................... #endif`
-		854	`.................... signed int8 n;`
-		855	`.................... int1 s;`
-		856	`.................... #ifdef _ERRNO`
-		857	`.................... if(x > 88.722838)`
-		858	`.................... {`
-		859	`.................... errno=ERANGE;`
-		860	`.................... return(0);`
-		861	`.................... }`
-		862	`.................... #endif`
-		863	`.................... n = (signed int16)(x/LN2);`
-		864	`.................... s = 0;`
-		865	`.................... y = x;`
-		866	`....................`
-		867	`.................... if (x < 0)`
-		868	`.................... {`
-		869	`.................... s = 1;`
-		870	`.................... n = -n;`
-		871	`.................... y = -y;`
-		872	`.................... }`
-		873	`....................`
-		874	`.................... res = 0.0;`
-		875	`.................... #if !defined(__PCD__)`
-		876	`.................... ((unsigned int8 )(&res)) = n + 0x7F;`
-		877	`.................... #endif`
-		878	`....................`
-		879	`.................... #if defined(__PCD__) // Takes care of IEEE format for PCD`
-		880	`.................... data1 = n+0x7F;`
-		881	`.................... if(bit_test(data1,0))`
-		882	`.................... bit_set((((unsigned int8 )(&res)+2)),7);`
-		883	`.................... rotate_right(&data1,1);`
-		884	`.................... bit_clear(data1,7);`
-		885	`.................... (((unsigned int8 )(&res)+3)) = data1;`
-		886	`.................... #endif`
-		887	`....................`
-		888	`.................... y = y/LN2 - (float32)n;`
-		889	`....................`
-		890	`.................... r = pe[0]*y + pe[1];`
-		891	`.................... r = r*y + pe[2];`
-		892	`.................... r = r*y + pe[3];`
-		893	`.................... r = r*y + pe[4];`
-		894	`.................... r = r*y + pe[5];`
-		895	`....................`
-		896	`.................... res = res(1.0 + yr);`
-		897	`....................`
-		898	`.................... if (s)`
-		899	`.................... res = 1.0/res;`
-		900	`.................... return(res);`
-		901	`.................... }`
-		902	`....................`
-		903	`....................`
-		904	`.................... //Overloaded function for exp() for PCD`
-		905	`.................... // Overloaded function exp() for data type - Float48`
-		906	`.................... #if defined(__PCD__)`
-		907	`.................... float48 exp(float48 x)`
-		908	`.................... {`
-		909	`.................... float48 y, res, r;`
-		910	`.................... int8 data1;`
-		911	`.................... signed int8 n;`
-		912	`.................... int1 s;`
-		913	`.................... #ifdef _ERRNO`
-		914	`.................... if(x > 88.722838)`
-		915	`.................... {`
-		916	`.................... errno=ERANGE;`
-		917	`.................... return(0);`
-		918	`.................... }`
-		919	`.................... #endif`
-		920	`.................... n = (signed int16)(x/LN2);`
-		921	`.................... s = 0;`
-		922	`.................... y = x;`
-		923	`....................`
-		924	`.................... if (x < 0)`
-		925	`.................... {`
-		926	`.................... s = 1;`
-		927	`.................... n = -n;`
-		928	`.................... y = -y;`
-		929	`.................... }`
-		930	`....................`
-		931	`.................... res = 0.0;`
-		932	`....................`
-		933	`.................... data1 = n+0x7F;`
-		934	`.................... if(bit_test(data1,0))`
-		935	`.................... bit_set((((unsigned int8 )(&res)+4)),7);`
-		936	`.................... rotate_right(&data1,1);`
-		937	`.................... bit_clear(data1,7);`
-		938	`.................... (((unsigned int8 )(&res)+5)) = data1;`
-		939	`....................`
-		940	`.................... y = y/LN2 - (float48)n;`
-		941	`....................`
-		942	`.................... r = pe[0]*y + pe[1];`
-		943	`.................... r = r*y + pe[2];`
-		944	`.................... r = r*y + pe[3];`
-		945	`.................... r = r*y + pe[4];`
-		946	`.................... r = r*y + pe[5];`
-		947	`....................`
-		948	`.................... res = res(1.0 + yr);`
-		949	`....................`
-		950	`.................... if (s)`
-		951	`.................... res = 1.0/res;`
-		952	`.................... return(res);`
-		953	`.................... }`
-		954	`....................`
-		955	`.................... // Overloaded function exp() for data type - Float64`
-		956	`.................... float64 exp(float64 x)`
-		957	`.................... {`
-		958	`.................... float64 y, res, r;`
-		959	`.................... unsigned int16 data1, data2;`
-		960	`.................... unsigned int16 *p;`
-		961	`.................... signed int16 n;`
-		962	`.................... int1 s;`
-		963	`.................... #ifdef _ERRNO`
-		964	`.................... if(x > 709.7827128)`
-		965	`.................... {`
-		966	`.................... errno=ERANGE;`
-		967	`.................... return(0);`
-		968	`.................... }`
-		969	`.................... #endif`
-		970	`.................... n = (signed int16)(x/LN2);`
-		971	`.................... s = 0;`
-		972	`.................... y = x;`
-		973	`....................`
-		974	`.................... if (x < 0)`
-		975	`.................... {`
-		976	`.................... s = 1;`
-		977	`.................... n = -n;`
-		978	`.................... y = -y;`
-		979	`.................... }`
-		980	`....................`
-		981	`.................... res = 0.0;`
-		982	`....................`
-		983	`.................... #if !defined(__PCD__)`
-		984	`.................... ((unsigned int16 )(&res)) = n + 0x7F;`
-		985	`.................... #endif`
-		986	`.................... p= (((unsigned int16 *)(&res))+3);`
-		987	`.................... data1 = *p;`
-		988	`.................... data2 = *p;`
-		989	`.................... data1 = n + 0x3FF;`
-		990	`.................... data1 = data1 <<4;`
-		991	`.................... if(bit_test(data2,15))`
-		992	`.................... bit_set(data1,15);`
-		993	`.................... data2 = data2 & 0x000F;`
-		994	`.................... data1 ^= data2;`
-		995	`....................`
-		996	`.................... (((unsigned int16 )(&res)+3)) = data1;`
-		997	`....................`
-		998	`....................`
-		999	`.................... y = y/LN2 - (float64)n;`
-		1000	`....................`
-		1001	`.................... r = pe[0]*y + pe[1];`
-		1002	`.................... r = r*y + pe[2];`
-		1003	`.................... r = r*y + pe[3];`
-		1004	`.................... r = r*y + pe[4];`
-		1005	`.................... r = r*y + pe[5];`
-		1006	`....................`
-		1007	`.................... res = res(1.0 + yr);`
-		1008	`....................`
-		1009	`.................... if (s)`
-		1010	`.................... res = 1.0/res;`
-		1011	`.................... return(res);`
-		1012	`.................... }`
-		1013	`....................`
-		1014	`.................... #ENDIF`
-		1015	`....................`
-		1016	`....................`
-		1017	`.................... /************************************************************/`
-		1018	`....................`
-		1019	`.................... float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};`
-		1020	`.................... float32 const ql[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};`
-		1021	`....................`
-		1022	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1023	`.................... // float log(float x)`
-		1024	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1025	`.................... // Description : returns the the natural log of x`
-		1026	`.................... // Date : N/A`
-		1027	`.................... //`
-		1028	`.................... float32 log(float32 x)`
-		1029	`.................... {`
-		1030	`.................... float32 y, res, r, y2;`
-		1031	`.................... #if defined(__PCD__)`
-		1032	`.................... unsigned int8 data1,data2;`
-		1033	`.................... #endif`
-		1034	`.................... signed int8 n;`
-		1035	`.................... #ifdef _ERRNO`
-		1036	`.................... if(x <0)`
-		1037	`.................... {`
-		1038	`.................... errno=EDOM;`
-		1039	`.................... }`
-		1040	`.................... if(x ==0)`
-		1041	`.................... {`
-		1042	`.................... errno=ERANGE;`
-		1043	`.................... return(0);`
-		1044	`.................... }`
-		1045	`.................... #endif`
-		1046	`.................... y = x;`
-		1047	`....................`
-		1048	`.................... if (y != 1.0)`
-		1049	`.................... {`
-		1050	`.................... #if !defined(__PCD__)`
-		1051	`.................... ((unsigned int8 )(&y)) = 0x7E;`
-		1052	`.................... #endif`
-		1053	`....................`
-		1054	`.................... #if defined(__PCD__) // Takes care of IEEE format`
-		1055	`.................... data2 = (((unsigned int8 )(&y))+3);`
-		1056	`.................... (((unsigned int8 )(&y))+3) = 0x3F;`
-		1057	`.................... data1 = (((unsigned int8 )(&y))+2);`
-		1058	`.................... bit_clear(data1,7);`
-		1059	`.................... (((unsigned int8 )(&y))+2) = data1;`
-		1060	`.................... if(bit_test(data2,7))`
-		1061	`.................... bit_set((((unsigned int8 )(&y))+3),7);`
-		1062	`.................... #endif`
-		1063	`....................`
-		1064	`.................... y = (y - 1.0)/(y + 1.0);`
-		1065	`....................`
-		1066	`.................... y2=y*y;`
-		1067	`....................`
-		1068	`.................... res = pl[0]*y2 + pl[1];`
-		1069	`.................... res = res*y2 + pl[2];`
-		1070	`.................... res = res*y2 + pl[3];`
-		1071	`....................`
-		1072	`.................... r = ql[0]*y2 + ql[1];`
-		1073	`.................... r = r*y2 + ql[2];`
-		1074	`.................... r = r*y2 + ql[3];`
-		1075	`....................`
-		1076	`.................... res = y*res/r;`
-		1077	`.................... #if !defined(__PCD__)`
-		1078	`.................... n = ((unsigned int8 )(&x)) - 0x7E;`
-		1079	`.................... #endif`
-		1080	`.................... #if defined(__PCD__)`
-		1081	`.................... data1 = (((unsigned int8 )(&x)+3));`
-		1082	`.................... rotate_left(&data1,1);`
-		1083	`.................... data2 = (((unsigned int8 )(&x)+2));`
-		1084	`.................... if(bit_test (data2,7))`
-		1085	`.................... bit_set(data1,0);`
-		1086	`.................... n = data1 - 0x7E;`
-		1087	`.................... #endif`
-		1088	`....................`
-		1089	`.................... if (n<0)`
-		1090	`.................... r = -(float32)-n;`
-		1091	`.................... else`
-		1092	`.................... r = (float32)n;`
-		1093	`....................`
-		1094	`.................... res += r*LN2;`
-		1095	`.................... }`
-		1096	`....................`
-		1097	`.................... else`
-		1098	`.................... res = 0.0;`
-		1099	`....................`
-		1100	`.................... return(res);`
-		1101	`.................... }`
-		1102	`....................`
-		1103	`.................... //Overloaded function for log() for PCD`
-		1104	`.................... // Overloaded function log() for data type - Float48`
-		1105	`.................... #if defined(__PCD__)`
-		1106	`.................... float48 log(float48 x)`
-		1107	`.................... {`
-		1108	`.................... float48 y, res, r, y2;`
-		1109	`.................... unsigned int8 data1,data2;`
-		1110	`.................... signed int8 n;`
-		1111	`.................... #ifdef _ERRNO`
-		1112	`.................... if(x <0)`
-		1113	`.................... {`
-		1114	`.................... errno=EDOM;`
-		1115	`.................... }`
-		1116	`.................... if(x ==0)`
-		1117	`.................... {`
-		1118	`.................... errno=ERANGE;`
-		1119	`.................... return(0);`
-		1120	`.................... }`
-		1121	`.................... #endif`
-		1122	`.................... y = x;`
-		1123	`....................`
-		1124	`.................... if (y != 1.0)`
-		1125	`.................... {`
-		1126	`....................`
-		1127	`.................... #if !defined(__PCD__)`
-		1128	`.................... ((unsigned int8 )(&y)) = 0x7E;`
-		1129	`.................... #endif`
-		1130	`.................... data2 = (((unsigned int8 )(&y))+5);`
-		1131	`.................... (((unsigned int8 )(&y))+5) = 0x3F;`
-		1132	`.................... data1 = (((unsigned int8 )(&y))+4);`
-		1133	`.................... bit_clear(data1,7);`
-		1134	`.................... (((unsigned int8 )(&y))+4) = data1;`
-		1135	`....................`
-		1136	`.................... if(bit_test(data2,7))`
-		1137	`.................... bit_set((((unsigned int8 )(&y))+4),7);`
-		1138	`.................... y = (y - 1.0)/(y + 1.0);`
-		1139	`....................`
-		1140	`.................... y2=y*y;`
-		1141	`....................`
-		1142	`.................... res = pl[0]*y2 + pl[1];`
-		1143	`.................... res = res*y2 + pl[2];`
-		1144	`.................... res = res*y2 + pl[3];`
-		1145	`....................`
-		1146	`.................... r = ql[0]*y2 + ql[1];`
-		1147	`.................... r = r*y2 + ql[2];`
-		1148	`.................... r = r*y2 + ql[3];`
-		1149	`....................`
-		1150	`.................... res = y*res/r;`
-		1151	`....................`
-		1152	`.................... data1 = (((unsigned int8 )(&x)+5));`
-		1153	`.................... rotate_left(&data1,1);`
-		1154	`.................... data2 = (((unsigned int8 )(&x)+4));`
-		1155	`.................... if(bit_test (data2,7))`
-		1156	`.................... bit_set(data1,0);`
-		1157	`....................`
-		1158	`.................... n = data1 - 0x7E;`
-		1159	`....................`
-		1160	`.................... if (n<0)`
-		1161	`.................... r = -(float48)-n;`
-		1162	`.................... else`
-		1163	`.................... r = (float48)n;`
-		1164	`....................`
-		1165	`.................... res += r*LN2;`
-		1166	`.................... }`
-		1167	`....................`
-		1168	`.................... else`
-		1169	`.................... res = 0.0;`
520	`....................`	1170	`....................`
-		1171	`.................... return(res);`
-		1172	`.................... }`
-		1173	`....................`
-		1174	`.................... // Overloaded function log() for data type - Float48`
-		1175	`.................... #if defined(__PCD__)`
-		1176	`.................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};`
-		1177	`.................... float32 const ql_64[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};`
-		1178	`.................... #endif`
-		1179	`.................... float64 log(float64 x)`
-		1180	`.................... {`
-		1181	`.................... float64 y, res, r, y2;`
-		1182	`.................... unsigned int16 data1,data2;`
-		1183	`.................... unsigned int16 *p;`
-		1184	`.................... signed int16 n;`
-		1185	`.................... #ifdef _ERRNO`
-		1186	`.................... if(x <0)`
-		1187	`.................... {`
-		1188	`.................... errno=EDOM;`
-		1189	`.................... }`
-		1190	`.................... if(x ==0)`
-		1191	`.................... {`
-		1192	`.................... errno=ERANGE;`
-		1193	`.................... return(0);`
-		1194	`.................... }`
-		1195	`.................... #endif`
-		1196	`.................... y = x;`
521	`....................`	1197	`....................`
-		1198	`.................... if (y != 1.0)`
-		1199	`.................... {`
-		1200	`.................... #if !defined(__PCD__)`
-		1201	`.................... ((unsigned int8 )(&y)) = 0x7E;`
-		1202	`.................... #endif`
-		1203	`.................... p= (((unsigned int16 *)(&y))+3);`
-		1204	`.................... data1 = *p;`
-		1205	`.................... data2 = *p;`
-		1206	`.................... data1 = 0x3FE;`
-		1207	`.................... data1 = data1 <<4;`
-		1208	`.................... if(bit_test (data2,15))`
-		1209	`.................... bit_set(data1,15);`
-		1210	`.................... data2 = data2 & 0x000F;`
-		1211	`.................... data1 ^=data2;`
-		1212	`....................`
-		1213	`.................... *p = data1;`
-		1214	`....................`
-		1215	`.................... y = (y - 1.0)/(y + 1.0);`
-		1216	`....................`
-		1217	`.................... y2=y*y;`
-		1218	`....................`
-		1219	`.................... res = pl_64[0]*y2 + pl_64[1];`
-		1220	`.................... res = res*y2 + pl_64[2];`
-		1221	`.................... res = res*y2 + pl_64[3];`
-		1222	`....................`
-		1223	`.................... r = ql_64[0]*y2 + ql_64[1];`
-		1224	`.................... r = r*y2 + ql_64[2];`
-		1225	`.................... r = r*y2 + ql_64[3];`
-		1226	`....................`
-		1227	`.................... res = y*res/r;`
-		1228	`....................`
-		1229	`.................... p= (((unsigned int16 *)(&x))+3);`
-		1230	`.................... data1 = *p;`
-		1231	`.................... bit_clear(data1,15);`
-		1232	`.................... data1 = data1 >>4;`
-		1233	`.................... n = data1 - 0x3FE;`
-		1234	`....................`
-		1235	`....................`
-		1236	`.................... if (n<0)`
-		1237	`.................... r = -(float64)-n;`
-		1238	`.................... else`
-		1239	`.................... r = (float64)n;`
-		1240	`....................`
-		1241	`.................... res += r*LN2;`
-		1242	`.................... }`
-		1243	`....................`
-		1244	`.................... else`
-		1245	`.................... res = 0.0;`
-		1246	`....................`
-		1247	`.................... return(res);`
-		1248	`.................... }`
-		1249	`.................... #endif`
522	`....................`	1250	`....................`
523	`....................`	1251	`....................`
-		1252	`.................... #define LN10 2.3025850929940456`
-		1253	`....................`
-		1254	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1255	`.................... // float log10(float x)`
-		1256	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1257	`.................... // Description : returns the the log base 10 of x`
-		1258	`.................... // Date : N/A`
-		1259	`.................... //`
-		1260	`.................... float32 log10(float32 x)`
-		1261	`.................... {`
-		1262	`.................... float32 r;`
-		1263	`....................`
-		1264	`.................... r = log(x);`
-		1265	`.................... r = r/LN10;`
-		1266	`.................... return(r);`
-		1267	`.................... }`
-		1268	`....................`
-		1269	`.................... //Overloaded functions for log10() for PCD`
-		1270	`.................... // Overloaded function log10() for data type - Float48`
-		1271	`.................... #if defined(__PCD__)`
-		1272	`.................... float48 log10(float48 x)`
-		1273	`.................... {`
-		1274	`.................... float48 r;`
-		1275	`....................`
-		1276	`.................... r = log(x);`
-		1277	`.................... r = r/LN10;`
-		1278	`.................... return(r);`
-		1279	`.................... }`
-		1280	`....................`
-		1281	`.................... // Overloaded function log10() for data type - Float64`
-		1282	`.................... float64 log10(float64 x)`
-		1283	`.................... {`
-		1284	`.................... float64 r;`
-		1285	`....................`
-		1286	`.................... r = log(x);`
-		1287	`.................... r = r/LN10;`
-		1288	`.................... return(r);`
-		1289	`.................... }`
-		1290	`.................... #endif`
-		1291	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1292	`.................... // float modf(float x)`
-		1293	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1294	`.................... // Description :breaks the argument value int integral and fractional parts,`
-		1295	`.................... // ach of which have the same sign as the argument. It stores the integral part`
-		1296	`.................... // as a float in the object pointed to by the iptr`
-		1297	`.................... // Returns : returns the signed fractional part of value.`
-		1298	`.................... // Date : N/A`
-		1299	`.................... //`
-		1300	`....................`
-		1301	`.................... float32 modf(float32 value,float32 *iptr)`
-		1302	`.................... {`
-		1303	`.................... *iptr=(value < 0.0)? ceil(value): floor(value);`
-		1304	`.................... return(value - *iptr);`
-		1305	`.................... }`
-		1306	`.................... //Overloaded functions for modf() for PCD`
-		1307	`.................... // Overloaded function modf() for data type - Float48`
-		1308	`.................... #if defined(__PCD__)`
-		1309	`.................... float48 modf(float48 value,float48 *iptr)`
-		1310	`.................... {`
-		1311	`.................... *iptr=(value < 0.0)? ceil(value): floor(value);`
-		1312	`.................... return(value - *iptr);`
-		1313	`.................... }`
-		1314	`.................... // Overloaded function modf() for data type - Float64`
-		1315	`.................... float64 modf(float64 value,float64 *iptr)`
-		1316	`.................... {`
-		1317	`.................... *iptr=(value < 0.0)? ceil(value): floor(value);`
-		1318	`.................... return(value - *iptr);`
-		1319	`.................... }`
-		1320	`.................... #endif`
-		1321	`....................`
-		1322	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1323	`.................... // float pwr(float x,float y)`
-		1324	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1325	`.................... // Description : returns the value (x^y)`
-		1326	`.................... // Date : N/A`
-		1327	`.................... // Note : 0 is returned when the function will generate an imaginary number`
-		1328	`.................... //`
-		1329	`.................... float32 pwr(float32 x,float32 y)`
-		1330	`.................... {`
-		1331	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1332	`.................... if(fmod(y, 2) == 0) {`
-		1333	`.................... return (exp(log(-x) * y));`
-		1334	`.................... } else {`
-		1335	`.................... return (-exp(log(-x) * y));`
-		1336	`.................... }`
-		1337	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1338	`.................... return 0;`
-		1339	`.................... } else {`
-		1340	`.................... if(x != 0 \|\| 0 >= y) {`
-		1341	`.................... return (exp(log(x) * y));`
-		1342	`.................... }`
-		1343	`.................... }`
-		1344	`.................... }`
-		1345	`.................... //Overloaded functions for pwr() for PCD`
-		1346	`.................... // Overloaded function pwr() for data type - Float48`
-		1347	`.................... #if defined(__PCD__)`
-		1348	`.................... float48 pwr(float48 x,float48 y)`
-		1349	`.................... {`
-		1350	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1351	`.................... if(fmod(y, 2) == 0) {`
-		1352	`.................... return (exp(log(-x) * y));`
-		1353	`.................... } else {`
-		1354	`.................... return (-exp(log(-x) * y));`
-		1355	`.................... }`
-		1356	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1357	`.................... return 0;`
-		1358	`.................... } else {`
-		1359	`.................... if(x != 0 \|\| 0 >= y) {`
-		1360	`.................... return (exp(log(x) * y));`
-		1361	`.................... }`
-		1362	`.................... }`
-		1363	`.................... }`
-		1364	`.................... // Overloaded function pwr() for data type - Float64`
-		1365	`.................... float64 pwr(float64 x,float64 y)`
-		1366	`.................... {`
-		1367	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1368	`.................... if(fmod(y, 2) == 0) {`
-		1369	`.................... return (exp(log(-x) * y));`
-		1370	`.................... } else {`
-		1371	`.................... return (-exp(log(-x) * y));`
-		1372	`.................... }`
-		1373	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1374	`.................... return 0;`
-		1375	`.................... } else {`
-		1376	`.................... if(x != 0 \|\| 0 >= y) {`
-		1377	`.................... return (exp(log(x) * y));`
-		1378	`.................... }`
-		1379	`.................... }`
-		1380	`.................... }`
-		1381	`.................... #endif`
-		1382	`....................`
-		1383	`.................... //////////////////// Power functions ////////////////////`
-		1384	`....................`
-		1385	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1386	`.................... // float pow(float x,float y)`
-		1387	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1388	`.................... // Description : returns the value (x^y)`
-		1389	`.................... // Date : N/A`
-		1390	`.................... // Note : 0 is returned when the function will generate an imaginary number`
-		1391	`.................... //`
-		1392	`.................... float32 pow(float32 x,float32 y)`
-		1393	`.................... {`
-		1394	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1395	`.................... if(fmod(y, 2) == 0) {`
-		1396	`.................... return (exp(log(-x) * y));`
-		1397	`.................... } else {`
-		1398	`.................... return (-exp(log(-x) * y));`
-		1399	`.................... }`
-		1400	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1401	`.................... return 0;`
-		1402	`.................... } else {`
-		1403	`.................... if(x != 0 \|\| 0 >= y) {`
-		1404	`.................... return (exp(log(x) * y));`
-		1405	`.................... }`
-		1406	`.................... }`
-		1407	`.................... }`
-		1408	`.................... //Overloaded functions for pow() for PCD`
-		1409	`.................... // Overloaded function for pow() data type - Float48`
-		1410	`.................... #if defined(__PCD__)`
-		1411	`.................... float48 pow(float48 x,float48 y)`
-		1412	`.................... {`
-		1413	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1414	`.................... if(fmod(y, 2) == 0) {`
-		1415	`.................... return (exp(log(-x) * y));`
-		1416	`.................... } else {`
-		1417	`.................... return (-exp(log(-x) * y));`
-		1418	`.................... }`
-		1419	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1420	`.................... return 0;`
-		1421	`.................... } else {`
-		1422	`.................... if(x != 0 \|\| 0 >= y) {`
-		1423	`.................... return (exp(log(x) * y));`
-		1424	`.................... }`
-		1425	`.................... }`
-		1426	`.................... }`
-		1427	`....................`
-		1428	`.................... // Overloaded function pow() for data type - Float64`
-		1429	`.................... float64 pow(float64 x,float64 y)`
-		1430	`.................... {`
-		1431	`.................... if(0 > x && fmod(y, 1) == 0) {`
-		1432	`.................... if(fmod(y, 2) == 0) {`
-		1433	`.................... return (exp(log(-x) * y));`
-		1434	`.................... } else {`
-		1435	`.................... return (-exp(log(-x) * y));`
-		1436	`.................... }`
-		1437	`.................... } else if(0 > x && fmod(y, 1) != 0) {`
-		1438	`.................... return 0;`
-		1439	`.................... } else {`
-		1440	`.................... if(x != 0 \|\| 0 >= y) {`
-		1441	`.................... return (exp(log(x) * y));`
-		1442	`.................... }`
-		1443	`.................... }`
-		1444	`.................... }`
-		1445	`.................... #endif`
-		1446	`....................`
-		1447	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1448	`.................... // float sqrt(float x)`
-		1449	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1450	`.................... // Description : returns the square root of x`
-		1451	`.................... // Date : N/A`
-		1452	`.................... //`
-		1453	`.................... float32 sqrt(float32 x)`
-		1454	`.................... {`
-		1455	`.................... float32 y, res;`
-		1456	`.................... #if defined(__PCD__)`
-		1457	`.................... unsigned int16 data1,data2;`
-		1458	`.................... #endif`
-		1459	`.................... BYTE *p;`
-		1460	`....................`
-		1461	`.................... #ifdef _ERRNO`
-		1462	`.................... if(x < 0)`
-		1463	`.................... {`
-		1464	`.................... errno=EDOM;`
-		1465	`.................... }`
-		1466	`.................... #endif`
-		1467	`....................`
-		1468	`.................... if( x<=0.0)`
-		1469	`.................... return(0.0);`
-		1470	`....................`
-		1471	`.................... y=x;`
-		1472	`....................`
-		1473	`.................... #if !defined(__PCD__)`
-		1474	`.................... p=&y;`
-		1475	`.................... (p)=(BYTE)((((unsigned int16)(p)) + 127) >> 1);`
-		1476	`.................... #endif`
-		1477	`....................`
-		1478	`.................... #if defined(__PCD__)`
-		1479	`.................... p = (((unsigned int8 *)(&y))+3);`
-		1480	`.................... data1 = (((unsigned int8 )(&y))+3);`
-		1481	`.................... data2 = (((unsigned int8 )(&y))+2);`
-		1482	`.................... rotate_left(&data1,1);`
-		1483	`.................... if(bit_test(data2,7))`
-		1484	`.................... bit_set(data1,0);`
-		1485	`.................... data1 = ((data1+127) >>1);`
-		1486	`.................... bit_clear(data2,7);`
-		1487	`.................... if(bit_test(data1,0))`
-		1488	`.................... bit_set(data2,7);`
-		1489	`.................... data1 = data1 >>1;`
-		1490	`.................... (((unsigned int8 )(&y))+3) = data1;`
-		1491	`.................... (((unsigned int8 )(&y))+2) = data2;`
-		1492	`....................`
-		1493	`.................... #endif`
-		1494	`....................`
-		1495	`.................... do {`
-		1496	`.................... res=y;`
-		1497	`.................... y+=(x/y);`
-		1498	`....................`
-		1499	`.................... #if !defined(__PCD__)`
-		1500	`.................... (*p)--;`
-		1501	`.................... #endif`
-		1502	`....................`
-		1503	`.................... #if defined(__PCD__)`
-		1504	`.................... data1 = (((unsigned int8 )(&y))+3);`
-		1505	`.................... data2 = (((unsigned int8 )(&y))+2);`
-		1506	`.................... rotate_left(&data1,1);`
-		1507	`.................... if(bit_test(data2,7))`
-		1508	`.................... bit_set(data1,0);`
-		1509	`.................... data1--;`
-		1510	`.................... bit_clear(data2,7);`
-		1511	`.................... if(bit_test(data1,0))`
-		1512	`.................... bit_set(data2,7);`
-		1513	`.................... data1 = data1 >>1;`
-		1514	`.................... (((unsigned int8 )(&y))+3) = data1;`
-		1515	`.................... (((unsigned int8 )(&y))+2) = data2;`
-		1516	`....................`
-		1517	`.................... #endif`
-		1518	`.................... } while(res != y);`
-		1519	`....................`
-		1520	`.................... return(res);`
-		1521	`.................... }`
-		1522	`.................... //Overloaded functions for sqrt() for PCD`
-		1523	`.................... // Overloaded function sqrt() for data type - Float48`
-		1524	`.................... #if defined(__PCD__)`
-		1525	`.................... float48 sqrt(float48 x)`
-		1526	`.................... {`
-		1527	`.................... float48 y, res;`
-		1528	`.................... unsigned int16 data1,data2;`
-		1529	`.................... BYTE *p;`
-		1530	`....................`
-		1531	`.................... #ifdef _ERRNO`
-		1532	`.................... if(x < 0)`
-		1533	`.................... {`
-		1534	`.................... errno=EDOM;`
-		1535	`.................... }`
-		1536	`.................... #endif`
-		1537	`....................`
-		1538	`.................... if( x<=0.0)`
-		1539	`.................... return(0.0);`
-		1540	`....................`
-		1541	`.................... y=x;`
-		1542	`....................`
-		1543	`.................... #if !defined(__PCD__)`
-		1544	`.................... p=&y;`
-		1545	`.................... (p)=(BYTE)((((unsigned int16)(p)) + 127) >> 1);`
-		1546	`.................... #endif`
-		1547	`....................`
-		1548	`.................... #if defined(__PCD__)`
-		1549	`.................... p = (((unsigned int8 *)(&y))+5);`
-		1550	`.................... data1 = (((unsigned int8 )(&y))+5);`
-		1551	`.................... data2 = (((unsigned int8 )(&y))+4);`
-		1552	`.................... rotate_left(&data1,1);`
-		1553	`.................... if(bit_test(data2,7))`
-		1554	`.................... bit_set(data1,0);`
-		1555	`.................... data1 = ((data1+127) >>1);`
-		1556	`.................... bit_clear(data2,7);`
-		1557	`.................... if(bit_test(data1,0))`
-		1558	`.................... bit_set(data2,7);`
-		1559	`.................... data1 = data1 >>1;`
-		1560	`.................... (((unsigned int8 )(&y))+5) = data1;`
-		1561	`.................... (((unsigned int8 )(&y))+4) = data2;`
-		1562	`....................`
-		1563	`.................... #endif`
-		1564	`....................`
-		1565	`.................... do {`
-		1566	`.................... res=y;`
-		1567	`.................... y+=(x/y);`
-		1568	`....................`
-		1569	`.................... #if !defined(__PCD__)`
-		1570	`.................... (*p)--;`
-		1571	`.................... #endif`
-		1572	`....................`
-		1573	`.................... data1 = (((unsigned int8 )(&y))+5);`
-		1574	`.................... data2 = (((unsigned int8 )(&y))+4);`
-		1575	`.................... rotate_left(&data1,1);`
-		1576	`.................... if(bit_test(data2,7))`
-		1577	`.................... bit_set(data1,0);`
-		1578	`.................... data1--;`
-		1579	`.................... bit_clear(data2,7);`
-		1580	`.................... if(bit_test(data1,0))`
-		1581	`.................... bit_set(data2,7);`
-		1582	`.................... data1 = data1 >>1;`
-		1583	`.................... (((unsigned int8 )(&y))+5) = data1;`
-		1584	`.................... (((unsigned int8 )(&y))+4) = data2;`
-		1585	`....................`
-		1586	`.................... } while(res != y);`
-		1587	`....................`
-		1588	`.................... return(res);`
-		1589	`.................... }`
-		1590	`....................`
-		1591	`.................... // Overloaded function sqrt() for data type - Float64`
-		1592	`.................... float64 sqrt(float64 x)`
-		1593	`.................... {`
-		1594	`.................... float64 y, res;`
-		1595	`.................... unsigned int16 *p;`
-		1596	`.................... unsigned int16 temp1,temp2;`
-		1597	`....................`
-		1598	`.................... #ifdef _ERRNO`
-		1599	`.................... if(x < 0)`
-		1600	`.................... {`
-		1601	`.................... errno=EDOM;`
-		1602	`.................... }`
-		1603	`.................... #endif`
-		1604	`....................`
-		1605	`.................... if( x<=0.0)`
-		1606	`.................... return(0.0);`
-		1607	`....................`
-		1608	`.................... y=x;`
-		1609	`.................... p= (((unsigned int16 *)(&y))+3);`
-		1610	`.................... temp1 = *p;`
-		1611	`.................... temp2 = *p;`
-		1612	`.................... bit_clear(temp1,15);`
-		1613	`.................... temp1 = (temp1>>4)+1023;`
-		1614	`.................... temp1 = temp1 >> 1;`
-		1615	`.................... temp1 = (temp1<<4) & 0xFFF0;`
-		1616	`.................... if(bit_test(temp2,15))`
-		1617	`.................... bit_set(temp1,15);`
-		1618	`.................... temp2 = temp2 & 0x000F;`
-		1619	`.................... temp1 ^= temp2;`
-		1620	`....................`
-		1621	`.................... (*p) = temp1;`
-		1622	`....................`
-		1623	`.................... do {`
-		1624	`.................... res=y;`
-		1625	`.................... y+=(x/y);`
-		1626	`.................... temp1 = *p;`
-		1627	`.................... temp2 = *p;`
-		1628	`.................... bit_clear(temp1,15);`
-		1629	`.................... temp1 = (temp1>>4);`
-		1630	`.................... temp1--;`
-		1631	`.................... temp1 = (temp1<<4) & 0xFFF0;`
-		1632	`.................... if(bit_test(temp2,15))`
-		1633	`.................... bit_set(temp1,15);`
-		1634	`.................... temp2 = temp2 & 0x000F;`
-		1635	`.................... temp1 ^= temp2;`
-		1636	`.................... (*p) = temp1;`
-		1637	`....................`
-		1638	`.................... } while(res != y);`
-		1639	`....................`
-		1640	`.................... return(res);`
-		1641	`.................... }`
-		1642	`.................... #endif`
-		1643	`....................`
-		1644	`.................... ////////////////////////////// Trig Functions //////////////////////////////`
-		1645	`.................... #ifdef PI_DIV_BY_TWO`
-		1646	`.................... #undef PI_DIV_BY_TWO`
-		1647	`.................... #endif`
-		1648	`.................... #define PI_DIV_BY_TWO 1.5707963267948966`
-		1649	`.................... #ifdef TWOBYPI`
-		1650	`.................... #undef TWOBYPI`
-		1651	`.................... #define TWOBYPI 0.6366197723675813`
-		1652	`.................... #endif`
-		1653	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1654	`.................... // float cos(float x)`
-		1655	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1656	`.................... // Description : returns the cosine value of the angle x, which is in radian`
-		1657	`.................... // Date : 9/20/2001`
-		1658	`.................... //`
-		1659	`.................... float32 cos(float32 x)`
-		1660	`.................... {`
-		1661	`.................... float32 y, t, t2 = 1.0;`
-		1662	`.................... unsigned int8 quad, i;`
-		1663	`.................... float32 frac;`
-		1664	`.................... float32 p[6] = { //by the series definition for cosine`
-		1665	`.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )`
-		1666	`.................... 0.04166666666667,`
-		1667	`.................... -0.00138888888889,`
-		1668	`.................... 0.00002480158730,`
-		1669	`.................... -0.00000027557319,`
-		1670	`.................... 0.00000000208767,`
-		1671	`.................... //-0.00000000001147,`
-		1672	`.................... // 0.00000000000005`
-		1673	`.................... };`
-		1674	`....................`
-		1675	`.................... if (x < 0) x = -x; // absolute value of input`
-		1676	`....................`
-		1677	`.................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant`
-		1678	`.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input`
-		1679	`.................... quad = quad % 4; // quadrant (0 to 3)`
-		1680	`....................`
-		1681	`.................... if (quad == 0 \|\| quad == 2)`
-		1682	`.................... t = frac * PI_DIV_BY_TWO;`
-		1683	`.................... else if (quad == 1)`
-		1684	`.................... t = (1-frac) * PI_DIV_BY_TWO;`
-		1685	`.................... else // should be 3`
-		1686	`.................... t = (frac-1) * PI_DIV_BY_TWO;`
-		1687	`....................`
-		1688	`.................... y = 1.0;`
-		1689	`.................... t = t * t;`
-		1690	`.................... for (i = 0; i <= 5; i++)`
-		1691	`.................... {`
-		1692	`.................... t2 = t2 * t;`
-		1693	`.................... y = y + p[i] * t2;`
-		1694	`.................... }`
-		1695	`....................`
-		1696	`.................... if (quad == 2 \|\| quad == 1)`
-		1697	`.................... y = -y; // correct sign`
-		1698	`....................`
-		1699	`.................... return (y);`
-		1700	`.................... }`
-		1701	`....................`
-		1702	`....................`
-		1703	`.................... //Overloaded functions for cos() for PCD`
-		1704	`.................... // Overloaded function cos() for data type - Float48`
-		1705	`.................... #if defined(__PCD__)`
-		1706	`.................... float48 cos(float48 x)`
-		1707	`.................... {`
-		1708	`.................... float48 y, t, t2 = 1.0;`
-		1709	`.................... unsigned int8 quad, i;`
-		1710	`.................... float48 frac;`
-		1711	`.................... float48 p[6] = { //by the series definition for cosine`
-		1712	`.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )`
-		1713	`.................... 0.04166666666667,`
-		1714	`.................... -0.00138888888889,`
-		1715	`.................... 0.00002480158730,`
-		1716	`.................... -0.00000027557319,`
-		1717	`.................... 0.00000000208767,`
-		1718	`.................... //-0.00000000001147,`
-		1719	`.................... // 0.00000000000005`
-		1720	`.................... };`
-		1721	`....................`
-		1722	`.................... if (x < 0) x = -x; // absolute value of input`
-		1723	`....................`
-		1724	`.................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant`
-		1725	`.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input`
-		1726	`.................... quad = quad % 4; // quadrant (0 to 3)`
-		1727	`....................`
-		1728	`.................... if (quad == 0 \|\| quad == 2)`
-		1729	`.................... t = frac * PI_DIV_BY_TWO;`
-		1730	`.................... else if (quad == 1)`
-		1731	`.................... t = (1-frac) * PI_DIV_BY_TWO;`
-		1732	`.................... else // should be 3`
-		1733	`.................... t = (frac-1) * PI_DIV_BY_TWO;`
-		1734	`....................`
-		1735	`.................... y = 0.999999999781;`
-		1736	`.................... t = t * t;`
-		1737	`.................... for (i = 0; i <= 5; i++)`
-		1738	`.................... {`
-		1739	`.................... t2 = t2 * t;`
-		1740	`.................... y = y + p[i] * t2;`
-		1741	`.................... }`
-		1742	`....................`
-		1743	`.................... if (quad == 2 \|\| quad == 1)`
-		1744	`.................... y = -y; // correct sign`
-		1745	`....................`
-		1746	`.................... return (y);`
-		1747	`.................... }`
-		1748	`....................`
-		1749	`.................... // Overloaded function cos() for data type - Float48`
-		1750	`.................... float64 cos(float64 x)`
-		1751	`.................... {`
-		1752	`.................... float64 y, t, t2 = 1.0;`
-		1753	`.................... unsigned int8 quad, i;`
-		1754	`.................... float64 frac;`
-		1755	`.................... float64 p[6] = { //by the series definition for cosine`
-		1756	`.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )`
-		1757	`.................... 0.04166666666667,`
-		1758	`.................... -0.00138888888889,`
-		1759	`.................... 0.00002480158730,`
-		1760	`.................... -0.00000027557319,`
-		1761	`.................... 0.00000000208767,`
-		1762	`.................... //-0.00000000001147,`
-		1763	`.................... // 0.00000000000005`
-		1764	`.................... };`
-		1765	`....................`
-		1766	`.................... if (x < 0) x = -x; // absolute value of input`
-		1767	`....................`
-		1768	`.................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant`
-		1769	`.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input`
-		1770	`.................... quad = quad % 4; // quadrant (0 to 3)`
-		1771	`....................`
-		1772	`.................... if (quad == 0 \|\| quad == 2)`
-		1773	`.................... t = frac * PI_DIV_BY_TWO;`
-		1774	`.................... else if (quad == 1)`
-		1775	`.................... t = (1-frac) * PI_DIV_BY_TWO;`
-		1776	`.................... else // should be 3`
-		1777	`.................... t = (frac-1) * PI_DIV_BY_TWO;`
-		1778	`....................`
-		1779	`.................... y = 0.999999999781;`
-		1780	`.................... t = t * t;`
-		1781	`.................... for (i = 0; i <= 5; i++)`
-		1782	`.................... {`
-		1783	`.................... t2 = t2 * t;`
-		1784	`.................... y = y + p[i] * t2;`
-		1785	`.................... }`
-		1786	`....................`
-		1787	`.................... if (quad == 2 \|\| quad == 1)`
-		1788	`.................... y = -y; // correct sign`
-		1789	`....................`
-		1790	`.................... return (y);`
-		1791	`.................... }`
-		1792	`....................`
-		1793	`.................... #endif`
-		1794	`....................`
-		1795	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1796	`.................... // float sin(float x)`
-		1797	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1798	`.................... // Description : returns the sine value of the angle x, which is in radian`
-		1799	`.................... // Date : 9/20/2001`
-		1800	`.................... //`
-		1801	`.................... float32 sin(float32 x)`
-		1802	`.................... {`
-		1803	`.................... return cos(x - PI_DIV_BY_TWO);`
-		1804	`.................... }`
-		1805	`....................`
-		1806	`.................... //Overloaded functions for sin() for PCD`
-		1807	`.................... // Overloaded function sin() for data type - Float48`
-		1808	`.................... #if defined(__PCD__)`
-		1809	`.................... float48 sin(float48 x)`
-		1810	`.................... {`
-		1811	`.................... return cos(x - PI_DIV_BY_TWO);`
-		1812	`.................... }`
-		1813	`....................`
-		1814	`.................... // Overloaded function sin() for data type - Float48`
-		1815	`.................... float64 sin(float64 x)`
-		1816	`.................... {`
-		1817	`.................... return cos(x - PI_DIV_BY_TWO);`
-		1818	`.................... }`
-		1819	`.................... #endif`
-		1820	`....................`
-		1821	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1822	`.................... // float tan(float x)`
-		1823	`.................... ////////////////////////////////////////////////////////////////////////////`
-		1824	`.................... // Description : returns the tangent value of the angle x, which is in radian`
-		1825	`.................... // Date : 9/20/2001`
-		1826	`.................... //`
-		1827	`.................... float32 tan(float32 x)`
-		1828	`.................... {`
-		1829	`.................... float32 c, s;`
-		1830	`....................`
-		1831	`.................... c = cos(x);`
-		1832	`.................... if (c == 0.0)`
-		1833	`.................... return (1.0e+36);`
-		1834	`....................`
-		1835	`.................... s = sin(x);`
-		1836	`.................... return(s/c);`
-		1837	`.................... }`
-		1838	`.................... //Overloaded functions for tan() for PCD`
-		1839	`.................... // Overloaded function tan() for data type - Float48`
-		1840	`.................... #if defined(__PCD__)`
-		1841	`.................... float48 tan(float48 x)`
-		1842	`.................... {`
-		1843	`.................... float48 c, s;`
-		1844	`....................`
-		1845	`.................... c = cos(x);`
-		1846	`.................... if (c == 0.0)`
-		1847	`.................... return (1.0e+36);`
-		1848	`....................`
-		1849	`.................... s = sin(x);`
-		1850	`.................... return(s/c);`
-		1851	`.................... }`
-		1852	`....................`
-		1853	`.................... // Overloaded function tan() for data type - Float48`
-		1854	`.................... float64 tan(float64 x)`
-		1855	`.................... {`
-		1856	`.................... float64 c, s;`
-		1857	`....................`
-		1858	`.................... c = cos(x);`
-		1859	`.................... if (c == 0.0)`
-		1860	`.................... return (1.0e+36);`
-		1861	`....................`
-		1862	`.................... s = sin(x);`
-		1863	`.................... return(s/c);`
-		1864	`.................... }`
-		1865	`.................... #endif`
-		1866	`....................`
-		1867	`.................... float32 const pas[3] = {0.49559947, -4.6145309, 5.6036290};`
-		1868	`.................... float32 const qas[3] = {1.0000000, -5.5484666, 5.6036290};`
-		1869	`....................`
-		1870	`.................... float32 ASIN_COS(float32 x, unsigned int8 n)`
-		1871	`.................... {`
-		1872	`.................... float32 y, res, r, y2;`
-		1873	`.................... int1 s;`
-		1874	`.................... #ifdef _ERRNO`
-		1875	`.................... if(x <-1 \|\| x > 1)`
-		1876	`.................... {`
-		1877	`.................... errno=EDOM;`
-		1878	`.................... }`
-		1879	`.................... #endif`
-		1880	`.................... s = 0;`
-		1881	`.................... y = x;`
-		1882	`....................`
-		1883	`.................... if (x < 0)`
-		1884	`.................... {`
-		1885	`.................... s = 1;`
-		1886	`.................... y = -y;`
-		1887	`.................... }`
-		1888	`....................`
-		1889	`.................... if (y > 0.5)`
-		1890	`.................... {`
-		1891	`.................... y = sqrt((1.0 - y)/2.0);`
-		1892	`.................... n += 2;`
-		1893	`.................... }`
-		1894	`....................`
-		1895	`.................... y2=y*y;`
-		1896	`....................`
-		1897	`.................... res = pas[0]*y2 + pas[1];`
-		1898	`.................... res = res*y2 + pas[2];`
-		1899	`....................`
-		1900	`.................... r = qas[0]*y2 + qas[1];`
-		1901	`.................... r = r*y2 + qas[2];`
-		1902	`....................`
-		1903	`.................... res = y*res/r;`
-		1904	`....................`
-		1905	`.................... if (n & 2) // \|x\| > 0.5`
-		1906	`.................... res = PI_DIV_BY_TWO - 2.0*res;`
-		1907	`.................... if (s)`
-		1908	`.................... res = -res;`
-		1909	`.................... if (n & 1) // take arccos`
-		1910	`.................... res = PI_DIV_BY_TWO - res;`
-		1911	`....................`
-		1912	`.................... return(res);`
-		1913	`.................... }`
-		1914	`....................`
-		1915	`.................... //Overloaded functions for ASIN_COS() for PCD`
-		1916	`.................... // Overloaded function ASIN_COS() for data type - Float48`
-		1917	`.................... #if defined(__PCD__)`
-		1918	`.................... float48 ASIN_COS(float48 x, unsigned int8 n)`
-		1919	`.................... {`
-		1920	`.................... float48 y, res, r, y2;`
-		1921	`.................... int1 s;`
-		1922	`.................... #ifdef _ERRNO`
-		1923	`.................... if(x <-1 \|\| x > 1)`
-		1924	`.................... {`
-		1925	`.................... errno=EDOM;`
-		1926	`.................... }`
-		1927	`.................... #endif`
-		1928	`.................... s = 0;`
-		1929	`.................... y = x;`
-		1930	`....................`
-		1931	`.................... if (x < 0)`
-		1932	`.................... {`
-		1933	`.................... s = 1;`
-		1934	`.................... y = -y;`
-		1935	`.................... }`
-		1936	`....................`
-		1937	`.................... if (y > 0.5)`
-		1938	`.................... {`
-		1939	`.................... y = sqrt((1.0 - y)/2.0);`
-		1940	`.................... n += 2;`
-		1941	`.................... }`
-		1942	`....................`
-		1943	`.................... y2=y*y;`
-		1944	`....................`
-		1945	`.................... res = pas[0]*y2 + pas[1];`
-		1946	`.................... res = res*y2 + pas[2];`
-		1947	`....................`
-		1948	`.................... r = qas[0]*y2 + qas[1];`
-		1949	`.................... r = r*y2 + qas[2];`
-		1950	`....................`
-		1951	`.................... res = y*res/r;`
-		1952	`....................`
-		1953	`.................... if (n & 2) // \|x\| > 0.5`
-		1954	`.................... res = PI_DIV_BY_TWO - 2.0*res;`
-		1955	`.................... if (s)`
-		1956	`.................... res = -res;`
-		1957	`.................... if (n & 1) // take arccos`
-		1958	`.................... res = PI_DIV_BY_TWO - res;`
-		1959	`....................`
-		1960	`.................... return(res);`
-		1961	`.................... }`
-		1962	`....................`
-		1963	`.................... // Overloaded function ASIN_COS() for data type - Float64`
-		1964	`.................... float64 ASIN_COS(float64 x, unsigned int8 n)`
-		1965	`.................... {`
-		1966	`.................... float64 y, res, r, y2;`
-		1967	`.................... int1 s;`
-		1968	`.................... #ifdef _ERRNO`
-		1969	`.................... if(x <-1 \|\| x > 1)`
-		1970	`.................... {`
-		1971	`.................... errno=EDOM;`
-		1972	`.................... }`
-		1973	`.................... #endif`
-		1974	`.................... s = 0;`
-		1975	`.................... y = x;`
-		1976	`....................`
-		1977	`.................... if (x < 0)`
-		1978	`.................... {`
-		1979	`.................... s = 1;`
-		1980	`.................... y = -y;`
-		1981	`.................... }`
-		1982	`....................`
-		1983	`.................... if (y > 0.5)`
-		1984	`.................... {`
-		1985	`.................... y = sqrt((1.0 - y)/2.0);`
-		1986	`.................... n += 2;`
-		1987	`.................... }`
-		1988	`....................`
-		1989	`.................... y2=y*y;`
-		1990	`....................`
-		1991	`.................... res = pas[0]*y2 + pas[1];`
-		1992	`.................... res = res*y2 + pas[2];`
-		1993	`....................`
-		1994	`.................... r = qas[0]*y2 + qas[1];`
-		1995	`.................... r = r*y2 + qas[2];`
-		1996	`....................`
-		1997	`.................... res = y*res/r;`
-		1998	`....................`
-		1999	`.................... if (n & 2) // \|x\| > 0.5`
-		2000	`.................... res = PI_DIV_BY_TWO - 2.0*res;`
-		2001	`.................... if (s)`
-		2002	`.................... res = -res;`
-		2003	`.................... if (n & 1) // take arccos`
-		2004	`.................... res = PI_DIV_BY_TWO - res;`
-		2005	`....................`
-		2006	`.................... return(res);`
-		2007	`.................... }`
-		2008	`.................... #endif`
-		2009	`....................`
-		2010	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2011	`.................... // float asin(float x)`
-		2012	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2013	`.................... // Description : returns the arcsine value of the value x.`
-		2014	`.................... // Date : N/A`
-		2015	`.................... //`
-		2016	`.................... float32 asin(float32 x)`
-		2017	`.................... {`
-		2018	`.................... float32 r;`
-		2019	`....................`
-		2020	`.................... r = ASIN_COS(x, 0);`
-		2021	`.................... return(r);`
-		2022	`.................... }`
-		2023	`.................... //Overloaded functions for asin() for PCD`
-		2024	`.................... // Overloaded function asin() for data type - Float48`
-		2025	`.................... #if defined(__PCD__)`
-		2026	`.................... float48 asin(float48 x)`
-		2027	`.................... {`
-		2028	`.................... float48 r;`
-		2029	`....................`
-		2030	`.................... r = ASIN_COS(x, 0);`
-		2031	`.................... return(r);`
-		2032	`.................... }`
-		2033	`....................`
-		2034	`.................... // Overloaded function asin() for data type - Float64`
-		2035	`.................... float64 asin(float64 x)`
-		2036	`.................... {`
-		2037	`.................... float64 r;`
-		2038	`....................`
-		2039	`.................... r = ASIN_COS(x, 0);`
-		2040	`.................... return(r);`
-		2041	`.................... }`
-		2042	`.................... #endif`
-		2043	`....................`
-		2044	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2045	`.................... // float acos(float x)`
-		2046	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2047	`.................... // Description : returns the arccosine value of the value x.`
-		2048	`.................... // Date : N/A`
-		2049	`.................... //`
-		2050	`.................... float32 acos(float32 x)`
-		2051	`.................... {`
-		2052	`.................... float32 r;`
-		2053	`....................`
-		2054	`.................... r = ASIN_COS(x, 1);`
-		2055	`.................... return(r);`
-		2056	`.................... }`
-		2057	`.................... //Overloaded functions for acos() for PCD`
-		2058	`.................... // Overloaded function acos() for data type - Float48`
-		2059	`.................... #if defined(__PCD__)`
-		2060	`.................... float48 acos(float48 x)`
-		2061	`.................... {`
-		2062	`.................... float48 r;`
-		2063	`....................`
-		2064	`.................... r = ASIN_COS(x, 1);`
-		2065	`.................... return(r);`
-		2066	`.................... }`
-		2067	`....................`
-		2068	`.................... // Overloaded function acos() for data type - Float64`
-		2069	`.................... float64 acos(float64 x)`
-		2070	`.................... {`
-		2071	`.................... float64 r;`
-		2072	`....................`
-		2073	`.................... r = ASIN_COS(x, 1);`
-		2074	`.................... return(r);`
-		2075	`.................... }`
-		2076	`.................... #endif`
-		2077	`....................`
-		2078	`.................... float32 const pat[4] = {0.17630401, 5.6710795, 22.376096, 19.818457};`
-		2079	`.................... float32 const qat[4] = {1.0000000, 11.368190, 28.982246, 19.818457};`
-		2080	`....................`
-		2081	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2082	`.................... // float atan(float x)`
-		2083	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2084	`.................... // Description : returns the arctangent value of the value x.`
-		2085	`.................... // Date : N/A`
-		2086	`.................... //`
-		2087	`.................... float32 atan(float32 x)`
-		2088	`.................... {`
-		2089	`.................... float32 y, res, r;`
-		2090	`.................... int1 s, flag;`
-		2091	`....................`
-		2092	`.................... s = 0;`
-		2093	`.................... flag = 0;`
-		2094	`.................... y = x;`
-		2095	`....................`
-		2096	`.................... if (x < 0)`
-		2097	`.................... {`
-		2098	`.................... s = 1;`
-		2099	`.................... y = -y;`
-		2100	`.................... }`
-		2101	`....................`
-		2102	`.................... if (y > 1.0)`
-		2103	`.................... {`
-		2104	`.................... y = 1.0/y;`
-		2105	`.................... flag = 1;`
-		2106	`.................... }`
-		2107	`....................`
-		2108	`.................... res = pat[0]yy + pat[1];`
-		2109	`.................... res = resyy + pat[2];`
-		2110	`.................... res = resyy + pat[3];`
-		2111	`....................`
-		2112	`.................... r = qat[0]yy + qat[1];`
-		2113	`.................... r = ryy + qat[2];`
-		2114	`.................... r = ryy + qat[3];`
-		2115	`....................`
-		2116	`.................... res = y*res/r;`
-		2117	`....................`
-		2118	`....................`
-		2119	`.................... if (flag) // for \|x\| > 1`
-		2120	`.................... res = PI_DIV_BY_TWO - res;`
-		2121	`.................... if (s)`
-		2122	`.................... res = -res;`
-		2123	`....................`
-		2124	`.................... return(res);`
-		2125	`.................... }`
-		2126	`.................... //Overloaded functions for atan() for PCD`
-		2127	`.................... // Overloaded function atan() for data type - Float48`
-		2128	`.................... #if defined(__PCD__)`
-		2129	`.................... float48 atan(float48 x)`
-		2130	`.................... {`
-		2131	`.................... float48 y, res, r;`
-		2132	`.................... int1 s, flag;`
-		2133	`....................`
-		2134	`.................... s = 0;`
-		2135	`.................... flag = 0;`
-		2136	`.................... y = x;`
-		2137	`....................`
-		2138	`.................... if (x < 0)`
-		2139	`.................... {`
-		2140	`.................... s = 1;`
-		2141	`.................... y = -y;`
-		2142	`.................... }`
-		2143	`....................`
-		2144	`.................... if (y > 1.0)`
-		2145	`.................... {`
-		2146	`.................... y = 1.0/y;`
-		2147	`.................... flag = 1;`
-		2148	`.................... }`
-		2149	`....................`
-		2150	`.................... res = pat[0]yy + pat[1];`
-		2151	`.................... res = resyy + pat[2];`
-		2152	`.................... res = resyy + pat[3];`
-		2153	`....................`
-		2154	`.................... r = qat[0]yy + qat[1];`
-		2155	`.................... r = ryy + qat[2];`
-		2156	`.................... r = ryy + qat[3];`
-		2157	`....................`
-		2158	`.................... res = y*res/r;`
-		2159	`....................`
-		2160	`....................`
-		2161	`.................... if (flag) // for \|x\| > 1`
-		2162	`.................... res = PI_DIV_BY_TWO - res;`
-		2163	`.................... if (s)`
-		2164	`.................... res = -res;`
-		2165	`....................`
-		2166	`.................... return(res);`
-		2167	`.................... }`
-		2168	`....................`
-		2169	`.................... // Overloaded function atan() for data type - Float64`
-		2170	`.................... float64 atan(float64 x)`
-		2171	`.................... {`
-		2172	`.................... float64 y, res, r;`
-		2173	`.................... int1 s, flag;`
-		2174	`....................`
-		2175	`.................... s = 0;`
-		2176	`.................... flag = 0;`
-		2177	`.................... y = x;`
-		2178	`....................`
-		2179	`.................... if (x < 0)`
-		2180	`.................... {`
-		2181	`.................... s = 1;`
-		2182	`.................... y = -y;`
-		2183	`.................... }`
-		2184	`....................`
-		2185	`.................... if (y > 1.0)`
-		2186	`.................... {`
-		2187	`.................... y = 1.0/y;`
-		2188	`.................... flag = 1;`
-		2189	`.................... }`
-		2190	`....................`
-		2191	`.................... res = pat[0]yy + pat[1];`
-		2192	`.................... res = resyy + pat[2];`
-		2193	`.................... res = resyy + pat[3];`
-		2194	`....................`
-		2195	`.................... r = qat[0]yy + qat[1];`
-		2196	`.................... r = ryy + qat[2];`
-		2197	`.................... r = ryy + qat[3];`
-		2198	`....................`
-		2199	`.................... res = y*res/r;`
-		2200	`....................`
-		2201	`....................`
-		2202	`.................... if (flag) // for \|x\| > 1`
-		2203	`.................... res = PI_DIV_BY_TWO - res;`
-		2204	`.................... if (s)`
-		2205	`.................... res = -res;`
-		2206	`....................`
-		2207	`.................... return(res);`
-		2208	`.................... }`
-		2209	`.................... #endif`
-		2210	`....................`
-		2211	`.................... /////////////////////////////////////////////////////////////////////////////`
-		2212	`.................... // float atan2(float y, float x)`
-		2213	`.................... /////////////////////////////////////////////////////////////////////////////`
-		2214	`.................... // Description :computes the principal value of arc tangent of y/x, using the`
-		2215	`.................... // signs of both the arguments to determine the quadrant of the return value`
-		2216	`.................... // Returns : returns the arc tangent of y/x.`
-		2217	`.................... // Date : N/A`
-		2218	`.................... //`
-		2219	`....................`
-		2220	`.................... float32 atan2(float32 y,float32 x)`
-		2221	`.................... {`
-		2222	`.................... float32 z;`
-		2223	`.................... int1 sign;`
-		2224	`.................... unsigned int8 quad;`
-		2225	`.................... sign=0;`
-		2226	`.................... quad=0; //quadrant`
-		2227	`.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));`
-		2228	`.................... if(y<0.0)`
-		2229	`.................... {`
-		2230	`.................... sign=1;`
-		2231	`.................... y=-y;`
-		2232	`.................... }`
-		2233	`.................... if(x<0.0)`
-		2234	`.................... {`
-		2235	`.................... x=-x;`
-		2236	`.................... }`
-		2237	`.................... if (x==0.0)`
-		2238	`.................... {`
-		2239	`.................... if(y==0.0)`
-		2240	`.................... {`
-		2241	`.................... #ifdef _ERRNO`
-		2242	`.................... {`
-		2243	`.................... errno=EDOM;`
-		2244	`.................... }`
-		2245	`.................... #endif`
-		2246	`.................... }`
-		2247	`.................... else`
-		2248	`.................... {`
-		2249	`.................... if(sign)`
-		2250	`.................... {`
-		2251	`.................... return (-(PI_DIV_BY_TWO));`
-		2252	`.................... }`
-		2253	`.................... else`
-		2254	`.................... {`
-		2255	`.................... return (PI_DIV_BY_TWO);`
-		2256	`.................... }`
-		2257	`.................... }`
-		2258	`.................... }`
-		2259	`.................... else`
-		2260	`.................... {`
-		2261	`.................... z=y/x;`
-		2262	`.................... switch(quad)`
-		2263	`.................... {`
-		2264	`.................... case 1:`
-		2265	`.................... {`
-		2266	`.................... return atan(z);`
-		2267	`.................... break;`
-		2268	`.................... }`
-		2269	`.................... case 2:`
-		2270	`.................... {`
-		2271	`.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122`
-		2272	`.................... return (PI-atan(z));`
-		2273	`.................... break;`
-		2274	`.................... }`
-		2275	`.................... case 3:`
-		2276	`.................... {`
-		2277	`.................... return (atan(z)-PI);`
-		2278	`.................... break;`
-		2279	`.................... }`
-		2280	`.................... case 4:`
-		2281	`.................... {`
-		2282	`.................... return (-atan(z));`
-		2283	`.................... break;`
-		2284	`.................... }`
-		2285	`.................... }`
-		2286	`.................... }`
-		2287	`.................... }`
-		2288	`....................`
-		2289	`.................... //Overloaded functions for atan2() for PCD`
-		2290	`.................... // Overloaded function atan2() for data type - Float48`
-		2291	`.................... #if defined(__PCD__)`
-		2292	`.................... float48 atan2(float48 y,float48 x)`
-		2293	`.................... {`
-		2294	`.................... float48 z;`
-		2295	`.................... int1 sign;`
-		2296	`.................... unsigned int8 quad;`
-		2297	`.................... sign=0;`
-		2298	`.................... quad=0; //quadrant`
-		2299	`.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));`
-		2300	`.................... if(y<0.0)`
-		2301	`.................... {`
-		2302	`.................... sign=1;`
-		2303	`.................... y=-y;`
-		2304	`.................... }`
-		2305	`.................... if(x<0.0)`
-		2306	`.................... {`
-		2307	`.................... x=-x;`
-		2308	`.................... }`
-		2309	`.................... if (x==0.0)`
-		2310	`.................... {`
-		2311	`.................... if(y==0.0)`
-		2312	`.................... {`
-		2313	`.................... #ifdef _ERRNO`
-		2314	`.................... {`
-		2315	`.................... errno=EDOM;`
-		2316	`.................... }`
-		2317	`.................... #endif`
-		2318	`.................... }`
-		2319	`.................... else`
-		2320	`.................... {`
-		2321	`.................... if(sign)`
-		2322	`.................... {`
-		2323	`.................... return (-(PI_DIV_BY_TWO));`
-		2324	`.................... }`
-		2325	`.................... else`
-		2326	`.................... {`
-		2327	`.................... return (PI_DIV_BY_TWO);`
-		2328	`.................... }`
-		2329	`.................... }`
-		2330	`.................... }`
-		2331	`.................... else`
-		2332	`.................... {`
-		2333	`.................... z=y/x;`
-		2334	`.................... switch(quad)`
-		2335	`.................... {`
-		2336	`.................... case 1:`
-		2337	`.................... {`
-		2338	`.................... return atan(z);`
-		2339	`.................... break;`
-		2340	`.................... }`
-		2341	`.................... case 2:`
-		2342	`.................... {`
-		2343	`.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122`
-		2344	`.................... return (PI-atan(z));`
-		2345	`.................... break;`
-		2346	`.................... }`
-		2347	`.................... case 3:`
-		2348	`.................... {`
-		2349	`.................... return (atan(z)-PI);`
-		2350	`.................... break;`
-		2351	`.................... }`
-		2352	`.................... case 4:`
-		2353	`.................... {`
-		2354	`.................... return (-atan(z));`
-		2355	`.................... break;`
-		2356	`.................... }`
-		2357	`.................... }`
-		2358	`.................... }`
-		2359	`.................... }`
-		2360	`....................`
-		2361	`.................... // Overloaded function atan2() for data type - Float64`
-		2362	`.................... float64 atan2(float64 y,float64 x)`
-		2363	`.................... {`
-		2364	`.................... float64 z;`
-		2365	`.................... int1 sign;`
-		2366	`.................... unsigned int8 quad;`
-		2367	`.................... sign=0;`
-		2368	`.................... quad=0; //quadrant`
-		2369	`.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));`
-		2370	`.................... if(y<0.0)`
-		2371	`.................... {`
-		2372	`.................... sign=1;`
-		2373	`.................... y=-y;`
-		2374	`.................... }`
-		2375	`.................... if(x<0.0)`
-		2376	`.................... {`
-		2377	`.................... x=-x;`
-		2378	`.................... }`
-		2379	`.................... if (x==0.0)`
-		2380	`.................... {`
-		2381	`.................... if(y==0.0)`
-		2382	`.................... {`
-		2383	`.................... #ifdef _ERRNO`
-		2384	`.................... {`
-		2385	`.................... errno=EDOM;`
-		2386	`.................... }`
-		2387	`.................... #endif`
-		2388	`.................... }`
-		2389	`.................... else`
-		2390	`.................... {`
-		2391	`.................... if(sign)`
-		2392	`.................... {`
-		2393	`.................... return (-(PI_DIV_BY_TWO));`
-		2394	`.................... }`
-		2395	`.................... else`
-		2396	`.................... {`
-		2397	`.................... return (PI_DIV_BY_TWO);`
-		2398	`.................... }`
-		2399	`.................... }`
-		2400	`.................... }`
-		2401	`.................... else`
-		2402	`.................... {`
-		2403	`.................... z=y/x;`
-		2404	`.................... switch(quad)`
-		2405	`.................... {`
-		2406	`.................... case 1:`
-		2407	`.................... {`
-		2408	`.................... return atan(z);`
-		2409	`.................... break;`
-		2410	`.................... }`
-		2411	`.................... case 2:`
-		2412	`.................... {`
-		2413	`.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122`
-		2414	`.................... return (PI-atan(z));`
-		2415	`.................... break;`
-		2416	`.................... }`
-		2417	`.................... case 3:`
-		2418	`.................... {`
-		2419	`.................... return (atan(z)-PI);`
-		2420	`.................... break;`
-		2421	`.................... }`
-		2422	`.................... case 4:`
-		2423	`.................... {`
-		2424	`.................... return (-atan(z));`
-		2425	`.................... break;`
-		2426	`.................... }`
-		2427	`.................... }`
-		2428	`.................... }`
-		2429	`.................... }`
-		2430	`.................... #endif`
-		2431	`....................`
-		2432	`.................... //////////////////// Hyperbolic functions ////////////////////`
-		2433	`....................`
-		2434	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2435	`.................... // float cosh(float x)`
-		2436	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2437	`.................... // Description : Computes the hyperbolic cosine value of x`
-		2438	`.................... // Returns : returns the hyperbolic cosine value of x`
-		2439	`.................... // Date : N/A`
-		2440	`.................... //`
-		2441	`....................`
-		2442	`.................... float32 cosh(float32 x)`
-		2443	`.................... {`
-		2444	`.................... return ((exp(x)+exp(-x))/2);`
-		2445	`.................... }`
-		2446	`.................... //Overloaded functions for cosh() for PCD`
-		2447	`.................... // Overloaded function cosh() for data type - Float48`
-		2448	`.................... #if defined(__PCD__)`
-		2449	`.................... float48 cosh(float48 x)`
-		2450	`.................... {`
-		2451	`.................... return ((exp(x)+exp(-x))/2);`
-		2452	`.................... }`
-		2453	`....................`
-		2454	`.................... // Overloaded function cosh() for data type - Float64`
-		2455	`.................... float64 cosh(float64 x)`
-		2456	`.................... {`
-		2457	`.................... return ((exp(x)+exp(-x))/2);`
-		2458	`.................... }`
-		2459	`.................... #endif`
-		2460	`....................`
-		2461	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2462	`.................... // float sinh(float x)`
-		2463	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2464	`.................... // Description : Computes the hyperbolic sine value of x`
-		2465	`.................... // Returns : returns the hyperbolic sine value of x`
-		2466	`.................... // Date : N/A`
-		2467	`.................... //`
-		2468	`....................`
-		2469	`.................... float32 sinh(float32 x)`
-		2470	`.................... {`
-		2471	`....................`
-		2472	`.................... return ((exp(x) - exp(-x))/2);`
-		2473	`.................... }`
-		2474	`.................... //Overloaded functions for sinh() for PCD`
-		2475	`.................... // Overloaded function sinh() for data type - Float48`
-		2476	`.................... #if defined(__PCD__)`
-		2477	`.................... float48 sinh(float48 x)`
-		2478	`.................... {`
-		2479	`....................`
-		2480	`.................... return ((exp(x) - exp(-x))/2);`
-		2481	`.................... }`
-		2482	`....................`
-		2483	`.................... // Overloaded function sinh() for data type - Float48`
-		2484	`.................... float64 sinh(float64 x)`
-		2485	`.................... {`
-		2486	`....................`
-		2487	`.................... return ((exp(x) - exp(-x))/2);`
-		2488	`.................... }`
-		2489	`.................... #endif`
-		2490	`....................`
-		2491	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2492	`.................... // float tanh(float x)`
-		2493	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2494	`.................... // Description : Computes the hyperbolic tangent value of x`
-		2495	`.................... // Returns : returns the hyperbolic tangent value of x`
-		2496	`.................... // Date : N/A`
-		2497	`.................... //`
-		2498	`....................`
-		2499	`.................... float32 tanh(float32 x)`
-		2500	`.................... {`
-		2501	`.................... return(sinh(x)/cosh(x));`
-		2502	`.................... }`
-		2503	`.................... //Overloaded functions for tanh() for PCD`
-		2504	`.................... // Overloaded function tanh() for data type - Float48`
-		2505	`.................... #if defined(__PCD__)`
-		2506	`.................... float48 tanh(float48 x)`
-		2507	`.................... {`
-		2508	`.................... return(sinh(x)/cosh(x));`
-		2509	`.................... }`
-		2510	`....................`
-		2511	`.................... // Overloaded function tanh() for data type - Float64`
-		2512	`.................... float64 tanh(float64 x)`
-		2513	`.................... {`
-		2514	`.................... return(sinh(x)/cosh(x));`
-		2515	`.................... }`
-		2516	`.................... #endif`
-		2517	`....................`
-		2518	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2519	`.................... // float frexp(float x, signed int *exp)`
-		2520	`.................... ////////////////////////////////////////////////////////////////////////////`
-		2521	`.................... // Description : breaks a floating point number into a normalized fraction and an integral`
-		2522	`.................... // power of 2. It stores the integer in the signed int object pointed to by exp.`
-		2523	`.................... // Returns : returns the value x, such that x is a double with magnitude in the interval`
-		2524	`.................... // [1/2,1) or zero, and value equals x times 2 raised to the power *exp.If value is zero,`
-		2525	`.................... // both parts of the result are zero.`
-		2526	`.................... // Date : N/A`
-		2527	`.................... //`
-		2528	`....................`
-		2529	`.................... #define LOG2 .30102999566398119521`
-		2530	`.................... float32 frexp(float32 x, signed int8 *exp)`
-		2531	`.................... {`
-		2532	`.................... float32 res;`
-		2533	`.................... int1 sign = 0;`
-		2534	`.................... if(x == 0.0)`
-		2535	`.................... {`
-		2536	`.................... *exp=0;`
-		2537	`.................... return (0.0);`
-		2538	`.................... }`
-		2539	`.................... if(x < 0.0)`
-		2540	`.................... {`
-		2541	`.................... x=-x;`
-		2542	`.................... sign=1;`
-		2543	`.................... }`
-		2544	`.................... if (x > 1.0)`
-		2545	`.................... {`
-		2546	`.................... *exp=(ceil(log10(x)/LOG2));`
-		2547	`.................... res=x/(pow(2, *exp));`
-		2548	`.................... if (res == 1)`
-		2549	`.................... {`
-		2550	`.................... exp=exp+1;`
-		2551	`.................... res=.5;`
-		2552	`.................... }`
-		2553	`.................... }`
-		2554	`.................... else`
-		2555	`.................... {`
-		2556	`.................... if(x < 0.5)`
-		2557	`.................... {`
-		2558	`.................... *exp=-1;`
-		2559	`.................... res=x*2;`
-		2560	`.................... }`
-		2561	`.................... else`
-		2562	`.................... {`
-		2563	`.................... *exp=0;`
-		2564	`.................... res=x;`
-		2565	`.................... }`
-		2566	`.................... }`
-		2567	`.................... if(sign)`
-		2568	`.................... {`
-		2569	`.................... res=-res;`
-		2570	`.................... }`
-		2571	`.................... return res;`
-		2572	`.................... }`
-		2573	`....................`
-		2574	`.................... //Overloaded functions for frexp() for PCD`
-		2575	`.................... // Overloaded function frexp() for data type - Float48`
-		2576	`.................... #if defined(__PCD__)`
-		2577	`.................... float48 frexp(float48 x, signed int8 *exp)`
-		2578	`.................... {`
-		2579	`.................... float48 res;`
-		2580	`.................... int1 sign = 0;`
-		2581	`.................... if(x == 0.0)`
-		2582	`.................... {`
-		2583	`.................... *exp=0;`
-		2584	`.................... return (0.0);`
-		2585	`.................... }`
-		2586	`.................... if(x < 0.0)`
-		2587	`.................... {`
-		2588	`.................... x=-x;`
-		2589	`.................... sign=1;`
-		2590	`.................... }`
-		2591	`.................... if (x > 1.0)`
-		2592	`.................... {`
-		2593	`.................... *exp=(ceil(log10(x)/LOG2));`
-		2594	`.................... res=x/(pow(2, *exp));`
-		2595	`.................... if (res == 1)`
-		2596	`.................... {`
-		2597	`.................... exp=exp+1;`
-		2598	`.................... res=.5;`
-		2599	`.................... }`
-		2600	`.................... }`
-		2601	`.................... else`
-		2602	`.................... {`
-		2603	`.................... if(x < 0.5)`
-		2604	`.................... {`
-		2605	`.................... *exp=-1;`
-		2606	`.................... res=x*2;`
-		2607	`.................... }`
-		2608	`.................... else`
-		2609	`.................... {`
-		2610	`.................... *exp=0;`
-		2611	`.................... res=x;`
-		2612	`.................... }`
-		2613	`.................... }`
-		2614	`.................... if(sign)`
-		2615	`.................... {`
-		2616	`.................... res=-res;`
-		2617	`.................... }`
-		2618	`.................... return res;`
-		2619	`.................... }`
-		2620	`....................`
-		2621	`.................... // Overloaded function frexp() for data type - Float64`
-		2622	`.................... float64 frexp(float64 x, signed int8 *exp)`
-		2623	`.................... {`
-		2624	`.................... float64 res;`
-		2625	`.................... int1 sign = 0;`
-		2626	`.................... if(x == 0.0)`
-		2627	`.................... {`
-		2628	`.................... *exp=0;`
-		2629	`.................... return (0.0);`
-		2630	`.................... }`
-		2631	`.................... if(x < 0.0)`
-		2632	`.................... {`
-		2633	`.................... x=-x;`
-		2634	`.................... sign=1;`
-		2635	`.................... }`
-		2636	`.................... if (x > 1.0)`
-		2637	`.................... {`
-		2638	`.................... *exp=(ceil(log10(x)/LOG2));`
-		2639	`.................... res=x/(pow(2, *exp));`
-		2640	`.................... if (res == 1)`
-		2641	`.................... {`
-		2642	`.................... exp=exp+1;`
-		2643	`.................... res=.5;`
-		2644	`.................... }`
-		2645	`.................... }`
-		2646	`.................... else`
-		2647	`.................... {`
-		2648	`.................... if(x < 0.5)`
-		2649	`.................... {`
-		2650	`.................... *exp=-1;`
-		2651	`.................... res=x*2;`
-		2652	`.................... }`
-		2653	`.................... else`
-		2654	`.................... {`
-		2655	`.................... *exp=0;`
-		2656	`.................... res=x;`
-		2657	`.................... }`
-		2658	`.................... }`
-		2659	`.................... if(sign)`
-		2660	`.................... {`
-		2661	`.................... res=-res;`
-		2662	`.................... }`
-		2663	`.................... return res;`
-		2664	`.................... }`
-		2665	`.................... #endif`
-		2666	`....................`
-		2667	`.................... //////////////////////////////////////////////////////////////////////////////`
-		2668	`.................... // float ldexp(float x, signed int *exp)`
-		2669	`.................... //////////////////////////////////////////////////////////////////////////////`
-		2670	`.................... // Description : multiplies a floating point number by an integral power of 2.`
-		2671	`.................... // Returns : returns the value of x times 2 raised to the power exp.`
-		2672	`.................... // Date : N/A`
-		2673	`.................... //`
-		2674	`....................`
-		2675	`.................... float32 ldexp(float32 value, signed int8 exp)`
-		2676	`.................... {`
-		2677	`.................... return (value * pow(2,exp));`
-		2678	`.................... }`
-		2679	`.................... //Overloaded functions for ldexp() for PCD`
-		2680	`.................... // Overloaded function ldexp() for data type - Float48`
-		2681	`....................`
-		2682	`.................... #if defined(__PCD__)`
-		2683	`.................... float48 ldexp(float48 value, signed int8 exp)`
-		2684	`.................... {`
-		2685	`.................... return (value * pow(2,exp));`
-		2686	`.................... }`
-		2687	`.................... // Overloaded function ldexp() for data type - Float64`
-		2688	`.................... float64 ldexp(float64 value, signed int8 exp)`
-		2689	`.................... {`
-		2690	`.................... return (value * pow(2,exp));`
-		2691	`.................... }`
-		2692	`.................... #endif`
-		2693	`....................`
-		2694	`.................... #endif`
-		2695	`....................`
524	`....................`	2696	`....................`
525	`.................... void main()`	2697	`.................... void main()`
526	`.................... {`	2698	`.................... {`
527	`*`	2699	`*`
528	`0250: CLRF 04`	2700	`024F: CLRF 04`
529	`0251: BCF 03.7`	2701	`0250: BCF 03.7`
530	`0252: MOVLW 1F`	2702	`0251: MOVLW 1F`
531	`0253: ANDWF 03,F`	2703	`0252: ANDWF 03,F`
532	`0254: MOVLW 71`	2704	`0253: MOVLW 71`
533	`0255: BSF 03.5`	2705	`0254: BSF 03.5`
534	`0256: MOVWF 0F`	2706	`0255: MOVWF 0F`
535	`0257: MOVF 0F,W`	2707	`0256: MOVF 0F,W`
536	`0258: BCF 03.5`	2708	`0257: BCF 03.5`
537	`0259: BCF 20.7`	2709	`0258: BCF 20.7`
538	`025A: MOVF 20,W`	2710	`0259: MOVF 20,W`
539	`025B: BSF 03.5`	2711	`025A: BSF 03.5`
540	`025C: MOVWF 07`	2712	`025B: MOVWF 07`
541	`025D: BCF 03.5`	2713	`025C: BCF 03.5`
542	`025E: BSF 07.7`	2714	`025D: BSF 07.7`
543	`025F: BSF 03.5`	2715	`025E: BSF 03.5`
544	`0260: BSF 03.6`	2716	`025F: BSF 03.6`
545	`0261: MOVF 09,W`	2717	`0260: MOVF 09,W`
546	`0262: ANDLW C0`	2718	`0261: ANDLW C0`
547	`0263: MOVWF 09`	2719	`0262: MOVWF 09`
548	`0264: BCF 03.6`	2720	`0263: BCF 03.6`
549	`0265: BCF 1F.4`	2721	`0264: BCF 1F.4`
550	`0266: BCF 1F.5`	2722	`0265: BCF 1F.5`
551	`0267: MOVLW 00`	2723	`0266: MOVLW 00`
552	`0268: BSF 03.6`	2724	`0267: BSF 03.6`
553	`0269: MOVWF 08`	2725	`0268: MOVWF 08`
554	`026A: BCF 03.5`	2726	`0269: BCF 03.5`
555	`026B: CLRF 07`	2727	`026A: CLRF 07`
556	`026C: CLRF 08`	2728	`026B: CLRF 08`
557	`026D: CLRF 09`	2729	`026C: CLRF 09`
558	`*`	2730	`*`
559	`0277: CLRF 29`	2731	`0276: CLRF 34`
560	`0278: CLRF 28`	2732	`0277: CLRF 33`
561	`.................... int1 last;`	2733	`.................... float last,b,anemo_speed;`
562	`.................... unsigned int16 anemo_round=0;`	2734	`.................... unsigned int16 anemo_round=0;`
563	`.................... unsigned int16 i;`	2735	`.................... unsigned int16 i;`
564	`....................`	2736	`....................`
565	`....................`	2737	`....................`
566	`.................... //signed int16 X,Y,Z;`	2738	`.................... //signed int16 X,Y,Z;`
567	`.................... setup_adc_ports(NO_ANALOGS\|VSS_VDD);`	2739	`.................... setup_adc_ports(NO_ANALOGS\|VSS_VDD);`
568	`0279: BSF 03.5`	2740	`0278: BSF 03.5`
569	`027A: BSF 03.6`	2741	`0279: BSF 03.6`
570	`027B: MOVF 09,W`	2742	`027A: MOVF 09,W`
571	`027C: ANDLW C0`	2743	`027B: ANDLW C0`
572	`027D: MOVWF 09`	2744	`027C: MOVWF 09`
573	`027E: BCF 03.6`	2745	`027D: BCF 03.6`
574	`027F: BCF 1F.4`	2746	`027E: BCF 1F.4`
575	`0280: BCF 1F.5`	2747	`027F: BCF 1F.5`
576	`0281: MOVLW 00`	2748	`0280: MOVLW 00`
577	`0282: BSF 03.6`	2749	`0281: BSF 03.6`
578	`0283: MOVWF 08`	2750	`0282: MOVWF 08`
579	`.................... setup_adc(ADC_CLOCK_DIV_2);`	2751	`.................... setup_adc(ADC_CLOCK_DIV_2);`
580	`0284: BCF 03.5`	2752	`0283: BCF 03.5`
581	`0285: BCF 03.6`	2753	`0284: BCF 03.6`
582	`0286: BCF 1F.6`	2754	`0285: BCF 1F.6`
583	`0287: BCF 1F.7`	2755	`0286: BCF 1F.7`
584	`0288: BSF 03.5`	2756	`0287: BSF 03.5`
585	`0289: BCF 1F.7`	2757	`0288: BCF 1F.7`
586	`028A: BCF 03.5`	2758	`0289: BCF 03.5`
587	`028B: BSF 1F.0`	2759	`028A: BSF 1F.0`
588	`.................... setup_spi(SPI_SS_DISABLED);`	2760	`.................... setup_spi(SPI_SS_DISABLED);`
589	`028C: BCF 14.5`	2761	`028B: BCF 14.5`
590	`028D: BCF 20.5`	2762	`028C: BCF 20.5`
591	`028E: MOVF 20,W`	2763	`028D: MOVF 20,W`
592	`028F: BSF 03.5`	2764	`028E: BSF 03.5`
593	`0290: MOVWF 07`	2765	`028F: MOVWF 07`
594	`0291: BCF 03.5`	2766	`0290: BCF 03.5`
595	`0292: BSF 20.4`	2767	`0291: BSF 20.4`
596	`0293: MOVF 20,W`	2768	`0292: MOVF 20,W`
597	`0294: BSF 03.5`	2769	`0293: BSF 03.5`
598	`0295: MOVWF 07`	2770	`0294: MOVWF 07`
599	`0296: BCF 03.5`	2771	`0295: BCF 03.5`
600	`0297: BCF 20.3`	2772	`0296: BCF 20.3`
601	`0298: MOVF 20,W`	2773	`0297: MOVF 20,W`
602	`0299: BSF 03.5`	2774	`0298: BSF 03.5`
603	`029A: MOVWF 07`	2775	`0299: MOVWF 07`
604	`029B: MOVLW 01`	2776	`029A: MOVLW 01`
605	`029C: BCF 03.5`	2777	`029B: BCF 03.5`
606	`029D: MOVWF 14`	2778	`029C: MOVWF 14`
607	`029E: MOVLW 00`	2779	`029D: MOVLW 00`
608	`029F: BSF 03.5`	2780	`029E: BSF 03.5`
609	`02A0: MOVWF 14`	2781	`029F: MOVWF 14`
610	`.................... setup_timer_0(RTCC_INTERNAL\|RTCC_DIV_1);`	2782	`.................... setup_timer_0(RTCC_INTERNAL\|RTCC_DIV_1);`
611	`02A1: MOVF 01,W`	2783	`02A0: MOVF 01,W`
612	`02A2: ANDLW C7`	2784	`02A1: ANDLW C7`
613	`02A3: IORLW 08`	2785	`02A2: IORLW 08`
614	`02A4: MOVWF 01`	2786	`02A3: MOVWF 01`
615	`.................... setup_timer_1(T1_DISABLED);`	2787	`.................... setup_timer_1(T1_DISABLED);`
616	`02A5: BCF 03.5`	2788	`02A4: BCF 03.5`
617	`02A6: CLRF 10`	2789	`02A5: CLRF 10`
618	`.................... setup_timer_2(T2_DISABLED,0,1);`	2790	`.................... setup_timer_2(T2_DISABLED,0,1);`
619	`02A7: MOVLW 00`	2791	`02A6: MOVLW 00`
620	`02A8: MOVWF 78`	2792	`02A7: MOVWF 78`
621	`02A9: MOVWF 12`	2793	`02A8: MOVWF 12`
622	`02AA: MOVLW 00`	2794	`02A9: MOVLW 00`
623	`02AB: BSF 03.5`	2795	`02AA: BSF 03.5`
624	`02AC: MOVWF 12`	2796	`02AB: MOVWF 12`
625	`.................... setup_ccp1(CCP_OFF);`	2797	`.................... setup_ccp1(CCP_OFF);`
626	`02AD: BCF 03.5`	2798	`02AC: BCF 03.5`
627	`02AE: BSF 20.2`	2799	`02AD: BSF 20.2`
628	`02AF: MOVF 20,W`	2800	`02AE: MOVF 20,W`
629	`02B0: BSF 03.5`	2801	`02AF: BSF 03.5`
630	`02B1: MOVWF 07`	2802	`02B0: MOVWF 07`
631	`02B2: BCF 03.5`	2803	`02B1: BCF 03.5`
632	`02B3: CLRF 17`	2804	`02B2: CLRF 17`
633	`02B4: BSF 03.5`	2805	`02B3: BSF 03.5`
634	`02B5: CLRF 1B`	2806	`02B4: CLRF 1B`
635	`02B6: CLRF 1C`	2807	`02B5: CLRF 1C`
636	`02B7: MOVLW 01`	2808	`02B6: MOVLW 01`
637	`02B8: MOVWF 1D`	2809	`02B7: MOVWF 1D`
638	`.................... setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard`	2810	`.................... setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard`
639	`02B9: BCF 03.5`	2811	`02B8: BCF 03.5`
640	`02BA: BSF 03.6`	2812	`02B9: BSF 03.6`
641	`02BB: CLRF 07`	2813	`02BA: CLRF 07`
642	`02BC: CLRF 08`	2814	`02BB: CLRF 08`
643	`02BD: CLRF 09`	2815	`02BC: CLRF 09`
644	`....................`	2816	`....................`
645	`.................... // Init the HMC5883L. Set Mode register for`	2817	`.................... // Init the HMC5883L. Set Mode register for`
646	`.................... // continuous measurements.`	2818	`.................... // continuous measurements.`
647	`.................... hmc5883l_write_reg(HMC5883L_CFG_A_REG, 0x18); // no average, maximal update range`	2819	`.................... hmc5883l_write_reg(HMC5883L_CFG_A_REG, 0x18); // no average, maximal update range`
648	`02BE: BCF 03.6`	2820	`02BD: BCF 03.6`
649	`02BF: CLRF 2C`	2821	`02BE: CLRF 37`
650	`02C0: MOVLW 18`	2822	`02BF: MOVLW 18`
651	`02C1: MOVWF 2D`	2823	`02C0: MOVWF 38`
652	`02C2: CALL 069`	2824	`02C1: CALL 069`
653	`.................... hmc5883l_write_reg(HMC5883L_CFG_B_REG, 0xE0); // maximal range`	2825	`.................... hmc5883l_write_reg(HMC5883L_CFG_B_REG, 0xE0); // maximal range`
654	`02C3: MOVLW 01`	2826	`02C2: MOVLW 01`
655	`02C4: MOVWF 2C`	2827	`02C3: MOVWF 37`
656	`02C5: MOVLW E0`	2828	`02C4: MOVLW E0`
657	`02C6: MOVWF 2D`	2829	`02C5: MOVWF 38`
658	`02C7: CALL 069`	2830	`02C6: CALL 069`
659	`.................... hmc5883l_write_reg(HMC5883L_MODE_REG, 0x00);`	2831	`.................... hmc5883l_write_reg(HMC5883L_MODE_REG, 0x00);`
660	`02C8: MOVLW 02`	2832	`02C7: MOVLW 02`
661	`02C9: MOVWF 2C`	2833	`02C8: MOVWF 37`
662	`02CA: CLRF 2D`	2834	`02C9: CLRF 38`
663	`02CB: CALL 069`	2835	`02CA: CALL 069`
664	`....................`	2836	`....................`
665	`.................... // Continuously read and display the x,y,z results.`	2837	`.................... // Continuously read and display the x,y,z results.`
666	`.................... // Wait at least 67 ms between reads, re the HMC5883L data sheet.`	2838	`.................... // Wait at least 67 ms between reads, re the HMC5883L data sheet.`
667	`....................`	2839	`....................`
668	`....................`	2840	`....................`
669	`.................... printf("Magnetometr: \r\n",);`	2841	`.................... printf("Magnetometr: \r\n",);`
670	`02CC: MOVLW 04`	2842	`02CB: MOVLW 04`
671	`02CD: BSF 03.6`	2843	`02CC: BSF 03.6`
672	`02CE: MOVWF 0D`	2844	`02CD: MOVWF 0D`
673	`02CF: MOVLW 00`	2845	`02CE: MOVLW 00`
674	`02D0: MOVWF 0F`	2846	`02CF: MOVWF 0F`
675	`02D1: BCF 03.6`	2847	`02D0: BCF 03.6`
676	`02D2: CALL 0C6`	2848	`02D1: CALL 0C5`
677	`.................... printf("(c)mlab JACHO 2013: \r\n",);`	2849	`.................... printf("(c)mlab JACHO 2013: \r\n",);`
678	`02D3: MOVLW 0D`	2850	`02D2: MOVLW 0D`
679	`02D4: BSF 03.6`	2851	`02D3: BSF 03.6`
680	`02D5: MOVWF 0D`	2852	`02D4: MOVWF 0D`
681	`02D6: MOVLW 00`	2853	`02D5: MOVLW 00`
682	`02D7: MOVWF 0F`	2854	`02D6: MOVWF 0F`
683	`02D8: BCF 03.6`	2855	`02D7: BCF 03.6`
684	`02D9: CALL 0C6`	2856	`02D8: CALL 0C5`
685	`.................... printf("X, Y, Z \r\n",);`	2857	`.................... printf("X, Y, Z \r\n",);`
686	`02DA: MOVLW 19`	2858	`02D9: MOVLW 19`
687	`02DB: BSF 03.6`	2859	`02DA: BSF 03.6`
688	`02DC: MOVWF 0D`	2860	`02DB: MOVWF 0D`
689	`02DD: MOVLW 00`	2861	`02DC: MOVLW 00`
690	`02DE: MOVWF 0F`	2862	`02DD: MOVWF 0F`
691	`02DF: BCF 03.6`	2863	`02DE: BCF 03.6`
692	`02E0: CALL 0C6`	2864	`02DF: CALL 0C5`
693	`....................`	2865	`....................`
694	`.................... /* while(true)`	2866	`.................... /* while(true)`
695	`.................... {`	2867	`.................... {`
696	`.................... X = mag_readX();`	2868	`.................... X = mag_readX();`
697	`.................... Y = mag_readY();`	2869	`.................... Y = mag_readY();`
Line 703...		Line 2875...
703	`.................... */`	2875	`.................... */`
704	`....................`	2876	`....................`
705	`.................... while(TRUE)`	2877	`.................... while(TRUE)`
706	`.................... {`	2878	`.................... {`
707	`....................`	2879	`....................`
708	`.................... for( i=0;i<=1000;i++)`	2880	`.................... // for(i=0;i<=10;i++)`
709	`02E1: CLRF 2B`	-
710	`02E2: CLRF 2A`	-
711	`02E3: MOVF 2B,W`	-
712	`02E4: SUBLW 03`	-
713	`02E5: BTFSS 03.0`	-
714	`02E6: GOTO 303`	-
715	`02E7: BTFSS 03.2`	-
716	`02E8: GOTO 2ED`	-
717	`02E9: MOVF 2A,W`	-
718	`02EA: SUBLW E8`	-
719	`02EB: BTFSS 03.0`	-
720	`02EC: GOTO 303`	-
721	`.................... {`	2881	`.................... // {`
722	`.................... // delay_ms();`	-
723	`.................... hmc5883l_read_data();`	2882	`.................... hmc5883l_read_data();`
724	`02ED: GOTO 151`	2883	`02E0: GOTO 150`
725	`....................`	2884	`....................`
726	`.................... if(compass.x < 0)`	2885	`.................... // b = atan2((float)compass.y,(float)compass.x); // vypocet azimutu z kartezskych souradnic`
727	`02EE: BTFSS 22.7`	-
728	`02EF: GOTO 2F6`	-
729	`.................... {`	2886	`.................... // b = (b/3.141596)*180; // prevod na stupne`
730	`.................... if(last == 1) anemo_round++;`	2887	`.................... // b += 180;`
731	`02F0: BTFSS 27.0`	-
732	`02F1: GOTO 2F5`	-
733	`02F2: INCF 28,F`	-
734	`02F3: BTFSC 03.2`	2888	`....................`
735	`02F4: INCF 29,F`	-
736	`.................... last=0;`	2889	`.................... // anemo_speed += (b-last);`
737	`02F5: BCF 27.0`	-
738	`.................... }`	2890	`.................... // last=b;`
739	`.................... if(compass.x > 0) last=1;`	2891	`.................... // delay_ms(10);`
740	`02F6: BTFSC 22.7`	-
741	`02F7: GOTO 2FF`	-
742	`02F8: MOVF 22,F`	-
743	`02F9: BTFSS 03.2`	-
744	`02FA: GOTO 2FE`	-
745	`02FB: MOVF 21,W`	-
746	`02FC: SUBLW 00`	-
747	`02FD: BTFSS 03.0`	-
748	`02FE: BSF 27.0`	-
749	`.................... }`	2892	`.................... // }`
750	`02FF: INCF 2A,F`	-
751	`0300: BTFSC 03.2`	-
752	`0301: INCF 2B,F`	2893	`.................... // anemo_speed=anemo_speed/10;`
753	`0302: GOTO 2E3`	-
754	`....................`	2894	`....................`
755	`.................... printf("%6Ld %6Ld %6Ld %6Ld \n\r", compass.x, compass.y, compass.z, anemo_round);`	2895	`.................... printf("%6Ld %6Ld %6Ld \n\r", compass.x, compass.y, compass.z);`
756	`0303: MOVLW 00`	2896	`02E1: MOVLW 00`
757	`0304: MOVWF 04`	2897	`02E2: MOVWF 04`
758	`0305: MOVF 22,W`	2898	`02E3: MOVF 22,W`
759	`0306: MOVWF 2D`	2899	`02E4: MOVWF 38`
760	`0307: MOVF 21,W`	2900	`02E5: MOVF 21,W`
761	`0308: MOVWF 2C`	2901	`02E6: MOVWF 37`
762	`0309: CALL 1D0`	2902	`02E7: CALL 1CF`
763	`030A: MOVLW 20`	2903	`02E8: MOVLW 20`
764	`030B: MOVWF 35`	2904	`02E9: MOVWF 40`
765	`030C: CALL 0A2`	2905	`02EA: CALL 0A2`
766	`030D: MOVLW 00`	2906	`02EB: MOVLW 00`
767	`030E: MOVWF 04`	2907	`02EC: MOVWF 04`
768	`030F: MOVF 24,W`	2908	`02ED: MOVF 24,W`
769	`0310: MOVWF 2D`	2909	`02EE: MOVWF 38`
770	`0311: MOVF 23,W`	2910	`02EF: MOVF 23,W`
771	`0312: MOVWF 2C`	2911	`02F0: MOVWF 37`
772	`0313: CALL 1D0`	2912	`02F1: CALL 1CF`
773	`0314: MOVLW 20`	2913	`02F2: MOVLW 20`
774	`0315: MOVWF 35`	2914	`02F3: MOVWF 40`
775	`0316: CALL 0A2`	2915	`02F4: CALL 0A2`
776	`0317: MOVLW 00`	2916	`02F5: MOVLW 00`
777	`0318: MOVWF 04`	2917	`02F6: MOVWF 04`
778	`0319: MOVF 26,W`	2918	`02F7: MOVF 26,W`
779	`031A: MOVWF 2D`	2919	`02F8: MOVWF 38`
780	`031B: MOVF 25,W`	2920	`02F9: MOVF 25,W`
781	`031C: MOVWF 2C`	-
782	`031D: CALL 1D0`	-
783	`031E: MOVLW 20`	-
784	`031F: MOVWF 35`	2921	`02FA: MOVWF 37`
785	`0320: CALL 0A2`	-
786	`0321: MOVLW 00`	-
787	`0322: MOVWF 04`	-
788	`0323: MOVF 29,W`	-
789	`0324: MOVWF 2D`	-
790	`0325: MOVF 28,W`	-
791	`0326: MOVWF 2C`	-
792	`0327: CALL 1D0`	2922	`02FB: CALL 1CF`
793	`0328: MOVLW 20`	2923	`02FC: MOVLW 20`
794	`0329: MOVWF 35`	2924	`02FD: MOVWF 40`
795	`032A: CALL 0A2`	2925	`02FE: CALL 0A2`
796	`032B: MOVLW 0A`	2926	`02FF: MOVLW 0A`
797	`032C: MOVWF 35`	2927	`0300: MOVWF 40`
798	`032D: CALL 0A2`	2928	`0301: CALL 0A2`
799	`032E: MOVLW 0D`	2929	`0302: MOVLW 0D`
800	`032F: MOVWF 35`	2930	`0303: MOVWF 40`
801	`0330: CALL 0A2`	2931	`0304: CALL 0A2`
802	`.................... anemo_round=0;`	2932	`.................... // delay_ms(100);`
803	`0331: CLRF 29`	-
804	`0332: CLRF 28`	-
805	`.................... }`	2933	`.................... }`
806	`0333: GOTO 2E1`	2934	`0305: GOTO 2E0`
807	`....................`	2935	`....................`
808	`.................... }`	2936	`.................... }`
809	`....................`	2937	`....................`
810	`....................`	2938	`....................`
811	`....................`	2939	`....................`
812	`0334: SLEEP`	2940	`0306: SLEEP`
813		2941
814	`Configuration Fuses:`	2942	`Configuration Fuses:`
815	`Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG`	2943	`Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG`
816	`Word 2: 3FFF NOWRT BORV40`	2944	`Word 2: 3FFF NOWRT BORV40`

Subversion Repositories – MLAB

(root)/Modules/Sensors/MAG01A/SW/PIC16F887/main.lst

Rev 2985 → Rev 2988