Init repo

49 files changed, 36849 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a51f015
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+*.[ado]
+op
+opgui
diff --git a/24c02.hex b/24c02.hex
new file mode 100644
index 0000000..ff0489b
--- /dev/null
+++ b/24c02.hex
@@ -0,0 +1,18 @@
+:020000040000FA
+:100000004828000000000000A8000308A9001030E4
+:100010008506A003031D1428A1030F3021052730F6
+:1000200003192830A00026140B111F302405031DCE
+:100030003C2819302506031D3C2810302006031DDE
+:100040003C28271C252827103C28FF302C050319A5
+:100050003C2800302406031935283C30AA00230828
+:10006000AA022C082A0203183C28AC03A71C3B2830
+:10007000A00A27143C28A0032908830028080900A7
+:100080000000000000000000000000000000000070
+:1000900083160313803081002830850000308600ED
+:1000A000831207309F00A0308B0007308500FF309F
+:1000B00086003230A5002830A0000E30A2000F309C
+:1000C000A3000430AB000030A400A600A70081000C
+:1000D000261C7028B220CB20A61C7028A610342124
+:1000E0000630051A103E8500FF302406261D7A28AA
+:1000F000FE309C208600AD20FF308600A320053016
+:00000001FF
diff --git a/I2CSPI.c b/I2CSPI.c
new file mode 100644
index 0000000..e911792
--- /dev/null
+++ b/I2CSPI.c
@@ -0,0 +1,243 @@
+/*
+ * I2CSPI.c - algorithms to interface generic I2C/SPI devices
+ * Copyright (C) 2010-2022 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+
+//configure for GUI or command-line
+#include "common.h"
+#ifdef __GTK_H__
+#define _GTKGUI
+#endif
+
+
+#ifdef _GTKGUI
+	#define printM(id) PrintMessageI2C(id);
+#else
+	#define printM(id) printf(id);
+#endif
+
+#define CS 8
+#define HLD 16
+
+void I2CReceive(int mode,int speed,int N,BYTE *buffer)
+// I2C/SPI receive
+// mode:
+// 0 = I2C 8bit
+// 1 = I2C 16bit
+// 2 = SPI 00
+// 3 = SPI 01
+// 4 = SPI 10
+// 5 = SPI 11
+// speed:
+// 0 = 100 kbps
+// 1 = 200 kbps
+// 2 = 300/400 kbps (SPI/I2C)
+// 3 = 500/800 kbps (SPI/I2C)
+{
+	int j=0;
+	if(N<0) N=0;
+	if(N>60) N=60;
+	if(mode<0) mode=0;
+	if(mode>5) mode=5;
+	if(speed<0) speed=0;
+	if(speed>3) speed=3;
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"I2C-SPI receive\tmode=%d\tspeed=%d\n",mode,speed);
+	}
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	if(mode<2){					//I2C mode
+		bufferU[j++]=I2C_INIT;
+		bufferU[j++]=(speed<<3)+(speed>0?0x40:0);	//enable slew control if >100k
+	}
+	else{						//SPI mode
+		bufferU[j++]=EXT_PORT;	//CS=1
+		bufferU[j++]=CS;
+		bufferU[j++]=0;
+		bufferU[j++]=EXT_PORT;	//CS=0
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_INIT;
+		bufferU[j++]=speed+((mode-2)<<2);
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	if(mode==0){					//I2C read
+		bufferU[j++]=I2C_READ;
+		bufferU[j++]=N>(DIMBUF-4)?DIMBUF-4:N;
+		bufferU[j++]=buffer[0];		//Control byte
+		bufferU[j++]=buffer[1];		//Address;
+	}
+	else if(mode==1){				//I2C read 16bit
+		bufferU[j++]=I2C_READ2;
+		bufferU[j++]=N>(DIMBUF-4)?DIMBUF-4:N;
+		bufferU[j++]=buffer[0];		//Control byte
+		bufferU[j++]=buffer[1];		//Address H;
+		bufferU[j++]=buffer[2];		//Address L;
+	}
+	else if(mode>=2){					//SPI read
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=N>(DIMBUF-5)?DIMBUF-5:N;
+		bufferU[j++]=EXT_PORT;		//CS=1
+		bufferU[j++]=CS;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(10);
+	if(saveLog){
+		CloseLogFile();
+	}
+	if(bufferI[0]==I2C_READ||bufferI[0]==I2C_READ2||bufferI[0]==SPI_READ){
+		if(bufferI[1]==0xFD){
+			printM(strings[S_I2CAckErr]); //"acknowledge error"
+		}
+		else if(bufferI[1]>0xFA){
+			printM(strings[S_InsErr]); //"unknown instruction"
+		}
+		else{
+			char str[1024]="";
+			char t[16]="";
+			int i;
+			if(mode==0)	sprintf(str,"> %02X %02X\r\n",bufferU[2],bufferU[3]);
+			else if(mode==1)	sprintf(str,"> %02X %02X\r\n",bufferU[2],bufferU[3]);
+			strcat(str,"< ");
+			for(i=0;i<bufferI[1];i++){
+				sprintf(t,"%02X ",bufferI[i+2]);
+				strcat(str,t);
+				if(i&&i%16==15){
+					strcat(str,"\r\n");
+				}
+			}
+			strcat(str,"\r\n");
+			printM(str);
+			fflush(stdout);
+		}
+	}
+	else printM(strings[S_ComErr]);
+}
+
+void I2CSend(int mode,int speed,int N,BYTE *buffer)
+{
+// I2C/SPI send
+// mode:
+// 0 = I2C 8bit
+// 1 = I2C 16bit
+// 2 = SPI 00
+// 3 = SPI 01
+// 4 = SPI 10
+// 5 = SPI 11
+// speed:
+// 0 = 100 kbps
+// 1 = 200 kbps
+// 2 = 300/400 kbps (SPI/I2C)
+// 3 = 500/800 kbps (SPI/I2C)
+	int i,j=0;
+	if(N<0) N=0;
+	if(N>57) N=57;
+	if(mode<0) mode=0;
+	if(mode>5) mode=5;
+	if(speed<0) speed=0;
+	if(speed>3) speed=3;
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"I2C-SPI send\tmode=%d\tspeed=%d\n",mode,speed);
+	}
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	if(mode<2){					//I2C mode
+		bufferU[j++]=I2C_INIT;
+		bufferU[j++]=(speed<<3)+(speed>0?0x40:0);	//enable slew control if >100k
+	}
+	else{						//SPI mode
+		bufferU[j++]=EXT_PORT;	//CS=1
+		bufferU[j++]=CS;
+		bufferU[j++]=0;
+		bufferU[j++]=EXT_PORT;	//CS=0
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_INIT;
+		bufferU[j++]=speed+((mode-2)<<2);
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	if(mode==0){					//I2C write
+		bufferU[j++]=I2C_WRITE;
+		bufferU[j++]=N>(DIMBUF-5)?DIMBUF-5:N;
+		bufferU[j++]=buffer[0];		//Control byte
+		bufferU[j++]=buffer[1];		//Address
+		for(i=0;i<bufferU[1];i++) bufferU[j++]=buffer[i+2];
+	}
+	else if(mode==1){				//I2C write 16bit
+		bufferU[j++]=I2C_WRITE;
+		bufferU[j++]=N+1>(DIMBUF-5)?DIMBUF-5:N+1;
+		bufferU[j++]=buffer[0];		//Control byte
+		bufferU[j++]=buffer[1];		//Address
+		bufferU[j++]=buffer[2];		//Address L
+		for(i=0;i<bufferU[1]-1;i++) bufferU[j++]=buffer[i+3];
+	}
+	if(mode>=2){					//SPI write
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=N>(DIMBUF-5)?DIMBUF-5:N;
+		for(i=0;i<bufferU[1];i++) bufferU[j++]=buffer[i];
+		bufferU[j++]=EXT_PORT;	//CS=1
+		bufferU[j++]=CS;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(20);
+	if(saveLog){
+		CloseLogFile();
+	}
+	if(bufferI[0]==I2C_WRITE||bufferI[0]==SPI_WRITE){
+		if(bufferI[1]==0xFD){
+			printM(strings[S_I2CAckErr]); //"acknowledge error"
+		}
+		else if(bufferI[1]>0xFA){
+			printM(strings[S_InsErr]); //"unknown instruction"
+		}
+		else{
+			char str[1024];
+			char t[16];
+			int n=2;
+			int i;
+			sprintf(str,"> ");
+			if(mode<2) n=4;
+			for(i=0;i<bufferU[1];i++){
+				sprintf(t,"%02X ",(BYTE)bufferU[i+n]);
+				strcat(str,t);
+				if(i&&i%16==15){
+					strcat(str,"\r\n");
+				}
+			}
+			strcat(str,"\r\n");
+			printM(str);
+		}
+	}
+	else printM(strings[S_ComErr]);	//"communication error \r\n"
+}
+
diff --git a/I2CSPI.h b/I2CSPI.h
new file mode 100644
index 0000000..b3af575
--- /dev/null
+++ b/I2CSPI.h
@@ -0,0 +1,2 @@
+void I2CReceive(int mode,int speed,int N,BYTE *buffer);
+void I2CSend(int mode,int speed,int N,BYTE *buffer);
diff --git a/Makefile_op b/Makefile_op
new file mode 100644
index 0000000..2593383
--- /dev/null
+++ b/Makefile_op
@@ -0,0 +1,52 @@
+# equivalent to #define in c code
+VERSION = 0.12.0
+CC = gcc
+CFLAGS = '-DVERSION="$(VERSION)"' -w -Os -s #size
+#CFLAGS = -w -O3 -s
+#CFLAGS = -w -g		#debug
+OBJECTS = 	op.o \
+			progP12.o \
+			progP16.o \
+			progP18.o \
+			progP24.o \
+			progEEPROM.o \
+			progAVR.o \
+			fileIO.o \
+			deviceRW.o \
+			I2CSPI.o \
+			strings.o
+
+UNAME := $(shell uname)
+ifneq (, $(findstring _NT-, $(UNAME)))
+	OPFLAG =
+else
+	OPFLAG = -lrt 
+endif
+
+all: op
+
+op : $(OBJECTS)
+	$(CC) $(CFLAGS) $(OBJECTS) -o op $(OPFLAG)
+	rm $(OBJECTS)
+
+%.o : %.c
+	$(CC) $(CFLAGS) -c $<
+
+clean:
+	rm -f op $(OBJECTS)
+
+prefix	:= /usr/local
+    
+install: op
+	test -d $(prefix) || mkdir $(prefix)
+	test -d $(prefix)/bin || mkdir $(prefix)/bin
+	install -m 0755 op $(prefix)/bin;
+
+package:
+	@echo "Creating op_$(VERSION).tar.gz"
+	@mkdir op-$(VERSION)
+	@cp *.c *.h gpl-2.0.txt Makefile readme utils/*.c op-$(VERSION)
+	@tar -czf op_$(VERSION).tar.gz op-$(VERSION)
+	@rm -rf op-$(VERSION)
+
+.PHONY: all clean install package
diff --git a/Makefile_opgui b/Makefile_opgui
new file mode 100644
index 0000000..9a15ef7
--- /dev/null
+++ b/Makefile_opgui
@@ -0,0 +1,67 @@
+# equivalent to #define in c code
+VERSION = 0.12.1
+CC = gcc
+PREFIX = /usr/local
+
+CFLAGS =  '-DVERSION="$(VERSION)"' `pkg-config --libs --cflags gtk+-3.0` 
+CFLAGS += -DOPGUI
+CFLAGS += -Os -s #size
+#CFLAGS += -O3 -s #speed
+#CFLAGS += -g #debug
+
+OBJECTS = opgui.o \
+	deviceRW.o \
+	progP12.o \
+	progP16.o \
+	progP18.o \
+	progP24.o \
+	progEEPROM.o \
+	progAVR.o \
+	fileIO.o \
+	I2CSPI.o \
+	coff.o \
+	icd.o \
+	strings.o \
+	resources.o
+#	progP32.o \
+
+# Check if we are running on windows
+UNAME := $(shell uname)
+ifneq (, $(findstring _NT-, $(UNAME)))
+	CFLAGS += -mwindows
+else
+	CFLAGS += -lrt
+endif
+	
+
+# Targets
+all: opgui
+
+opgui : $(OBJECTS)
+	$(CC) -o $@ $(OBJECTS) $(CFLAGS)
+	rm $(OBJECTS) resources.c
+
+%.o : %.c
+	$(CC) $(CFLAGS) -c $<
+
+resources.c: resources.xml opgui.glade
+	glib-compile-resources resources.xml --target=resources.c --generate-source
+
+clean:
+	rm -f opgui $(OBJECTS) resources.c
+	
+install: all
+	#test -d $(prefix) || mkdir $(prefix)
+	#test -d $(prefix)/bin || mkdir $(prefix)/bin
+	@echo "Installing opgui"
+	mkdir -p $(PREFIX)/bin
+	install -m 0755 opgui $(PREFIX)/bin;
+	
+package:
+	@echo "Creating opgui_$(VERSION).tar.gz"
+	@mkdir opgui-$(VERSION)
+	@cp *.c *.h *.png gpl-2.0.txt Makefile readme resources.xml opgui.glade style.css opgui-$(VERSION)
+	@tar -czf opgui_$(VERSION).tar.gz opgui-$(VERSION)
+	@rm -rf opgui-$(VERSION)
+
+.PHONY: all clean install package
diff --git a/coff.c b/coff.c
new file mode 100644
index 0000000..fc3120e
--- /dev/null
+++ b/coff.c
@@ -0,0 +1,207 @@
+// COFF file parser
+// COFF file structure:
+// file header
+// optional header
+// sections(name, address, size, raw data pointer, reloc entry, ptr to first line, number of lines)
+// relocation entries
+// symbols (name, value, section, type, class) + optional info
+// lines (source file symbol, line number, address of code)
+// symbol table
+// string table
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "coff.h"
+
+// Analyze COFF file named filename, extract code labels in label[address], undefined labels in ulabel[address],
+// info about each symbol (name, source line, source file index) in source_info,
+// list of source files (index, name, file pointer) in s_files, raw data in data[0x2200]
+int analyzeCOFF(char *filename,char* label[LMAX],char* ulabel[ULMAX],struct src_i source_info[LMAX],struct srcfile **s_files_p,unsigned short data[0x2200],struct symbol **sym_p, int* nsym)
+{
+	int i,j,k;
+	FILE*f=fopen(filename,"rb");
+	if(!f) return 0;
+	scnhdr_t* sections;
+	filehdr_t FileHeader;
+	opthdr_t OptHeader;
+	fread((char*)&FileHeader,sizeof(filehdr_t),1,f); //file header
+/*	printf("File header:\nmagic %X, sections %d, time %d, symbol ptr %d, nsymbol %d, opt size %d, flags %X\n",\
+	FileHeader.f_magic,FileHeader.f_nscns,FileHeader.f_timdat,FileHeader.f_symptr,FileHeader.f_nsyms,FileHeader.f_opthdr,FileHeader.f_flags);*/
+	if(FileHeader.f_opthdr==18){	//optional header
+		fread((char*)&OptHeader,2,1,f);
+		fread((char*)&OptHeader+4,16,1,f);
+/*		printf("Optional header:\nmagic %X, version %X, processor %X, rom width %d, data width %d\n",\
+		OptHeader.magic,OptHeader.vstamp,OptHeader.proc_type,OptHeader.rom_width_bits,OptHeader.ram_width_bits);*/
+	}
+	sections=(scnhdr_t*)malloc(sizeof(scnhdr_t)*FileHeader.f_nscns);
+	for(i=0;i<FileHeader.f_nscns;i++){
+		fread(&sections[i],40,1,f);
+	}
+	if(fseek(f,FileHeader.f_symptr+FileHeader.f_nsyms*20,SEEK_SET)) printf("seek error\n");
+	int strsize=0,strN=0;
+	char* strtable,**strings;
+	fread((char*)&strsize,4,1,f);
+	strtable=malloc(strsize);
+	strtable[0]=strtable[1]=strtable[2]=strtable[3]=0;
+	fread(&strtable[4],strsize-4,1,f);
+	for(i=4;i<strsize;i++) if(strtable[i]==0) strN++;  //count end of string
+	strings=malloc(strN*sizeof(char*));
+	if(strN) strings[0]=&strtable[4];
+	j=1;
+	for(i=4;i<strsize&&j<strN;i++){
+		if(strtable[i]==0){
+			strings[j]=&strtable[i+1];
+			j++;
+		}
+	}
+	char* name,null[]="";
+	for(i=0;i<FileHeader.f_nscns;i++){
+		if(sections[i]._s._s_name[0]) name=sections[i]._s._s_name;
+		else if(sections[i]._s._s_s._s_zeroes==0) name=&strtable[sections[i]._s._s_s._s_offset];
+		else name=null;
+/*		printf("Section %d:\nname \"%s\", Paddr %X, Vaddr %X, size %d\nrawptr %d, relptr %d, lineptr %d, Nreloc %d, Nlines %d, flags %X\n",\
+		i,name,sections[i].s_paddr,sections[i].s_vaddr,sections[i].s_size,sections[i].s_scnptr,sections[i].s_relptr,\
+		sections[i].s_lnnoptr,sections[i].s_nreloc,sections[i].s_nlnno,sections[i].s_flags);*/
+	}
+	syment_t symbol;
+	for(i=0;i<LMAX;i++) label[i]=0;
+	for(i=0;i<ULMAX;i++) ulabel[i]=0;
+	int filemax=0;
+	*nsym=0;
+	if(fseek(f,FileHeader.f_symptr,SEEK_SET)) printf("seek error\n");
+	// read all symbols
+	for(i=0;i<FileHeader.f_nsyms;i++){
+		j=fread((void*)&symbol,  1,14,f);
+		j=fread((void*)&symbol+16,1,6,f);
+		if(symbol._n._n_name[0]) name=symbol._n._n_name;
+		else if(symbol._n._n_n._n_zeroes==0) name=&strtable[symbol._n._n_n._n_offset];
+		else name=null;
+		if(symbol.n_sclass==6&&symbol.n_value<LMAX){	//code labels
+			if(label[symbol.n_value]==0){
+				label[symbol.n_value]=malloc(strlen(name)+1);
+				strcpy(label[symbol.n_value],name);
+			}
+			else{
+				printf("conflicting labels at address %X: %s vs. %s\n",(unsigned int)symbol.n_value,label[symbol.n_value],name);
+/*				char* temp=malloc(strlen(label[symbol.n_value])+strlen(name)+2);
+				sprintf(temp,"%s %s",label[symbol.n_value],name);
+				free(label[symbol.n_value]);
+				label[symbol.n_value]=temp;*/
+			}
+		}
+		//if(symbol.n_sclass==7&&includesym&&symbol.n_value==0x3fff) includesym=0;
+		if(symbol.n_sclass==7&&symbol.n_value<ULMAX&&symbol.n_scnum>0&&sections[symbol.n_scnum-1].s_size>0){	//store symbols defined in non-empty sections up to ULMAX
+			if(ulabel[symbol.n_value]==0){
+				ulabel[symbol.n_value]=malloc(strlen(name)+1);
+				strcpy(ulabel[symbol.n_value],name);
+			}
+			else{
+				printf("conflicting labels at address %X: %s vs. %s\n",(unsigned int)symbol.n_value,ulabel[symbol.n_value],name);
+/*				char* temp=malloc(strlen(ulabel[symbol.n_value])+strlen(name)+2);
+				sprintf(temp,"%s %s",ulabel[symbol.n_value],name);
+				free(ulabel[symbol.n_value]);
+				ulabel[symbol.n_value]=temp;*/
+			}
+//			printf("%d %s\n",symbol.n_value,name);
+		}
+		if(symbol.n_sclass==7){
+			//store all symbols in the sym_p array
+			(*nsym)++;
+			*sym_p=realloc(*sym_p,(*nsym)*sizeof(struct symbol));
+			(*sym_p)[*nsym-1].name=strdup(name);
+			(*sym_p)[*nsym-1].value=symbol.n_value;
+		}
+/*		printf("\"%s\", Value %X, Section %d, type %X, Storage class %d, Naux %d, %d\n",\
+		name,symbol.n_value,symbol.n_scnum,symbol.n_type,symbol.n_sclass,symbol.n_numaux,i);*/
+		// store file info in s_files
+		if(symbol.n_sclass==103){	//type C_FILE
+			aux_file_t aux;
+			fread(&aux,20,1,f);
+			symbol.n_numaux--;
+//			printf("-> \"%s\", line %d, flags %X\n",&strtable[aux.x_offset],aux.x_incline,aux.x_flags);
+			filemax++;
+			*s_files_p=realloc(*s_files_p,filemax*sizeof(struct srcfile));
+			(*s_files_p)[filemax-1].name=strdup(&strtable[aux.x_offset]);
+			(*s_files_p)[filemax-1].ptr=0;
+			(*s_files_p)[filemax-1].l_srcndx=i;
+			(*s_files_p)[filemax-1].nlines=0;
+			(*s_files_p)[filemax-1].lineptr=NULL;
+//			printf("%s, idx %d, a %X, i=%d\n",(*s_files_p)[filemax-1].name,(*s_files_p)[filemax-1].l_srcndx,&(*s_files_p)[filemax-1],filemax-1);
+			i++;
+		}
+		i+=symbol.n_numaux;
+		for(j=symbol.n_numaux;j;j--)fread(&symbol,20,1,f);
+	}
+//	printf("filemax=%d a[0]=%X\n",filemax,&s_files[0]);
+	// read line info for all sections (line physical address should be unique)
+	struct coff_lineno line;
+	for(i=0;i<LMAX;i++){
+		source_info[i].label=0;
+		source_info[i].src_file=0;
+		source_info[i].src_line=0;
+	}
+	for(i=0;i<FileHeader.f_nscns;i++){
+//		printf("lines in section %d:\n",i);
+		if(fseek(f,sections[i].s_lnnoptr,SEEK_SET)) printf("seek error\n");
+		for(j=0;j<sections[i].s_nlnno;j++){
+			fread((void*)&line,6,1,f);
+			fread((void*)&line+8,6,1,f);
+			fread((void*)&line+16,4,1,f);
+			if(line.l_paddr<DATA_MAX){
+				source_info[line.l_paddr].label=0;
+				for(k=0;k<filemax;k++){
+					if((*s_files_p)[k].l_srcndx==line.l_srcndx){
+						source_info[line.l_paddr].src_file=k;
+						if((*s_files_p)[k].ptr==0){
+							//printf("file %s (%X), nlines %d, k=%d, a=%X\n",(*s_files_p)[k].name,(*s_files_p)[k].name,(*s_files_p)[k].nlines,k,s_files_p[k]);
+							scanSourceFile(&(*s_files_p)[k]);
+						}
+						k=filemax+10;
+					}
+				}
+				if(k==filemax)source_info[line.l_paddr].src_file=-1; //no source found
+				source_info[line.l_paddr].src_line=line.l_lnno;
+			}
+		}
+	}
+	unsigned char* raw;
+	for(i=0;i<0x2200;i++) data[i]=0xFFFF;
+	// read raw data in data[0x2200]
+	for(i=0;i<FileHeader.f_nscns;i++){
+		if(sections[i].s_size>0){
+			if(fseek(f,sections[i].s_scnptr,SEEK_SET)) printf("seek error\n");
+			raw=malloc(sections[i].s_size);
+			fread(raw,sections[i].s_size,1,f);
+			if((sections[i].s_paddr+sections[i].s_size/2)<0x2200)memcpy(&data[sections[i].s_paddr],raw,sections[i].s_size);
+			free(raw);
+		}
+	}
+	free(strtable);
+	free(strings);
+	free(raw);
+	return 1;
+}
+
+//open a source file and store a pointer for each line
+FILE* scanSourceFile(struct srcfile *s_files_p){
+//	printf("Scansource  ptr %X,  file %s, nlines %d\n",s_files_p,(*s_files_p).name,(*s_files_p).nlines);
+	FILE* f=fopen((*s_files_p).name,"rb");
+	char line[4096];
+	long int p;
+	char* i;
+	(*s_files_p).ptr=f;
+	if(!f) return f;
+	(*s_files_p).nlines=1;		//line # start from index 1
+	p=ftell(f);
+	for(i=fgets(line,4096,f);i;){
+		(*s_files_p).lineptr=realloc((*s_files_p).lineptr,((*s_files_p).nlines+1)*sizeof(long int));
+		(*s_files_p).lineptr[(*s_files_p).nlines]=p;
+		//printf("nlines%d ptr%d %s",(*s_files_p).nlines,p,line);
+		(*s_files_p).nlines++;
+		p=ftell(f);
+		i=fgets(line,4096,f);
+	}
+//	printf("file %s, nlines %d\n",(*s_files_p).name,(*s_files_p).nlines);
+	return f;
+}
diff --git a/coff.h b/coff.h
new file mode 100644
index 0000000..1175c04
--- /dev/null
+++ b/coff.h
@@ -0,0 +1,208 @@
+// COFF file parser
+// COFF file structure:
+// file header
+// optional header
+// sections(name, address, size, raw data pointer, reloc entry, ptr to first line, number of lines)
+// relocation entries
+// symbols (name, value, section, type, class) + optional info
+// lines (source file symbol, line number, address of code)
+// symbol table
+// string table
+
+#define LMAX 0x2200
+#define DATA_MAX 0x2200
+#define ULMAX 0x400
+
+typedef struct filehdr
+{
+    unsigned short f_magic;
+    unsigned short f_nscns;
+    unsigned long f_timdat;
+    unsigned long f_symptr;
+    unsigned long f_nsyms;
+    unsigned short f_opthdr;
+    unsigned short f_flags;
+} filehdr_t;
+
+typedef struct opthdr
+{
+    unsigned short magic;
+    unsigned long vstamp;
+    unsigned long proc_type;
+    unsigned long rom_width_bits;
+    unsigned long ram_width_bits;
+} opthdr_t;
+
+typedef struct scnhdr
+{
+    union
+    {
+      char _s_name[8]; /* section name is a string */
+      struct
+        {
+          unsigned long _s_zeroes;
+          unsigned long _s_offset;
+        }_s_s;
+    }_s;
+	unsigned long s_paddr;
+    unsigned long s_vaddr;
+    unsigned long s_size;
+    unsigned long s_scnptr;
+    unsigned long s_relptr;
+    unsigned long s_lnnoptr;
+    unsigned short s_nreloc;
+    unsigned short s_nlnno;
+    unsigned long s_flags;
+} scnhdr_t;
+
+typedef struct reloc
+{
+    unsigned long r_vaddr;
+    unsigned long r_symndx;
+    short r_offset;
+    unsigned short r_type;
+} reloc_t;
+
+#define SYMNMLEN 8
+typedef struct syment
+{
+    union
+    {
+      char _n_name[SYMNMLEN];
+      struct
+      {
+        unsigned long _n_zeroes;
+        unsigned long _n_offset;
+      } _n_n;
+      char *_n_nptr[2];
+    } _n;
+    unsigned long n_value;
+    short n_scnum;
+    unsigned long n_type;
+    char n_sclass;
+    unsigned char n_numaux;
+} syment_t;
+
+typedef struct coff_lineno
+{
+    unsigned long l_srcndx;
+    unsigned short l_lnno;
+    unsigned long l_paddr;
+    unsigned short l_flags;
+    unsigned long l_fcnndx;
+} coff_lineno_t;
+
+typedef struct aux_file
+{
+    unsigned long x_offset;
+    unsigned long x_incline;
+    unsigned char x_flags;
+    char _unused[11];
+} aux_file_t;
+
+typedef struct aux_scn
+{
+    unsigned long x_scnlen;
+    unsigned short x_nreloc;
+    unsigned short x_nlinno;
+    char _unused[12];
+} aux_scn_t;
+
+typedef struct aux_tag
+{
+    char _unused[6];
+    unsigned short x_size;
+    char _unused2[4];
+    unsigned long x_endndx;
+    char _unused3[4];
+} aux_tag_t;
+
+typedef struct aux_eos
+{
+    unsigned long x_tagndx;
+    char _unused[2];
+    unsigned short x_size;
+    char _unused2[12];
+} aux_eos_t;
+
+typedef struct aux_fcn
+{
+    unsigned long x_tagndx;
+    unsigned long x_size;
+    unsigned long x_lnnoptr;
+    unsigned long x_endndx;
+    short x_actscnum;
+    char _unused[2];
+} aux_fcn_t;
+
+typedef struct aux_fcn_calls
+{
+    unsigned long x_calleendx;
+    unsigned long x_is_interrupt;
+    char _unused[12];
+} aux_fcn_calls_t;
+
+#define X_DIMNUM 4
+typedef struct aux_arr
+{
+    unsigned long x_tagndx;
+    unsigned short x_lnno;
+    unsigned short x_size;
+    unsigned short x_dimen[X_DIMNUM];
+    char _unused[4];
+} aux_arr_t;
+
+typedef struct aux_eobf
+{
+    char _unused[4];
+    unsigned short x_lnno;
+    char _unused2[14];
+} aux_eobf_t;
+
+typedef struct aux_bobf
+{
+    char _unused[4];
+    unsigned short x_lnno;
+    char _unused2[6];
+    unsigned long x_endndx;
+    char _unused3[4];
+} aux_bobf_t;
+
+typedef struct aux_var
+{
+    unsigned long x_tagndx;
+    char _unused[2];
+    unsigned short x_size;
+    char _unused2[12];
+} aux_var_t;
+
+typedef struct aux_field
+{
+    char _unused[6];
+    unsigned short x_size;
+    char _unused2[12];
+} aux_field_t;
+
+struct src_i
+{
+	char* label;
+	int src_file;
+	int src_line;
+};
+
+struct srcfile {
+	unsigned long l_srcndx;
+	char* name;
+	FILE* ptr;
+	int nlines;
+	long int *lineptr;	//line pointer array
+};
+
+struct symbol {
+	char* name;
+	int value;
+};
+
+FILE* scanSourceFile(struct srcfile *s_files_p);
+int analyzeCOFF(char *filename,char* label[LMAX],char* ulabel[ULMAX],struct src_i source_info[LMAX],\
+					struct srcfile **s_files_p,unsigned short data[0x2200],struct symbol **sym_p, int* nsym);
diff --git a/common.h b/common.h
new file mode 100644
index 0000000..59ab489
--- /dev/null
+++ b/common.h
@@ -0,0 +1,5 @@
+#ifdef OPGUI
+	#include "common_opgui.h"
+#else
+	#include "common_op.h"
+#endif
diff --git a/common_op.h b/common_op.h
new file mode 100644
index 0000000..c1f688a
--- /dev/null
+++ b/common_op.h
@@ -0,0 +1,114 @@
+#ifndef _COMMON_DECLARATIONS
+#define _COMMON_DECLARATIONS
+//#define DEBUG
+#define _APPNAME "OP"
+#define _CMD
+
+#if !defined _WIN32 && !defined __CYGWIN__
+//linux:
+	#include <sys/ioctl.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <asm/types.h>
+	#include <fcntl.h>
+	#include <linux/hiddev.h>
+	#include <linux/hidraw.h>
+	#include <linux/input.h>
+	#include <sys/timeb.h>
+	#include <stdint.h>
+	#include <errno.h>
+#else
+//windows
+	#include <windows.h>
+	#include <setupapi.h>
+	#include <hidusage.h>
+	#include <hidpi.h>
+	#include <math.h>
+	#include <sys/timeb.h>
+	#include <wchar.h>
+#endif
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <string.h>
+#include "strings.h"
+#include "instructions.h"
+
+typedef unsigned long DWORD;
+typedef unsigned short WORD;
+typedef unsigned char BYTE;
+
+//to use the same code of windows version
+#define PrintMessage printf
+#define PrintMessage1 printf
+#define PrintMessage2 printf
+#define PrintMessage3 printf
+#define PrintMessage4 printf
+#define PrintStatus(s,p1,p2) printf("\b\b\b\b%3d%%",p1); fflush(stdout);
+#define	PrintStatusSetup() printf("    ");
+#define	PrintStatusEnd() printf("\b\b\b\b");
+#define	PrintStatusClear() //only for GUI
+#define COL 16
+//Version defined in makefile
+#if !defined VERSION
+  #define VERSION "unknown"
+#endif
+#define G (12.0/34*1024/5)		//=72,2823529412
+#define LOCK	1
+#define FUSE	2
+#define FUSE_H  4
+#define FUSE_X	8
+#define CAL 	16
+#define SLOW	256
+
+#if !defined _WIN32 && !defined __CYGWIN__		//Linux
+	#define SYSNAME "Linux"
+	#define DIMBUF 64
+	DWORD GetTickCount();
+	extern unsigned char bufferU[128],bufferI[128];
+#else	//Windows
+	#define SYSNAME "Windows"
+	#define DIMBUF 64
+	extern unsigned char bufferU0[128],bufferI0[128];
+	extern unsigned char *bufferU,*bufferI;
+	extern DWORD NumberOfBytesRead,BytesWritten;
+	extern ULONG Result;
+	extern HANDLE WriteHandle,ReadHandle;
+	extern OVERLAPPED HIDOverlapped;
+	extern HANDLE hEventObject;
+#endif
+
+extern char str[4096];
+extern int saveLog;
+extern char** strings;
+extern int fd;
+extern int saveLog,programID,MinDly,load_osccal,load_BKosccal;
+extern int use_osccal,use_BKosccal;
+extern int load_calibword,max_err;
+extern int AVRlock,AVRfuse,AVRfuse_h,AVRfuse_x;
+extern int ICDenable,ICDaddr;
+extern int FWVersion,HwID;
+extern FILE* logfile;
+extern char LogFileName[512];
+extern char loadfile[512],savefile[512];
+extern WORD *memCODE_W;
+extern int size,sizeW,sizeEE,sizeCONFIG,sizeUSERID;
+extern unsigned char *memCODE,*memEE,memID[64],memCONFIG[48],memUSERID[8];
+extern double hvreg;
+extern int RWstop;
+
+int StartHVReg(double V);
+void msDelay(double delay);
+void DisplayEE();
+void PrintMessageI2C(const char *msg);
+int CheckV33Regulator(void);
+void OpenLogFile(void);
+void WriteLogIO();
+void CloseLogFile();
+unsigned int htoi(const char *hex, int length);
+void PacketIO(double delay);
+#endif
diff --git a/common_opgui.h b/common_opgui.h
new file mode 100644
index 0000000..e8b1afa
--- /dev/null
+++ b/common_opgui.h
@@ -0,0 +1,117 @@
+#ifndef _COMMON_DECLARATIONS
+#define _COMMON_DECLARATIONS
+//#define DEBUG
+#define _APPNAME "OPGUI"
+
+#if !defined _WIN32 && !defined __CYGWIN__
+//linux:
+	#include <sys/ioctl.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <asm/types.h>
+	#include <fcntl.h>
+	#include <linux/hiddev.h>
+	#include <linux/hidraw.h>
+	#include <linux/input.h>
+	#include <sys/timeb.h>
+	#include <stdint.h>
+	#include <errno.h>
+#else
+//windows
+	#include <windows.h>
+	#include <setupapi.h>
+	#include <hidusage.h>
+	#include <hidpi.h>
+	#include <math.h>
+	#include <sys/timeb.h>
+	#include <wchar.h>
+#endif
+
+#include <gtk/gtk.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <string.h>
+#include "strings.h"
+#include "instructions.h"
+
+typedef unsigned long DWORD;
+typedef unsigned short WORD;
+typedef unsigned char BYTE;
+
+//to use the same code of windows version
+#define PrintMessage1(s,p) {sprintf(str,s,p); PrintMessage(str);}
+#define PrintMessage2(s,p1,p2) {sprintf(str,s,p1,p2); PrintMessage(str);}
+#define PrintMessage3(s,p1,p2,p3) {sprintf(str,s,p1,p2,p3); PrintMessage(str);}
+#define PrintMessage4(s,p1,p2,p3,p4) {sprintf(str,s,p1,p2,p3,p4); PrintMessage(str);}
+#define PrintStatus(s,p1,p2) {sprintf(str,s,p1,p2); gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);while (gtk_events_pending ()) gtk_main_iteration();}
+#define	PrintStatusSetup() //only needed for console version
+#define	PrintStatusEnd() //only needed for console version
+#define	PrintStatusClear() gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+
+#define COL 16
+//Version defined in makefile
+#if !defined VERSION
+  #define VERSION "unknown"
+#endif
+#define G (12.0/34*1024/5)		//=72,2823529412
+#define LOCK	1
+#define FUSE	2
+#define FUSE_H  4
+#define FUSE_X	8
+#define CAL 	16
+#define SLOW	256
+
+#if !defined _WIN32 && !defined __CYGWIN__		//Linux
+	#define SYSNAME "Linux"
+	#define DIMBUF 64
+	DWORD GetTickCount();
+	extern unsigned char bufferU[128],bufferI[128];
+#else	//Windows
+	#define SYSNAME "Windows"
+	#define DIMBUF 64
+	extern unsigned char bufferU0[128],bufferI0[128];
+	extern unsigned char *bufferU,*bufferI;
+	extern DWORD NumberOfBytesRead,BytesWritten;
+	extern ULONG Result;
+	extern HANDLE WriteHandle,ReadHandle;
+	extern OVERLAPPED HIDOverlapped;
+	extern HANDLE hEventObject;
+#endif
+
+extern int statusID;
+extern GtkWidget *status_bar;
+extern char str[4096];
+extern int saveLog;
+extern char** strings;
+extern int fd;
+extern int saveLog,programID,MinDly,load_osccal,load_BKosccal;
+extern int use_osccal,use_BKosccal;
+extern int load_calibword,max_err;
+extern int AVRlock,AVRfuse,AVRfuse_h,AVRfuse_x;
+extern int ICDenable,ICDaddr;
+extern int FWVersion,HwID;
+extern FILE* logfile;
+extern char LogFileName[512];
+extern char loadfile[512],savefile[512];
+extern WORD *memCODE_W;
+extern int size,sizeW,sizeEE,sizeCONFIG,sizeUSERID;
+extern unsigned char *memCODE,*memEE,memID[64],memCONFIG[48],memUSERID[8];
+extern double hvreg;
+extern int RWstop;
+
+int StartHVReg(double V);
+void msDelay(double delay);
+void DisplayEE();
+void PrintMessage(const char *msg);
+void PrintMessageI2C(const char *msg);
+int CheckV33Regulator(void);
+void OpenLogFile(void);
+void WriteLogIO();
+void CloseLogFile();
+unsigned int htoi(const char *hex, int length);
+void PacketIO(double delay);
+#endif
diff --git a/deviceRW.c b/deviceRW.c
new file mode 100644
index 0000000..127a7b6
--- /dev/null
+++ b/deviceRW.c
@@ -0,0 +1,1248 @@
+/*
+ * deviceRW.c - Read-write calls for various devices
+ * Copyright (C) 2010-2022 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+//configure for GUI or command-line
+#include "common.h"
+#include "progP12.h"
+#include "progP16.h"
+#include "progP18.h"
+#include "progP24.h"
+#include "progEEPROM.h"
+#include "progAVR.h"
+//#include "progP32.h"
+
+#ifdef __GTK_H__
+#define _GTKGUI
+#endif
+
+#include "deviceRW.h"
+
+char* devices[]={
+"10F200","10F202","10F204","10F206","10F220","10F222",
+"10F320","10F322",
+"12C508","12C508A","12C509","12C509A","12F508","12F509","12F510","12F519",
+"12F609","12F615","12F617","12F629","12F635","12C671","12C672","12CE673","12CE674","12F675","12F683",
+"12F752",
+"12F529T39","12F529T48",
+"12F1501","12F1571","12F1572","12F1612","12F1822","12F1840",
+"16F505","16F506","16F526","16F527","16F54","16F57","16F570","16F59",
+"16F610","16F616","16F627","16F627A","16F628","16F628A","16F630","16F631",
+"16F636","16F639","16F648A","16F676","16F677","16F684","16F685","16F687",
+"16F688","16F689","16F690",
+"16F707","16F716","16F72","16F720","16F721","16F722","16F722A","16F723","16F723A",
+"16F724","16F726","16F727","16F73","16F737","16F74","16F747","16F753","16F76",
+"16F767","16F77","16F777","16F785",
+"16F818","16F819","16C83","16F83","16F83A","16C84","16F84","16F84A","16F87","16F870","16F871","16F872",
+"16F873","16F873A","16F874","16F874A","16F876","16F876A","16F877","16F877A",
+"16F88","16F882","16F883","16F884","16F886","16F887",
+"16F913","16F914","16F916","16F917","16F946",
+"16F1454","16F1455","16F1459",
+"16F1503","16F1507","16F1508","16F1509","16F1512","16F1513","16F1516","16F1517","16F1518","16F1519",
+"16F1526","16F1527","16LF1554","16LF1559","16F1574","16F1575","16F1578","16F1579",
+"16F1613","16F1614","16F1615","16F1618","16F1619",
+"16F1703","16F1704","16F1705","16F1707","16F1708","16F1709","16F1713","16F1716","16F1717","16F1718","16F1719",
+"16F1764","16F1765","16F1768","16F1769","16F1773","16F1776","16F1777","16F17784","16F1779",
+"16F1782","16F1783","16F1784","16F1786","16F1787","16F1788","16F1789",
+"16F1823","16F1824","16F1825","16F1826","16F1827","16F1828","16F1829","16F1847",
+"16LF1902","16LF1903","16LF1904","16LF1906","16LF1907",
+"16F1933","16F1934","16F1936","16F1937","16F1938","16F1939","16F1946","16F1947",
+"16F15213","16F15214","16F15223""16F15224","16F15225","16F15243","16F15244","16F15245",
+"16F15254","16F15255","16F15256","16F15274","16F15275","16F15276",
+"16F15313","16F15323","16F15324","16F15325","16F15344","16F15345","16F15354","16F15355","16F15356",
+"16F15375","16F15376","16F15385","16F15386",
+"16F17114","16F17115","16F17124","16F17125","16F17126","16F17144","16F17145","16F17146",
+"16F17154","16F17155","16F17156","16F17174","16F17175","16F17176",
+"16F18013","16F18014","16F18015","16F18023","16F18024","16F18025","16F18026","16F18044","16F18045","16F18046",
+"16F18054","16F18055","16F18056","16F18074","16F18075","16F18076",
+"16F18114","16F18115","16F18124","16F18125","16F18126","16F18144","16F18145","16F18146",
+"16F18154","16F18155","16F18156","16F18174","16F18175","16F18176",
+"16F18313","16F18323","16F18324","16F18325","16F18326","16F18344","16F18345","16F18346",
+"16F18424","16F18425","16F18426","16F18444","16F18445","16F18446","16F18455","16F18456",
+"16F18854","16F18855","16F18856","16F18857","16F18875","16F18876","16F18877",
+"16F19155","16F19156","16F19175","16F19176","16F19185","16F19186","16F19195","16F19196","16F19197",
+"18F04Q40","18F04Q41","18F05Q40","18F05Q41","18F06Q40","18F06Q41","18F14Q40","18F14Q41","18F15Q40","18F15Q41","18F16Q40","18F16Q41",
+"18F242","18F248","18F252","18F258","18F442","18F448","18F452","18F458",
+"18F1220","18F1230","18F1320","18F1330","18F13K22","18F13K50","18F14K22","18F14K50",
+"18F2220","18F2221","18F2320","18F23K20","18F23K22","18F2321","18F2331","18F2410",
+"18F24J10","18F24J11","18F2420","18F24K20","18F24K22","18F2423","18F2431","18F2439",
+"18F2450","18F24J50","18F24K50","18F2455","18F2458","18F24Q71","18F2480",
+"18F2510","18F25J10","18F25J11","18F2515","18F2520","18F25K20","18F25K22","18F2523",
+"18F2525","18F2539","18F25K42","18F25Q43","18F2550","18F25J50","18F25K50","18F2553","18F25Q71","18F2580","18F25K80","18F25K83","18F2585",
+"18F2610","18F26J11","18F26J13","18F2620","18F26K20","18F26K22","18F26K42","18F26Q43","18F26J50","18F26K50",
+"18F26J53","18F26Q71","18F2680","18F26K80","18F2682","18F26K83","18F26Q83","18F26Q84","18F2685",
+"18F27J13","18F27K42","18F27Q43","18F27J53","18F27Q83","18F27Q84",
+"18F4220","18F4221","18F4320","18F43K20","18F43K22","18F4321","18F4331",
+"18F4410","18F44J10","18F44J11","18F4420","18F44K20","18F44K22","18F4423","18F4431",
+"18F4439","18F4450","18F44J50","18F4455","18F4458","18F44Q71","18F4480",
+"18F4510","18F45J10","18F45J11","18F4515","18F4520","18F45K20","18F45K22","18F4523",
+"18F4525","18F4539","18F45K42","18F45Q43","18F4550","18F45J50","18F45K50","18F4553","18F45Q71","18F4580","18F45K80","18F4585",
+"18F4610","18F46J11","18F46J13","18F4620","18F46K20","18F46K22","18F46K42","18F46Q43","18F46J50","18F46K50",
+"18F46J53","18F46Q71","18F4680","18F46K80","18F4682","18F46Q83","18F46Q84","18F4685",
+"18F47J13","18F47K42","18F47Q43","18F47J53","18F47Q83","18F47Q84",
+"18F54Q71","18F55K42","18F55Q43","18F55Q71","18F56K42","18F56Q43","18F56Q71","18F56Q83","18F56Q84","18F57K42","18F57Q43","18F57Q83","18F57Q84",
+"18F63J11","18F63J90","18F64J11","18F64J90",
+"18F65J10","18F65J11","18F65J15","18F65J50","18F65J90","18F65K80",
+"18F66J10","18F66J11","18F66J15","18F66J16","18F66J50","18F66J55","18F66J60","18F66J65","18F66J90","18F66J93",
+"18F67J10","18F67J11","18F67J50","18F67J60","18F66K80","18F67J90","18F67J93",
+"18F83J11","18F83J90","18F84J11","18F84J90","18F85J10","18F85J11","18F85J15","18F85J50","18F85J90",
+"18F8520","18F86J10","18F86J11","18F86J15","18F86J16","18F86J50","18F86J55","18F86J60","18F86J65",
+"18F86J72","18F86J90","18F86J93",
+"18F8722","18F87J10","18F87J11","18F87J50","18F87J60","18F87J72","18F87J90","18F87J93",
+"18F96J60","18F96J65","18F97J60",
+"24F04KA200","24F04KA201",
+"24F08KA101","24F08KA102",
+"24F16KA101","24F16KA102",
+"24FJ16GA002","24FJ16GA004",
+"24FJ32GA002","24FJ32GA004","24FJ32GA102","24FJ32GA104",
+"24FJ32GB002","24FJ32GB004",
+"24FJ48GA002","24FJ48GA004",
+"24FJ64GA002","24FJ64GA004","24FJ64GA006","24FJ64GA008","24FJ64GA010",
+"24FJ64GA102","24FJ64GA104","24FJ64GA306","24FJ64GA308","24FJ64GA310",
+"24FJ64GB002","24FJ64GB004","24FJ64GB106","24FJ64GB108","24FJ64GB110",
+"24FJ64GC006","24FJ64GC008","24FJ64GC010",
+"24FJ96GA006","24FJ96GA008","24FJ96GA010",
+"24FJ128GA006","24FJ128GA008","24FJ128GA010","24FJ128GA106","24FJ128GA108","24FJ128GA110",
+"24FJ128GA306","24FJ128GA308","24FJ128GA310",
+"24FJ128GB106","24FJ128GB108","24FJ128GB110","24FJ128GB206","24FJ128GB210",
+"24FJ128GC006","24FJ128GC008","24FJ128GC010",
+"24FJ128DA106","24FJ128DA110","24FJ128DA206","24FJ128DA210",
+"24FJ192GA106","24FJ192GA108","24FJ192GA110",
+"24FJ192GB106","24FJ192GB108","24FJ192GB110",
+"24FJ256GA106","24FJ256GA108","24FJ256GA110",
+"24FJ256GB106","24FJ256GB108","24FJ256GB110",
+"24FJ256GB206","24FJ256GB210",
+"24FJ256DA106","24FJ256DA110","24FJ256DA206","24FJ256DA210",
+"24EP32GP202","24EP32GP203","24EP32GP204",
+"24EP32MC202","24EP32MC203","24EP32MC204",
+"24EP64GP202","24EP64GP203","24EP64GP204","24EP64GP206",
+"24EP64MC202","24EP64MC203","24EP64MC204","24EP64MC206",
+"24EP128GP202","24EP128GP204","24EP128GP206",
+"24EP128MC202","24EP128MC204","24EP128MC206",
+"24EP256GP202","24EP256GP204","24EP256GP206",
+"24EP256MC202","24EP256MC204","24EP256MC206",
+"24EP512GP202","24EP512GP204","24EP512GP206",
+"24EP512MC202","24EP512MC204","24EP512MC206",
+"24HJ12GP201","24HJ12GP202",
+"24HJ16GP304",
+"24HJ32GP202","24HJ32GP204","24HJ32GP302","24HJ32GP304",
+"24HJ64GP202","24HJ64GP204","24HJ64GP206","24HJ64GP210","24HJ64GP502",
+"24HJ64GP504","24HJ64GP506","24HJ64GP510",
+"24HJ128GP202","24HJ128GP204","24HJ128GP206","24HJ128GP210",
+"24HJ128GP306","24HJ128GP310","24HJ128GP502","24HJ128GP504","24HJ128GP506","24HJ128GP510",
+"24HJ256GP206","24HJ256GP210","24HJ256GP610",
+"30F1010","30F2010","30F2011","30F2012","30F2020","30F2023",
+"30F3010","30F3011","30F3012","30F3013","30F3014",
+"30F4011","30F4012","30F4013",
+"30F5011","30F5013","30F5015","30F5016",
+"30F6010","30F6011","30F6012","30F6013","30F6014","30F6015",
+//"32MX270F256",
+"33FJ06GS101","33FJ06GS102","33FJ06GS202",
+"33FJ12GP201","33FJ12GP202","33FJ12MC201","33FJ12MC202",
+"33FJ16GP304","33FJ16GS402","33FJ16GS404","33FJ16GS502","33FJ16GS504","33FJ16MC304",
+"33FJ32GP202","33FJ32GP204","33FJ32GP302","33FJ32GP304",
+"33FJ32GS406","33FJ32GS606","33FJ32GS608","33FJ32GS610",
+"33FJ32MC202","33FJ32MC204","33FJ32MC302","33FJ32MC304",
+"33FJ64GP202","33FJ64GP204","33FJ64GP206","33FJ64GP306","33FJ64GP310",
+"33FJ64GP706","33FJ64GP708","33FJ64GP710","33FJ64GP802","33FJ64GP804",
+"33FJ64GS406","33FJ64GS606","33FJ64GS608","33FJ64GS610",
+"33FJ64MC202","33FJ64MC204","33FJ64MC506","33FJ64MC508","33FJ64MC510",
+"33FJ64MC706","33FJ64MC710","33FJ64MC802","33FJ64MC804",
+"33FJ128GP202","33FJ128GP204","33FJ128GP206","33FJ128GP306","33FJ128GP310","33FJ128GP706",
+"33FJ128GP708","33FJ128GP710","33FJ128GP802","33FJ128GP804",
+"33FJ128MC202","33FJ128MC204","33FJ128MC506","33FJ128MC510","33FJ128MC706","33FJ128MC708",
+"33FJ128MC710","33FJ128MC802","33FJ128MC804",
+"33FJ256GP506","33FJ256GP510","33FJ256GP710",
+"33FJ256MC510","33FJ256MC710",
+"33EP32GP502","33EP32GP503","33EP32GP504",
+"33EP32MC202","33EP32MC203","33EP32MC204","33EP32MC502","33EP32MC503","33EP32MC504",
+"33EP64GP502","33EP64GP503","33EP64GP504","33EP64GP506",
+"33EP64MC202","33EP64MC203","33EP64MC204","33EP64MC206","33EP64MC502","33EP64MC503","33EP64MC504","33EP64MC506",
+"33EP128GP502","33EP128GP504","33EP128GP506",
+"33EP128MC202","33EP128MC204","33EP128MC206","33EP128MC502","33EP128MC504","33EP128MC506",
+"33EP256GP502","33EP256GP504","33EP256GP506",
+"33EP256MC202","33EP256MC204","33EP256MC206","33EP256MC502","33EP256MC504","33EP256MC506",
+"33EP512GP502","33EP512GP504","33EP512GP506",
+"33EP512MC202","33EP512MC204","33EP512MC206","33EP512MC502","33EP512MC504","33EP512MC506",
+"AT90S1200","AT90S2313",
+"AT90S8515","AT90S8535","ATmega48","ATmega8","ATmega88","ATmega8515",
+"ATmega8535","ATmega16","ATmega164","ATmega168","ATmega32","ATmega324",
+"ATmega328","ATmega64","ATmega644","ATmega1284",
+"ATtiny11","ATtiny12","ATtiny13",
+"ATtiny2313","ATtiny24","ATtiny25","ATtiny26","ATtiny261","ATtiny4313","ATtiny44","ATtiny45",
+"ATtiny461","ATtiny48","ATtiny84","ATtiny85","ATtiny88","ATtiny861",
+"2400","2401","2402","2404","2408","2416","2432","2464","24128","24256","24512","241024","241025",
+"25010","25020","25040","25080","25160","25320","25640","25128","25256","25512","251024",
+"95010","95020","95040","95080","95160","95320","95640","95128","95256","95512","95M01","95M02",
+"251005","252005","254005","258005","251605",
+"25X05","25X10","25X20","25X40","25X80","25X16","25X32","25X64","25X128","25Q40",
+"93S46","93x46","93x46A","93S56","93x56","93x56A","93S66","93x66", "93x66A","93x76","93x76A","93x86","93x86A",
+"DS2430","DS2431","DS2433","DS28EC20","DS1820",
+"11010","11020","11040","11080","11160"
+};
+
+int Ndevices=sizeof(devices)/sizeof(char*);
+
+struct DEVICES DEVLIST[]={
+//-------------PIC10-16---------------------------------------------------------
+	{"10F200,10F204,10F220",
+		PIC12,13.0,0,Read12F5xx,{0x100,5},0x40,Write12F5xx,{0x100,0xFF},0},		//256
+	{"10F320",
+		PIC16,9.0,1,Read16Fxxx,{0x100,0,10,0},0x80,Write12F6xx,{0x100,0,-10},0},	//256, vpp, 3.3V
+	{"12C508,12C508A",
+		PIC12,13.0,0,Read12F5xx,{0x200,4},0x40,Write12C5xx,{0x200,0},0},		//512
+	{"12F508,10F202,10F206,10F222",
+		PIC12,13.0,0,Read12F5xx,{0x200,5},0x40,Write12F5xx,{0x200,0x1FF},0},	//512
+	{"16F54",
+		PIC12,13.0,0,Read12F5xx,{0x200,4},0x40,Write12F5xx,{0x200,-1},0},		//512, no osccal
+	{"10F322",
+		PIC16,9.0,1,Read16Fxxx,{0x200,0,10,0},0x80,Write12F6xx,{0x200,0,-10},0},	//512, vpp, 3.3V
+	{"12C509,12C509A",
+		PIC12,13.0,0,Read12F5xx,{0x400,4},0x40,Write12C5xx,{0x400,0},0},		//1K
+	{"12F509,12F510,16F505,16F506",
+		PIC12,13.0,0,Read12F5xx,{0x400,5},0x40,Write12F5xx,{0x400,0x3FF},0},	//1K
+	{"12F519,16F526,16F527",
+		PIC12,13.0,0,Read12F5xx,{0x440,8},0x60,Write12F5xx,{0x440,0x3FF},0},	//1K + 64
+	{"12F529T39,12F529T48",
+		PIC12,13.0,0,Read12F5xx,{0x640,8},0x78,Write12F5xx,{0x640,0x5FF},0},	//1.5K + 64
+	{"16F57,16F59",
+		PIC12,13.0,0,Read12F5xx,{0x800,4},0x40,Write12F5xx,{0x800,-1},0},		//2K
+	{"16F570",
+		PIC12,13.0,0,Read12F5xx,{0x840,8},0x70,Write12F5xx,{0x840,0x7FF},0},	//2K + 64
+	{"16C83,16F83,16F83A",
+		PIC16,13.0,0,Read16Fxxx,{0x200,0x40,8,1},0x10,Write16F8x,{0x200,0x40,-10},0},		//512, 64, vdd
+	{"12C671,12CE673",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0,0,0},0x100,0,{},0},								//1K, vpp
+	{"12F1501",
+		PIC16,8.5,1,Read16F1xxx,{0x400,0,11,0},0x100,Write16F1xxx,{0x400,0,0},0},			//1K, vpp, 3.3V
+	{"12F1571",
+		PIC16,8.5,1,Read16F1xxx,{0x400,0,12,0},0x200,Write16F1xxx,{0x400,0,0},0},			//1K, vpp, 3.3V
+	{"12F609,12F615,16F610",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0,9,0},0x40,Write12F61x,{0x400,0,0},0},			//1K, vpp, cal1
+	{"12F752",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0,10,0},0x80,Write12F61x,{0x400,0,0},0},			//1K, vpp, cal1
+	{"16C84,16F84,16F84A",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x40,8,1},0x10,Write16F8x,{0x400,0x40,-10},0},		//1K, 64, vdd
+	{"12F635",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x80,10,0},0x80,Write12F6xx,{0x400,0x80,-10},0},		//1K, 128, vpp, cal1 + cal2
+	{"16F631",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x80,9,0},0x80,Write12F6xx,{0x400,0x80,-10},0},		//1K, 128, vpp, cal1
+	{"12F629,12F675,16F630,16F676",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,0},0x20,Write12F62x,{0x400,0x80,-10},0},		//1K, 128, vpp
+	{"16F627",
+		PIC16,13.0,0,Read16Fxxx,{0x400,-0x80,8,0},0x10,Write16F62x,{0x400,0x80,-10},0},		//1K, 128, vpp, ee@0x2200
+	{"16F627A",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,0},0x10,Write12F6xx,{0x400,0x80,-10},0},		//1K, 128, vpp
+	{"16F818",
+		PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,2},0x10,Write16F81x,{0x400,0x80,-10},0},		//1K, 128, vdd short delay
+	{"16F72",
+		PIC16,8.5,1,Read16Fxxx,{0x800,0,8,1},0x20,Write16F7x,{0x800,0,-10},0},				//2K, vdd, 3.3V
+	{"16F720,16F722,16F722A",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0,11,0},0x100,Write16F72x,{0x800,0,0},0},		//2K, vpp, config1-2 + cal1-2, 3.3V
+	{"12C672,12CE674",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0,0,0},0x100,0,{},0},								//2K, vpp
+	{"16F716",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0,8,2},8,Write16F71x,{0x800,1,-10},0},				//2K, vdd
+	{"16F616,12F617",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0,9,0},0x40,Write12F61x,{0x800,0,0},0},			//2K, vpp, cal1
+	{"16F753",
+		PIC16,12.5,0,Read16Fxxx,{0x800,0,10,0},0x80,Write12F61x,{0x800,0,0},0},			//2K, vpp, cal1
+	{"16LF1902,16F1503,16F1507,16F1512",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0,11,0},0x200,Write16F1xxx,{0x800,0,0},0},			//2K, vpp, 3.3V
+	{"12F1572",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0,12,0},0x200,Write16F1xxx,{0x800,0,0},0},			//2K, vpp, 3.3V
+	{"16F1703,16F1707",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0,13,0},0x200,Write16F1xxx,{0x800,0,0},0},			//2K, vpp, 3.3V
+	{"12F1612,16F1613",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0,13,4},0x200,Write16F1xxx,{0x800,0,4},0},			//2K, vpp, 3.3V
+	{"16F15213,16F15223,16F15243,16F15313,16F15323",
+		PIC16,8.5,1,Read16F18xxx,{0x800,0,0,0},0,Write16F18xxx,{0x800,0,0},0},				//2K, vpp, 3.3V, 8b commands
+	{"16F870,16F871,16F872",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x40,8,1},0x100,Write16F87x,{0x800,0x40,-10},0},		//2K, 64, vdd
+	{"16F628",
+		PIC16,13.0,0,Read16Fxxx,{0x800,-0x80,8,0},0x10,Write16F62x,{0x800,0x80,-10},0},		//2K, 128, vpp, ee@0x2200
+	{"16F628A",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x80,8,0},0x10,Write12F6xx,{0x800,0x80,-10},0},		//2K, 128, vpp
+	{"16F882",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x80,10,0},0x80,Write16F88x,{0x800,0x80,-10},0},		//2K, 128, vpp, config2 + cal1
+	{"16F819",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x100,8,2},0x10,Write16F81x,{0x800,0x100,-10},0},	//2K, 256, vdd short delay
+	{"12F683,16F684",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x100,9,0},0x40,Write12F6xx,{0x800,0x100,-10},0},	//2K, 256, vpp, cal1
+	{"16F636,16F639,16F785",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x100,10,0},0x40,Write12F6xx,{0x800,0x100,-10},0},	//2K, 256, vpp, cal1 + cal2
+	{"16F677,16F687",
+		PIC16,13.0,0,Read16Fxxx,{0x800,0x100,9,0},0x80,Write12F6xx,{0x800,0x100,-10},0},	//2K, 256, vpp, cal1
+	{"12F1822,16F1823,16F1826",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0x100,11,0},0x200,Write16F1xxx,{0x800,0x100,0},0},	//2K, 256, vpp, 3.3V
+	{"16F1782",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0x100,19,0},0x200,Write16F1xxx,{0x800,0x100,0},0},	//2K, 256, vpp, 3.3V
+	{"16F18313,16F18323",
+		PIC16,8.5,1,Read16F1xxx,{0x800,0x100,11,0x1C},0x20,Write16F1xxx,{0x800,0x100,0x1C},0},	//2K, 256, vpp, 3.3V, new cmd
+	{"16F18013,16F18023",
+		PIC16,8.5,1,Read16F18xxx,{0x800,1,0,0},0,Write16F18xxx,{0x800,0x100,0},0},			//2K, 256, vpp, 3.3V, 8b commands
+	{"16F73,16F74",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0,8,1},0x20,Write16F7x,{0x1000,0,-10},0},			//4K, vdd
+	{"16F737,16F747",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0,9,2},9,Write16F7x,{0x1000,1,-10},0},				//4K, vdd short/no delay
+	{"16F721,16F723,16F723A,16F724",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0,11,0},0x100,Write16F72x,{0x1000,0,0},0},			//4K, vpp, config1-2 + cal1-2, 3.3V
+	{"16LF1903,16LF1904,16F1508,16F1513,16LF1554",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,11,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1574,16F1578",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,12,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1704,16F1708",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,13,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1614,16F1618",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,13,4},0x200,Write16F1xxx,{0x1000,0,4},0},			//4K, vpp, 3.3V
+	{"16F1713",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,17,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1783,16F1784",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,19,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1764,16F1768",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,20,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F1773",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0,24,0},0x200,Write16F1xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V
+	{"16F15214,16F15224,16F15244,16F15254,16F15274,16F15324,16F15344,16F15354",
+		PIC16,8.5,1,Read16F18xxx,{0x1000,0,0,0},0,Write16F18xxx,{0x1000,0,0},0},			//4K, vpp, 3.3V, 8b commands
+	{"16F873A,16F874A",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x80,8,1},0x100,Write16F87xA,{0x1000,0x80,1},0},	//4K, 128, vdd
+	{"16F873,16F874",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,-0x80,8,1},0x100,Write16F87x,{0x1000,-0x80,-10},0},	//4K, 128, vdd, ee@0x2200
+	{"16F685,16F689,16F690",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,0},0x80,Write12F6xx,{0x1000,0x100,-10},0},	//4K, 256, vpp, cal1
+	{"16F688",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,0},0x40,Write12F6xx,{0x1000,0x100,-10},0},	//4K, 256, vpp, cal1
+	{"16F883,16F884",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,10,0},0x80,Write16F88x,{0x1000,0x100,-10},0},	//4K, 256, vpp, config2 + cal1
+	{"16F648A",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,8,0},0x10,Write12F6xx,{0x1000,0x100,-10},0},	//4K, 256, vpp
+	{"16F87,16F88",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,2},0x10,Write16F81x,{0x1000,0x100,-10},0},	//4K, 256, vdd short delay
+	{"16F913,16F914",
+		PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,10,0},0x40,Write12F6xx,{0x1000,0x100,-10},0},	//4K, 256, vpp, cal1 + cal2
+	{"16F1933,16F1934,16F1824,16F1827,16F1828,12F1840",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0x100,11,0},0x200,Write16F1xxx,{0x1000,0x100,0},0},	//4K, 256, vpp, 3.3V
+	{"16F18324,16F18344",
+		PIC16,8.5,1,Read16F1xxx,{0x1000,0x100,11,0x1C},0x20,Write16F1xxx,{0x1000,0x100,0x1C},0},	//4K, 256, vpp, 3.3V, new cmd
+	{"16F17114,16F17124,16F17144,16F17154,16F17174,16F18014,16F18024,16F18044,16F18054,16F18074,16F18114,16F18124,16F18144,\
+	16F18154,16F18174,16F18424,16F18444",
+		PIC16,8.5,1,Read16F18xxx,{0x1000,1,0,0},0,Write16F18xxx,{0x1000,0x100,0},0},		//4K, 256, vpp, 3.3V, 8b commands
+	{"16F18854",
+		PIC16,8.5,1,Read16F18xxx,{0x1000,0x100,0,0x10},0,Write16F18xxx,{0x1000,0x100,0x10},0},	//4K, 256, vpp, 3.3V, 8b commands no DIA
+	{"16F76,16F77",
+		PIC16,13.0,0,Read16Fxxx,{0x2000,0,8,1},0x20,Write16F7x,{0x2000,0,-10},0},			//8K, vdd
+	{"16F767,16F777",
+		PIC16,13.0,0,Read16Fxxx,{0x2000,0,9,2},0x40,Write16F7x,{0x2000,1,-10},0},			//8K, vdd short delay
+	{"16F726,16F727,16F707",
+		PIC16,8.5,1,Read16Fxxx,{0x2000,0,11,0},0x100,Write16F72x,{0x2000,0,0},0},			//8K, vpp, config1-2 + cal1-2, 3.3V
+	{"16LF1906,16LF1907,16F1509,16F1454,16F1455,16F1459,16F1516,16F1517,16F1526,16LF1559",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,11,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F1575,16F1579",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,12,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F1705,16F1709",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,13,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F1615,16F1619",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,13,4},0x200,Write16F1xxx,{0x2000,0,4},0},			//8K, vpp, 3.3V
+	{"16F1716,16F1717",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,17,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F1765,16F1769",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,20,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F1776,16F1777",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0,24,0},0x200,Write16F1xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V
+	{"16F15225,16F15245,16F15255,16F15275,16F15325,16F15345,16F15355,16F15375,16F15385",
+		PIC16,8.5,1,Read16F18xxx,{0x2000,0,0,0},0,Write16F18xxx,{0x2000,0,0},0},			//8K, vpp, 3.3V, 8b commands
+	{"16F876A,16F877A",
+		PIC16,13.0,0,Read16Fxxx,{0x2000,0x100,8,1},0x100,Write16F87xA,{0x2000,0x100,1},0},	//8K, 256, vdd
+	{"16F876,16F877",
+		PIC16,13.0,0,Read16Fxxx,{0x2000,-0x100,8,1},0x100,Write16F87x,{0x2000,-0x100,-10},0},	//8K, 256, vdd, ee@0x2200
+	{"16F886,16F887",
+		PIC16,11.0,0,Read16Fxxx,{0x2000,0x100,10,0},0x80,Write16F88x,{0x2000,0x100,-10},0},	//8K, 256, vpp, config2 + cal1
+	{"16F916,16F917,16F946",
+		PIC16,13.0,0,Read16Fxxx,{0x2000,0x100,10,0},0x40,Write12F6xx,{0x2000,0x100,-10},0},	//8K, 256, vpp, cal1 + cal2
+	{"16F1936,16F1937,16F1946,16F1825,16F1829,16F1847",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,11,0},0x200,Write16F1xxx,{0x2000,0x100,0},0},	//8K, 256, vpp, 3.3V
+	{"16F1786,16F1787",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,19,0},0x200,Write16F1xxx,{0x2000,0x100,0},0},	//8K, 256, vpp, 3.3V
+	{"16F18325,16F18345",
+		PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,11,0x1C},0x20,Write16F1xxx,{0x2000,0x100,0x1C},0},	//8K, 256, vpp, 3.3V, new cmd
+	{"16F17115,16F17125,16F17145,16F17155,16F17175,16F18015,16F18025,16F18045,16F18055,16F18075,16F18115,16F18125,16F18145,16F18155,16F18175,\
+	16F18425,16F18445,16F18455,16F19155,16F19175,16F19185,16F19195",
+		PIC16,8.5,1,Read16F18xxx,{0x2000,1,0,0},0,Write16F18xxx,{0x2000,0x100,0},0},    	//8K, 256, vpp, 3.3V, 8b commands
+	{"16F18855,16F18875",
+		PIC16,8.5,1,Read16F18xxx,{0x2000,0x100,0,0x10},0,Write16F18xxx,{0x2000,0x100,0x10},0}, 	//8K, 256, vpp, 3.3V, 8b commands no DIA
+	{"16F1518,16F1519,16F1527",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0,11,0},0x200,Write16F1xxx,{0x4000,0,0},0},			//16K, vpp, 3.3V
+	{"16F1718,16F1719",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0,17,0},0x200,Write16F1xxx,{0x4000,0,0},0},			//16K, vpp, 3.3V
+	{"16F1778,16F1779",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0,24,0},0x200,Write16F1xxx,{0x4000,0,0},0},			//16K, vpp, 3.3V
+	{"16F15256,16F15276,16F15356,16F15376,16F15386",
+		PIC16,8.5,1,Read16F18xxx,{0x4000,0,0,0},0,Write16F18xxx,{0x4000,0,0},0},			//16K, vpp, 3.3V, 8b commands
+	{"16F1938,16F1939,16F1947",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,11,0},0x200,Write16F1xxx,{0x4000,0x100,0},0},	//16K, 256, vpp, 3.3V
+	{"16F1788,16F1789",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,19,0},0x200,Write16F1xxx,{0x4000,0x100,0},0},	//16K, 256, vpp, 3.3V
+	{"16F18326,16F18346",
+		PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,11,0x1C},0x20,Write16F1xxx,{0x4000,0x100,0x1C},0},	//16K, 256, vpp, 3.3V, new cmd
+	{"16F17126,16F17146,16F17156,16F17176,16F18026,16F18046,16F18056,16F18076,16F18126,16F18146,16F18156,16F18176,\
+	16F18426,16F18446,16F18456,16F19156,16F19176,16F19186,16F19196",
+		PIC16,8.5,1,Read16F18xxx,{0x4000,1,0,0},0,Write16F18xxx,{0x4000,0x100,0},0},    	//16K, 256, vpp, 3.3V, 8b commands
+	{"16F18856,16F18876",
+		PIC16,8.5,1,Read16F18xxx,{0x4000,0x100,0,0x10},0,Write16F18xxx,{0x4000,0x100,0x10},0}, 	//16K, 256, vpp, 3.3V, 8b commands no DIA
+	{"16F19197",
+		PIC16,8.5,1,Read16F18xxx,{0x8000,1,0,0},0,Write16F18xxx,{0x8000,0x100,0},0},    	//32K, 256, vpp, 3.3V, 8b commands
+	{"16F18857,16F18877",
+		PIC16,8.5,1,Read16F18xxx,{0x8000,0x100,0,0x10},0,Write16F18xxx,{0x8000,0x100,0x10},0}, 	//32K, 256, vpp, 3.3V, 8b commands no DIA
+//-------------PIC18---------------------------------------------------------
+// Read18Fx options:
+//	bit [3:0]
+//     0 = vdd before vpp (12V)
+//     1 = vdd before vpp (9V)
+//     2 = low voltage entry with 32 bit key
+//	bit [7:4]
+//     0 = normal control registers address
+//     1 = new control registers address (18FxxK80)
+//
+// Write18Fx options:
+//	bit [3:0]
+//     0 = vdd before vpp (12V)
+//     1 = vdd before vpp (9V)
+//     2 = low voltage entry with 32 bit key
+//	bit [7:4]
+//     0 = normal eeprom write algoritm
+//     1 = with unlock sequence 55 AA
+//	bit [11:8]
+//     0 = 15ms erase delay, 1ms code write time, 5ms EE write, 5ms config write
+//     1 = 550ms erase delay, 1.2ms code write time, no config or EEPROM
+//     2 = 550ms erase delay, 3.4ms code write time, no config or EEPROM
+//     3 = separate block erase with 5ms delay, 1ms code write, 5ms EE write, 5ms config write
+//         + new control registers address (18FxxK80)
+	{"18F1230",
+		PIC18,12,0,Read18Fx,{0x1000,0x80,0},0,Write18Fx,{0x1000,0x80,8,0x0F0F,0x8787,0},0},		//4K, 128, 8
+	{"18F2221,18F4221",
+		PIC18,12,0,Read18Fx,{0x1000,0x100,0},0,Write18Fx,{0x1000,0x100,8,0x3F3F,0x8F8F,0},0},	//4K, 256, 8
+	{"18F1220,18F2220,18F4220",
+		PIC18,12,0,Read18Fx,{0x1000,0x100,0},0,Write18Fx,{0x1000,0x100,8,0x10000,0x80,0x10},0},	//4K, 256, 8, EE with unlock
+	{"18F63J11,18F63J90,18F83J11,18F83J90",
+		PIC18,-1,1,Read18Fx,{0x2000,0,2},0,Write18Fx,{0x2000,0,64,0x0101,0x8080,0x202},0},		//8K, 0, 64, LV
+	{"18F1330",
+		PIC18,12,0,Read18Fx,{0x2000,0x80,0},0,Write18Fx,{0x2000,0x80,8,0x0F0F,0x8787,0},0},		//8K, 128, 8
+	{"18F2321,18F4321",
+		PIC18,12,0,Read18Fx,{0x2000,0x100,0},0,Write18Fx,{0x2000,0x100,8,0x3F3F,0x8F8F,0},0},	//8K, 256, 8
+	{"18F1320,18F2320,18F4320,18F2331,18F4331",
+		PIC18,12,0,Read18Fx,{0x2000,0x100,0},0,Write18Fx,{0x2000,0x100,8,0x10000,0x80,0x10},0},	//8K, 256, 8, EE with unlock
+	{"18F13K50,18F13K22",
+		PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,8,0x0F0F,0x8F8F,1},0},	//8K, 256, 8, 9V
+	{"18F23K20,18F43K20",
+		PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,16,0x0F0F,0x8F8F,1},0},	//8K, 256, 16, 9V
+	{"18F23K22,18F43K22",
+		PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,64,0x0F0F,0x8F8F,1},0},	//8K, 256, 64, 9V
+	{"18F2439,18F4439",
+		PIC18,12,0,Read18Fx,{0x3000,0x100,0},0,Write18Fx,{0x3000,0x100,8,0x10000,0x80,0x10},0},	//12K, 256, 8, EE with unlock
+	{"18F2410,18F4410",
+		PIC18,12,0,Read18Fx,{0x4000,0,0},0,Write18Fx,{0x4000,0,32,0x3F3F,0x8F8F,0},0},			//16K, 0, 32
+	{"18F24J10,18F44J10,18F64J11,18F64J90,18F84J11,18F84J90",
+		PIC18,-1,1,Read18Fx,{0x4000,0,2},0,Write18Fx,{0x4000,0,64,0x0101,0x8080,0x202},0},		//16K, 0, 64, LV
+	{"18F24J11,18F24J50,18F44J11,18F44J50",
+		PIC18,-1,1,Read18Fx,{0x4000,0,2},0,Write18Fx,{0x4000,0,64,0x0101,0x8080,0x102},0},		//16K, 0, 64, LV
+	{"18F2420,18F2423,18F4420,18F4423,18F2480,18F4480",
+		PIC18,12,0,Read18Fx,{0x4000,0x100,0},0,Write18Fx,{0x4000,0x100,32,0x3F3F,0x8F8F,0},0},	//16K, 256, 32
+	{"18F2431,18F4431,18F242,18F248,18F442,18F448",
+		PIC18,12,0,Read18Fx,{0x4000,0x100,0},0,Write18Fx,{0x4000,0x100,8,0x10000,0x80,0x10},0},	//16K, 256, 8, EE with unlock
+	{"18F2450,18F4450",
+		PIC18,12,0,Read18Fx,{0x4000,0,0},0,Write18Fx,{0x4000,0,16,0x3F3F,0x8F8F,0},0},			//16K, 0, 16
+	{"18F14K50,18F14K22",
+		PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,16,0x0F0F,0x8F8F,1},0},	//16K, 256, 16, 9V
+	{"18F24K20,18F44K20",
+		PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,32,0x0F0F,0x8F8F,1},0},	//16K, 256, 32, 9V
+	{"18F24K22,18F44K22,18F24K50",
+		PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,64,0x0F0F,0x8F8F,1},0},	//16K, 256, 64, 9V
+	{"18F04Q40,18F14Q40,18F04Q41,18F14Q41,18F24Q71,18F44Q71,18F54Q71",
+		PIC18,8.5,1,Read18FKx,{0x4000,1,0x10},0,Write18FKx,{0x4000,0x200,0x10,0,0,0},0},		//16K, 256, --, LV
+	{"18F2455,18F2458,18F4455,18F4458",
+		PIC18,12,0,Read18Fx,{0x6000,0x100,0},0,Write18Fx,{0x6000,0x100,32,0x3F3F,0x8F8F,0},0},	//24K, 256, 32
+	{"18F2539,18F4539",
+		PIC18,12,0,Read18Fx,{0x6000,0x100,0},0,Write18Fx,{0x6000,0x100,8,0x10000,0x80,0x10},0},	//24K, 256, 8, EE with unlock
+	{"18F2510,18F4510",
+		PIC18,12,0,Read18Fx,{0x8000,0,0},0,Write18Fx,{0x8000,0,32,0x3F3F,0x8F8F,0},0},			//32K, 0, 32
+	{"18F25J10,18F45J10,18F65J10,18F65J11,18F65J50,18F65J90,18F85J10,18F85J11,18F85J50,18F85J90",
+		PIC18,-1,1,Read18Fx,{0x8000,0,2},0,Write18Fx,{0x8000,0,64,0x0101,0x8080,0x202},0},		//32K, 0, 64, LV
+	{"18F25J11,18F25J50,18F45J11,18F45J50",
+		PIC18,-1,1,Read18Fx,{0x8000,0,2},0,Write18Fx,{0x8000,0,64,0x0101,0x8080,0x102},0},		//32K, 0, 64, LV
+	{"18F252,18F258,18F452,18F458",
+		PIC18,12,0,Read18Fx,{0x8000,0x100,0},0,Write18Fx,{0x8000,0x100,8,0x10000,0x80,0x10},0},	//32K, 256, 8, EE with unlock
+	{"18F2550,18F2553,18F4550,18F4553,18F2520,18F2523,18F4520,18F4523,18F2580,18F4580",
+		PIC18,12,0,Read18Fx,{0x8000,0x100,0},0,Write18Fx,{0x8000,0x100,32,0x3F3F,0x8F8F,0},0},	//32K, 256, 32
+	{"18F25K20,18F45K20",
+		PIC18,8.5,1,Read18Fx,{0x8000,0x100,1},0,Write18Fx,{0x8000,0x100,32,0x0F0F,0x8F8F,1},0},	//32K, 256, 32, 9V
+	{"18F25K22,18F45K22,18F25K50,18F45K50",
+		PIC18,8.5,1,Read18Fx,{0x8000,0x100,1},0,Write18Fx,{0x8000,0x100,64,0x0F0F,0x8F8F,1},0},	//32K, 256, 64, 9V
+	{"18F25K42,18F45K42,18F55K42",
+		PIC18,8.5,1,Read18FKx,{0x8000,1,0},0,Write18FKx,{0x8000,0x100,0,0,0,0},0},				//32K, 256, --, LV
+	{"18F05Q40,18F15Q40,18F05Q41,18F15Q41,18F25Q71,18F45Q71,18F55Q71",
+		PIC18,8.5,1,Read18FKx,{0x8000,1,0x10},0,Write18FKx,{0x8000,0x200,0x10,0,0,0},0},		//32K, 256, --, LV
+	{"18F25K80,18F45K80,18F65K80",
+		PIC18,8.5,1,Read18Fx,{0x8000,0x400,0x13},0,Write18Fx,{0x8000,0x400,64,0,0,0x303},0},	//32K, 1K, 64, 9V, xxK80
+	{"18F8520",
+		PIC18,12,0,Read18Fx,{0x8000,0x400,0},0,Write18Fx,{0x8000,0x400,8,0x10000,0x0080,0x10},0},//32K, 1K, 8, EE with unlock
+	{"18F25Q43,18F45Q43,18F55Q43",
+		PIC18,8.5,1,Read18FKx,{0x8000,1,0x10},0,Write18FKx,{0x8000,0x400,0x10,0,0,0},0},		//32K, 1k, --, LV
+	{"18F25K83",
+		PIC18,8.5,1,Read18FKx,{0x8000,1,0},0,Write18FKx,{0x8000,0x400,0,0,0,0},0},				//32K, 1k, --, LV
+	{"18F2515,18F4515",
+		PIC18,12,0,Read18Fx,{0xC000,0,0},0,Write18Fx,{0xC000,0,64,0x3F3F,0x8F8F,0},0},			//48K, 0, 64
+	{"18F65J15,18F85J15",
+		PIC18,-1,1,Read18Fx,{0xC000,0,2},0,Write18Fx,{0xC000,0,64,0x0101,0x8080,0x202},0},		//48K, 0, 64, LV
+	{"18F2525,18F2585,18F4525,18F4585",
+		PIC18,12,0,Read18Fx,{0xC000,0x400,0},0,Write18Fx,{0xC000,0x400,64,0x3F3F,0x8F8F,0},0},	//48K, 1K, 64
+	{"18F2610,18F4610",
+		PIC18,12,0,Read18Fx,{0x10000,0,0},0,Write18Fx,{0x10000,0,64,0x3F3F,0x8F8F,0},0},		//64K, 0, 64
+	{"18F26J11,18F26J13,18F26J50,18F26J53,18F46J11,18F46J13,18F46J50,18F46J53",
+		PIC18,-1,1,Read18Fx,{0x10000,0,2},0,Write18Fx,{0x10000,0,64,0x0101,0x8080,0x102},0},	//64K, 0, 64, LV
+	{"18F66J60,18F86J60,18F96J60,18F66J10,18F66J11,18F66J50,18F66J90,18F66J93,18F86J10,18F86J11,18F86J50,18F86J72,18F86J90,18F86J93",
+		PIC18,-1,1,Read18Fx,{0x10000,0,2},0,Write18Fx,{0x10000,0,64,0x0101,0x8080,0x202},0},	//64K, 0, 64, LV
+	{"18F2620,18F2680,18F4620,18F4680",
+		PIC18,12,0,Read18Fx,{0x10000,0x400,0},0,Write18Fx,{0x10000,0x400,64,0x3F3F,0x8F8F,0},0},//64K, 1K, 64
+	{"18F26K20,18F46K20,18F26K22,18F46K22,18F26K50,18F46K50",
+		PIC18,12,0,Read18Fx,{0x10000,0x100,1},0,Write18Fx,{0x10000,0x100,64,0x0F0F,0x8F8F,1},0},//64K, 256, 64, 9V
+	{"18F06Q40,18F16Q40,18F06Q41,18F16Q41,18F26Q71,18F46Q71,18F56Q71",
+		PIC18,8.5,1,Read18FKx,{0x10000,1,0x10},0,Write18FKx,{0x10000,0x200,0x10,0,0,0},0},		//64K, 256, --, LV
+	{"18F26K80,18F46K80,18F66K80",
+		PIC18,8.5,1,Read18Fx,{0x10000,0x400,0x13},0,Write18Fx,{0x10000,0x400,64,0,0,0x303},0},	//64K, 1K, 64, 9V, xxK80
+	{"18F26Q43,18F46Q43,18F56Q43",
+		PIC18,8.5,1,Read18FKx,{0x10000,1,0x10},0,Write18FKx,{0x10000,0x400,0x10,0,0,0},0},		//64K, 1k, --, LV
+	{"18F26K42,18F46K42,18F56K42,18F26K83",
+		PIC18,8.5,1,Read18FKx,{0x10000,1,0},0,Write18FKx,{0x10000,0x400,0,0,0,0},0},			//64K, 1k, --, LV
+	{"18F26Q83,18F26Q84,18F46Q83,18F46Q84,18F56Q83,18F56Q84",
+		PIC18,8.5,1,Read18FKx,{0x10000,1,0x20},0,Write18FKx,{0x10000,0x400,0x20,0,0,0},0},		//64K, 1k, --, LV
+	{"18F2682,18F4682",
+		PIC18,12,0,Read18Fx,{0x14000,0x400,0},0,Write18Fx,{0x14000,0x400,64,0x3F3F,0x8F8F,0},0},//80K, 1K, 64
+	{"18F66J65,18F86J65,18F96J65,18F66J15,18F66J16,18F66J55,18F86J15,18F86J16,18F86J55",
+		PIC18,-1,1,Read18Fx,{0x18000,0,2},0,Write18Fx,{0x18000,0,64,0x0101,0x8080,0x202},0},	//96K, 0, 64, LV
+	{"18F2685,18F4685",
+		PIC18,12,0,Read18Fx,{0x18000,0x400,0},0,Write18Fx,{0x18000,0x400,64,0x3F3F,0x8F8F,0},0},//96K, 1K, 64
+	{"18F27J13,18F27J53,18F47J13,18F47J53,18F67J10,18F87J10",
+		PIC18,-1,1,Read18Fx,{0x20000,0,2},0,Write18Fx,{0x20000,0,64,0x0101,0x8080,0x102},0},	//128K, 0, 64, LV
+	{"18F67J60,18F87J60,18F97J60,18F67J11,18F67J50,18F67J90,18F67J93,18F87J11,18F87J50,18F87J72,18F87J90,18F87J93",
+		PIC18,-1,1,Read18Fx,{0x20000,0,2},0,Write18Fx,{0x20000,0,64,0x0101,0x8080,0x202},0},	//128K, 0, 64, LV
+	{"18F8722",
+		PIC18,12,0,Read18Fx,{0x20000,0x400,0},0,Write18Fx,{0x20000,0x400,64,0xFFFF,0x8787,0},0},//128K, 1K, 64
+	{"18F27Q43,18F47Q43,18F57Q43",
+		PIC18,8.5,1,Read18FKx,{0x20000,1,0x10},0,Write18FKx,{0x20000,0x400,0x10,0,0,0},0},		//128K, 1k, --, LV
+	{"18F27K42,18F47K42,18F57K42",
+		PIC18,8.5,1,Read18FKx,{0x20000,1,0},0,Write18FKx,{0x20000,0x400,0,0,0,0},0},			//128K, 1k, --, LV
+	{"18F27Q83,18F27Q84,18F47Q83,18F47Q84,18F57Q83,18F57Q84",
+		PIC18,8.5,1,Read18FKx,{0x20000,1,0x20},0,Write18FKx,{0x20000,0x400,0x20,0,0,0},0},		//128K, 1k, --, LV
+//-------------PIC24---------------------------------------------------------
+// options:
+//	bit [3:0]
+//     0 = low voltage ICSP entry
+//     1 = High voltage ICSP entry (6V)
+//     2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
+//     3 = low voltage ICSP entry (5V power supply)
+//	bit [7:4]
+//	   0 = config area in the last 2 program words
+//	   1 = config area in the last 3 program words
+//	   2 = config area in the last 4 program words
+//	   3 = 0xF80000 to 0xF80010 except 02 (24F)
+//     4 = 0xF80000 to 0xF80016 (24H-33F)
+//     5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
+//     6 = 0xF80000 to 0xF8000E (30FSMPS)
+//	bit [11:8]
+//	   0 = code erase word is 0x4064, row write is 0x4004
+//	   1 = code erase word is 0x404F, row write is 0x4001
+//	   2 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (2 ms)
+//	   3 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (200 ms)
+//	bit [15:12]
+//	   0 = eeprom erase word is 0x4050, write word is 0x4004
+//	   1 = eeprom erased with bulk erase, write word is 0x4004
+//	   2 = eeprom erased with special sequence, write word is 0x4004
+//	bit [19:16]
+//	   0 = config write is 0x4000
+//	   1 = config write is 0x4003
+//	   2 = config write is 0x4004
+//	   3 = config write is 0x4008
+	{"24F04KA200,24F04KA201",
+		PIC24,6,1,Read24Fx,{0xB00,0,0x31,0x05BE},0x800,Write24Fx,{0xB00,0,0x20031,0x05BE,32},2.0},				//1.375KW, HV
+	{"24F08KA101,24F08KA102",
+		PIC24,6,1,Read24Fx,{0x1600,0x200,0x31,0x05BE},0x800,Write24Fx,{0x1600,0x200,0x20031,0x05BE,32},2.0},	//2.75KW, HV, 512
+	{"24F16KA101,24F16KA102",
+		PIC24,6,1,Read24Fx,{0x2C00,0x200,0x31,0x05BE},0x800,Write24Fx,{0x2C00,0x200,0x20031,0x05BE,32},2.0},	//5.5KW, HV, 512
+	{"24FJ16GA002,24FJ16GA004",
+		PIC24,-1,1,Read24Fx,{0x2C00,0,0,0x05BE},0x800,Write24Fx,{0x2C00,0,0x10100,0x05BE,64},2.0},				//5.5KW
+	{"24FJ32GA002,24FJ32GA004",
+		PIC24,-1,1,Read24Fx,{0x5800,0,0,0x05BE},0x800,Write24Fx,{0x5800,0,0x10100,0x05BE,64},2.0},				//11KW
+	{"24FJ32GA102,24FJ32GA104,24FJ32GB002,24FJ32GB004",
+		PIC24,-1,1,Read24Fx,{0x5800,0,0x20,0x07F0},0x800,Write24Fx,{0x5800,0,0x10120,0x07F0,64},2.0},				//11KW 4 Config Word
+	{"24FJ48GA002,24FJ48GA004",
+		PIC24,-1,1,Read24Fx,{0x8400,0,0,0x05BE},0x800,Write24Fx,{0x8400,0,0x10100,0x05BE,64},2.0},				//16.5KW
+	{"24FJ64GA002,24FJ64GA004,24FJ64GA006,24FJ64GA008,24FJ64GA010",
+		PIC24,-1,1,Read24Fx,{0xAC00,0,0,0x05BE},0x800,Write24Fx,{0xAC00,0,0x10100,0x05BE,64},2.0},				//22KW
+	{"24FJ64GA102,24FJ64GA104,24FJ64GB002,24FJ64GB004",
+		PIC24,-1,1,Read24Fx,{0xAC00,0,0x20,0x07F0},0x800,Write24Fx,{0xAC00,0,0x10120,0x07F0,64},2.0},				//22KW 4 Config Word
+	{"24FJ64GA306,24FJ64GA308,24FJ64GA310,24FJ64GC006,24FJ64GC008,24FJ64GC010",
+		PIC24,-1,1,Read24Fx,{0xAC00,0,0x120,0x07F0},0x800,Write24Fx,{0xAC00,0,0x110120,0x07F0,64},2.0},			//22KW 4 Config Word new TABLPAG
+	{"24FJ64GB106,24FJ64GB108,24FJ64GB110",
+		PIC24,-1,1,Read24Fx,{0xAC00,0,0x10,0x07F0},0x800,Write24Fx,{0xAC00,0,0x10110,0x07F0,64},2.0},			//22KW 3 Config Word
+	{"24FJ96GA006,24FJ96GA008,24FJ96GA010",
+		PIC24,-1,1,Read24Fx,{0x10000,0,0,0x05BE},0x800,Write24Fx,{0x10000,0,0x10100,0x05BE,64},2.0},			//32KW
+	{"24FJ128GA006,24FJ128GA008,24FJ128GA010",
+		PIC24,-1,1,Read24Fx,{0x15800,0,0,0x05BE},0x800,Write24Fx,{0x15800,0,0x10100,0x05BE,64},2.0},			//44KW
+	{"24FJ128GA106,24FJ128GA108,24FJ128GA110,24FJ128GB106,24FJ128GB108,24FJ128GB110",
+		PIC24,-1,1,Read24Fx,{0x15800,0,0x10,0x07F0},0x800,Write24Fx,{0x15800,0,0x10110,0x07F0,64},2.0},			//44KW 3 Config Word
+	{"24FJ128GA306,24FJ128GA308,24FJ128GA310,24FJ128GB206,24FJ128GB210,24FJ128GC006,24FJ128GC008,\
+24FJ128GC010,24FJ128DA106,24FJ128DA110,24FJ128DA206,24FJ128DA210",
+		PIC24,-1,1,Read24Fx,{0x15800,0,0x120,0x07F0},0x800,Write24Fx,{0x15800,0,0x110120,0x07F0,64},2.0},		//44KW 4 Config Word new TABLPAG
+	{"24FJ192GA106,24FJ192GA108,24FJ192GA110,24FJ192GB106,24FJ192GB108,24FJ192GB110",
+		PIC24,-1,1,Read24Fx,{0x20C00,0,0x10,0x07F0},0x800,Write24Fx,{0x20C00,0,0x10110,0x07F0,64},2.0},			//68KW 3 Config Word
+	{"24FJ256GA106,24FJ256GA108,24FJ256GA110,24FJ256GB106,24FJ256GB108,24FJ256GB110",
+		PIC24,-1,1,Read24Fx,{0x2AC00,0,0x10,0x07F0},0x800,Write24Fx,{0x2AC00,0,0x10110,0x07F0,64},2.0},			//88KW 3 Config Word
+	{"24FJ256DA106,24FJ256DA110,24FJ256DA206,24FJ256DA210,24FJ256GB206,24FJ256GB210",
+		PIC24,-1,1,Read24Fx,{0x2AC00,0,0x120,0x07F0},0x800,Write24Fx,{0x2AC00,0,0x110120,0x07F0,64},2.0},		//88KW 4 Config Word new TABLPAG
+	{"33FJ06GS101,33FJ06GS102,33FJ06GS202",
+			PIC24,-1,1,Read24Fx,{0x1000,0,0x40,0x07F0},0x800,Write24Fx,{0x1000,0,0x00140,0x07F0,64},2.0},			//2KW
+	{"24HJ12GP201,24HJ12GP202,33FJ12GP201,33FJ12GP202,33FJ12MC201,33FJ12MC202",
+		PIC24,-1,1,Read24Fx,{0x2000,0,0x40,0x07F0},0x800,Write24Fx,{0x2000,0,0x00140,0x07F0,64},2.0},			//4KW
+	{"24HJ16GP304,33FJ16GP304,33FJ16GS402,33FJ16GS404,33FJ16GS502,33FJ16GS504,33FJ16MC304",
+		PIC24,-1,1,Read24Fx,{0x2C00,0,0x40,0x07F0},0x800,Write24Fx,{0x2C00,0,0x00140,0x07F0,64},2.0},			//5.5KW
+	{"24HJ32GP202,24HJ32GP204,24HJ32GP302,24HJ32GP304,33FJ32GP202,33FJ32GP204,33FJ32GP302,\
+33FJ32GP304,33FJ32GS406,33FJ32GS606,33FJ32GS608,33FJ32GS610,33FJ32MC202,33FJ32MC204,33FJ32MC302,33FJ32MC304",
+		PIC24,-1,1,Read24Fx,{0x5800,0,0x40,0x07F0},0x1000,Write24Fx,{0x5800,0,0x00140,0x07F0,64},2.0},			//11KW
+	{"24HJ64GP202,24HJ64GP204,24HJ64GP206,24HJ64GP210,24HJ64GP502,24HJ64GP504,24HJ64GP506,24HJ64GP510,\
+33FJ64GP202,33FJ64GP204,33FJ64GP206,33FJ64GP306,33FJ64GP310,33FJ64GP706,33FJ64GP708,33FJ64GP710,33FJ64GP802,\
+33FJ64GP804,33FJ64GS406,33FJ64GS606,33FJ64GS608,33FJ64GS610,33FJ64MC202,33FJ64MC204,33FJ64MC506,33FJ64MC508,33FJ64MC510,\
+33FJ64MC706,33FJ64MC710,33FJ64MC802,33FJ64MC804",
+		PIC24,-1,1,Read24Fx,{0xAC00,0,0x40,0x07F0},0x1000,Write24Fx,{0xAC00,0,0x00140,0x07F0,64},2.0},			//22KW
+	{"24HJ128GP202,24HJ128GP204,24HJ128GP206,24HJ128GP210,24HJ128GP306,24HJ128GP310,24HJ128GP502,\
+24HJ128GP504,24HJ128GP506,24HJ128GP510,\
+33FJ128GP202,33FJ128GP204,33FJ128GP206,33FJ128GP306,33FJ128GP310,33FJ128GP706,33FJ128GP708,33FJ128GP710,\
+33FJ128GP802,33FJ128GP804,33FJ128MC202,33FJ128MC204,33FJ128MC506,33FJ128MC510,33FJ128MC706,33FJ128MC708,\
+33FJ128MC710,33FJ128MC802,33FJ128MC804",
+		PIC24,-1,1,Read24Fx,{0x15800,0,0x40,0x07F0},0x1000,Write24Fx,{0x15800,0,0x00140,0x07F0,64},2.0},		//44KW
+	{"24HJ256GP206,24HJ256GP210,24HJ256GP610,\
+33FJ256GP506,33FJ256GP510,33FJ256GP710,33FJ256MC510,33FJ256MC710",
+		PIC24,-1,1,Read24Fx,{0x2AC00,0,0x40,0x07F0},0x1000,Write24Fx,{0x2AC00,0,0x00140,0x07F0,64},2.0},		//88KW
+	{"24EP32GP202,24EP32GP203,24EP32GP204,33EP32GP502,33EP32GP503,33EP32GP504,\
+24EP32MC202,24EP32MC203,24EP32MC204,33EP32MC202,33EP32MC203,33EP32MC204,33EP32MC502,33EP32MC503,33EP32MC504",
+		PIC24,-1,1,Read24Ex,{0x5800,0,0,0x0FF0},0x1000,Write24Ex,{0x5800,0,0,0,0,0},2.0},						//11KW 10 Config Word
+	{"24EP64GP202,24EP64GP203,24EP64GP204,24EP64GP206,33EP64GP502,33EP64GP503,33EP64GP504,33EP64GP506,\
+24EP64MC202,24EP64MC203,24EP64MC204,24EP64MC206,33EP64MC202,33EP64MC203,33EP64MC204,33EP64MC206,\
+33EP64MC502,33EP64MC503,33EP64MC504,33EP64MC506",
+		PIC24,-1,1,Read24Ex,{0xB000,0,0,0x0FF0},0x1000,Write24Ex,{0xB000,0,0,0,0,0},2.0},						//22.5KW 10 Config Word
+	{"24EP128GP202,24EP128GP204,24EP128GP206,33EP128GP502,33EP128GP504,33EP128GP506,\
+24EP128MC202,24EP128MC204,24EP128MC206,33EP128MC202,33EP128MC204,33EP128MC206,\
+33EP128MC502,33EP128MC504,33EP128MC506",
+		PIC24,-1,1,Read24Ex,{0x15800,0,0,0x0FF0},0x1000,Write24Ex,{0x15800,0,0,0,0,0},2.0},						//44KW 10 Config Word
+	{"24EP256GP202,24EP256GP204,24EP256GP206,33EP256GP502,33EP256GP504,33EP256GP506,\
+24EP256MC202,24EP256MC204,24EP256MC206,33EP256MC202,33EP256MC204,33EP256MC206,\
+33EP256MC502,33EP256MC504,33EP256MC506",
+		PIC24,-1,1,Read24Ex,{0x2B000,0,0,0x0FF0},0x1000,Write24Ex,{0x2B000,0,0,0,0,0},2.0},						//88KW 10 Config Word
+	{"24EP512GP202,24EP512GP204,24EP512GP206,33EP512GP502,33EP512GP504,33EP512GP506,\
+24EP512MC202,24EP512MC204,24EP512MC206,33EP512MC202,33EP512MC204,33EP512MC206,\
+33EP512MC502,33EP512MC504,33EP512MC506",
+		PIC24,-1,1,Read24Ex,{0x56000,0,0,0x0FF0},0x1000,Write24Ex,{0x56000,0,0,0,0,0},2.0},						//175KW 10 Config Word
+	{"30F1010",
+		PIC24,-1,0,Read24Fx,{0x1000,0,0x63,0x05BE},0x600,Write24Fx,{0x1000,0,0x30263,0x05BE,32},2.0},			//1KW, LV5V
+	{"30F2020,30F2023",
+		PIC24,-1,0,Read24Fx,{0x2000,0,0x63,0x05BE},0x600,Write24Fx,{0x2000,0,0x30263,0x05BE,32},2.0},			//2KW, LV5V
+	{"30F2010",
+		PIC24,12,0,Read24Fx,{0x2000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x2000,0x400,0x31252,0x05BE,32},2.0},	//4KW, 1K, HV12
+	{"30F2011,30F2012",
+		PIC24,12,0,Read24Fx,{0x2000,0,0x52,0x05BE},0x600,Write24Fx,{0x2000,0,0x31252,0x05BE,32},2.0},			//4KW, HV12
+	{"30F3010,30F3011,30F3012,30F3013,30F3014",
+		PIC24,12,0,Read24Fx,{0x4000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x4000,0x400,0x31252,0x05BE,32},2.0},	//8KW, 1K, HV12
+	{"30F4011,30F4012,30F4013",
+		PIC24,12,0,Read24Fx,{0x8000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x8000,0x400,0x31252,0x05BE,32},2.0},	//16KW, 1K, HV12
+	{"30F5011,30F5013,30F5015,30F5016",
+		PIC24,12,0,Read24Fx,{0xB000,0x400,0x52,0x05BE},0x600,Write24Fx,{0xB000,0x400,0x31252,0x05BE,32},2.0},	//22KW, 1K, HV12
+	{"30F6011,30F6013",
+		PIC24,12,0,Read24Fx,{0x16000,0x800,0x52,0x05BE},0x600,Write24Fx,{0x16000,0x800,0x31252,0x05BE,32},2.0},	//44KW, 2K, HV12
+	{"30F6010,30F6012,30F6014,30F6015",
+		PIC24,12,0,Read24Fx,{0x18000,0x1000,0x52,0x05BE},0x600,Write24Fx,{0x18000,0x1000,0x31252,0x05BE,32},2.0},	//49KW, 4K, HV12
+//-------------PIC32---------------------------------------------------------
+// options:
+//	{"32MX270F256",
+//				PIC32,-1,1,Read32x,{0x40000,0},0x800,0,{0,0,0,0,0},0.0},								//256K
+//-------------ATMEL---------------------------------------------------------
+	{"AT90S1200",
+		AVR,-1,0,ReadAT,{0x400,0x40,0},0,WriteAT,{0x400,0x40,0,0},0},									//1K, 64
+	{"ATtiny11",
+		AVR,12,0,ReadAT_HV,{0x400,0,LOCK+FUSE+CAL},0,WriteAT_HV,{0x400,0,0,0},0},						//1K, HV
+	{"ATtiny12",
+		AVR,12,0,ReadAT_HV,{0x400,0x40,LOCK+FUSE+CAL},0,WriteAT_HV,{0x400,0x40,0,0},0},					//1K, 64, HV
+	{"ATtiny13",
+		AVR,12,0,ReadAT_HV,{0x400,0x40,LOCK+FUSE+FUSE_H+CAL},0,WriteAT_HV,{0x400,0x40,16,0},0},			//1K, 64, HV
+	{"AT90S2313",
+		AVR,-1,0,ReadAT,{0x800,0x80,0},0,WriteAT,{0x800,0x80,0,0},0},									//2K, 128
+	{"ATtiny2313",
+		AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x800,0x80,16,0},0},//2K, 128
+	{"ATtiny24,ATtiny25",
+		AVR,12,0,ReadAT_HV,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x800,0x80,16,0},0},	//2K, 128, HV
+	{"ATtiny26",
+		AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x800,0x80,16,0},0},	//2K, 128
+	{"ATtiny261",
+		AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x800,0x80,16,0},0},	//2K, 128
+	{"ATtiny44,ATtiny45",
+		AVR,12,0,ReadAT_HV,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x1000,0x100,32,0},0},	//4K, 256, HV
+	{"ATtiny461,ATtiny4313,ATmega48",
+		AVR,-1,0,ReadAT,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x1000,0x100,32,0},0},	//4K, 256
+	{"ATtiny48",
+		AVR,-1,0,ReadAT,{0x1000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x1000,0x40,32,0},0},		//4K, 64
+	{"ATtiny88",
+		AVR,-1,0,ReadAT,{0x2000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x2000,0x40,32,0},0},		//8K, 64
+	{"AT90S8515,AT90S8535",
+		AVR,-1,0,ReadAT,{0x2000,0x100,0},0,WriteAT,{0x2000,0x100,0,0},0},									//8K, 256
+	{"ATmega8,ATmega8515,ATmega8535",
+		AVR,-1,0,ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x2000,0x200,32,0},0},			//8K, 512
+	{"ATmega88,ATtiny861",
+		AVR,-1,0,ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x2000,0x200,32,0},0},	//8K, 512
+	{"ATtiny84,ATtiny85",
+		AVR,12,0,ReadAT_HV,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x2000,0x200,32,0},0},	//8K, 512, HV
+	{"ATmega16",
+		AVR,-1,0,ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x4000,0x200,64,0},0},			//16K, 512
+	{"ATmega164,ATmega168",
+		AVR,-1,0,ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x4000,0x200,64,0},0},	//16K, 512
+	{"ATmega32",
+		AVR,-1,0,ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x8000,0x400,64,0},0},			//32K, 1K
+	{"ATmega324,ATmega328",
+		AVR,-1,0,ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x8000,0x400,64,0},0},	//32K, 1K
+	{"ATmega64,ATmega644",
+		AVR,-1,0,ReadAT,{0x10000,0x800,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x10000,0x800,128,0},0},	//64K, 2K
+	{"ATmega1284",
+		AVR,-1,0,ReadAT,{0x20000,0x1000,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x20000,0x1000,128,0},0},//128K, 4K
+//-------------I2C---------------------------------------------------------
+	{"2400",
+		I2CEE,-1,0,ReadI2C,{0x10,0},0,WriteI2C,{0x10,0,1},0},					//16, 1B addr.
+	{"2401",
+		I2CEE,-1,0,ReadI2C,{0x80,0},0,WriteI2C,{0x80,0,8},0},					//128, 1B addr.
+	{"2402",
+		I2CEE,-1,0,ReadI2C,{0x100,0},0,WriteI2C,{0x100,0,8},0},					//256, 1B addr.
+	{"2404",
+		I2CEE,-1,0,ReadI2C,{0x200,0},0,WriteI2C,{0x200,0,16},0},				//512, 1B addr.
+	{"2408",
+		I2CEE,-1,0,ReadI2C,{0x400,0},0,WriteI2C,{0x400,0,16},0},				//1K, 1B addr.
+	{"2416",
+		I2CEE,-1,0,ReadI2C,{0x800,0},0,WriteI2C,{0x800,0,16},0},				//2K, 1B addr.
+	{"2432",
+		I2CEE,-1,0,ReadI2C,{0x1000,1},0,WriteI2C,{0x1000,1,32},0},				//4K, 2B addr.
+	{"2464",
+		I2CEE,-1,0,ReadI2C,{0x2000,1},0,WriteI2C,{0x2000,1,32},0},				//8K, 2B addr.
+	{"24128",
+		I2CEE,-1,0,ReadI2C,{0x4000,1},0,WriteI2C,{0x4000,1,64},0},				//16K, 2B addr.
+	{"24256",
+		I2CEE,-1,0,ReadI2C,{0x8000,1},0,WriteI2C,{0x8000,1,64},0},				//32K, 2B addr.
+	{"24512",
+		I2CEE,-1,0,ReadI2C,{0x10000,1},0,WriteI2C,{0x10000,1,128},0},			//64K, 2B addr.
+	{"241024",
+		I2CEE,-1,0,ReadI2C,{0x20000,0x201},0,WriteI2C,{0x20000,0x201,256},0},	//128K, 2B addr.
+	{"241025",
+		I2CEE,-1,0,ReadI2C,{0x20000,0x841},0,WriteI2C,{0x20000,0x841,128},0},	//128K, 2B addr.
+//-------------Microwire EEPROM---------------------------------------------------------
+	{"93S46",
+		UWEE,-1,0,Read93x,{0x80,6,0},0,Write93Sx,{0x80,6,8},0},					//128, 6b addr, 4W page
+	{"93x46",
+		UWEE,-1,0,Read93x,{0x80,6,0},0,Write93Cx,{0x80,6,0},0},			//128, 6b addr
+	{"93x46A",
+		UWEE,-1,0,Read93x,{0x80,7,1},0,Write93Cx,{0x80,7,1},0},			//128, 6b addr x8
+	{"93S56",
+		UWEE,-1,0,Read93x,{0x100,8,0},0,Write93Sx,{0x100,8,8},0},		//256, 8b addr, 4W page
+	{"93x56",
+		UWEE,-1,0,Read93x,{0x100,8,0},0,Write93Cx,{0x100,8,0},0},		//256, 8b addr
+	{"93x56A",
+		UWEE,-1,0,Read93x,{0x100,9,1},0,Write93Cx,{0x100,9,1},0},		//256, 8b addr x8
+	{"93S66",
+		UWEE,-1,0,Read93x,{0x200,8,0},0,Write93Sx,{0x200,8,8},0},		//512, 8b addr, 4W page
+	{"93x66",
+		UWEE,-1,0,Read93x,{0x200,8,0},0,Write93Cx,{0x200,8,0},0},		//512, 8b addr
+	{"93x66A",
+		UWEE,-1,0,Read93x,{0x200,9,1},0,Write93Cx,{0x200,9,1},0},		//512, 8b addr x8
+	{"93x76",
+		UWEE,-1,0,Read93x,{0x400,10,0},0,Write93Cx,{0x400,10,0},0},		//1k, 10b addr
+	{"93x76A",
+		UWEE,-1,0,Read93x,{0x400,11,1},0,Write93Cx,{0x400,11,1},0},		//1k, 10b addr x8
+	{"93x86",
+		UWEE,-1,0,Read93x,{0x800,10,0},0,Write93Cx,{0x800,10,0},0},		//2k, 10b addr
+	{"93x86A",
+		UWEE,-1,0,Read93x,{0x800,11,1},0,Write93Cx,{0x800,11,1},0},		//2k, 10b addr x8
+//-------------SPI---------------------------------------------------------
+	{"25010,95010",
+		SPIEE,-1,0,Read25xx,{0x80},0,Write25xx,{0x80,16},0},			//128
+	{"25020,95020",
+		SPIEE,-1,0,Read25xx,{0x100},0,Write25xx,{0x100,16},0},			//256
+	{"25040,95040",
+		SPIEE,-1,0,Read25xx,{0x200},0,Write25xx,{0x200,16},0},			//512
+	{"25080,95080",
+		SPIEE,-1,0,Read25xx,{0x400},0,Write25xx,{0x400,16},0},			//1K
+	{"25160,95160",
+		SPIEE,-1,0,Read25xx,{0x800},0,Write25xx,{0x800,16},0},			//2K
+	{"25320,95320",
+		SPIEE,-1,0,Read25xx,{0x1000},0,Write25xx,{0x1000,32},0},		//4K
+	{"25640,95640",
+		SPIEE,-1,0,Read25xx,{0x2000},0,Write25xx,{0x2000,32},0},		//8K
+	{"25128,95128",
+		SPIEE,-1,0,Read25xx,{0x4000},0,Write25xx,{0x4000,64},0},		//16K
+	{"25256,95256",
+		SPIEE,-1,0,Read25xx,{0x8000},0,Write25xx,{0x8000,64},0},		//32K
+	{"25512,95512",
+		SPIEE,-1,0,Read25xx,{0x10000},0,Write25xx,{0x10000,128},0},		//64K
+	{"251024,95M01",
+		SPIEE,-1,0,Read25xx,{0x20000},0,Write25xx,{0x20000,256},0},		//128K
+	{"95M02",
+		SPIEE,-1,0,Read25xx,{0x40000},0,Write25xx,{0x40000,256},0},		//256K
+	{"25X05",
+		SPIEE,-1,0,Read25xx,{0x10000},0,Write25xx,{0x10000,0x1000+256},0},	//64K flash 3.3V
+	{"251005,25X10",
+		SPIEE,-1,0,Read25xx,{0x20000},0,Write25xx,{0x20000,0x1000+256},0},	//128K flash 3.3V
+	{"252005,25X20",
+		SPIEE,-1,0,Read25xx,{0x40000},0,Write25xx,{0x40000,0x1000+256},0},	//256K flash 3.3V
+	{"254005,25X40",
+		SPIEE,-1,0,Read25xx,{0x80000},0,Write25xx,{0x80000,0x1000+256},0},	//512K flash 3.3V
+	{"25Q40",
+		SPIEE,-1,0,Read25xx,{0x80000},0,Write25xx,{0x80000,0x3000+256},0},	//512K flash 3.3V STATUS2
+	{"258005,25X80",
+		SPIEE,-1,0,Read25xx,{0x100000},0,Write25xx,{0x100000,0x1000+256},0},//1M flash 3.3V
+	{"251605,25X16",
+		SPIEE,-1,0,Read25xx,{0x200000},0,Write25xx,{0x200000,0x1000+256},0},//2M flash 3.3V
+	{"25X32",
+		SPIEE,-1,0,Read25xx,{0x400000},0,Write25xx,{0x400000,0x1000+256},0},//4M flash 3.3V
+	{"25X64",
+		SPIEE,-1,0,Read25xx,{0x800000},0,Write25xx,{0x800000,0x1000+256},0},//8M flash 3.3V
+	{"25X128",
+		SPIEE,-1,0,Read25xx,{0x1000000},0,Write25xx,{0x1000000,0x1000+256},0},//16M flash 3.3V
+//-------------One wire devices---------------------------------------------------------
+	{"DS2430",
+		OWEE,-1,0,ReadOneWireMem,{0x20,1},0,WriteOneWireMem,{0x20,1},0},		//32
+	{"DS2431",
+		OWEE,-1,0,ReadOneWireMem,{0x80,2},0,WriteOneWireMem,{0x80,0},0},		//128
+	{"DS2433",
+		OWEE,-1,0,ReadOneWireMem,{0x200,0},0,WriteOneWireMem,{0x200,1},0},		//512
+	{"DS28EC20",
+		OWEE,-1,0,ReadOneWireMem,{0xA00,2},0,WriteOneWireMem,{0xA00,1},0},		//2560
+	{"DS1820",
+		OWEE,-1,0,ReadDS1820,{-10},0,0,{0},0},		//digital thermometer
+//-------------UNIO devices---------------------------------------------------------
+	{"11010",
+		UNIOEE,-1,0,Read11xx,{0x80},0,Write11xx,{0x80,16},0},		//128
+	{"11020",
+		UNIOEE,-1,0,Read11xx,{0x100},0,Write11xx,{0x100,16},0},		//256
+	{"11040",
+		UNIOEE,-1,0,Read11xx,{0x200},0,Write11xx,{0x200,16},0},		//512
+	{"11080",
+		UNIOEE,-1,0,Read11xx,{0x400},0,Write11xx,{0x400,16},0},		//1k
+	{"11160",
+		UNIOEE,-1,0,Read11xx,{0x800},0,Write11xx,{0x800,16},0}		//2k
+};
+
+int NDEVLIST = (sizeof(DEVLIST)/sizeof(struct DEVICES));
+
+//Add all devices to the appropriate structure
+#ifndef _GTKGUI
+void AddDevices(char *list){		//make sure list is long enough
+	int i;
+	static char last[8]="";
+	for(i=0;i<sizeof(devices)/sizeof(char*);i++){
+		if(last[0]) strcat(list,", ");
+		if(strncmp(devices[i],last,2)){
+			strcat(list,"\n");
+			last[0]=devices[i][0];
+			last[1]=devices[i][1];
+			last[2]=0;
+		}
+		strcat(list,devices[i]);
+	}
+}
+#endif
+
+//Make a list of all supported devices (insert \n between types)
+char* ListDevices(){
+	int i,len=0,l;
+	static char last[8]="";
+	char* list=0;
+	for(i=0;i<Ndevices;i++){
+		l=strlen(devices[i]);
+		if(!last[0]){
+			list=realloc(list,len+l+1);
+			strcpy(list+len,devices[i]);
+			len+=l;
+		}
+		else{
+			list=realloc(list,len+l+3);
+			if(strncmp(devices[i],last,2)) strcpy(list+len,",\n");
+			else strcpy(list+len,", ");
+			strcpy(list+len+2,devices[i]);
+			len+=l+2;
+		}
+		last[0]=devices[i][0];
+		last[1]=devices[i][1];
+		last[2]=0;
+	}
+	return list;
+}
+
+#ifdef DEBUG
+//Check that all devices in the list have a read/write function
+void CheckDevices(){
+	int i;
+	for(i=0;i<Ndevices;i++){
+		if(GetDevType(devices[i])<0){
+			printf("Can't find %s\n",devices[i]);fflush(stdout);
+		}
+	}
+	printf("OK %d devices\n",Ndevices);fflush(stdout);
+}
+#endif
+
+
+void Read(char* dev,int ee,int r)
+{
+	int i,j;
+	int params[5];
+	char *str=0,*tok;
+#ifdef DEBUG
+	CheckDevices();
+#endif
+	//parse all device names until "dev" is found,
+	//then execute the read function with the right number of parameters
+	for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+		if(str) free(str);
+		str=malloc(strlen(DEVLIST[i].device)+1);
+		strcpy(str,DEVLIST[i].device);
+		for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){		//compare every device name
+			if(!strcmp(dev,tok)){	//proceed if found
+				for(j=0;j<4;j++) params[j]=DEVLIST[i].ReadParam[j];
+				if(DEVLIST[i].V33>0){	//3.3V required
+					if(!CheckV33Regulator()){
+						PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+						return;
+					}
+				}
+				if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
+				if(DEVLIST[i].ReadPtr==0){
+					PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+					return;
+				}
+				switch(DEVLIST[i].family){		//call read function with the right number of arguments (better ways to do it???)
+					case PIC12:
+						if(r) params[1]=DEVLIST[i].ResArea;	//modify reserved area parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1]);
+					break;
+					case PIC16:
+						if(r) params[2]=DEVLIST[i].ResArea;	//modify reserved area parameter
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1],params[2],params[3]);
+					break;
+					case PIC18:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
+					break;
+					case PIC24:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1],params[2],params[3],r?DEVLIST[i].ResArea:0);
+					break;
+					case PIC32:
+//						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1]);
+					break;
+					case AVR:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
+					break;
+					case I2CEE:
+						(*DEVLIST[i].ReadPtr)(params[0],params[1]);
+					break;
+					case UWEE:
+						(*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
+					break;
+					case SPIEE:
+						(*DEVLIST[i].ReadPtr)(params[0]);
+					break;
+					case OWEE:
+						if(params[0]==-10) (*DEVLIST[i].ReadPtr)();
+						else (*DEVLIST[i].ReadPtr)(params[0],params[1]);
+					break;
+					case UNIOEE:
+						(*DEVLIST[i].ReadPtr)(params[0]);
+					break;
+					default:
+						PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+				}
+				return;
+			}
+		}
+	}
+	PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+}
+
+
+void Write(char* dev,int ee)
+{
+	int i,j;
+	int params[6];
+	char *str=0,*tok;
+	//parse all device names until "dev" is found,
+	//then execute the write function with the right number of parameters
+	for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+		if(str) free(str);
+		str=malloc(strlen(DEVLIST[i].device)+1);
+		strcpy(str,DEVLIST[i].device);
+		for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){		//compare every device name
+			if(!strcmp(dev,tok)){		//proceed if found
+				for(j=0;j<6;j++) params[j]=DEVLIST[i].WriteParam[j];
+				if(DEVLIST[i].V33>0){	//3.3V required
+					if(!CheckV33Regulator()){
+						PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+						return;
+					}
+				}
+				if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
+				if(DEVLIST[i].WritePtr==0){
+					PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+					return;
+				}
+				switch(DEVLIST[i].family){		//call write function with the right number of arguments (better ways to do it???)
+					case PIC12:
+						(*DEVLIST[i].WritePtr)(params[0],params[1]);
+					break;
+					case PIC16:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						if(params[2]==-10) (*DEVLIST[i].WritePtr)(params[0],params[1]);
+						else (*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
+					break;
+					case PIC18:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3],params[4],params[5]);
+					break;
+					case PIC24:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3],params[4],DEVLIST[i].WriteParamD);
+					break;
+					case AVR:
+						if(!ee) params[1]=0;					//clear eeprom parameter
+						(*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3]);
+					break;
+					case I2CEE:
+						(*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
+					break;
+					case UWEE:
+						(*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
+					break;
+					case SPIEE:
+						(*DEVLIST[i].WritePtr)(params[0],params[1]);
+					break;
+					case OWEE:
+						(*DEVLIST[i].WritePtr)(params[0],params[1]);
+					break;
+					case UNIOEE:
+						(*DEVLIST[i].WritePtr)(params[0],params[1]);
+					break;
+					default:
+						PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+				}
+				return;
+			}
+		}
+	}
+	PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+}
+
+///Search the device type
+int GetDevType(const char* dev)
+{
+	int i,type=-1;
+	char *str=0,*tok;
+	//parse all device names until "dev" is found
+	for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+		if(str) free(str);
+		str=malloc(strlen(DEVLIST[i].device)+1);
+		strcpy(str,DEVLIST[i].device);
+		for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){		//compare every device name
+			if(!strcmp(dev,tok)){	//proceed if found
+				type=DEVLIST[i].family;
+				tok=0;
+				i=sizeof(DEVLIST)/sizeof(DEVLIST[0]);
+			}
+		}
+	}
+	free(str);
+	return type;
+}
+
+/// Determine the group of a specific device
+enum group_t nameToGroup(const char *devName) {
+	if(!strncmp(devName,"10F",3)||!strncmp(devName,"12F",3)||!strncmp(devName,"12C",3))
+		return G_PIC_10_12;
+	if(!strncmp(devName,"16F",3)||!strncmp(devName,"16LF",4)||!strncmp(devName,"16C",3))
+		return G_PIC_16;
+	if(!strncmp(devName,"18F",3))
+		return G_PIC_18;
+	if(!strncmp(devName,"24F",3)||!strncmp(devName,"24H",3)||!strncmp(devName,"24E",3))
+		return G_PIC_24;
+	if(!strncmp(devName,"30F",3)||!strncmp(devName,"33F",3)||!strncmp(devName,"33E",3))
+		return G_PIC_30_33;
+	if(!strncmp(devName,"AT",2))
+		return G_ATMEL;
+	if(!strncmp(devName,"24",2)||!strncmp(devName,"25",2)||!strncmp(devName,"93",2)|| \
+		!strncmp(devName,"95",2)||!strncmp(devName,"11",2)||!strncmp(devName,"DS",2))
+		return G_EEPROM;
+	PrintMessage1("can't determine group of device '%s'\n",devName);
+	return -1;
+}
+
+/// Copies the device info from the passed devlist entry into the passed DevInfo
+/// Does NOT populate fields 'device' and 'group' as these are device-specific
+void populateDevInfo(struct DevInfo *info, const struct DEVICES *devlistEntry) {
+	char str2[256],str3[64],strF[32];
+	info->family=devlistEntry->family;
+	info->HV=devlistEntry->HV;
+	info->V33=devlistEntry->V33;
+	info->size=devlistEntry->ReadParam[0];
+	info->sizeEE=devlistEntry->ReadParam[1];
+	str2[0]=0;
+	double x=info->size/1024.0;
+	if(x-(int)x) sprintf(strF,"%.1f",x);
+	else sprintf(strF,"%d",(int)x);
+	switch(info->family){
+	case -1:
+		sprintf(str2,"?? ");
+		break;
+	case PIC12:
+		sprintf(str2,"PIC12, ");
+		if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+		else sprintf(str3,"%sKW FLASH",strF);
+		strcat(str2,str3);
+		break;
+	case PIC16:
+		sprintf(str2,"PIC16, ");
+		if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+		else sprintf(str3,"%sKW FLASH",strF);
+		strcat(str2,str3);
+		if(info->sizeEE){
+			int ee=info->sizeEE;
+			if(ee<0) ee=-ee;
+			sprintf(str3," + %dB EEPROM",ee);
+			strcat(str2,str3);
+		}
+		break;
+	case PIC18:
+		sprintf(str2,"PIC18, ");
+		if(info->size<1024) sprintf(str3,"%dB FLASH ",info->size);
+		else sprintf(str3,"%sKB FLASH ",strF);
+		strcat(str2,str3);
+		if(info->sizeEE){
+			sprintf(str3,"+ %dB EEPROM ",info->sizeEE);
+			strcat(str2,str3);
+		}
+		break;
+	case PIC24:
+		sprintf(str2,"PIC24, ");
+		if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+		else sprintf(str3,"%sKW FLASH",strF);
+		strcat(str2,str3);
+		if(info->sizeEE){
+			sprintf(str3," + %dB EEPROM",info->sizeEE);
+			strcat(str2,str3);
+		}
+		break;
+	case PIC32:
+		sprintf(str2,"PIC32, ");
+		if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+		else sprintf(str3,"%sKW FLASH",strF);
+		strcat(str2,str3);
+		if(info->sizeEE){
+			sprintf(str3," + %dB EEPROM",info->sizeEE);
+			strcat(str2,str3);
+		}
+		break;
+	case AVR:
+		sprintf(str2,"AVR, ");
+		if(info->size<1024) sprintf(str3,"%dB FLASH",info->size);
+		else sprintf(str3,"%sKB FLASH",strF);
+		strcat(str2,str3);
+		if(info->sizeEE){
+			sprintf(str3," + %dB EEPROM",info->sizeEE);
+			strcat(str2,str3);
+		}
+		break;
+	case I2CEE:
+		if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_I2CMEM],info->size); //I2C Memory
+		else sprintf(str2,"%s, %sKB",strings[I_I2CMEM],strF); //I2C Memory
+		break;
+	case SPIEE:
+		if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_SPIMEM],info->size); //SPI Memory
+		else sprintf(str2,"%s, %sKB",strings[I_SPIMEM],strF); //SPI Memory
+		break;
+	case UWEE:
+		if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UWMEM],info->size); //Microwire Memory
+		else sprintf(str2,"%s,%sKB",strings[I_UWMEM],strF);
+		break;
+	case OWEE:
+		if(info->size<0) sprintf(str2,strings[I_OWDEV]); //OneWire device
+		else if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_OWMEM],info->size); //OneWire Memory
+		else sprintf(str2,"%s, %sKB",strings[I_OWMEM],strF);
+		break;
+	case UNIOEE:
+		if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UNIOMEM],info->size); //UNI/O Memory
+		else sprintf(str2,"%s, %sKB",strings[I_UNIOMEM],strF);
+		break;
+	}
+	if(info->HV>0){
+		sprintf(str3,", %.1fV",info->HV);
+		strcat(str2,str3);
+	}
+	if(info->V33){
+		strcat(str2,", ");
+		strcat(str2,strings[I_3V3REQUIRED]); // 3.3V adapter
+	}
+	info->features=malloc(strlen(str2)+1);
+	strcpy(info->features,str2);
+}
+
+
+///Search and return device info
+struct DevInfo GetDevInfo(const char* dev)
+{
+	int i;
+	char *str=0,*tok;
+	struct DevInfo info;
+	info.device=0;
+	info.family=-1;
+	info.HV=-1;
+	info.V33=-1;
+	info.size=-1;
+	info.sizeEE=-1;
+	info.features=0;
+	//parse all device names until "dev" is found
+	for(i=0;i<NDEVLIST;i++){
+		str=malloc(strlen(DEVLIST[i].device)+1);
+		strcpy(str,DEVLIST[i].device);
+		for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){		//compare every device name
+			if(!strcmp(dev,tok)){	//proceed if found
+				info.device=malloc(strlen(tok)+1);
+				strcpy(info.device,tok);
+				info.group=nameToGroup(info.device);
+				populateDevInfo(&info, &(DEVLIST[i]));
+				free(str);
+				return info;
+			}
+		}
+		free(str);
+	}
+	return info;
+}
diff --git a/deviceRW.h b/deviceRW.h
new file mode 100644
index 0000000..9efdd7b
--- /dev/null
+++ b/deviceRW.h
@@ -0,0 +1,52 @@
+extern char* devices[];
+extern int Ndevices;
+enum family_t {PIC12=0,PIC16,PIC18,PIC24,PIC32,AVR,I2CEE,SPIEE,UWEE,OWEE,UNIOEE,NUM_FAMILIES};
+enum group_t {G_PIC_10_12=0,G_PIC_16,G_PIC_18,G_PIC_24,G_PIC_30_33,G_ATMEL,G_EEPROM,NUM_GROUPS};
+
+
+// This struct stores information about how to program a set of devices
+struct DEVICES {
+	char *device;				//comma-separated list of device names which share the same method of programming
+	enum family_t family;		//architecture type
+	double HV;					//High voltage value (-1= turn off HV)
+	int V33;					//3.3V regulator required (0=not required)
+	void (*ReadPtr)();			//Read function pointer
+	int ReadParam[4];			//Read function parameters; -10 = NU
+	int ResArea;				//reserved area size
+	void (*WritePtr)();			//Write function pointer
+	int WriteParam[6];			//Write function parameters; -10 = NU
+	double WriteParamD;			//Write function parameter, double
+};
+
+// This struct stores information about a specific device
+struct DevInfo{
+	char *device;				//device name
+	enum group_t group;			//device group (used for selection in GUI only) - see nameToGroup()
+	enum family_t family;		//architecture type
+//	int type;					//type
+	double HV;					//High voltage value (-1= turn off HV)
+	int V33;					//3.3V regulator required (0=not required)
+	int size;					//memory size
+	int sizeEE;					//EE memory size
+	char *features;				//device features string
+};
+
+extern int NDEVLIST;
+extern struct DEVICES DEVLIST[];
+
+/// Determine the group of a specific device
+enum group_t nameToGroup(const char *devName);
+
+/// Copies the device info from the passed devlist entry into the passed DevInfo
+/// Does NOT populate fields 'device' and 'group' as these are device-specific
+void populateDevInfo(struct DevInfo *info, const struct DEVICES *devlistEntry);
+
+///Search and return device info. Uses strtok (so don't call inside a strtok loop)
+struct DevInfo GetDevInfo(const char* dev);
+
+void AddDevices();
+char* ListDevices();
+int GetDevType(const char* device);
+struct DevInfo GetDevInfo(const char* dev);
+void Write(char* dev,int ee);
+void Read(char* dev,int ee,int r);
diff --git a/fileIO.c b/fileIO.c
new file mode 100644
index 0000000..30da4b0
--- /dev/null
+++ b/fileIO.c
@@ -0,0 +1,835 @@
+/*
+ * fileIO.c - file read and write
+ * Copyright (C) 2010-2021 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+//configure for GUI or command-line
+#include "common.h"
+#include "progP12.h"
+#include "progP16.h"
+#include "progP18.h"
+#include "progP24.h"
+#include "progAVR.h"
+
+unsigned int htoi(const char *hex, int length)
+{
+	int i;
+	unsigned int v = 0;
+	for (i = 0; i < length; i++) {
+		v <<= 4;
+		if (hex[i] >= '0' && hex[i] <= '9') v += hex[i] - '0';
+		else if (hex[i] >= 'a' && hex[i] <= 'f') v += hex[i] - 'a' + 10;
+		else if (hex[i] >= 'A' && hex[i] <= 'F') v += hex[i] - 'A' + 10;
+		else PrintMessage1(strings[S_Inohex],hex);	//"Error: '%.4s' doesn't look very hexadecimal, right?\n"
+	}
+	return v;
+}
+
+void Save(char* dev,char* savefile)
+{
+	FILE* f=fopen(savefile,"w");
+	if(!f) return;
+	char str[512],str1[512]="";
+	int i,sum=0,count=0,ext=0,s,base;
+//**************** 10-16F *******************************************
+	if(!strncmp(dev,"10",2)||!strncmp(dev,"12",2)||!strncmp(dev,"16",2)){
+		int x=0x3fff,addr;
+		//if(!strncmp(dev,"16",2)||!strncmp(dev,"12F6",4)) x=0x3fff;
+		fprintf(f,":020000040000FA\n");			//extended address=0
+		for(i=0;i<sizeW;i++) memCODE_W[i]&=x;
+		for(i=0;i<sizeW&&memCODE_W[i]>=x;i++); //remove leading 0xFFF
+		for(;i<sizeW;i++){
+			sum+=(memCODE_W[i]>>8)+(memCODE_W[i]&0xff);
+			sprintf(str,"%02X%02X",memCODE_W[i]&0xff,memCODE_W[i]>>8);
+			strcat(str1,str);
+			count++;
+			if(count==8||i==sizeW-1){
+				base=i-count+1;
+				for(s=i;s>=base&&memCODE_W[s]>=x;s--){	//remove trailing 0xFFF
+					sum-=(memCODE_W[s]>>8)+(memCODE_W[s]&0xff);
+					str1[strlen(str1)-4]=0;
+				}
+				count-=i-s;
+				addr=(s-count+1)*2;
+				sum+=count*2+(addr&0xff)+(addr>>8);
+				if(base>>15>ext){
+					ext=base>>15;
+					fprintf(f,":02000004%04X%02X\n",ext,(-6-ext)&0xff);
+				}
+				if(count) fprintf(f,":%02X%04X00%s%02X\n",count*2,addr&0xFFFF,str1,(-sum)&0xff);
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		if(sizeEE){		//this is only for 16F1xxx
+			if(ext!=0x01) fprintf(f,":020000040001F9\n");
+			for(i=0,count=sum=0;i<sizeEE;i++){
+				sum+=memEE[i];
+				sprintf(str,"%02X00",memEE[i]&0xff);
+				strcat(str1,str);
+				count++;
+				if(count==8||i==sizeEE-1){
+					for(s=i;s>i-count&&memEE[s]>=0xff;s--){	//remove trailing 0xFF
+						sum-=memEE[s]&0xff;
+						str1[strlen(str1)-4]=0;
+					}
+					count-=i-s;
+					addr=(s-count+1)*2+0xE000;
+					sum+=count*2+(addr&0xff)+(addr>>8);
+					if(count){
+						fprintf(f,":%02X%04X00%s%02X\n",count*2,addr,str1,(-sum)&0xff);
+					}
+					str1[0]=0;
+					count=sum=0;
+				}
+			}
+		}
+		fprintf(f,":00000001FF\n");
+	}
+//**************** 18F *******************************************
+	else if(!strncmp(dev,"18F",3)){
+		fprintf(f,":020000040000FA\n");			//extended address=0
+		for(i=0;i<size&&memCODE[i]==0xff;i++); //remove leading 0xFF
+		for(;i<size;i++){
+			sum+=memCODE[i];
+			sprintf(str,"%02X",memCODE[i]);
+			strcat(str1,str);
+			count++;
+			if(count==16||i==size-1){
+				base=i-count+1;
+				for(s=i;s>=base&&memCODE[s]==0xff;s--){	//remove trailing 0xFF
+					sum-=memCODE[s];
+					str1[strlen(str1)-2]=0;
+				}
+				count-=i-s;
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(base>>16>ext){
+					ext=base>>16;
+					fprintf(f,":02000004%04X%02X\n",ext,(-6-ext)&0xff);
+				}
+				if(count){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		for(i=0,count=sum=0;i<8;i++){
+			sum+=memID[i];
+			sprintf(str,"%02X",memID[i]&0xff);
+			strcat(str1,str);
+			count++;
+			if(count==8){
+				fprintf(f,":020000040020DA\n");
+					base=i-count+1;
+				for(s=i;s>i-count&&memID[s]>=0xff;s--){	//remove trailing 0xFF
+					sum-=memID[s]&0xff;
+					str1[strlen(str1)-2]=0;
+				}
+				count-=i-s;
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(count){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		for(i=0,count=sum=0;i<14;i++){
+			sum+=memCONFIG[i];
+			sprintf(str,"%02X",memCONFIG[i]&0xff);
+			strcat(str1,str);
+			count++;
+			if(count==14){
+				fprintf(f,":020000040030CA\n");
+				base=i-count+1;
+				for(s=i;s>i-count&&memCONFIG[s]>=0xff;s--){	//remove trailing 0xFF
+					sum-=memCONFIG[s]&0xff;
+					str1[strlen(str1)-2]=0;
+				}
+				count-=i-s;
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(count){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		if(sizeEE){
+			fprintf(f,":0200000400F00A\n");
+			for(i=0,count=sum=0;i<sizeEE;i++){
+				sum+=memEE[i];
+				sprintf(str,"%02X",memEE[i]&0xff);
+				strcat(str1,str);
+				count++;
+				if(count==16||i==sizeEE-1){
+					base=i-count+1;
+					for(s=i;s>i-count&&memEE[s]>=0xff;s--){	//remove trailing 0xFF
+						sum-=memEE[s]&0xff;
+						str1[strlen(str1)-2]=0;
+					}
+					count-=i-s;
+					sum+=count+(base&0xff)+((base>>8)&0xff);
+					if(count){
+						fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+					}
+					str1[0]=0;
+					count=sum=0;
+				}
+			}
+		}
+		fprintf(f,":00000001FF\n");
+	}
+//**************** 24F *******************************************
+	else if((!strncmp(dev,"24F",3)||!strncmp(dev,"24H",3)||!strncmp(dev,"24E",3)||!strncmp(dev,"30F",3)||!strncmp(dev,"33F",3)||!strncmp(dev,"33E",3))){
+		int valid;
+		fprintf(f,":020000040000FA\n");			//extended address=0
+		int sum=0,count=0,s,word;
+		word=memCODE[0]+(memCODE[1]<<8)+(memCODE[2]<<16)+(memCODE[3]<<24);
+		for(i=0;i<size&&word==0xffffffff;i+=4) //remove leading 0xFFFFFFFF
+			word=memCODE[i]+(memCODE[i+1]<<8)+(memCODE[i+2]<<16)+(memCODE[i+3]<<24);
+		for(;i<size;i++){
+			sum+=memCODE[i];
+			sprintf(str,"%02X",memCODE[i]);
+			strcat(str1,str);
+			count++;
+			if(count==16||i==size-1){
+				base=i-count+1;
+				for(s=base,valid=0;s<=i&&!valid;s+=4){	//remove empty lines
+					if(memCODE[s]<0xFF||memCODE[s+1]<0xFF||+memCODE[s+2]<0xFF) valid=1;
+				}
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(base>>16>ext){
+					ext=base>>16;
+					fprintf(f,":02000004%04X%02X\n",ext,(-6-ext)&0xff);
+				}
+				if(count&&valid){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		if(sizeCONFIG){
+			fprintf(f,":0200000401F009\n");
+			for(i=0,count=sum=0;i<sizeCONFIG&&i<48;i++){
+				sum+=memCONFIG[i];
+				sprintf(str,"%02X",memCONFIG[i]);
+				strcat(str1,str);
+				count++;
+				if(count==4||i==sizeCONFIG-1){
+					base=i-count+1;
+					sum+=count+(base&0xff)+((base>>8)&0xff);
+					if(count){
+						fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+					}
+					str1[0]=0;
+					count=sum=0;
+				}
+			}
+		}
+		if(sizeEE){
+			fprintf(f,":0200000400FFFB\n");
+			str1[0]=0;
+			for(i=0,count=sum=0;i<sizeEE;i+=2){		//append 0000 every 2 bytes
+				sum+=memEE[i]+memEE[i+1];
+				sprintf(str,"%02X%02X0000",memEE[i]&0xff,memEE[i+1]&0xff);
+				strcat(str1,str);
+				count+=4;
+				if(count==16||i==sizeEE-2){
+					base=2*i-count+4;
+					for(s=base/2,valid=0;s<=i&&!valid;s+=2){	//remove empty lines
+						if(memEE[s]<0xFF||memEE[s+1]<0xFF) valid=1;
+					}
+					sum+=0xE0+count+(base&0xff)+(base>>8);
+					if(count&&valid){
+						fprintf(f,":%02X%04X00%s%02X\n",count,base+0xE000,str1,(-sum)&0xff);
+					}
+					str1[0]=0;
+					count=sum=0;
+				}
+			}
+		}
+		fprintf(f,":00000001FF\n");
+	}
+//**************** ATxxxx *******************************************
+	else if(!strncmp(dev,"AT",2)){
+		fprintf(f,":020000040000FA\n");			//extended address=0
+		for(i=0;i<size&&memCODE[i]==0xff;i++); //remove leading 0xFF
+		for(;i<size;i++){
+			sum+=memCODE[i];
+			sprintf(str,"%02X",memCODE[i]);
+			strcat(str1,str);
+			count++;
+			if(count==16||i==size-1){
+				base=i-count+1;
+				for(s=i;s>=base&&memCODE[s]==0xff;s--){	//remove trailing 0xFF
+					sum-=memCODE[s];
+					str1[strlen(str1)-2]=0;
+				}
+				count-=i-s;
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(base>>16>ext){
+					ext=base>>16;
+					fprintf(f,":02000004%04X%02X\n",ext,(-6-ext)&0xff);
+				}
+				if(count){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		fprintf(f,":00000001FF\n");
+	}
+//**************** 24xxx / 93xxx / 25xxx / 95xxx / DSxxxx *******************************************
+	else if(!strncmp(dev,"24",2)||!strncmp(dev,"93",2)||!strncmp(dev,"25",2)||!strncmp(dev,"95",2)||\
+		!strncmp(dev,"DS",2)||!strncmp(dev,"11",2)){
+		if(strstr(savefile,".bin")||strstr(savefile,".BIN")){
+			#ifdef _WIN32
+			//brain-damaged op. systems need this to avoid messing with some bytes
+			f=freopen(savefile,"wb",f);
+			if(!f) return;
+			#endif
+			fwrite(memEE,1,sizeEE,f);
+		}
+		else{			//HEX
+			int valid;
+			fprintf(f,":020000040000FA\n");			//extended address=0
+			for(i=0;i<sizeEE;i++){
+				sum+=memEE[i];
+				sprintf(str,"%02X",memEE[i]);
+				strcat(str1,str);
+				count++;
+				if(count==16||i==sizeEE-1){
+					for(s=valid=0;str1[s]&&!valid;s++) if(str1[s]!='F') valid=1;
+					if(valid){
+						base=i-count+1;
+						sum+=count+(base&0xff)+((base>>8)&0xff);
+						if(base>>16>ext){
+							ext=base>>16;
+							fprintf(f,":02000004%04X%02X\n",ext,(-6-ext)&0xff);
+						}
+						if(count){
+							fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+						}
+					}
+					str1[0]=0;
+					count=sum=0;
+				}
+			}
+			fprintf(f,":00000001FF\n");
+		}
+	}
+	if(f) fclose(f);
+}
+
+void SaveEE(char* dev,char* savefile){
+	FILE* f=fopen(savefile,"w");
+	if(!f) return;
+//**************** ATMEL *******************************************
+	if(!strncmp(dev,"AT",2)){
+		char str[512],str1[512]="";
+		int i,base;
+		fprintf(f,":020000040000FA\n");			//extended address=0
+		int sum=0,count=0,s;
+		for(i=0,count=sum=0;i<sizeEE;i++){
+			sum+=memEE[i];
+			sprintf(str,"%02X",memEE[i]&0xff);
+			strcat(str1,str);
+			count++;
+			if(count==16||i==sizeEE-1){
+				base=i-count+1;
+				for(s=i;s>i-count&&memEE[s]>=0xff;s--){	//remove trailing 0xFF
+					sum-=memEE[s]&0xff;
+					str1[strlen(str1)-2]=0;
+				}
+				count-=i-s;
+				sum+=count+(base&0xff)+((base>>8)&0xff);
+				if(count){
+					fprintf(f,":%02X%04X00%s%02X\n",count,base&0xFFFF,str1,(-sum)&0xff);
+				}
+				str1[0]=0;
+				count=sum=0;
+			}
+		}
+		fprintf(f,":00000001FF\n");
+	}
+	if(f) fclose(f);
+}
+
+int Load(char*dev,char*loadfile){
+	int i,input_address=0,ext_addr=0,sum,valid;
+	char line[256];
+	FILE* f=fopen(loadfile,"r");
+	if(!f) return -1;
+	PrintMessage1("%s :\r\n",loadfile);
+//**************** 10-16F *******************************************
+	if(!strncmp(dev,"10",2)||!strncmp(dev,"12",2)||!strncmp(dev,"16",2)){
+		unsigned char buffer[0x20000],bufferEE[0x1000];
+		int sizeM=0;
+		memset(buffer,0xFF,sizeof(buffer));
+		memset(bufferEE,0xFF,sizeof(bufferEE));
+		sizeEE=0;
+		for(;fgets(line,256,f);){
+			if(strlen(line)>9&&line[0]==':'){
+				int hex_count = htoi(line+1, 2);
+					if((int)strlen(line)-11<hex_count*2) {
+						PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+				}
+				else{
+					input_address=(ext_addr<<16)+htoi(line+3,4);
+					sum=0;
+					for (i=1;i<=hex_count*2+9;i+=2) sum += htoi(line+i,2);
+					if ((sum & 0xff)!=0) {
+							PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+					}
+					else{
+						switch(htoi(line+7,2)){
+							case 0:		//Data record
+								if(input_address<0x1E000){		//Code
+									sizeM=input_address+hex_count;
+									if(sizeM>sizeW) sizeW=sizeM;
+									for (i=0;i<hex_count;i++){
+										buffer[input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if(input_address>=0x1E000&&input_address<0x1F000){	//EEPROM
+									sizeM=(input_address-0x1E000+hex_count)/2;
+									if(sizeM>sizeEE) sizeEE=sizeM;
+									for (i=0;i<hex_count;i+=2){
+										bufferEE[(input_address-0x1E000)/2+i/2]=htoi(line+9+i*2,2);
+									}
+								}
+								break;
+							case 4:		//extended linear address record
+								if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+								break;
+							default:
+								break;
+						}
+					}
+				}
+			}
+		}
+		sizeW/=2;
+		if(memCODE_W) free(memCODE_W);
+		memCODE_W=(WORD*)malloc(sizeof(WORD)*sizeW);
+		for(i=0;i<sizeW;i++){		//Swap bytes
+			memCODE_W[i]=(buffer[i*2+1]<<8)+buffer[i*2];
+		}
+		if(memEE) free(memEE);
+		if(sizeEE){
+			memEE=(unsigned char*)malloc(sizeEE);
+			memcpy(memEE,bufferEE,sizeEE);
+		}
+		else memEE=0;
+		PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+		int imax=sizeW>0x8000?0x8500:0x2100;
+		DisplayCODE16F(imax);
+		if(sizeW>=0x2100&&sizeW<0x3000){	//EEPROM@0x2100
+			PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+			DisplayEE16F(0x700);
+		}
+		else if(sizeEE) DisplayEE();
+		PrintMessage("\r\n");
+	}
+//**************** 18F *******************************************
+	else if(!strncmp(dev,"18F",3)){
+		unsigned char buffer[0x30000],bufferEE[0x1000];
+		int sizeM;
+		memset(buffer,0xFF,sizeof(buffer));
+		memset(bufferEE,0xFF,sizeof(bufferEE));
+		memset(memID,0xFF,sizeof(memID));
+		memset(memCONFIG,0xFF,sizeof(memCONFIG));
+		for(;fgets(line,256,f);){
+			if(strlen(line)>9&&line[0]==':'){
+				int hex_count = htoi(line+1, 2);
+				if((int)strlen(line) - 11 < hex_count * 2) {
+					PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+				}
+				else{
+					input_address=htoi(line+3,4);
+					sum=0;
+					for (i=1;i<=hex_count*2+9;i+=2)
+						sum += htoi(line+i,2);
+					if ((sum & 0xff)!=0) {
+						PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+					}
+					else{
+						switch(htoi(line+7,2)){
+							case 0:		//Data record
+								if(ext_addr<0x20){		//Code	<0x200000
+									sizeM=(ext_addr<<16)+input_address+hex_count;
+									if(sizeM>size) size=sizeM;
+									for (i=0;i<hex_count;i++){
+										buffer[(ext_addr<<16)+input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if(ext_addr==0x20&&input_address<64){	//ID: 0x200000
+									for (i=0;i<hex_count;i++){
+										memID[input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if(ext_addr==0x30&&input_address<14){	//CONFIG: 0x300000
+									for (i=0;i<hex_count;i++){
+										memCONFIG[input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if((ext_addr==0xF0||ext_addr==0x31||ext_addr==0x38)&&input_address<0x1000){	
+								//EEPROM: 0xF00000, 0x310000, 0x380000
+									for (i=0;i<hex_count;i++){
+										bufferEE[input_address+i]=htoi(line+9+i*2,2);
+									}
+									sizeM=input_address+hex_count;
+									if(sizeM>sizeEE) sizeEE=sizeM;
+
+								}
+								break;
+							case 4:		//extended linear address record
+								if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+								break;
+							default:
+								break;
+						}
+					}
+				}
+			}
+		}
+		if(memCODE) free(memCODE);
+		memCODE=(unsigned char*)malloc(size);
+		memcpy(memCODE,buffer,size);
+		if(memEE) free(memEE);
+		memEE=(unsigned char*)malloc(sizeEE);
+		memcpy(memEE,bufferEE,sizeEE);
+		PrintMessage(strings[S_IDMem]);	//"ID memory:\r\n"
+		for(i=0;i<8;i+=2)	PrintMessage4("ID%d: 0x%02X   ID%d: 0x%02X\r\n",i,memID[i],i+1,memID[i+1]);
+		PrintMessage(strings[S_ConfigMem]);	//"CONFIG memory:\r\n"
+		for(i=0;i<7;i++){
+			PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]);	//"CONFIG%dH: 0x%02X\t"
+			PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]);	//"CONFIG%dL: 0x%02X\r\n"
+		}
+		PrintMessage(strings[S_CodeMem]);	//"\r\nCODE memory:\r\n"
+		DisplayCODE18F(size);
+		if(sizeEE) DisplayEE();
+		PrintMessage("\r\n");
+	}
+//**************** 24F *******************************************
+	else if(!strncmp(dev,"24F",3)||!strncmp(dev,"24H",3)||!strncmp(dev,"24E",3)||!strncmp(dev,"30F",3)||!strncmp(dev,"33F",3)||!strncmp(dev,"33E",3)){
+		unsigned char *buffer,bufferEE[0x2000];
+		int d;
+		buffer=(unsigned char*)malloc(0x100000);
+		memset(buffer,0xFF,0x100000);
+		memset(bufferEE,0xFF,sizeof(bufferEE));
+		memset(memCONFIG,0xFF,sizeof(memCONFIG));
+		memset(memUSERID,0xFF,sizeof(memUSERID));
+		sizeUSERID=0;
+		for(;fgets(line,256,f);){
+			if(strlen(line)>9&&line[0]==':'){
+				int hex_count = htoi(line+1, 2);
+				if((int)strlen(line) - 11 < hex_count * 2) {
+						PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+				}
+				else{
+					input_address=htoi(line+3,4);
+					sum=0;
+					for (i=1;i<=hex_count*2+9;i+=2)
+						sum += htoi(line+i,2);
+					if ((sum & 0xff)!=0) {
+							PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+					}
+					else{
+						switch(htoi(line+7,2)){
+							case 0:		//Data record
+								if(ext_addr<0x20){		//Code
+									int end1=(ext_addr<<16)+input_address+hex_count;
+									if(size<end1) size=end1;
+									for (i=0;i<hex_count;i++){
+										buffer[(ext_addr<<16)+input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if(ext_addr==0x1F0&&input_address<48){	//CONFIG
+									sizeCONFIG=input_address+hex_count;
+									for (i=0;i<hex_count;i++){
+										memCONFIG[input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								else if(ext_addr==0xFF&&input_address>=0xE000){	//EEPROM
+									for (i=0;i<hex_count;i++){
+										bufferEE[input_address-0xE000+i]=htoi(line+9+i*2,2);
+									}
+									sizeEE=input_address-0xE000+hex_count;
+								}
+								else if(ext_addr==0x100&&input_address<8){	//USER ID
+									sizeUSERID=input_address+hex_count;
+									for (i=0;i<hex_count&&(i+input_address)<8;i++){
+										memUSERID[input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								break;
+							case 4:		//extended linear address record
+								if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+								break;
+							default:
+								break;
+						}
+					}
+				}
+			}
+		}
+		if(memCODE) free(memCODE);
+		memCODE=(unsigned char*)malloc(size);
+		memcpy(memCODE,buffer,size);
+		free(buffer);
+		sizeEE=sizeEE?0x1000:0;
+		if(memEE) free(memEE);
+		memEE=(unsigned char*)malloc(sizeEE);
+		for(i=0;i<sizeEE;i+=2){		//skip voids in the hex file organization
+			memEE[i]=bufferEE[i*2]; 	//0 1 4 5 8 9 12 13 ...
+			memEE[i+1]=bufferEE[i*2+1];
+		}
+		for(i=valid=0;i<48;i++) if(memCONFIG[i]<0xFF) valid=1;
+		if(valid){
+			PrintMessage(strings[S_ConfigMem]);				//"\r\nCONFIG memory:\r\n"
+			for(i=0;i<48;i+=4){
+				d=(memCONFIG[i+1]<<8)+memCONFIG[i];
+				if(i<36||d<0xFFFF)PrintMessage2("0xF800%02X: 0x%04X\r\n",i/2,d);
+			}
+		}
+		if(size) PrintMessage(strings[S_CodeMem]);	//"\r\nCODE memory:\r\n"
+		DisplayCODE24F(size);
+		if(sizeEE){			//show eeprom with address offset by 0x7FF000
+			PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+			DisplayEE24F();
+		}
+		PrintMessage("\r\n");
+	}
+//**************** ATxxxx *******************************************
+	else if(!strncmp(dev,"AT",2)){
+		unsigned char buffer[0x30000];
+		memset(buffer,0xFF,sizeof(buffer));
+		for(;fgets(line,256,f);){
+			if(strlen(line)>9&&line[0]==':'){
+				int hex_count = htoi(line+1, 2);
+				if((int)strlen(line) - 11 < hex_count * 2) {
+					PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+				}
+				else{
+					input_address=htoi(line+3,4);
+					sum=0;
+					for (i=1;i<=hex_count*2+9;i+=2)
+						sum += htoi(line+i,2);
+					if ((sum & 0xff)!=0) {
+							PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+					}
+					else{
+						switch(htoi(line+7,2)){
+							case 0:		//Data record
+								if(ext_addr<0x20){		//Code
+									size=input_address+hex_count;
+									for (i=0;i<hex_count;i++){
+										buffer[(ext_addr<<16)+input_address+i]=htoi(line+9+i*2,2);
+									}
+								}
+								break;
+							case 4:		//extended linear address record
+								if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+								break;
+							default:
+								break;
+						}
+					}
+				}
+			}
+		}
+		if(memCODE) free(memCODE);
+		memCODE=(unsigned char*)malloc(size);
+		memcpy(memCODE,buffer,size);
+		if(size) PrintMessage(strings[S_CodeMem]);	//"\r\nmemoria CODICE:\r\n"
+		DisplayCODEAVR(size);
+		PrintMessage("\r\n");
+	}
+//**************** 24xxx / 93xxx / 25xxx / 95xxx / DSxxxx /11xxx *******************************
+	else if(!strncmp(dev,"24",2)||!strncmp(dev,"93",2)||!strncmp(dev,"25",2)||!strncmp(dev,"95",2)||\
+		!strncmp(dev,"DS",2)||!strncmp(dev,"11",2)){
+		if(strstr(loadfile,".bin")||strstr(loadfile,".BIN")){
+			#ifdef _WIN32
+			//brain-damaged op. systems need this to avoid messing with some bytes
+			f=freopen(loadfile,"rb",f);
+			if(!f) return -1;
+			#endif
+			fseek(f, 0L, SEEK_END);
+			sizeEE=ftell(f);
+			fseek(f, 0L, SEEK_SET);
+			if(sizeEE>0x1000000) sizeEE=0x1000000;	//max 16MB
+			if(memEE) free(memEE);
+			memEE=(unsigned char*)malloc(sizeEE);
+			sizeEE=fread(memEE,1,sizeEE,f);
+		}
+		else{			//Hex file
+			int bufSize=0x40000;	//256K
+			unsigned char *bufferEE=(unsigned char*)malloc(bufSize);
+			memset(bufferEE,0xFF,bufSize);
+			for(;fgets(line,256,f);){
+				if(strlen(line)>9&&line[0]==':'){
+					int hex_count = htoi(line+1, 2);
+					if((int)strlen(line) - 11 < hex_count * 2) {
+							PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+					}
+					else{
+						input_address=htoi(line+3,4);
+						sum=0;
+						int end1;
+						for (i=1;i<=hex_count*2+9;i+=2) sum+=htoi(line+i,2);
+						if ((sum & 0xff)!=0) {
+								PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+						}
+						else{
+							switch(htoi(line+7,2)){
+								case 0:		//Data record
+									end1=(ext_addr<<16)+input_address+hex_count;
+									if(end1>=0x1000000) break; //max 16MB
+									if(sizeEE<end1){			//grow array
+										sizeEE=end1;
+									}
+									if(bufSize<=end1){			//grow buffer
+										int newsize=(end1&0xFFFC0000)+0x40000;
+										bufferEE=(unsigned char*)realloc(bufferEE,newsize);
+										memset(bufferEE+bufSize,0xFF,newsize-bufSize);
+										bufSize=newsize;
+									}
+									for (i=0;i<hex_count;i++){
+										bufferEE[(ext_addr<<16)+input_address+i]=htoi(line+9+i*2,2);
+									}
+									break;
+								case 4:		//extended linear address record
+									if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+									break;
+								default:
+									break;
+							}
+						}
+					}
+				}
+			}
+			if(memEE) free(memEE);
+			memEE=(unsigned char*)malloc(sizeEE);
+			memcpy(memEE,bufferEE,sizeEE);
+			free(bufferEE);
+		}
+		DisplayEE();	//visualize
+		int sum=0;
+		for(i=0;i<sizeEE;i++) sum+=memEE[i];
+		PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+		PrintMessage("\r\n");
+	}
+	fclose(f);
+	return 0;
+}
+
+void LoadEE(char*dev,char*loadfile){
+	FILE* f=fopen(loadfile,"r");
+	if(!f) return;
+	int i;
+//**************** ATMEL *******************************************
+	if(!strncmp(dev,"AT",2)){
+		char line[256];
+		int input_address=0,ext_addr=0;
+		unsigned char bufferEE[0x1000];
+		PrintMessage1("%s :\r\n\r\n",loadfile);
+		memset(bufferEE,0xFF,sizeof(bufferEE));
+		for(;fgets(line,256,f);){
+			if(strlen(line)>9&&line[0]==':'){
+				int hex_count = htoi(line+1, 2);
+				if((int)strlen(line) - 11 < hex_count * 2) {
+					PrintMessage1(strings[S_IhexShort],line);	//"Intel hex8 line too short:\r\n%s\r\n"
+				}
+				else{
+					input_address=htoi(line+3,4);
+					int sum = 0;
+					for (i=1;i<=hex_count*2+9;i+=2)	sum+=htoi(line+i,2);
+					if ((sum & 0xff)!=0) {
+						PrintMessage1(strings[S_IhexChecksum],line);	//"Intel hex8 checksum error in line:\r\n%s\r\n"
+					}
+					else{
+						switch(htoi(line+7,2)){
+							case 0:		//Data record
+								if(ext_addr==0&&input_address<0x1000){	//EEPROM
+									for (i=0;i<hex_count;i++){
+										bufferEE[input_address+i]=htoi(line+9+i*2,2);
+									}
+									sizeEE=input_address+hex_count;
+								}
+								break;
+							case 4:		//extended linear address record
+								if(strlen(line)>14)	ext_addr=htoi(line+9,4);
+								break;
+							default:
+								break;
+						}
+					}
+				}
+			}
+		}
+		if(memEE) free(memEE);
+		memEE=(unsigned char*)malloc(sizeEE);
+		memcpy(memEE,bufferEE,sizeEE);
+		if(sizeEE) DisplayEE();	//visualize
+		PrintMessage("\r\n");
+		fclose(f);
+	}
+}
+
+void OpenLogFile()
+{
+	logfile=fopen(LogFileName,"w");
+	if(!logfile) return;
+	fprintf(logfile,_APPNAME " version %s (%s)\n",VERSION,SYSNAME);
+	fprintf(logfile,"Firmware version %d.%d.%d\n",FWVersion>>16,(FWVersion>>8)&0xFF,FWVersion&0xFF);
+	struct tm * timeinfo;
+	time_t rawtime;
+	time( &rawtime );                /* Get time as long integer. */
+	timeinfo = localtime( &rawtime ); /* Convert to local time. */
+	fprintf(logfile,"%s\n", asctime (timeinfo) );
+}
+
+void CloseLogFile()
+{
+	if(logfile)fclose(logfile);
+	logfile=0;
+}
+
+void WriteLogIO()
+{
+	int i;
+	//fprintf(logfile,"bufferU=[%02X\n",bufferU[0]);
+	fprintf(logfile,"bufferU=[");
+	for(i=0;i<DIMBUF;i++){
+		if(i%32==0) fprintf(logfile,"\n");
+		fprintf(logfile,"%02X ",bufferU[i]);
+	}
+	fprintf(logfile,"]\n");
+	//fprintf(logfile,"bufferI=[%02X\n",bufferI[0]);
+	fprintf(logfile,"bufferI=[");
+		for(i=0;i<DIMBUF;i++){
+		if(i%32==0) fprintf(logfile,"\n");
+		fprintf(logfile,"%02X ",bufferI[i]);
+	}
+	fprintf(logfile,"]\n");
+}
diff --git a/fileIO.h b/fileIO.h
new file mode 100644
index 0000000..339d5a9
--- /dev/null
+++ b/fileIO.h
@@ -0,0 +1,8 @@
+unsigned int htoi(const char *hex, int length);
+void Save(char* dev,char* savefile);
+int Load(char*dev,char*loadfile);
+void SaveEE(char* dev,char* savefile);
+int LoadEE(char*dev,char*loadfile);
+void OpenLogFile(void);
+void WriteLogIO();
+void CloseLogFile();
diff --git a/gpl-2.0.txt b/gpl-2.0.txt
new file mode 100644
index 0000000..d511905
--- /dev/null
+++ b/gpl-2.0.txt
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/hid-example.c b/hid-example.c
new file mode 100644
index 0000000..37a0ffc
--- /dev/null
+++ b/hid-example.c
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Hidraw Userspace Example
+ *
+ * Copyright (c) 2010 Alan Ott <alan@signal11.us>
+ * Copyright (c) 2010 Signal 11 Software
+ *
+ * The code may be used by anyone for any purpose,
+ * and can serve as a starting point for developing
+ * applications using hidraw.
+ */
+
+/* Linux */
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/hidraw.h>
+
+/*
+ * Ugly hack to work around failing compilation on systems that don't
+ * yet populate new version of hidraw.h to userspace.
+ */
+#ifndef HIDIOCSFEATURE
+#warning Please have your distro update the userspace kernel headers
+#define HIDIOCSFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
+#define HIDIOCGFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
+#endif
+
+/* Unix */
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/* C */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+
+const char *bus_str(int bus);
+
+int main(int argc, char **argv)
+{
+	int fd;
+	int i, res, desc_size = 0;
+	char buf[256];
+	struct hidraw_report_descriptor rpt_desc;
+	struct hidraw_devinfo info;
+	char *device = "/dev/hidraw0";
+
+	if (argc > 1)
+		device = argv[1];
+
+	/* Open the Device with non-blocking reads. In real life,
+	   don't use a hard coded path; use libudev instead. */
+	fd = open(device, O_RDWR|O_NONBLOCK);
+
+	if (fd < 0) {
+		perror("Unable to open device");
+		return 1;
+	}
+
+	memset(&rpt_desc, 0x0, sizeof(rpt_desc));
+	memset(&info, 0x0, sizeof(info));
+	memset(buf, 0x0, sizeof(buf));
+
+	/* Get Report Descriptor Size */
+	res = ioctl(fd, HIDIOCGRDESCSIZE, &desc_size);
+	if (res < 0)
+		perror("HIDIOCGRDESCSIZE");
+	else
+		printf("Report Descriptor Size: %d\n", desc_size);
+
+	/* Get Report Descriptor */
+	rpt_desc.size = desc_size;
+	res = ioctl(fd, HIDIOCGRDESC, &rpt_desc);
+	if (res < 0) {
+		perror("HIDIOCGRDESC");
+	} else {
+		printf("Report Descriptor:\n");
+		for (i = 0; i < rpt_desc.size; i++)
+			printf("%hhx ", rpt_desc.value[i]);
+		puts("\n");
+	}
+
+	/* Get Raw Name */
+	res = ioctl(fd, HIDIOCGRAWNAME(256), buf);
+	if (res < 0)
+		perror("HIDIOCGRAWNAME");
+	else
+		printf("Raw Name: %s\n", buf);
+
+	/* Get Physical Location */
+	res = ioctl(fd, HIDIOCGRAWPHYS(256), buf);
+	if (res < 0)
+		perror("HIDIOCGRAWPHYS");
+	else
+		printf("Raw Phys: %s\n", buf);
+
+	/* Get Raw Info */
+	res = ioctl(fd, HIDIOCGRAWINFO, &info);
+	if (res < 0) {
+		perror("HIDIOCGRAWINFO");
+	} else {
+		printf("Raw Info:\n");
+		printf("\tbustype: %d (%s)\n",
+			info.bustype, bus_str(info.bustype));
+		printf("\tvendor: 0x%04hx\n", info.vendor);
+		printf("\tproduct: 0x%04hx\n", info.product);
+	}
+
+	/* Set Feature */
+	buf[0] = 0x9; /* Report Number */
+	buf[1] = 0xff;
+	buf[2] = 0xff;
+	buf[3] = 0xff;
+	res = ioctl(fd, HIDIOCSFEATURE(4), buf);
+	if (res < 0)
+		perror("HIDIOCSFEATURE");
+	else
+		printf("ioctl HIDIOCSFEATURE returned: %d\n", res);
+
+	/* Get Feature */
+	buf[0] = 0x9; /* Report Number */
+	res = ioctl(fd, HIDIOCGFEATURE(256), buf);
+	if (res < 0) {
+		perror("HIDIOCGFEATURE");
+	} else {
+		printf("ioctl HIDIOCGFEATURE returned: %d\n", res);
+		printf("Report data (not containing the report number):\n\t");
+		for (i = 0; i < res; i++)
+			printf("%hhx ", buf[i]);
+		puts("\n");
+	}
+
+	/* Send a Report to the Device */
+	buf[0] = 0x1; /* Report Number */
+	buf[1] = 0x77;
+	res = write(fd, buf, 2);
+	if (res < 0) {
+		printf("Error: %d\n", errno);
+		perror("write");
+	} else {
+		printf("write() wrote %d bytes\n", res);
+	}
+
+	/* Get a report from the device */
+	res = read(fd, buf, 16);
+	if (res < 0) {
+		perror("read");
+	} else {
+		printf("read() read %d bytes:\n\t", res);
+		for (i = 0; i < res; i++)
+			printf("%hhx ", buf[i]);
+		puts("\n");
+	}
+	close(fd);
+	return 0;
+}
+
+const char *
+bus_str(int bus)
+{
+	switch (bus) {
+	case BUS_USB:
+		return "USB";
+		break;
+	case BUS_HIL:
+		return "HIL";
+		break;
+	case BUS_BLUETOOTH:
+		return "Bluetooth";
+		break;
+	case BUS_VIRTUAL:
+		return "Virtual";
+		break;
+	default:
+		return "Other";
+		break;
+	}
+}
diff --git a/hid_test.c b/hid_test.c
new file mode 100644
index 0000000..ccc519d
--- /dev/null
+++ b/hid_test.c
@@ -0,0 +1,575 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+
+#if !defined _WIN32 && !defined __CYGWIN__
+	#include <sys/ioctl.h>
+	#include <sys/types.h>
+	#include <sys/stat.h>
+	#include <asm/types.h>
+	#include <fcntl.h>
+	#include <linux/hiddev.h>
+	#include <linux/input.h>
+	#include <sys/timeb.h>
+#else
+	#include <windows.h>
+	#include <setupapi.h>
+	#include <hidusage.h>
+	#include <hidpi.h>
+	#include <math.h>
+	#include <sys/timeb.h>
+	#include <wchar.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <time.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <string.h>
+
+int FindDevice();
+
+#if !defined _WIN32 && !defined __CYGWIN__
+DWORD GetTickCount();
+struct hiddev_report_info rep_info_i,rep_info_u;
+struct hiddev_usage_ref_multi ref_multi_i,ref_multi_u;
+struct hiddev_devinfo device_info;
+
+#else
+	#define write()	Result = WriteFile(WriteHandle,bufferU,n,&BytesWritten,NULL);
+	#define read()	Result = ReadFile(ReadHandle,bufferI,n,&NumberOfBytesRead,(LPOVERLAPPED) &HIDOverlapped);\
+					Result = WaitForSingleObject(hEventObject,50);\
+					ResetEvent(hEventObject);\
+					if(Result!=WAIT_OBJECT_0){\
+						printf("communication timeout\r\n");\
+					}
+
+unsigned char bufferU[128],bufferI[128];
+DWORD NumberOfBytesRead,BytesWritten;
+ULONG Result;
+HANDLE WriteHandle,ReadHandle;
+OVERLAPPED HIDOverlapped;
+HANDLE hEventObject;
+
+#endif
+
+int vid=0x1209,pid=0x5432,info=0;
+
+int main (int argc, char **argv) {
+#define L_IT 0
+#define L_EN 1
+	int d=0,v=0,q=0,r=1,lang=L_EN,c,i,j,block=0,R=0;
+	char path[512]="";
+	char buf[256];
+	for(i=0;i<256;i++) buf[i]=0;
+	#if defined _WIN32
+	int n=65;
+	int langID=GetUserDefaultLangID();
+	if((langID&0xFF)==0x10) lang=L_IT;
+	#else
+	int n=64;
+	if(getenv("LANG")&&strstr(getenv("LANG"),"it")!=0) lang=L_IT;
+	#endif
+	opterr = 0;
+	int option_index = 0;
+	struct option long_options[] =
+	{
+		{"b",       no_argument,    &block, 1},
+		{"block",   no_argument,    &block, 1},
+		{"verbose", no_argument,        &v, 1},
+		{"v",       no_argument,        &v, 1},
+		{"quiet",   no_argument,        &q, 1},
+		{"q",       no_argument,        &q, 1},
+		{"info",    no_argument,     &info, 1},
+		{"i",       no_argument,     &info, 1},
+		{"help",    no_argument,       0, 'h'},
+		{"path",    required_argument, 0, 'p'},
+		{"read",    required_argument, 0, 'R'},
+		{"repeat",  required_argument, 0, 'r'},
+		{"delay",   required_argument, 0, 'd'},
+		{0, 0, 0, 0}
+	};
+	while ((c = getopt_long_only (argc, argv, "n:d:p:hr:R:",long_options,&option_index)) != -1)
+        switch (c)
+           {
+           case 'h':	//guida
+             if(!lang) printf("hid_test [opzioni] [dati]\n"
+				"opzioni: \n"
+				"-b, block\tusa lettura bloccante\n"
+				"-d, delay\tritardo lettura (ms) [0]\n"
+				"-h, help\tguida\n"
+				"-i, info\tinformazioni sul dispositivo [no]\n"
+				"-n\t\tdimensione report [64]\n"
+				"-p, path\tpercorso dispositivo [/dev/usb/hiddev0] \n"
+				"-q, quiet\tmostra solo risposta [no]\n"
+				"-R, read\tripeti lettura N volte [0]\n\n"
+				"-r, repeat\tripeti scrittura-lettura N volte [1]\n\n"
+				"-v, verbose\tmostra funzioni [no]\n"
+				"es.  hid_test -i 1 2 3 4\n");
+             else printf("hid_test [otions] [data]\n"
+			 	"options: \n"
+				"-b, block\tuse blocking read\n"
+				"-d, delay\tread delay (ms) [0]\n"
+				"-h, help\thelp\n"
+				"-i, info\tdevice info [no]\n"
+				"-n\t\treport size [64]\n"
+				"-p, path\tdevice path [/dev/usb/hiddev0]\n"
+				"-q, quiet\tprint response only [no]\n"
+				"-R, repeat\trepeat read N times [0]\n\n"
+				"-r, repeat\trepeat N times [1]\n\n"
+				"-v, verbose\tshow functions [no]\n"
+				"e.g.  hid_test -i 1 2 3 4\n");
+		exit(1);
+            break;
+            case 'n':	//dim report
+             n = atoi(optarg);
+             break;
+           case 'd':	//ritardo lettura
+             d = atoi(optarg);
+             break;
+          case 'p':	//percorso hiddev
+             strncpy(path,optarg,sizeof(path));
+             break;
+            case 'r':	//ripeti IO
+             r = atoi(optarg);
+             break;
+            case 'R':	//ripeti lettura
+             R = atoi(optarg);
+             break;
+           case '?':
+             if (optopt == 'c')
+               fprintf (stderr, "Option -%c requires an argument.\n", optopt);
+             else if (isprint (optopt))
+               fprintf (stderr, "Unknown option `-%c'.\n", optopt);
+             else
+               fprintf (stderr, "Unknown option character 0x%02x\n", optopt);
+             return 1;
+           default:
+             //abort ();
+            break;
+           }
+
+	for (j=0,i = optind; i < argc&&i<128; i++,j++) sscanf(argv[i], "%x", &buf[j]);
+	for (;j<n;j++) buf[j]=0;
+
+	int fd = -1;
+
+	if(FindDevice()<0) exit(1);
+
+	if(!q){
+		printf("-> ");
+	 	for(i=0;i<j;i++) printf("%02X ",(unsigned char)buf[i]);
+		printf("\n");
+	}
+	if(v) printf("%slocking read\n",block?"B":"Non b");
+
+#if !defined _WIN32 && !defined __CYGWIN__
+	struct hiddev_event ev[80];
+	rep_info.report_type=HID_REPORT_TYPE_OUTPUT;
+	rep_info.report_id=HID_REPORT_ID_FIRST;
+	rep_info.num_fields=1;
+	ref_multi.uref.report_type=HID_REPORT_TYPE_OUTPUT;
+	ref_multi.uref.report_id=HID_REPORT_ID_FIRST;
+	ref_multi.uref.field_index=0;
+	ref_multi.uref.usage_index=0;
+	ref_multi.num_values=n;
+	for(i=0;i<n;i++) ref_multi.values[i]=buf[i];
+	int res;
+	res=ioctl(fd, HIDIOCSUSAGES, &ref_multi);
+	if(v) printf("HIDIOCSUSAGES:%d\n",res);
+	res=ioctl(fd,HIDIOCSREPORT, &rep_info);
+	if(v) printf("HIDIOCSREPORT:%d\n",res);
+	if(!block) for(j=0;j<r;j++){
+		usleep(d*1000);
+		rep_info.report_type=HID_REPORT_TYPE_INPUT;
+		res=ioctl(fd,HIDIOCGREPORT, &rep_info);
+		if(v) printf("HIDIOCGREPORT:%d\n",res);
+		ref_multi.uref.report_type=HID_REPORT_TYPE_INPUT;
+		res=ioctl(fd, HIDIOCGUSAGES, &ref_multi);
+		if(v) printf("HIDIOCGUSAGES:%d\n",res);
+		if(!q) printf("<- ");
+		for(i=0;i<n;i++) printf("%02X ",ref_multi.values[i]);
+		printf("\n");
+	}
+	else for(j=0;j<r;j++){
+		usleep(d*1000);
+		res=read(fd, ev,sizeof(struct hiddev_event) *n);
+		if(!q) printf("<- ");
+		for(i=0;i<n;i++) printf("%02X ",ev[i].value);
+		printf("\n");
+	}
+	else for(j=0;j<R;j++){
+		usleep(d*1000);
+		res=read(fd, ev,sizeof(struct hiddev_event) *n);
+		if(!q) printf("<- ");
+		for(i=0;i<n;i++) printf("%02X ",ev[i].value);
+		printf("\n");
+	}
+	close(fd);
+#else
+	__int64 start,stop,freq;
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+	bufferU[0]=0;
+	for(i=0;i<n;i++) bufferU[i+1]=buf[i];
+	for(j=0;j<r;j++){
+		QueryPerformanceCounter((LARGE_INTEGER *)&start);
+		write();
+		Sleep(d);
+		read();
+		QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+		if(!q) printf("<- ");
+		for(i=1;i<n;i++) printf("%02X ",bufferI[i]);
+		printf("\nT=%.2fms\n",(stop-start)*1000.0/freq);
+	}
+	for(j=0;j<R;j++){
+		QueryPerformanceCounter((LARGE_INTEGER *)&start);
+		read();
+		QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+		if(!q) printf("<- ");
+		for(i=1;i<n;i++) printf("%02X ",bufferI[i]);
+		printf("\nT=%.2fms\n",(stop-start)*1000.0/freq);
+	}
+
+#endif
+	return 0;
+}
+
+
+DWORD GetTickCount(){
+	struct timeb now;
+	ftime(&now);
+	return now.time*1000+now.millitm;
+}
+
+
+int FindDevice(){
+#if !defined _WIN32 && !defined __CYGWIN__
+	struct hiddev_devinfo device_info;
+	int i;
+	if(path[0]==0){	//search all devices
+		for(i=0;i<16;i++){
+			sprintf(path,"/dev/usb/hiddev%d",i);
+			if((fd = open(path, O_RDONLY ))>0){
+				ioctl(fd, HIDIOCGDEVINFO, &device_info);
+				if(device_info.vendor==vid&&device_info.product==pid) break;
+				else close(fd);
+			}
+		}
+		if(i==16){
+			printf(strings[S_noprog]);
+			return -1;
+		}
+	}
+	else{	//user supplied path
+		if ((fd = open(path, O_RDONLY )) < 0) {
+			printf(strings[S_DevPermission],path);
+			exit(1);
+		}
+		ioctl(fd, HIDIOCGDEVINFO, &device_info);
+		if(device_info.vendor!=vid||device_info.product!=pid){
+			printf(strings[S_noprog]);
+			return -1;
+		}
+	}
+	printf(strings[S_progDev],path);
+
+	rep_info_u.report_type=HID_REPORT_TYPE_OUTPUT;
+	rep_info_i.report_type=HID_REPORT_TYPE_INPUT;
+	rep_info_u.report_id=rep_info_i.report_id=HID_REPORT_ID_FIRST;
+	rep_info_u.num_fields=rep_info_i.num_fields=1;
+	ref_multi_u.uref.report_type=HID_REPORT_TYPE_OUTPUT;
+	ref_multi_i.uref.report_type=HID_REPORT_TYPE_INPUT;
+	ref_multi_u.uref.report_id=ref_multi_i.uref.report_id=HID_REPORT_ID_FIRST;
+	ref_multi_u.uref.field_index=ref_multi_i.uref.field_index=0;
+	ref_multi_u.uref.usage_index=ref_multi_i.uref.usage_index=0;
+	ref_multi_u.num_values=ref_multi_i.num_values=DIMBUF;
+
+	if(info){
+		ioctl(fd, HIDIOCGDEVINFO, &device_info);
+		printf("vendor 0x%04hx product 0x%04hx version 0x%04hx ",
+			device_info.vendor, device_info.product, device_info.version);
+		printf("has %i application%s ", device_info.num_applications,
+			(device_info.num_applications==1?"":"s"));
+		printf("and is on bus: %d devnum: %d ifnum: %d\n",
+			device_info.busnum, device_info.devnum, device_info.ifnum);
+		char name[256]= "Unknown";
+		if(ioctl(fd, HIDIOCGNAME(sizeof(name)), name) < 0) perror("evdev ioctl");
+		printf("The device on %s says its name is %s\n", path, name);
+	}
+
+#else
+	char string[256];
+	PSP_DEVICE_INTERFACE_DETAIL_DATA detailData;
+	HANDLE DeviceHandle;
+	HANDLE hDevInfo;
+	GUID HidGuid;
+	int MyDeviceDetected;
+	char MyDevicePathName[1024];
+	ULONG Length;
+	ULONG Required;
+	typedef struct _HIDD_ATTRIBUTES {
+	    ULONG   Size;
+	    USHORT  VendorID;
+	    USHORT  ProductID;
+	    USHORT  VersionNumber;
+	} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+
+	typedef void (__stdcall*GETHIDGUID) (OUT LPGUID HidGuid);
+	typedef BOOLEAN (__stdcall*GETATTRIBUTES)(IN HANDLE HidDeviceObject,OUT PHIDD_ATTRIBUTES Attributes);
+	typedef BOOLEAN (__stdcall*SETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT ULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT PULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETFEATURE) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETFEATURE) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETREPORT) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETREPORT) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETMANUFACTURERSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETPRODUCTSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETINDEXEDSTRING) (IN  HANDLE HidDeviceObject, IN ULONG  StringIndex, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	HIDD_ATTRIBUTES Attributes;
+	SP_DEVICE_INTERFACE_DATA devInfoData;
+	int LastDevice = FALSE;
+	int MemberIndex = 0;
+	LONG Result;
+	//char UsageDescription[256];
+
+	Length=0;
+	detailData=NULL;
+	DeviceHandle=NULL;
+
+	HMODULE hHID=0;
+	GETHIDGUID HidD_GetHidGuid=0;
+	GETATTRIBUTES HidD_GetAttributes=0;
+	SETNUMINPUTBUFFERS HidD_SetNumInputBuffers=0;
+	GETNUMINPUTBUFFERS HidD_GetNumInputBuffers=0;
+	GETFEATURE HidD_GetFeature=0;
+	SETFEATURE HidD_SetFeature=0;
+	GETREPORT HidD_GetInputReport=0;
+	SETREPORT HidD_SetOutputReport=0;
+	GETMANUFACTURERSTRING HidD_GetManufacturerString=0;
+	GETPRODUCTSTRING HidD_GetProductString=0;
+	hHID = LoadLibrary("hid.dll");
+	if(!hHID){
+		printf("Can't find hid.dll");
+		return 0;
+	}
+	HidD_GetHidGuid=(GETHIDGUID)GetProcAddress(hHID,"HidD_GetHidGuid");
+	HidD_GetAttributes=(GETATTRIBUTES)GetProcAddress(hHID,"HidD_GetAttributes");
+	HidD_SetNumInputBuffers=(SETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_SetNumInputBuffers");
+	HidD_GetNumInputBuffers=(GETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_GetNumInputBuffers");
+	HidD_GetFeature=(GETFEATURE)GetProcAddress(hHID,"HidD_GetFeature");
+	HidD_SetFeature=(SETFEATURE)GetProcAddress(hHID,"HidD_SetFeature");
+	HidD_GetInputReport=(GETREPORT)GetProcAddress(hHID,"HidD_GetInputReport");
+	HidD_SetOutputReport=(SETREPORT)GetProcAddress(hHID,"HidD_SetOutputReport");
+	HidD_GetManufacturerString=(GETMANUFACTURERSTRING)GetProcAddress(hHID,"HidD_GetManufacturerString");
+	HidD_GetProductString=(GETPRODUCTSTRING)GetProcAddress(hHID,"HidD_GetProductString");
+	if(HidD_GetHidGuid==NULL\
+		||HidD_GetAttributes==NULL\
+		||HidD_GetFeature==NULL\
+		||HidD_SetFeature==NULL\
+		||HidD_GetInputReport==NULL\
+		||HidD_SetOutputReport==NULL\
+		||HidD_GetManufacturerString==NULL\
+		||HidD_GetProductString==NULL\
+		||HidD_SetNumInputBuffers==NULL\
+		||HidD_GetNumInputBuffers==NULL) return -1;
+
+
+	HMODULE hSAPI=0;
+	hSAPI = LoadLibrary("setupapi.dll");
+	if(!hSAPI){
+		printf("Can't find setupapi.dll");
+		return 0;
+	}
+	typedef HDEVINFO (WINAPI* SETUPDIGETCLASSDEVS) (CONST GUID*,PCSTR,HWND,DWORD);
+	typedef BOOL (WINAPI* SETUPDIENUMDEVICEINTERFACES) (HDEVINFO,PSP_DEVINFO_DATA,CONST GUID*,DWORD,PSP_DEVICE_INTERFACE_DATA);
+	typedef BOOL (WINAPI* SETUPDIGETDEVICEINTERFACEDETAIL) (HDEVINFO,PSP_DEVICE_INTERFACE_DATA,PSP_DEVICE_INTERFACE_DETAIL_DATA_A,DWORD,PDWORD,PSP_DEVINFO_DATA);
+	typedef BOOL (WINAPI* SETUPDIDESTROYDEVICEINFOLIST) (HDEVINFO);
+	SETUPDIGETCLASSDEVS SetupDiGetClassDevsA=0;
+	SETUPDIENUMDEVICEINTERFACES SetupDiEnumDeviceInterfaces=0;
+	SETUPDIGETDEVICEINTERFACEDETAIL SetupDiGetDeviceInterfaceDetailA=0;
+	SETUPDIDESTROYDEVICEINFOLIST SetupDiDestroyDeviceInfoList=0;
+	SetupDiGetClassDevsA=(SETUPDIGETCLASSDEVS) GetProcAddress(hSAPI,"SetupDiGetClassDevsA");
+	SetupDiEnumDeviceInterfaces=(SETUPDIENUMDEVICEINTERFACES) GetProcAddress(hSAPI,"SetupDiEnumDeviceInterfaces");
+	SetupDiGetDeviceInterfaceDetailA=(SETUPDIGETDEVICEINTERFACEDETAIL) GetProcAddress(hSAPI,"SetupDiGetDeviceInterfaceDetailA");
+	SetupDiDestroyDeviceInfoList=(SETUPDIDESTROYDEVICEINFOLIST) GetProcAddress(hSAPI,"SetupDiDestroyDeviceInfoList");
+	if(SetupDiGetClassDevsA==NULL\
+		||SetupDiEnumDeviceInterfaces==NULL\
+		||SetupDiDestroyDeviceInfoList==NULL\
+		||SetupDiGetDeviceInterfaceDetailA==NULL) return -1;
+
+
+	/*
+	The following code is adapted from Usbhidio_vc6 application example by Jan Axelson
+	for more information see see http://www.lvr.com/hidpage.htm
+	*/
+
+	/*
+	API function: HidD_GetHidGuid
+	Get the GUID for all system HIDs.
+	Returns: the GUID in HidGuid.
+	*/
+	HidD_GetHidGuid(&HidGuid);
+
+	/*
+	API function: SetupDiGetClassDevs
+	Returns: a handle to a device information set for all installed devices.
+	Requires: the GUID returned by GetHidGuid.
+	*/
+	hDevInfo=SetupDiGetClassDevs(&HidGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);
+	devInfoData.cbSize = sizeof(devInfoData);
+
+	//Step through the available devices looking for the one we want.
+	//Quit on detecting the desired device or checking all available devices without success.
+	MemberIndex = 0;
+	LastDevice = FALSE;
+	do
+	{
+		/*
+		API function: SetupDiEnumDeviceInterfaces
+		On return, MyDeviceInterfaceData contains the handle to a
+		SP_DEVICE_INTERFACE_DATA structure for a detected device.
+		Requires:
+		The DeviceInfoSet returned in SetupDiGetClassDevs.
+		The HidGuid returned in GetHidGuid.
+		An index to specify a device.
+		*/
+		Result=SetupDiEnumDeviceInterfaces (hDevInfo, 0, &HidGuid, MemberIndex, &devInfoData);
+		if (Result != 0)
+		{
+			//A device has been detected, so get more information about it.
+			/*
+			API function: SetupDiGetDeviceInterfaceDetail
+			Returns: an SP_DEVICE_INTERFACE_DETAIL_DATA structure
+			containing information about a device.
+			To retrieve the information, call this function twice.
+			The first time returns the size of the structure in Length.
+			The second time returns a pointer to the data in DeviceInfoSet.
+			Requires:
+			A DeviceInfoSet returned by SetupDiGetClassDevs
+			The SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces.
+
+			The final parameter is an optional pointer to an SP_DEV_INFO_DATA structure.
+			This application doesn't retrieve or use the structure.
+			If retrieving the structure, set
+			MyDeviceInfoData.cbSize = length of MyDeviceInfoData.
+			and pass the structure's address.
+			*/
+			//Get the Length value.
+			//The call will return with a "buffer too small" error which can be ignored.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, NULL, 0, &Length, NULL);
+
+			//Allocate memory for the hDevInfo structure, using the returned Length.
+			detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(Length);
+
+			//Set cbSize in the detailData structure.
+			detailData -> cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+
+			//Call the function again, this time passing it the returned buffer size.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, detailData, Length,&Required, NULL);
+
+			// Open a handle to the device.
+			// To enable retrieving information about a system mouse or keyboard,
+			// don't request Read or Write access for this handle.
+			/*
+			API function: CreateFile
+			Returns: a handle that enables reading and writing to the device.
+			Requires:
+			The DevicePath in the detailData structure
+			returned by SetupDiGetDeviceInterfaceDetail.
+			*/
+			DeviceHandle=CreateFile(detailData->DevicePath,
+				0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+				(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING, 0, NULL);
+
+			/*
+			API function: HidD_GetAttributes
+			Requests information from the device.
+			Requires: the handle returned by CreateFile.
+			Returns: a HIDD_ATTRIBUTES structure containing
+			the Vendor ID, Product ID, and Product Version Number.
+			Use this information to decide if the detected device is
+			the one we're looking for.
+			*/
+
+			//Set the Size to the number of bytes in the structure.
+			Attributes.Size = sizeof(Attributes);
+			Result = HidD_GetAttributes(DeviceHandle,&Attributes);
+
+			//Is it the desired device?
+			MyDeviceDetected = FALSE;
+			if (Attributes.VendorID == vid)
+			{
+				if (Attributes.ProductID == pid)
+				{
+					//Both the Vendor ID and Product ID match.
+					MyDeviceDetected = TRUE;
+					strcpy(MyDevicePathName,detailData->DevicePath);
+
+					// Get a handle for writing Output reports.
+					WriteHandle=CreateFile(detailData->DevicePath,
+						GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
+						(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING,0,NULL);
+
+					//Get a handle to the device for the overlapped ReadFiles.
+					ReadHandle=CreateFile(detailData->DevicePath,
+						GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)NULL,
+						OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
+
+					if (hEventObject) CloseHandle(hEventObject);
+					hEventObject = CreateEvent(NULL,TRUE,TRUE,"");
+
+					//Set the members of the overlapped structure.
+					HIDOverlapped.hEvent = hEventObject;
+					HIDOverlapped.Offset = 0;
+					HIDOverlapped.OffsetHigh = 0;
+					Result=HidD_SetNumInputBuffers(DeviceHandle,64);
+				}
+				else
+					//The Product ID doesn't match.
+					CloseHandle(DeviceHandle);
+			}
+			else
+				//The Vendor ID doesn't match.
+				CloseHandle(DeviceHandle);
+		//Free the memory used by the detailData structure (no longer needed).
+		free(detailData);
+		}
+		else
+			//SetupDiEnumDeviceInterfaces returned 0, so there are no more devices to check.
+			LastDevice=TRUE;
+		//If we haven't found the device yet, and haven't tried every available device,
+		//try the next one.
+		MemberIndex = MemberIndex + 1;
+	} //do
+	while ((LastDevice == FALSE) && (MyDeviceDetected == FALSE));
+	//Free the memory reserved for hDevInfo by SetupDiClassDevs.
+	SetupDiDestroyDeviceInfoList(hDevInfo);
+
+	if (MyDeviceDetected == FALSE){
+		printf("Can't find device\n");
+		return -1;
+	}
+
+	if(info){
+		printf("Device detected: vid=0x%04X pid=0x%04X\nPath: %s\n",vid,pid,MyDevicePathName);
+		if(HidD_GetManufacturerString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Manufacturer string: %s\n",string);
+		if(HidD_GetProductString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Product string: %s\n",string);
+	}
+#endif
+	return 0;
+}
diff --git a/icd.c b/icd.c
new file mode 100644
index 0000000..3cf8e39
--- /dev/null
+++ b/icd.c
@@ -0,0 +1,1541 @@
+//General routines to communicate via ICD with a target
+#include "common.h"
+#include "coff.h"
+
+extern int saveLog;
+extern double Tcom;
+extern int running;
+extern int DeviceDetected;
+extern GtkWidget * b_log;
+extern char* cur_path;
+
+GtkWidget * statusTxt;
+GtkWidget * sourceTxt;
+GtkTextBuffer * sourceBuf;
+GtkWidget * icdVbox1;
+GtkWidget * icdMenuPC;
+GtkWidget * icdMenuSTAT;
+GtkWidget * icdMenuBank0;
+GtkWidget * icdMenuBank1;
+GtkWidget * icdMenuBank2;
+GtkWidget * icdMenuBank3;
+GtkWidget * icdMenuEE;
+GtkWidget * icdCommand;
+GtkTextBuffer * statusBuf;
+int icdTimer=0;
+int break_addr,print_addr;
+int currentSource=-1;
+int sourceHilight=0;
+char lastCmd[64]="";
+int UseCoff=0;
+struct src_i source_info[LMAX];
+struct srcfile *s_files;
+struct symbol *sym;
+int nsym=0;
+char* Slabel[LMAX],*Sulabel[ULMAX];
+struct symbol *watch;
+int nwatch=0;
+unsigned short coff_data[DATA_MAX];
+int ver=0,reset=1,freeze=0,icdConnected=0,running=0;
+#define Tck 30
+double Tcom=0.001*Tck*18+0.03; //communication time for a 16 bit tranfer (ms)
+
+void ShowContext();
+
+//The following commands are implemented in the debugger monitor
+//routine which is written in the last memory page on the target chip.
+#define VER 	1	//;version
+#define STEP 	2	//;step
+#define GO 		3	//;go
+#define RREG 	4	//;read register
+#define WREG 	5	//;write register
+#define EEADR 0x10D
+#define EEADRH 0x10F
+#define EEDATA 0x10C
+#define EEDATH 0x10E
+#define EECON1 0x18C
+#define EECON2 0x18D
+#define w_temp 0x6B
+#define status_temp 0x6C
+#define pclath_temp 0x6D
+#define fsr_temp 0x6E
+
+struct var{	char* name;	int display;} variables[0x200];
+
+//Prepare ICD interface by resetting the target with a power-up sequence.
+//MCLR is low so the target is reset even if power is not supplied by the programmer.
+//Set communication speed at 1/(2*Tck us)
+void startICD(int tck){
+	int j=0;
+	bufferU[j++]=PROG_RST;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=tck;				//T1=XXu
+	bufferU[j++]=100;				//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;			//2ms
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=VREG_DIS;			//disable HV regulator
+	bufferU[j++]=EN_VPP_VCC;		// reset target
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;				//set D as input
+	bufferU[j++]=EN_VPP_VCC;		// power-up
+	bufferU[j++]=0x1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(3);
+	if(saveLog){
+		fprintf(logfile,"startICD()\n");
+	}
+}
+
+//Check whether the target is running or is executing the debug routine.
+//This is signaled by RB7 (Data): D=1 -> debugger monitor running
+int isRunning(){
+	int z,j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;		//D=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=READ_PINS;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	if(saveLog){
+		fprintf(logfile,"isRunning()\n");
+	}
+	for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_PINS;z++);
+	if(bufferI[z+1]&1) running=0;
+	else running=1;
+	return running;
+}
+
+//Set the next breakpoint address, the freeze bit, 
+//and continue execution.
+//This is necessary because at every break 
+//the ICD register is loaded with the last address.
+void cont(int break_addr, int freeze){
+	int j=0;
+	//set breakpoint and freeze
+	break_addr&=0x1FFF;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x2;
+	bufferU[j++]=WREG;		//write register
+	bufferU[j++]=(break_addr>>8)+(freeze?0x40:0);
+	bufferU[j++]=0x1;
+	bufferU[j++]=0x8E;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x2;
+	bufferU[j++]=WREG;		//write register
+	bufferU[j++]=break_addr&0xFF;
+	bufferU[j++]=0x1;
+	bufferU[j++]=0x8F;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x1;
+	bufferU[j++]=GO;		//GO
+	bufferU[j++]=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+5*Tcom);
+	if(saveLog){
+		fprintf(logfile,"continue()\n");
+	}
+	running=1;
+}
+
+//Execute a single step
+void step(){
+	int j=0;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x1;
+	bufferU[j++]=STEP;		//single step
+	bufferU[j++]=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+Tcom);
+	if(saveLog){
+		fprintf(logfile,"step()\n");
+	}
+}
+
+//Remove reset so that the target can start executing its code.
+void run(){
+	int j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;
+	bufferU[j++]=EN_VPP_VCC;		//MCLR=H
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	if(saveLog){
+		fprintf(logfile,"run()\n");
+	}
+	running=1;
+}
+
+//Get the debugger monitor version
+int version(){
+	int j=0,z;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x1;
+	bufferU[j++]=VER;		//version
+	bufferU[j++]=0;
+	bufferU[j++]=RX16;
+	bufferU[j++]=0x1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+2*Tcom);
+	if(saveLog){
+		fprintf(logfile,"version()\n");
+	}
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=RX16;z++);
+	return bufferI[z+3];
+}
+
+//Halt execution by setting RB6 (Clock) low
+void Halt(){
+	int j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x6;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	if(saveLog){
+		fprintf(logfile,"halt()\n");
+	}
+	running=0;
+	//printf("halted\n");
+}
+
+//Read register at address addr
+int ReadRegister(int addr){
+	int j=0,z;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x2;
+	bufferU[j++]=RREG;		//Read register
+	bufferU[j++]=0x1;		//1 byte
+	bufferU[j++]=(addr>>8)&0xFF;
+	bufferU[j++]=addr&0xFF;
+	bufferU[j++]=RX16;
+	bufferU[j++]=0x1;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+3*Tcom);
+	if(saveLog){
+		fprintf(logfile,"ReadRegister(0x%X)\n",addr);
+	}
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=RX16;z++);
+	return bufferI[z+3];	
+}
+
+//Read n registers starting at address addr
+int ReadRegisterN(int addr,int n,int* buf){
+	int i,j=0,z,w;
+	for(i=0;i<n;i+=w){
+		w=i+(DIMBUF-9)/2<n?(DIMBUF-9)/2:n-i;
+		bufferU[j++]=TX16;
+		bufferU[j++]=0x2;
+		bufferU[j++]=RREG;				//Read register
+		bufferU[j++]=w;
+		bufferU[j++]=(addr+i)>>8;
+		bufferU[j++]=(addr+i)&0xFF;
+		bufferU[j++]=RX16;
+		bufferU[j++]=w;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1+(w+2)*Tcom);
+		if(saveLog){
+			fprintf(logfile,"ReadRegisterN(0x%X,%d)\n",addr,n);
+		}
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=RX16;z++);
+		for(j=0;j<w;j++) buf[i+j]=bufferI[z+3+j*2];
+		j=0;
+	}
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	return i==n?0:-1;
+}
+
+//Write data at address addr
+void WriteRegister(int addr,int data){
+	int j=0;
+	bufferU[j++]=TX16;
+	bufferU[j++]=0x2;
+	bufferU[j++]=WREG;		//write register
+	bufferU[j++]=data&0xFF;
+	bufferU[j++]=(addr>>8)&0xFF;
+	bufferU[j++]=addr&0xFF;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+2*Tcom);
+	if(saveLog){
+		fprintf(logfile,"WriteRegister(0x%X,0x%X)\n",addr,data);
+	}
+}
+
+//Read program memory at address addr
+int ReadProgMem(int addr){
+	int addr_temp, data_temp, eecon_temp,data;
+	addr_temp=(ReadRegister(EEADRH)<<8)+ReadRegister(EEADR);
+	data_temp=(ReadRegister(EEDATH)<<8)+ReadRegister(EEDATA);
+	eecon_temp=ReadRegister(EECON1);
+	WriteRegister(EEADRH,addr>>8);
+	WriteRegister(EEADR,addr&0xFF);
+	WriteRegister(EECON1,eecon_temp|0x80);	//EEPGD=1
+	WriteRegister(EECON1,eecon_temp|0x81);	//EEPGD=1 + RD=1
+	data=(ReadRegister(EEDATH)<<8)+ReadRegister(EEDATA);
+	WriteRegister(EEADRH,addr_temp<<8);
+	WriteRegister(EEADR,addr_temp&0xFF);
+	WriteRegister(EEDATH,data_temp<<8);
+	WriteRegister(EEDATA,data_temp&0xFF);
+	WriteRegister(EECON1,eecon_temp);
+	return data;
+}
+
+//Read program memory (n locations) starting at address addr
+int ReadProgMemN(int addr,int n,int* buf){
+	int addr_temp, data_temp, eecon_temp;
+	if(saveLog) fprintf(logfile,"ReadProgMemN(0x%X,%d)\n",addr,n);
+	int i,j=0,z,w,k;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=RREG;		//Read register
+	bufferU[j++]=4;			//4 bytes: EEDATA,EEADR,EEDATH,EEADRH
+	bufferU[j++]=(EEDATA>>8)&0xFF;
+	bufferU[j++]=EEDATA&0xFF;
+	bufferU[j++]=RX16;
+	bufferU[j++]=4;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=RREG;		//Read register
+	bufferU[j++]=1;			//1 byte
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=RX16;
+	bufferU[j++]=1;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=WREG;		//write register
+	bufferU[j++]=0x80;		//EEPGD=1
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+13*Tcom);
+	j=0;
+	for(z=0;z<DIMBUF-5&&bufferI[z]!=RX16;z++);
+	data_temp=bufferI[z+3]+(bufferI[z+7]<<8);
+	addr_temp=bufferI[z+5]+(bufferI[z+9]<<8);
+	for(z+=10;z<DIMBUF-3&&bufferI[z]!=RX16;z++);
+	eecon_temp=bufferI[z+3];
+	w=k=0;
+	for(i=0;i<n;i++){
+		bufferU[j++]=TX16;
+		bufferU[j++]=8;
+		bufferU[j++]=WREG;			//write register
+		bufferU[j++]=(addr+i)&0xFF;
+		bufferU[j++]=(EEADR>>8)&0xFF;
+		bufferU[j++]=EEADR&0xFF;
+		bufferU[j++]=WREG;			//write register
+		bufferU[j++]=((addr+i)>>8)&0xFF;
+		bufferU[j++]=(EEADRH>>8)&0xFF;
+		bufferU[j++]=EEADRH&0xFF;
+		bufferU[j++]=WREG;			//write register
+		bufferU[j++]=0x81;			//RD=1
+		bufferU[j++]=(EECON1>>8)&0xFF;
+		bufferU[j++]=EECON1&0xFF;
+		bufferU[j++]=RREG;		//Read register
+		bufferU[j++]=3;			//3 bytes: EEDATA,EEADR,EEDATH
+		bufferU[j++]=(EEDATA>>8)&0xFF;
+		bufferU[j++]=EEDATA&0xFF;
+		bufferU[j++]=RX16;
+		bufferU[j++]=3;
+		w++;
+		if(j>DIMBUF-21||i==n-1){
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2+13*Tcom*w);
+			j=0;
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==RX16){
+					buf[k++]=bufferI[z+3]+(bufferI[z+7]<<8);
+					z+=8; //******controllare!!**********
+				}
+			}
+		}
+	}
+	bufferU[j++]=TX16;
+	bufferU[j++]=10;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=eecon_temp;	//EEPGD=1
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=data_temp&0xFF;
+	bufferU[j++]=(EEDATA>>8)&0xFF;
+	bufferU[j++]=EEDATA&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=data_temp>>8;
+	bufferU[j++]=(EEDATH>>8)&0xFF;
+	bufferU[j++]=EEDATH&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=addr_temp&0xFF;
+	bufferU[j++]=(EEADR>>8)&0xFF;
+	bufferU[j++]=EEADR&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=addr_temp>>8;
+	bufferU[j++]=(EEADRH>>8)&0xFF;
+	bufferU[j++]=EEADRH&0xFF;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+10*Tcom);
+	return i;
+}
+
+//Read data memory at address addr
+int ReadDataMem(int addr){
+	int addr_temp, data_temp, eecon_temp,data;
+	addr_temp=ReadRegister(EEADR);
+	data_temp=ReadRegister(EEDATA);
+	eecon_temp=ReadRegister(EECON1);
+	WriteRegister(EEADR,addr);
+	WriteRegister(EECON1,eecon_temp&0x7F);			//EEPGD=0
+	WriteRegister(EECON1,(eecon_temp&0x7F)|0x1);	//EEPGD=0 + RD=1
+	data=ReadRegister(EEDATA);
+	WriteRegister(EEADR,addr_temp);
+	WriteRegister(EEDATA,data_temp);
+	WriteRegister(EECON1,eecon_temp);
+	return data;	
+}
+
+//Read n bytes from data memory starting at address addr
+int ReadDataMemN(int addr,int n,unsigned char* buf){
+	int addr_temp, data_temp, eecon_temp;
+	if(saveLog) fprintf(logfile,"ReadDataMemN(0x%X,%d)\n",addr,n);
+	int i,j=0,z,w,k;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=RREG;		//Read register
+	bufferU[j++]=2;			//2 bytes: EEDATA,EEADR
+	bufferU[j++]=(EEDATA>>8)&0xFF;
+	bufferU[j++]=EEDATA&0xFF;
+	bufferU[j++]=RX16;
+	bufferU[j++]=2;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=RREG;		//Read register
+	bufferU[j++]=1;			//1 byte
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=RX16;
+	bufferU[j++]=1;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=WREG;		//write register
+	bufferU[j++]=0;			//EEPGD=0
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+13*Tcom);
+	j=0;
+	for(z=0;z<DIMBUF-5&&bufferI[z]!=RX16;z++);
+	data_temp=bufferI[z+3];
+	addr_temp=bufferI[z+5];
+	for(z+=6;z<DIMBUF-3&&bufferI[z]!=RX16;z++);
+	eecon_temp=bufferI[z+3];
+	w=k=0;
+	for(i=0;i<n;i++){
+		bufferU[j++]=TX16;
+		bufferU[j++]=6;
+		bufferU[j++]=WREG;			//write register
+		bufferU[j++]=(addr+i)&0xFF;
+		bufferU[j++]=(EEADR>>8)&0xFF;
+		bufferU[j++]=EEADR&0xFF;
+		bufferU[j++]=WREG;			//write register
+		bufferU[j++]=0x1;			//RD=1
+		bufferU[j++]=(EECON1>>8)&0xFF;
+		bufferU[j++]=EECON1&0xFF;
+		bufferU[j++]=RREG;		//Read register
+		bufferU[j++]=1;			// EEDATA
+		bufferU[j++]=(EEDATA>>8)&0xFF;
+		bufferU[j++]=EEDATA&0xFF;
+		bufferU[j++]=RX16;
+		bufferU[j++]=1;
+		w++;
+		if(j>DIMBUF-17||i==n-1){
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2+10*Tcom*w);
+			j=0;
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==RX16){
+					buf[k++]=bufferI[z+3];
+					z+=4;
+				}
+			}
+		}
+	}
+	bufferU[j++]=TX16;
+	bufferU[j++]=6;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=eecon_temp;	//EEPGD=1
+	bufferU[j++]=(EECON1>>8)&0xFF;
+	bufferU[j++]=EECON1&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=data_temp&0xFF;
+	bufferU[j++]=(EEDATA>>8)&0xFF;
+	bufferU[j++]=EEDATA&0xFF;
+	bufferU[j++]=WREG;			//write register
+	bufferU[j++]=addr_temp&0xFF;
+	bufferU[j++]=(EEADR>>8)&0xFF;
+	bufferU[j++]=EEADR&0xFF;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;		//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+10*Tcom);
+	return i;
+}
+
+// get register name from list
+char* getVar(int addr,char *var){
+	addr&=0x1FF;
+	if(variables[addr].name) strcpy(var,variables[addr].name);
+	else sprintf(var,"0x%03X",addr);
+	return var;
+}
+
+//Disassemble a command and return string
+//addrH is the higher (bank) address for memory (RP1-RP0)
+char* decodeCmd(int cmd,char *str, int addrH){
+	char ins[32],reg[32];
+	if((cmd&0x3F9F)==0) sprintf(str,"nop");
+	else if(cmd==0x0001) sprintf(str,"reset");
+	else if(cmd==0x0008) sprintf(str,"return");
+	else if(cmd==0x0009) sprintf(str,"retfie");
+	else if(cmd==0x000A) sprintf(str,"callw");
+	else if(cmd==0x000B) sprintf(str,"brw");
+	else if(cmd==0x0062) sprintf(str,"option");
+	else if(cmd==0x0063) sprintf(str,"sleep");
+	else if(cmd==0x0064) sprintf(str,"clrwdt");
+	else if(cmd==0x0065) sprintf(str,"trisa");
+	else if(cmd==0x0066) sprintf(str,"trisb");
+	else if(cmd==0x0067) sprintf(str,"trisc");
+	else if((cmd>>12)==0){	//byte oriented instructions
+		if((cmd>>8)==0&&cmd&0x80) sprintf(str,"movwf %s",getVar(addrH+(cmd&0x7F),reg));
+		else if((cmd>>8)==1){
+			if(cmd&0x80) sprintf(str,"clrf %s",getVar(addrH+(cmd&0x7F),reg));
+			else sprintf(str,"clrf w");
+		}
+		else{
+			switch(cmd>>8){
+				case 2:
+					sprintf(ins,"subwf");
+				break;
+				case 3:
+					sprintf(ins,"decf");
+				break;
+				case 4:
+					sprintf(ins,"iorwf");
+				break;
+				case 5:
+					sprintf(ins,"andwf");
+				break;
+				case 6:
+					sprintf(ins,"xorwf");
+				break;
+				case 7:
+					sprintf(ins,"addwf");
+				break;
+				case 8:
+					sprintf(ins,"movf");
+				break;
+				case 9:
+					sprintf(ins,"comf");
+				break;
+				case 10:
+					sprintf(ins,"incf");
+				break;
+				case 11:
+					sprintf(ins,"decfsz");
+				break;
+				case 12:
+					sprintf(ins,"rrf");
+				break;
+				case 13:
+					sprintf(ins,"rlf");
+				break;
+				case 14:
+					sprintf(ins,"swapf");
+				break;
+				case 15:
+					sprintf(ins,"incfsz");
+				break;
+				default:
+					sprintf(ins,"???");
+				break;
+			}
+			sprintf(str,"%s %s,%c",ins,getVar(addrH+(cmd&0x7F),reg),cmd&0x80?'f':'w');
+		}
+	}
+	else if((cmd>>12)==1){	//bit oriented instructions
+		switch(cmd>>10){
+			case 4:
+				sprintf(ins,"bcf");
+			break;
+			case 5:
+				sprintf(ins,"bsf");
+			break;
+			case 6:
+				sprintf(ins,"btfsc");
+			break;
+			case 7:
+				sprintf(ins,"btfss");
+			break;
+			default:
+				sprintf(ins,"??");	//(not possible)
+		}
+		sprintf(str,"%s %s,%d",ins,getVar(addrH+(cmd&0x7F),reg),(cmd&0x380)>>7);
+	}
+	else if((cmd>>12)==2) sprintf(str,"%s 0x%X",cmd&0x800?"goto":"call",cmd&0x7FF);
+	else if((cmd>>10)==0xC) sprintf(str,"movlw 0x%X",cmd&0xFF);
+	else if((cmd>>10)==0xD) sprintf(str,"retlw 0x%X",cmd&0xFF);
+	else if((cmd>>9)==0x1E) sprintf(str,"sublw 0x%X",cmd&0xFF);
+	else if((cmd>>9)==0x1F) sprintf(str,"addlw 0x%X",cmd&0xFF);
+	else if((cmd>>8)==0x38) sprintf(str,"iorlw 0x%X",cmd&0xFF);
+	else if((cmd>>8)==0x39) sprintf(str,"andlw 0x%X",cmd&0xFF);
+	else if((cmd>>8)==0x3A) sprintf(str,"xorlw 0x%X",cmd&0xFF);
+	else sprintf(str,"unknown command");
+	return str;
+}
+
+//Functions tied to GUI:
+///
+///Print a message on the ICD data field
+void PrintMessageICD(const char *msg){
+	GtkTextIter iter;
+	gtk_text_buffer_set_text(statusBuf,msg,-1);
+	gtk_text_buffer_get_start_iter(statusBuf,&iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(statusTxt),&iter,0.0,FALSE,0,0);
+	while (gtk_events_pending ()) gtk_main_iteration();
+}
+///
+///Append a message on the ICD data field
+void AppendMessageICD(const char *msg){
+	GtkTextIter iter;
+	gtk_text_buffer_get_end_iter(statusBuf,&iter);
+	gtk_text_buffer_insert(statusBuf,&iter,msg,-1);
+	gtk_text_buffer_get_start_iter(statusBuf,&iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(statusTxt),&iter,0.0,FALSE,0,0);
+	while (gtk_events_pending ()) gtk_main_iteration();
+}
+///
+///Scroll source file
+void scrollToLine(int line)
+{
+	GtkTextIter iter,iter2;
+	gtk_text_buffer_get_end_iter(sourceBuf,&iter);
+	if(line>0){
+		gtk_text_iter_set_line(&iter,line-1);
+		iter2=iter;
+		gtk_text_iter_forward_char(&iter2);
+		gtk_text_iter_forward_to_line_end(&iter2);
+	}
+	else{
+		gtk_text_buffer_get_selection_bounds(sourceBuf,&iter,&iter2);
+		iter2=iter;
+	}
+	gtk_text_buffer_select_range(sourceBuf,&iter,&iter2);
+	while (gtk_events_pending ()) gtk_main_iteration();
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(sourceTxt),&iter,0.0,TRUE,0,0.5);
+}
+///
+///Hilight line in source code
+void SourceHilightLine(int line)
+{
+	GtkTextIter iter,iter2;
+	GtkTextTag* tag;
+	if(line>0){
+		tag=gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(sourceBuf),"break_text");
+		if(!tag) tag=gtk_text_buffer_create_tag(sourceBuf,"break_text","background","red", NULL);
+		gtk_text_buffer_get_end_iter(sourceBuf,&iter);
+		gtk_text_iter_set_line(&iter,line-1);
+		iter2=iter;
+		gtk_text_iter_forward_char(&iter2);
+		gtk_text_iter_forward_to_line_end(&iter2);
+		gtk_text_buffer_apply_tag (sourceBuf,tag,&iter,&iter2);
+	}
+	while (gtk_events_pending ()) gtk_main_iteration();
+}
+///
+///Remove hilight line in source code
+void SourceRemoveHilightLine(int line)
+{
+	GtkTextIter iter,iter2;
+	if(line>0){
+		gtk_text_buffer_get_end_iter(sourceBuf,&iter);
+		gtk_text_iter_set_line(&iter,line-1);
+		iter2=iter;
+		gtk_text_iter_forward_char(&iter2);
+		gtk_text_iter_forward_to_line_end(&iter2);
+		gtk_text_buffer_remove_tag_by_name(sourceBuf,"break_text",&iter,&iter2);
+	}
+	while (gtk_events_pending ()) gtk_main_iteration();
+}
+///
+///load source file into source pane
+int loadSource(FILE *f){
+	if(!f) return 0;
+	fseek(f,0,SEEK_END);
+	int size=ftell(f);
+	fseek(f,0,SEEK_SET);
+	char* tmp=(char*)malloc(size+1);
+	size=fread(tmp,1,size,f);
+	tmp[size]=0;
+	char* g=g_locale_to_utf8(tmp,-1,NULL,NULL,NULL);
+	gtk_text_buffer_set_text(sourceBuf,g,-1);
+	free(tmp);
+	g_free(g);
+	return 1;
+}
+///
+///load and analyze coff file
+void loadCoff(GtkWidget *widget,GtkWidget *window)
+{
+	GtkFileChooser *dialog;
+	dialog = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[I_LOAD_COFF], //"Open Coff File",
+						GTK_WINDOW(window),
+						GTK_FILE_CHOOSER_ACTION_OPEN,
+						strings[I_CANCEL], GTK_RESPONSE_CANCEL,
+						strings[I_OPEN], GTK_RESPONSE_ACCEPT,
+						NULL);
+	if(cur_path) gtk_file_chooser_set_current_folder(dialog,cur_path);
+    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT){
+	    char *filename;
+	    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+		if(cur_path) free(cur_path);
+		cur_path = gtk_file_chooser_get_current_folder(dialog);
+		UseCoff=analyzeCOFF(filename,Slabel,Sulabel,source_info,&s_files,coff_data,&sym,&nsym);
+		g_free (filename);
+		//load source for address 0
+		if(source_info[0].src_file!=-1){
+			if(currentSource==source_info[0].src_file){
+				scrollToLine(source_info[0].src_line);
+			}
+			else if(loadSource(s_files[source_info[0].src_file].ptr)){
+				scrollToLine(source_info[0].src_line);
+				currentSource=source_info[0].src_file;
+			}
+		}
+	}
+	gtk_widget_destroy (GTK_WIDGET(dialog));
+}
+///
+/// List of variables used when decoding an assembly word
+void initVar(){
+	int i;
+	for(i=0;i<0x200;i++){//clear variable list
+		variables[i].name=0;
+		variables[i].display=0;
+	}
+	variables[0].name="INDF";
+	variables[1].name="TMR0";
+	variables[2].name="PCL";
+	variables[3].name="STATUS";
+	variables[4].name="FSR";
+	variables[5].name="PORTA";
+	variables[6].name="PORTB";
+	variables[7].name="PORTC";
+	variables[8].name="PORTD";
+	variables[9].name="PORTE";
+	variables[10].name="PCLATH";
+	variables[11].name="INTCON";
+	variables[12].name="PIR1";
+	variables[13].name="PIR2";
+	variables[14].name="TMR1L";
+	variables[15].name="TMR1H";
+	variables[16].name="T1CON";
+	variables[17].name="TMR2";
+	variables[18].name="T2CON";
+	variables[19].name="SSPBUF";
+	variables[20].name="SSPCON";
+	variables[21].name="CCPR1L";
+	variables[22].name="CCPR1H";
+	variables[23].name="CCP1CON";
+	variables[24].name="RCSTA";
+	variables[25].name="TXREG";
+	variables[26].name="RCREG";
+	variables[27].name="CCPR2L";
+	variables[28].name="CCPR2H";
+	variables[29].name="CCP2CON";
+	variables[30].name="ADRESH";
+	variables[31].name="ADCON0";
+	variables[0x6B].name="DEBUG_VAR1";
+	variables[0x6C].name="DEBUG_VAR2";
+	variables[0x6D].name="DEBUG_VAR3";
+	variables[0x6E].name="DEBUG_VAR4";
+	variables[0x6F].name="DEBUG_VAR5";
+	variables[0x70].name="DEBUG_VAR6";
+	variables[0x71].name="DEBUG_VAR7";
+	variables[0x72].name="DEBUG_VAR8";
+	variables[0x80].name="INDF";
+	variables[0x81].name="OPTION_REG";
+	variables[0x82].name="PCL";
+	variables[0x83].name="STATUS";
+	variables[0x84].name="FSR";
+	variables[0x85].name="TRISA";
+	variables[0x86].name="TRISB";
+	variables[0x87].name="TRISC";
+	variables[0x88].name="TRISD";
+	variables[0x89].name="TRISE";
+	variables[0x8A].name="PCLATH";
+	variables[0x8B].name="INTCON";
+	variables[0x8C].name="PIE1";
+	variables[0x8D].name="PIE2";
+	variables[0x8E].name="PCON";
+	variables[0x91].name="SSPCON2";
+	variables[0x92].name="PR2";
+	variables[0x93].name="SSPADD";
+	variables[0x94].name="SSPSTAT";
+	variables[0x98].name="TXSTA";
+	variables[0x99].name="SPBRG";
+	variables[0x9E].name="ADRESL";
+	variables[0x9F].name="ADCON1";
+	variables[0x100].name="INDF";
+	variables[0x101].name="TMR0";
+	variables[0x102].name="PCL";
+	variables[0x103].name="STATUS";
+	variables[0x104].name="FSR";
+	variables[0x106].name="PORTB";
+	variables[0x10A].name="PCLATH";
+	variables[0x10B].name="INTCON";
+	variables[0x10C].name="EEDATA";
+	variables[0x10D].name="EEADR";
+	variables[0x10E].name="EEDATH";
+	variables[0x10F].name="EEADRH";
+	variables[0x180].name="INDF";
+	variables[0x181].name="OPTION_REG";
+	variables[0x182].name="PCL";
+	variables[0x183].name="STATUS";
+	variables[0x184].name="FSR";
+	variables[0x186].name="TRISB";
+	variables[0x18A].name="PCLATH";
+	variables[0x18B].name="INTCON";
+	variables[0x18C].name="EECON1";
+	variables[0x18D].name="EECON2";
+}
+///
+///Show ICD help window
+void ICDHelp(GtkWidget *widget,GtkWidget *window)
+{
+	GtkWidget* dialog = gtk_message_dialog_new (GTK_WINDOW(window),
+                                 GTK_DIALOG_DESTROY_WITH_PARENT,
+                                 GTK_MESSAGE_INFO,
+                                 GTK_BUTTONS_CLOSE,
+                                 strings[I_ICD_HELP_TXT]);
+
+	g_signal_connect_swapped (GTK_WINDOW(dialog), "response",G_CALLBACK (gtk_widget_destroy),dialog);
+	gtk_window_set_title(GTK_WINDOW(dialog),strings[I_ICD_HELP]);
+	gtk_widget_show_all (dialog);
+}
+///
+///ICD: check if program is running
+void icdCheck(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(!isRunning()){
+		g_source_remove(icdTimer);
+		ShowContext();
+	}
+}
+///
+///ICD: run program
+void icdRun(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(!icdConnected){
+		saveLog = (int) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_log));
+		if(saveLog){
+			OpenLogFile();	//"Log.txt"
+			fprintf(logfile,"ICD start\n");
+		}
+		startICD(Tck);	//start ICD mode by supplying the target and forcing a reset
+		run();			//remove reset
+		icdConnected=1;
+		icdTimer=g_timeout_add(20,(GSourceFunc)icdCheck,NULL);
+		PrintMessageICD("running");
+	}
+	else if(!running){
+		cont(break_addr,freeze);	//continue execution
+		icdTimer=g_timeout_add(20,(GSourceFunc)icdCheck,NULL);
+		PrintMessageICD("running");
+	}
+}
+///
+///ICD: halt program
+void icdHalt(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(running){
+		g_source_remove(icdTimer);
+		Halt();
+		ShowContext();
+	}
+}
+///
+///ICD: step program
+void icdStep(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(running){
+		g_source_remove(icdTimer);
+		Halt();
+	}
+	step();
+#ifdef DEBUG
+	addrDebug++;
+#endif
+	ShowContext();
+}
+///
+///ICD: step program jumping over calls
+void icdStepOver(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	int addr,data;
+	if(running){
+		g_source_remove(icdTimer);
+		Halt();
+	}
+	addr=((ReadRegister(0x18E)&0x1F)<<8)+ReadRegister(0x18F);
+	data=ReadProgMem(addr);
+	if((data>>11)==4){	//if call break at return address
+		cont(addr+1,freeze);
+		icdTimer=g_timeout_add(20,(GSourceFunc)icdCheck,NULL);
+	}
+	else{		//normal step
+		step();
+		#ifdef DEBUG
+		addrDebug++;
+		#endif
+		ShowContext();
+	}
+}
+///
+///ICD: stop program
+void icdStop(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(running){
+		g_source_remove(icdTimer);
+		Halt();
+	}
+//	bufferU[0]=0;
+	int j=0;
+	bufferU[j++]=EN_VPP_VCC;		// reset target
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x2;				//set D as input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(3);
+	if(saveLog)WriteLogIO();
+	icdConnected=0;
+	PrintMessageICD("stopped");
+	scrollToLine(source_info[0].src_line);
+}
+///
+///ICD: refresh status
+void icdRefresh(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(!running){
+		ShowContext();
+	}
+}
+///
+/// Read and display an entire bank of memory
+void ShowBank(int bank,char* status){
+	if(bank>3) bank=3;
+	if(bank<0) bank=0;
+	int b[128];
+	char temp[128];
+	int i;
+	sprintf(temp,"bank %d:",bank);
+	strcat(status,temp);
+	ReadRegisterN(bank*0x80,128,b);
+	for(i=0;i<128;i++){
+		if(i%16==0){
+			sprintf(temp,"\n0x%03X:",i+bank*0x80);
+			strcat(status,temp);
+		}
+		sprintf(temp,"%02X",b[i]);
+		strcat(status,temp);
+	}
+	strcat(status,"\n");
+}
+///
+/// Main ICD show function:
+/// prints status info according to selected options
+/// and the value of variables in the watch list
+void ShowContext(){
+	int i,addr,data,s;
+	char cmd[32]="";
+	char status[4096]="",temp[128];
+	addr=((ReadRegister(0x18E)&0x1F)<<8)+ReadRegister(0x18F);
+	data=ReadProgMem(addr);
+	s=ReadRegister(status_temp);
+	s=(s>>4)+((s<<4)&0xF0);		//STATUS is swapped
+//	printf("addr %X, status %X, data %X\n",addr,s,data);
+#ifdef DEBUG
+	addr=addrDebug;
+	s=statusDebug;
+	if(UseCoff) data=coff_data[addr];
+#endif
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuPC))){
+		sprintf(temp,"%s: %s (0x%04X) \nPC=0x%04X\n",strings[S_NextIns],decodeCmd(data,cmd,(s&0x60)<<2),data,addr); //"Next instruction"
+		strcat(status,temp);
+	}
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuSTAT))){
+		sprintf(temp,"STATUS=0x%02X (",s);
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x80?"IRP":"   ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x40?"RP1":"   ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x20?"RP0":"   ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x10?"TO":"  ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x8?"PD":"  ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x4?"Z":" ");
+		strcat(status,temp);
+		sprintf(temp,"%s ",s&0x2?"DC":"  ");
+		strcat(status,temp);
+		sprintf(temp,"%s)\n",s&0x1?"C":" ");
+		strcat(status,temp);
+		sprintf(temp,"W=0x%02X PCLATH=0x%02X FSR=0x%02X\n",ReadRegister(w_temp),ReadRegister(pclath_temp),ReadRegister(fsr_temp));
+		strcat(status,temp);
+	}
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuBank0))) ShowBank(0,status);
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuBank1))) ShowBank(1,status);
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuBank2))) ShowBank(2,status);
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuBank3))) ShowBank(3,status);
+	int rawsource=0;
+	if(UseCoff){	//hilight corresponding source line
+		if(data!=coff_data[addr]){
+			sprintf(temp,"code at address 0x%04X (0x%04X) is different than what specified in coff file (0x%04X)\n",addr,data,coff_data[addr]);
+			strcat(status,temp);
+			rawsource=1;
+		}
+#ifndef DEBUG
+		else{
+#endif
+//			printf("addr %d, file %d, line %d, current %d, ptr %X\n",addr,source_info[addr].src_file,source_info[addr].src_line,currentSource,s_files[source_info[addr].src_file].ptr);
+			if(source_info[addr].src_file!=-1){
+				if(currentSource==source_info[addr].src_file)	scrollToLine(source_info[addr].src_line);
+				else if(loadSource(s_files[source_info[addr].src_file].ptr)){
+					scrollToLine(source_info[addr].src_line);
+					currentSource=source_info[addr].src_file;
+				}
+				else rawsource=1;
+			}
+			else rawsource=1;
+#ifndef DEBUG
+		}
+#endif
+	}
+	if(!UseCoff || rawsource==1){	//show raw source if no source file is available
+		#define LINES_BEFORE 5
+		#define LINES_AFTER 7
+		#define NLINES LINES_BEFORE + LINES_AFTER
+		int addr0,addr1,line_pc=0;
+		char tmp[64*NLINES],t2[64];
+		tmp[0]=0;
+		int progmem[NLINES];
+		addr0=addr-LINES_BEFORE<0?0:addr-LINES_BEFORE;
+		addr1=addr+LINES_AFTER>0x1FFF?0x1FFF:addr+LINES_AFTER;
+		ReadProgMemN(addr0,addr1-addr0,progmem);
+		for(i=addr0;i<addr1;i++){
+			sprintf(t2,"0x%04X: %s (0x%04X)\n",i,decodeCmd(progmem[i-addr0],cmd,(s&0x60)<<2),progmem[i-addr0]);
+			strcat(tmp,t2);
+			if(i==addr) line_pc=i;
+		}
+		gtk_text_buffer_set_text(sourceBuf,tmp,-1);
+		currentSource=-1;
+		scrollToLine(line_pc-addr0+1);
+	}
+	for(i=0;i<nwatch;i++){
+		sprintf(temp,"%s=0x%02X\n",watch[i].name,ReadRegister(watch[i].value));
+		strcat(status,temp);
+	}
+	PrintMessageICD(status);
+	if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(icdMenuEE))){
+		unsigned char data[256];
+		str[0]=0;
+		char s[64],t[9],*g;
+		t[8]=0;
+		ReadDataMemN(0,256,data);
+		strcat(str,"EEPROM:\n");
+		for(i=0;i<0x100;i++){
+			if(i%8==0){
+				sprintf(s,"\n0x%02X: ",i);
+				strcat(str,s);
+			}
+			sprintf(s,"%02X ",data[i]);
+			strcat(str,s);
+			t[i&0x7]=isprint(data[i])?data[i]:'.';
+			if(i%8==7){
+				g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+				if(g) strcat(str,g);
+				g_free(g);
+			}
+		}
+		AppendMessageICD(str);
+	}
+}
+///
+///Add symbol to the list of watched variables
+int addWatch(struct symbol s){
+	int i;
+	for(i=0;i<nwatch&&strcmp(watch[i].name,s.name);i++);
+	if(i<nwatch){	//remove watch
+		for(;i<nwatch-1;i++){
+			watch[i].name=watch[i+1].name;
+			watch[i].value=watch[i+1].value;
+		}
+		nwatch--;
+		watch=realloc(watch,nwatch*sizeof(struct symbol));
+	}
+	else{			//add watch
+		nwatch++;
+		watch=realloc(watch,nwatch*sizeof(struct symbol));
+		watch[nwatch-1].name=s.name;
+		watch[nwatch-1].value=s.value;
+		return 1;
+	}
+	return 0;
+}
+///
+/// ICD Command parser
+int executeCommand(char *command){
+//******************* break ********************************
+	if(strstr(command,"break")){
+		if(sscanf(command,"break %x",&break_addr)==1){
+			if(running) Halt();
+			break_addr&=0x1FFF;
+			sprintf(str,"break at address 0x%04X\n",break_addr);
+			AppendMessageICD(str);
+			SourceRemoveHilightLine(sourceHilight);
+			SourceHilightLine(source_info[break_addr].src_line);
+			sourceHilight=source_info[break_addr].src_line;
+		}
+	}
+//******************* clear ********************************
+	if(strstr(command,"clear")){
+		PrintMessageICD("");
+	}
+//******************* freeze ********************************
+	else if(strstr(command,"freeze")){
+		char option[32];
+		if(sscanf(command,"freeze %s",option)==1){
+			if(running) Halt();
+			if(!strcmp(option,"on")) freeze=1;
+			if(!strcmp(option,"off")) freeze=0;
+			WriteRegister(0x18E,(break_addr>>8)+(freeze?0x40:0));
+		}
+		sprintf(str,"peripheral freeze is %s\n",freeze?"on":"off");
+		AppendMessageICD(str);
+	}
+//******************* halt ********************************
+	else if(!strcmp(command,"h")||!strcmp(command,"halt")){
+		icdHalt(NULL,NULL);
+	}
+//******************* help ********************************
+	else if(!strcmp(command,"help")){
+		ICDHelp(NULL,NULL);
+	}
+//******************* list ********************************
+	else if(strstr(command,"list ")){
+		#define LISTLINES 10
+		int addr,i;
+		char tmp[32*LISTLINES],t2[32],cmd[32]="";
+		tmp[0]=0;
+		int progmem[LISTLINES];
+		if(sscanf(command,"list %x",&addr)==1){
+			addr&=0x1FFF;
+			ReadProgMemN(addr,LISTLINES,progmem);
+			for(i=0;i<LISTLINES;i++){
+				sprintf(t2,"0x%04X: %s (0x%04X)\n",i+addr,decodeCmd(progmem[i],cmd,0),progmem[i]);
+				strcat(tmp,t2);
+			}
+			//printf(tmp);
+			AppendMessageICD(tmp);
+		}
+	}
+//******************* print ********************************
+	else if(strstr(command,"print ")||strstr(command,"p ")){
+		int bank,i,addr,data;
+		char var[128];
+		if(strstr(command,"print p")||strstr(command,"p p")){	//program memory
+			int addr;
+			if(sscanf(command,"print p %x",&addr)==1||sscanf(command,"p p %x",&addr)==1){
+				addr&=0x1FFF;
+				if(running) Halt();
+				data=ReadProgMem(addr);
+				sprintf(str,"0x%04X: %s (0x%04X)\n",addr,decodeCmd(data,var,0x1000),data);
+				AppendMessageICD(str);
+			}
+		}
+		else if(!strcmp(command,"print ee")||!strcmp(command,"p ee")){	//eeprom
+			unsigned char data[256];
+			str[0]=0;
+			char s[64],t[9],*g;
+			t[8]=0;
+			if(running) Halt();
+			ReadDataMemN(0,256,data);
+			sprintf(str,"EEPROM:\n");
+			for(i=0;i<0x100;i++){
+				if(i%8==0){
+					sprintf(s,"\n0x%02X: ",i);
+					strcat(str,s);
+				}
+				sprintf(s,"%02X ",data[i]);
+				strcat(str,s);
+				t[i&0x7]=isprint(data[i])?data[i]:'.';
+				if(i%8==7){
+					g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+					if(g) strcat(str,g);
+					g_free(g);
+				}
+			}
+			strcat(str,"\n");
+			//printf("EEPROM:\n");fflush(stdout);
+			AppendMessageICD(str);
+		}
+		else if(sscanf(command,"print ee %x",&addr)==1||sscanf(command,"p ee %x",&addr)==1){ //single EE address
+			addr&=0xFF;
+			if(running) Halt();
+			data=ReadDataMem(addr);
+			sprintf(str,"eeprom memory at 0x%02X=0x%02X (%c)\n",addr,data,isprint(data)?data:'.');
+			AppendMessageICD(str);
+		}
+		else if(sscanf(command,"print bank %x",&bank)==1||sscanf(command,"p bank %x",&bank)==1){	//memory bank
+			str[0]=0;
+			bank&=0x1FF;
+			if(bank>3) bank/=0x80;
+			if(running) Halt();
+			ShowBank(bank,str);
+			AppendMessageICD(str);
+		}
+		else if(sscanf(command,"print 0x%x",&print_addr)==1||sscanf(command,"p 0x%x",&print_addr)==1){ //mem address
+			print_addr&=0x1FF;
+			if(running) Halt();
+			sprintf(str,"[0x%03X]=0x%02X\n",print_addr,ReadRegister(print_addr));
+			AppendMessageICD(str);
+		}
+		else if(sscanf(command,"print %s",var)==1||sscanf(command,"p %s",var)==1){ //var name
+			str[0]=0;
+			if(running) Halt();
+			if(!strcmp("W",var)||!strcmp("w",var)) sprintf(str,"W = 0x%02X\n",ReadRegister(w_temp));
+			else if(!strcmp("STATUS",var)) sprintf(str,"0x003: STATUS = 0x%02X\n",ReadRegister(status_temp));
+			else if(!strcmp("FSR",var)) sprintf(str,"0x004: FSR = 0x%02X\n",ReadRegister(fsr_temp));
+			else if(!strcmp("PCLATH",var)) sprintf(str,"0x00A: PCLATH = 0x%02X\n",ReadRegister(pclath_temp));
+			else{
+				for(i=0;i<nsym&&strcmp(var,sym[i].name);i++);
+				if(i<nsym){
+					sprintf(str,"0x%03X: %s = 0x%02X\n",sym[i].value,sym[i].name,ReadRegister(sym[i].value));
+				}
+				else{	//look in standard variables
+					for(i=0;i<0x200;i++){
+						if(variables[i].name&&!strcmp(var,variables[i].name)){
+							sprintf(str,"0x%03X: %s = 0x%02X\n",i,variables[i].name,ReadRegister(i));
+							i=0x200;
+						}
+					}
+				}
+			}
+			AppendMessageICD(str);
+		}
+	}
+//******************* run ********************************
+	else if(!strcmp(command,"r")||!strcmp(command,"run")){
+		icdRun(NULL,NULL);
+	}
+//******************* step ********************************
+	else if(!strcmp(command,"s")||!strcmp(command,"step")||strstr(command,"step")||strstr(command,"s ")){
+		int i,n=1;
+		sscanf(command,"step %d",&n);
+		sscanf(command,"s %d",&n);
+#ifdef DEBUG
+		addrDebug+=n;
+#endif
+		if(running) Halt();
+		for(i=0;i<n;i++) step();
+		if(n>1)sprintf(str,"step %d\n",n);
+		else str[0]=0;
+		ShowContext();
+		AppendMessageICD(str);
+	}
+//******************* step over ********************************
+	else if(!strcmp(command,"ss")||!strcmp(command,"step over")||strstr(command,"step over ")||strstr(command,"ss ")){
+		int i,n=1;
+		sscanf(command,"step over %d",&n);
+		sscanf(command,"ss %d",&n);
+#ifdef DEBUG
+		addrDebug+=n;
+#endif
+		for(i=0;i<n;i++) icdStepOver(NULL,NULL);
+		if(n>1)sprintf(str,"step over %d\n",n);
+		AppendMessageICD(str);
+	}
+//******************* version ********************************
+	else if(!strcmp(command,"ver")||!strcmp(command,"version")){
+		if(running) Halt();
+		sprintf(str,"debugger version: %.1f\n",version()/10.0);
+		AppendMessageICD(str);
+	}
+//******************* watch ********************************
+	else if(strstr(command,"watch ")||strstr(command,"w ")){
+		int i,var_addr;
+		char var[64];
+		if(sscanf(command,"watch 0x%x",&var_addr)||sscanf(command,"w 0x%x",&var_addr)){
+			struct symbol s;
+			sprintf(var,"[0x%X]",var_addr);
+			s.name=strdup(var);
+			s.value=var_addr;
+			addWatch(s);
+			if(!running) ShowContext();
+		}
+		else if(sscanf(command,"watch %s",var)||sscanf(command,"w %s",var)){
+			for(i=0;i<nsym&&strcmp(var,sym[i].name);i++);
+			if(i<nsym){
+				addWatch(sym[i]);
+				if(!running) ShowContext();
+			}
+			else{	//look in standard variables
+				for(i=0;i<0x200;i++){
+					if(variables[i].name&&!strcmp(var,variables[i].name)){
+						struct symbol s;
+						s.name=variables[i].name;
+						s.value=i;
+						addWatch(s);
+						if(!running) ShowContext();
+						i=0x200;
+					}
+				}
+			}
+		}
+	}
+//******************* set variable ********************************
+//to do: special addresses (PC, status ecc)
+	else{
+		char var[64],*p;
+		int data,i,addr=-1;
+		if((p=strchr(command,'='))){
+			*p=0;
+			if(sscanf(command,"[%x]",&addr)&&sscanf(p+1,"%x",&data)){
+				if(running) Halt();
+				WriteRegister(addr,data);
+				ShowContext();
+				sprintf(str,"[0x%x]=0x%02X\n",addr,data);
+				AppendMessageICD(str);
+			}
+			else if(sscanf(command,"%s",var)&&sscanf(p+1,"%x",&data)){
+				for(i=0;i<nsym&&strcmp(var,sym[i].name);i++);
+				if(i<nsym&&sym[i].value<0x400){
+					addr=sym[i].value;
+				}
+				else{	//look in standard variables
+					for(i=0;i<0x200;i++){
+						if(variables[i].name&&!strcmp(var,variables[i].name)){
+							addr=i;
+							i=0x200;
+						}
+					}
+				}
+				if(addr!=-1){
+					if(running) Halt();
+					WriteRegister(addr,data);
+					ShowContext();
+					sprintf(str,"%s=0x%02X\n",var,data);
+					AppendMessageICD(str);
+				}
+			}
+		}
+		else return 0;
+	}
+	return 1;
+}
+///
+///Remove variable from watch list
+int removeWatch(char* name){
+	int i;
+	for(i=0;i<nwatch&&strcmp(watch[i].name,name);i++);
+	if(i<nwatch){	//remove watch
+		for(;i<nwatch-1;i++){
+			watch[i].name=watch[i+1].name;
+			watch[i].value=watch[i+1].value;
+		}
+		nwatch--;
+		watch=realloc(watch,nwatch*sizeof(struct symbol));
+		return 1;
+	}
+	return 0;
+}
+///
+///Handle mouse events in source code window
+gint source_mouse_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
+{
+	if(GTK_IS_TEXT_VIEW(widget)&&event->type==GDK_2BUTTON_PRESS){
+		gint x,y,i;
+		GtkTextIter iter,iter2,itx;
+		gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(widget),GTK_TEXT_WINDOW_WIDGET,event->x,event->y,&x,&y);
+		gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget),&iter,x,y);
+//		printf("x %d y %d\n",x,y);
+		iter2=iter;
+		char c;
+		for(itx=iter2,c=gtk_text_iter_get_char(&itx);isalnum(c)||c=='_';iter2=itx){
+			gtk_text_iter_forward_char(&itx);
+			c=gtk_text_iter_get_char(&itx);
+		}
+		for(itx=iter,c=gtk_text_iter_get_char(&itx);isalnum(c)||c=='_';iter=itx){
+			gtk_text_iter_backward_char(&itx);
+			c=gtk_text_iter_get_char(&itx);
+		}
+		gtk_text_iter_forward_char(&iter);
+		char* selection=gtk_text_buffer_get_text(sourceBuf,&iter,&iter2,FALSE);
+		for(i=0;i<nsym&&strcmp(selection,sym[i].name);i++);
+		if(i<nsym){
+			addWatch(sym[i]);
+			ShowContext();
+		}
+		else{	//set breakpoint
+			int line=gtk_text_iter_get_line(&iter)+1;
+			for(i=0;i<LMAX;i++) if(source_info[i].src_line==line){
+				//if(UseCoff && i>0 && (coff_data[i-1]>>11)!=4) i--; //if not a call break at previous address;
+				break_addr=i;
+				sprintf(str,"break at address 0x%x\n",i);
+				AppendMessageICD(str);
+				SourceRemoveHilightLine(sourceHilight);
+				SourceHilightLine(line);
+				sourceHilight=line;
+				break;
+			}
+		}
+	}
+	return FALSE;
+}
+///
+///Handle mouse events in ICD status window
+gint icdStatus_mouse_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
+{
+	if(GTK_IS_TEXT_VIEW(widget)&&event->type==GDK_2BUTTON_PRESS){
+		gint x,y;
+		GtkTextIter iter,iter2,itx;
+		gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(widget),GTK_TEXT_WINDOW_WIDGET,event->x,event->y,&x,&y);
+		gtk_text_view_get_iter_at_location  (GTK_TEXT_VIEW(widget),&iter,x,y);
+		iter2=iter;
+		char c;
+		for(itx=iter2,c=gtk_text_iter_get_char(&itx);isalnum(c)||c=='_';iter2=itx){
+			gtk_text_iter_forward_char(&itx);
+			c=gtk_text_iter_get_char(&itx);
+		}
+		for(itx=iter,c=gtk_text_iter_get_char(&itx);isalnum(c)||c=='_';iter=itx){
+			gtk_text_iter_backward_char(&itx);
+			c=gtk_text_iter_get_char(&itx);
+		}
+		gtk_text_iter_forward_char(&iter);
+		char* selection=gtk_text_buffer_get_text(statusBuf,&iter,&iter2,FALSE);
+		if(removeWatch(selection)) ShowContext();
+	}
+	return FALSE;
+}
+///
+///Handle keyboard events in ICD command edit box
+gint icdCommand_key_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
+{
+	if(event->type==GDK_KEY_PRESS&&((GdkEventKey*)event)->keyval==0xFF0D){	//enter
+		char s[64];
+		strncpy(s,gtk_entry_get_text(GTK_ENTRY(icdCommand)),63);
+		if(!strlen(s)){
+			strcpy(s,lastCmd);
+			gtk_entry_set_text(GTK_ENTRY(icdCommand),s);	//briefly flash last command
+			while (gtk_events_pending ()) gtk_main_iteration();
+			msDelay(60);
+		}
+		else strcpy(lastCmd,s);
+		if(executeCommand(s)) gtk_entry_set_text(GTK_ENTRY(icdCommand),"");
+//		sprintf(s,"k=%X\n",((GdkEventKey*)event)->keyval);
+//		AppendMessageICD(gtk_entry_get_text(icdCommand));
+	}
+	return FALSE;
+}
+///
+///Handle keyboard events in ICD tab
+gint icd_key_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
+{
+	while (gtk_events_pending ()) gtk_main_iteration();	//wait completion of other tasks
+	if(event->type==GDK_KEY_PRESS){
+		switch(((GdkEventKey*)event)->keyval){
+			case 0xFFBE:
+				ICDHelp(NULL,NULL);	//F1 = help
+				break;
+			case 0xFFC2:
+				icdHalt(NULL,NULL);	//F5 = halt
+				break;
+			case 0xFFC4:
+				icdStep(NULL,NULL);	//F7 = step
+				break;
+			case 0xFFC5:
+				icdStepOver(NULL,NULL);	//F8 = step over
+				break;
+			case 0xFFC6:
+				icdRun(NULL,NULL);	//F9 = run
+				break;
+		}
+//		char s[64];
+//		sprintf(s,"k=%X\n",((GdkEventKey*)event)->keyval);
+//		AppendMessageICD(s);
+	}
+	return FALSE;
+}
+
diff --git a/icd.h b/icd.h
new file mode 100644
index 0000000..e9f7ead
--- /dev/null
+++ b/icd.h
@@ -0,0 +1,185 @@
+//General routines to communicate via ICD with a target
+
+//The following commands are implemented in the debugger monitor
+//routine which is written in the last memory page on the target chip.
+#define VER 	1	//;version
+#define STEP 	2	//;step
+#define GO 		3	//;go
+#define RREG 	4	//;read register
+#define WREG 	5	//;write register
+#define EEADR 0x10D
+#define EEADRH 0x10F
+#define EEDATA 0x10C
+#define EEDATH 0x10E
+#define EECON1 0x18C
+#define EECON2 0x18D
+#define w_temp 0x6B
+#define status_temp 0x6C
+#define pclath_temp 0x6D
+#define fsr_temp 0x6E
+
+extern struct var{	char* name;	int display;} variables[0x200];
+
+extern GtkWidget * statusTxt;
+extern GtkWidget * sourceTxt;
+extern GtkTextBuffer * sourceBuf;
+extern GtkWidget * icdVbox1;
+extern GtkWidget * icdMenuPC;
+extern GtkWidget * icdMenuSTAT;
+extern GtkWidget * icdMenuBank0;
+extern GtkWidget * icdMenuBank1;
+extern GtkWidget * icdMenuBank2;
+extern GtkWidget * icdMenuBank3;
+extern GtkWidget * icdMenuEE;
+extern GtkWidget * icdCommand;
+extern GtkTextBuffer * statusBuf;
+
+extern int icdTimer;
+
+//Prepare ICD interface by resetting the target with a power-up sequence.
+//MCLR is low so the target is reset even if power is not supplied by the programmer.
+//Set communication speed at 1/(2*Tck us)
+void startICD(int Tck);
+
+//Check whether the target is running or is executing the debug routine.
+//This is signaled by RB7 (Data): D=1 -> debugger monitor running
+int isRunning();
+
+//Set the next breakpoint address, the freeze bit, 
+//and continue execution.
+//This is necessary because at every break 
+//the ICD register is loaded with the last address.
+void cont(int break_addr, int freeze);
+
+//Execute a single step
+void step();
+
+//Remove reset so that the target can start executing its code.
+void run();
+
+//Get the debugger monitor version
+int version();
+
+//Halt execution by setting RB6 (Clock) low
+void Halt();
+
+//Read register at address addr
+int ReadRegister(int addr);
+
+//Read n registers starting at address addr
+int ReadRegisterN(int addr,int n,int* buf);
+
+//Write data at address addr
+void WriteRegister(int addr,int data);
+
+//Read program memory at address addr
+int ReadProgMem(int addr);
+
+//Read program memory at address addr
+int ReadProgMemN(int addr,int n,int* buf);
+
+//Read data memory at address addr
+int ReadDataMem(int addr);
+
+//Read data memory at address addr
+int ReadDataMemN(int addr,int n,unsigned char* buf);
+
+//Disassemble a command and return string
+char* decodeCmd(int cmd,char *str, int addrH);
+
+// get register name from list
+char* getVar(int addr,char *var);
+
+///
+///Scroll source file
+void scrollToLine(int line);
+
+///
+///Hilight line in source code
+void SourceHilightLine(int line);
+
+///
+///Remove hilight line in source code
+void SourceRemoveHilightLine(int line);
+
+///
+///load source file into source pane
+int loadSource(FILE *f);
+
+///
+///load and analyze coff file
+void loadCoff(GtkWidget *widget,GtkWidget *window);
+
+///
+/// List of variables used when decoding an assembly word
+void initVar();
+
+///
+///Show ICD help window
+void ICDHelp(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: check if program is running
+void icdCheck(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: run program
+void icdRun(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: halt program
+void icdHalt(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: step program
+void icdStep(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: step program jumping over calls
+void icdStepOver(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: stop program
+void icdStop(GtkWidget *widget,GtkWidget *window);
+
+///
+///ICD: refresh status
+void icdRefresh(GtkWidget *widget,GtkWidget *window);
+
+///
+/// Read and display an entire bank of memory
+void ShowBank(int bank,char* status);
+
+///
+/// Main ICD show function:
+/// prints status info according to selected options
+/// and the value of variables in the watch list
+void ShowContext();
+
+///
+///Add symbol to the list of watched variables
+int addWatch(struct symbol s);
+
+///
+/// ICD Command parser
+int executeCommand(char *command);
+
+///
+///Remove variable from watch list
+int removeWatch(char* name);
+
+///
+///Handle mouse events in source code window
+gint source_mouse_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data);
+
+///
+///Handle mouse events in ICD status window
+gint icdStatus_mouse_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data);
+
+///
+///Handle keyboard events in ICD command edit box
+gint icdCommand_key_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data);
+
+///
+///Handle keyboard events in ICD tab
+gint icd_key_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data);
diff --git a/icons.c b/icons.c
new file mode 100644
index 0000000..7705a09
--- /dev/null
+++ b/icons.c
@@ -0,0 +1,546 @@
+#include <gtk/gtk.h>
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (write_icon)
+#endif
+#ifdef __GNUC__
+const guint8 write_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 write_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (1667) */
+  "\0\0\6\233"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\211\0\0\0\0\5\34\33\33\6\0\0\0\0\0\0\0-\0\1\1C\0\0\0=\202\0\0\0<\2\4"
+  "\0\0@\0\0\0\15\220\0\0\0\0\10@BBC\2\11\11\377*\0\0\3770\0\0\3774\0\0"
+  "\377/\0\0\377\0\0\0\377\3\0\0J\216\0\0\0\0\11\0\0\0\13\0\0\0\0\0\22\22"
+  "\217H\5\5\377\367\0\0\370\365\0\0\372\377\0\0\371b\0\0\377\0\0\0\253"
+  "\217\0\0\0\0\13\23\24\24\5\0\0\0\0\0\0\0qV\0\0\377\377\0\0\376\377\0"
+  "\0\377\363\0\0\377\0\0\0\377\0\1\1T\0\0\0\0\0\0\0\1\216\0\0\0\0\3\272"
+  "\201\201\23\0\26\26\312\205\0\0\377\202\377\0\0\377\2[\2\2\377\1\37\37"
+  "\265\221\0\0\0\0\12\0\12\12\77\40\11\11\377\354\0\0\370\377\0\0\376\377"
+  "\0\0\377.\1\1\377\0\15\15\361\10\0\0\303\0\0\0\275\0\0\0\1\216\0\0\0"
+  "\0\11\0\32\32l9\0\0\377\373\0\0\373\377\0\0\376\377\0\0\377\266\0\0\375"
+  "t\0\0\375$\0\0\377\0\0\0[\215\0\0\0\0\15\0\0\0\6\0""88\14\21\25\25\377"
+  "\265\0\0\377\377\0\0\377\376\0\0\376\377\0\0\377\377\0\0\376f\0\0\377"
+  "\0\0\0\317c\0\0\7\0\0\0\0\35\35\35\0\213\0\0\0\0\12\24\24\24\1\0\0\0"
+  "\7\4\0\0\3641\0\0\377\77\0\0\377\375\0\0\376\377\0\0\377\373\0\0\377"
+  "\27\0\0\377\0\0\0n\203\0\0\0\0\1""999\2\205\0\0\0\0\3""222\0""333\3A"
+  "AA\0\202\0\0\0\0\1###\2\202\0\0\0\0\11\0\0\0\23\0\0\0\325\352\0\0\377"
+  "\377\0\0\376\233\0\0\377\0\0\0\340\0\0\0\0\0\0\0\312$$$\355\202\0\0\0"
+  "\0\1\7\7\7\2\207\0\0\0\0\17///\15>>>X\0\0\0\0\5\5\5\20\0\0\0S\0\0\0\0"
+  "\3\0\0\314\355\0\0\377\360\0\0\377R\0\0\377\0\1\1=\0\0\0\26\24\24\24"
+  "\365\11\11\11\377\24\24\24\331\202\0\0\0\0\6+++\0\0\0\0\0\0\0\0\3\0\0"
+  "\0\0MMM\12,,,\225\202\0\0\0\0\17\17\17\17\377\0\0\0\\\0\0\0\0\3\3\3\377"
+  "\0\0\0T\4\0\0\266\365\0\0\377\307\0\0\377\3\0\0\373\0\0\0\247\0\0\0\357"
+  "\14\14\14\377\0\0\0\367\0\0\0\377###\327\202\0\0\0\0\17\377\377\377\0"
+  "\0\0\0:\0\0\0\265\0\0\0\0\15\15\15\377\12\12\12\234\202\202\202+\31\31"
+  "\31\377\0\0\0\377\11\11\11h\35\35\35\364\0\0\0\377\3\0\0\372\377\0\0"
+  "\377\205\0\0\376\203\0\0\0\377\16\0\0\0\374\2\2\2\377\0\0\0\375\6\6\6"
+  "\377%%%\271\0\0\0\0///\6""666\233\14\14\14\377\0\0\0\243\23\23\23\361"
+  "\14\14\14\377\35\35\35\377\0\0\0\376\204\0\0\0\377\3\1\0\0\377\377\0"
+  "\0\376\214\0\0\377\205\0\0\0\377\7\1\1\1\376\0\0\0\377\10\10\10\362Z"
+  "ZZ0\0\0\0\0\21\21\21\377\10\10\10\370\202\0\0\0\377\12\0\0\0\374\0\0"
+  "\0\372\0\0\0\376\0\0\0\377\1\1\1\373\0\0\0\376\0\0\0\377\16\2\2\376\373"
+  "\0\0\376K\1\1\377\202\0\0\0\376\15\15\15\15\377\11\11\11\376\213\213"
+  "\213\376\0\0\0\377\1\1\1\374\5\5\5\377\27\27\27\221\0\0\0\0\0\0\0\376"
+  "\0\0\0\377\3\3\3\376\1\1\1\376\2\2\2\377\202\0\0\0\376\23\7\7\7\377\0"
+  "\0\0\376\7\7\7\376.44\377\14\0\0\376\257\1\1\376\0\0\0\377.))\376QQQ"
+  "\376\377\377\377\377ccc\376\12\12\12\376\0\0\0\377\0\0\0\376\0\0\0\374"
+  "\21\21\21\377\77\77\77j\0\0\0\377\1\1\1\377\203\0\0\0\377\2\17\17\17"
+  "\377mmm\377\202\0\0\0\377\12\244\244\244\377MNN\377\0\0\0\377(\2\2\377"
+  "\0\0\0\377fee\377\77\77\77\377777\377[[[\377\12\12\12\377\202\0\0\0\377"
+  "\21\0\0\0\376\0\0\0\377\23\23\23\377\3\3\3\376\0\0\0\377\201\201\201"
+  "\376aaa\376vvv\377\0\0\0\376iii\376\331\331\331\377666\376'''\376\0\0"
+  "\0\377\3\4\4\376\0\0\0\376\2\1\1\377\202\0\0\0\376\1\0\0\0\377\202\0"
+  "\0\0\376\1\0\0\0\377\202\0\0\0\376\15\0\0\0\377\0\0\0\371\0\0\0\376\0"
+  "\0\0\377!!!\376\203\203\203\376qqq\377<<<\376\0\0\0\376\35\35\35\377"
+  "\3\3\3\376\0\0\0\376\1\1\1\377\202\0\0\0\376\5\0\0\0\377\0\0\0\376\0"
+  "\0\0\377\0\0\0\374\0\0\0\375\202\0\0\0\374\202\0\0\0\377\4\11\11\11\377"
+  "\10\10\10*\0\0\0\377\1\1\1\376\210\0\0\0\377\1\0\0\0\376\202\0\0\0\377"
+  "\3\0\0\0\376\0\0\0\377\0\0\0\374\204\0\0\0\377\12\0\0\0\177\0\0\0\222"
+  "\15\15\15\377111\250\33\33\33\374\0\0\0\377\1\1\1\376\2\2\2\376\2\2\2"
+  "\377\1\1\1\375\202\0\0\0\377\2\0\0\0\376\0\0\0\377\202\0\0\0\375\17\0"
+  "\0\0\374\3\3\3\377\0\0\0\377\10\10\10\377'''\221\0\0\0\254###{\21\21"
+  "\21\377\37\37\37\312\0\0\0\0\0\0\0\254\23\23\23\217!!!H\10\10\10\377"
+  "\0\0\0\364\202\0\0\0\377\21\1\1\1\377\16\16\16\350\0\0\0\332\10\10\10"
+  "\377\0\0\0\314\36\36\36\377MMMC\4\4\4\374\26\26\26\354NNN.\11\11\11\377"
+  "\1\1\1m\3\3\3\306&&&\311\0\0\0J\7\7\7\371444\213\202\0\0\0\0\23\325\325"
+  "\325\12\25\25\25\330\0\0\0\377\0\0\0\340\0\0\0g\2\2\2\377\"\"\"\253\0"
+  "\0\0n+++\377\16\16\16.\12\12\12\377@@@.\37\37\37\250\0\0\0\213\0\0\0"
+  "\0(((\215\0\0\0""7\1\1\1_\0\0\0o\207\0\0\0\0\14\37\37\37\360\4\4\4\315"
+  "\0\0\0\0\0\0\0C\0\0\0\305\0\0\0\3\12\12\12\322\13\13\13#\0\0\0B\0\0\0"
+  "\6\0\0\0\0\6\6\6(\205\0\0\0\0\5\0\0\0\4\5\5\5\4""222\3\0\0\0\0""333\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (read_icon)
+#endif
+#ifdef __GNUC__
+const guint8 read_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 read_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (1755) */
+  "\0\0\6\363"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\203\0\0\0\0\1\25\25\25\6\205\0\0\0\0\4HQH<FJF@JIJ<bbb\0\217\0\0\0\0"
+  "\11I9I3;7;\216A8A\177\35\1\35{\0\0\0\201\33\20\33\377\34\30\34\377\30"
+  "\31\30\377\2\2\2\3\215\0\0\0\0\13\0\0\0\2\0\0\0\267\11\5\11\361\20\1"
+  "\20\377\21\34\21\377\7c\7\377\0X\0\377\0n\0\370\0$\0\377\27\15\27\374"
+  "\377\377\377\0\215\0\0\0\0\12\0\0\0\3\0\30\0\377\0\223\0\377\0\235\0"
+  "\374\0\220\0\376\0\332\0\377\0\377\0\376\0X\0\377\0\0\0\342\34\35\34"
+  "%\216\0\0\0\0\3\0\0\0\2\0\31\0\374\0\253\0\377\203\0\377\0\377\3\0\374"
+  "\0\377\0\0\0\377\0\0\0\277\202\0\0\0\0\1,,,\1\214\0\0\0\0\12\4\0\4\2"
+  "\0\"\0\374\0r\0\377\0\335\0\376\0\377\0\376\0\377\0\377\0\377\0\376\0"
+  "\274\0\372\0\26\0\377\"\7\"\332\202\0\0\0\0\1""999\2\213\0\0\0\0\14\371"
+  "\363\371\5'\33'\377\0<\0\377\0n\0\377\0\240\0\373\0\377\0\377\0\377\0"
+  "\376\0\377\0\377\0\245\0\375\5\14\5\377)')\325\204{\204\17\203\0\0\0"
+  "\0\2""333\2""111\0\210\0\0\0\0\13\40\4\40\234\0I\0\377\0%\0\377\0\35"
+  "\0\377\0y\0\377\0\377\0\376\0\377\0\377\0\377\0\376\0\330\0\375\6\0\6"
+  "\377\40\30\40\177\202\0\0\0\0\1\22\22\22\2\202\0\0\0\0\1\25\25\25\0\205"
+  "\0\0\0\0\11""333\0\0\0\0\0\0\0\0.\0\17\0\377\0\14\0\353\0\0\0g\0\0\0"
+  "\377\0y\0\377\0\377\0\375\202\0\377\0\377\3\0D\0\377\24\0\24\360aya\34"
+  "\202\0\0\0\0\2""222\223+++\17\202\0\0\0\0\1""222\1\205\0\0\0\0\21\1\7"
+  "\1""2\1\0\1\334\0\0\0\15\0\0\0\0\0\0\0f\13\0\13\377\1z\1\377\0\375\0"
+  "\373\0\377\0\375\0\322\0\371\1\0\1\377\32\36\32\211\2\3\2\271\0\0\0\0"
+  "\0\0\0\332\4\4\4\345hhh2\202\0\0\0\0\1;;;\0\205\0\0\0\0\21\0\0\0/\0\0"
+  "\0\224\2\2\2b\0\0\0\0\77\32\77X\2\6\2\377\0\300\0\375\0\377\0\374\0\377"
+  "\0\377\0\\\0\376\23\1\23\377\4\4\4\264\0\0\0\16\24\24\24\362\11\11\11"
+  "\377\34\34\34\377...\241\203\0\0\0\0'\0\0\0\3\0\0\0\0\0\0\0\12\0\0\0"
+  "{+++w\7\7\7\377\0\0\0\377\0\0\0W\0\0\0\0\0\23\0\371\0\306\0\377\0\377"
+  "\0\377\0\377\0\376\0\206\0\377\0\0\0\374\0\0\0\346\0\0\0\352\14\14\14"
+  "\377\0\0\0\374\0\0\0\376\13\13\13\377\267\267\267\7\0\0\0\0\377\377\377"
+  "\0\0\0\0:\0\0\0\265\0\0\0\0\11\11\11\377\17\17\17\236\203\203\203.\33"
+  "\33\33\377\0\0\0\377\0\0\0\371\0\21\0\376\0\312\0\377\0\377\0\376\0\377"
+  "\0\377\0\320\0\376\0\25\0\376\202\0\0\0\377\2\0\0\0\374\2\2\2\376\202"
+  "\0\0\0\377\12$$$\267\0\0\0\0///\6""666\233\14\14\14\377\0\0\0\243\24"
+  "\24\24\361\14\14\14\377\36\36\36\377\0\0\0\376\202\0\0\0\377\2\0\22\0"
+  "\377\0\317\0\376\202\0\377\0\377\1\0\251\0\377\205\0\0\0\377\7\1\1\1"
+  "\376\0\0\0\377\10\10\10\362ZZZ0\0\0\0\0\21\21\21\377\10\10\10\370\202"
+  "\0\0\0\377\7\0\0\0\374\0\0\0\372\0\0\0\376\0\0\0\377\0\0\0\376\0\21\0"
+  "\376\0\310\0\377\202\0\377\0\376\1\2y\2\377\202\0\0\0\376\15\15\15\15"
+  "\377\11\11\11\376\213\213\213\376\0\0\0\377\1\1\1\374\5\5\5\377\27\27"
+  "\27\221\0\0\0\0\0\0\0\376\0\0\0\377\3\3\3\376\1\1\1\376\2\2\2\377\202"
+  "\0\0\0\376\1\6\6\6\377\202\0\0\0\376\20\0\2\0\377\0\0\0\376585\376\0"
+  "\0\0\377...\376QQQ\376\377\377\377\377ccc\376\12\12\12\376\0\0\0\377"
+  "\0\0\0\376\0\0\0\374\21\21\21\377\77\77\77j\0\0\0\377\1\1\1\377\203\0"
+  "\0\0\377\2\17\17\17\377mmm\377\202\0\0\0\377\12\3\3\3\377\0\0\0\377r"
+  "kr\377\263\254\263\377A>A\377VWV\377\77\77\77\377777\377[[[\377\12\12"
+  "\12\377\202\0\0\0\377\21\0\0\0\376\0\0\0\377\23\23\23\377\3\3\3\376\0"
+  "\0\0\377\201\201\201\376aaa\376vvv\377\0\0\0\376iii\376\333\333\333\377"
+  ",,,\376\0\0\0\376\0\0\0\377666\376\16\16\16\376444\377\202\0\0\0\376"
+  "\1\0\0\0\377\202\0\0\0\376\1\0\0\0\377\202\0\0\0\376\15\0\0\0\377\0\0"
+  "\0\371\0\0\0\376\0\0\0\377!!!\376\203\203\203\376qqq\377<<<\376\0\0\0"
+  "\376\35\35\35\377\4\4\4\376\0\0\0\376\1\1\1\377\202\0\0\0\376\7\0\0\0"
+  "\377\2\2\2\376\0\0\0\377\0\0\0\374\0\0\0\375\0\0\0\372\0\0\0\374\203"
+  "\0\0\0\377\3\0\0\0)\0\0\0\377\1\1\1\376\212\0\0\0\377\1\0\0\0\376\202"
+  "\0\0\0\377\1\0\0\0\374\204\0\0\0\377\12\26\26\26\375\7\7\7q\0\0\0\313"
+  "\36\36\36\254\33\33\33\374\0\0\0\377\1\1\1\376\2\2\2\376\2\2\2\377\1"
+  "\1\1\375\204\0\0\0\3777\0\0\0\373\3\3\3\377\0\0\0\377\0\0\0\356\0\0\0"
+  "\367\13\13\13\377'''\216\0\0\0\315\2\2\2P\0\0\0\232\13\13\13\377\0\0"
+  "\0\0\0\0\0h$$$\377!!!H\10\10\10\377\0\0\0\367\0\0\0\373\0\0\0\377\2\2"
+  "\2\377\16\16\16\347\0\0\0\340\0\0\0\322\0\0\0\311\35\35\35\377<<<\307"
+  "\0\0\0\346\15\15\15\262\0\0\0\0\0\0\0\360\0\0\0{888~\6\6\6\216\0\0\0"
+  "\0\0\0\0\227\0\0\0\21\0\0\0\0###\3\325\325\325\12\25\25\25\330\0\0\0"
+  "\377\10\10\10\377\26\26\26\277\0\0\0\370!!!\251\0\0\0s\2\2\2""2\0\0\0"
+  "\25\14\14\14\377333\40\0\0\0\0\22\22\22\373&&&C\0\0\0\1\0\0\0N\211\0"
+  "\0\0\0\15\36\36\36\351\12\12\12\352\0\0\0\0\0\0\0""9\0\0\0\253\0\0\0"
+  "\206\0\0\0W\0\0\0\0\0\0\0G\0\0\0\23\0\0\0\0\0\0\0\22\0\0\0\30\202\0\0"
+  "\0\0\4\30\30\30\6\5\5\5\3\0\0\0\0\0\0\0\3\203\0\0\0\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (system_icon)
+#endif
+#ifdef __GNUC__
+const guint8 system_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 system_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (695) */
+  "\0\0\2\317"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\215\240\345\201\0\207\0\0\0\377\221\240\345\201\0\1\0\0\0\377\204\377"
+  "\377\0\377\1\0\0\0\377\221\240\345\201\0\1\0\0\0\377\204\377\377\0\377"
+  "\1\0\0\0\377\222\240\345\201\0\1\0\0\0\377\204\377\377\0\377\1\0\0\0"
+  "\377\222\240\345\201\0\1\0\0\0\377\204\377\377\0\377\222\240\345\201"
+  "\0\1\0\0\0\377\204\377\377\0\377\203\0\0\0\377\220\240\345\201\0\1\0"
+  "\0\0\377\205\377\377\0\377\1\0\0\0\377\221\240\345\201\0\202\0\0\0\377"
+  "\204\377\377\0\377\1\0\0\0\377\213\240\345\201\0\1\0\0\0\377\203\240"
+  "\345\201\0\5\0\0\0\377\200\200\200\377\240\345\201\0\0\0\0\377\240\345"
+  "\201\0\203\377\377\0\377\202\240\345\201\0\3\200\200\200\377\0\0\0\377"
+  "\200\200\200\377\205\240\345\201\0\4\0\0\0\377\200\200\200\377\0\0\0"
+  "\377\200\200\200\377\202\240\345\201\0\5\0\0\0\377\200\200\200\377\240"
+  "\345\201\0\0\0\0\377\240\345\201\0\202\377\377\0\377\6\0\0\0\377\240"
+  "\345\201\0\0\0\0\377\200\200\200\377\0\0\0\377\200\200\200\377\205\240"
+  "\345\201\0\4\0\0\0\377\200\200\200\377\0\0\0\377\200\200\200\377\202"
+  "\240\345\201\0\5\0\0\0\377\200\200\200\377\240\345\201\0\0\0\0\377\240"
+  "\345\201\0\202\377\377\0\377\207\0\0\0\377\203\240\345\201\0\214\0\0"
+  "\0\377\1\377\377\0\377\210\0\0\0\377\202\240\345\201\0\226\0\0\0\377"
+  "\1\240\345\201\0\227\0\0\0\377\1\240\345\201\0\205\0\0\0\377\2\200\200"
+  "\200\377\377\377\377\377\202\0\0\0\377\3\377\377\377\377\0\0\0\377\377"
+  "\377\377\377\202\0\0\0\377\203\377\377\377\377\202\0\0\0\377\1\377\377"
+  "\377\377\203\0\0\0\377\1\240\345\201\0\202\0\0\0\377\1\377\377\377\377"
+  "\202\0\0\0\377\202\377\377\377\377\202\0\0\0\377\2\377\377\377\377\0"
+  "\0\0\377\202\377\377\377\377\4\0\0\0\377\377\377\377\377\0\0\0\377\377"
+  "\377\377\377\206\0\0\0\377\1\240\345\201\0\227\0\0\0\377\1\240\345\201"
+  "\0\227\0\0\0\377\1\240\345\201\0\227\0\0\0\377\1\240\345\201\0\221\0"
+  "\0\0\377\203\240\345\201\0\1\200\200\200\377\205\240\345\201\0\5\0\0"
+  "\0\377\200\200\200\377\240\345\201\0\0\0\0\377\200\200\200\377\202\240"
+  "\345\201\0\2\0\0\0\377\200\200\200\377\202\240\345\201\0\1\0\0\0\377"
+  "\203\240\345\201\0\1\200\200\200\377\210\240\345\201\0\5\0\0\0\377\200"
+  "\200\200\377\240\345\201\0\0\0\0\377\200\200\200\377\202\240\345\201"
+  "\0\1\0\0\0\377\203\240\345\201\0\1\0\0\0\377\214\240\345\201\0\5\0\0"
+  "\0\377\200\200\200\377\240\345\201\0\0\0\0\377\200\200\200\377\251\240"
+  "\345\201\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (go_icon)
+#endif
+#ifdef __GNUC__
+const guint8 go_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 go_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (599) */
+  "\0\0\2o"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\313\377\377\377\0\203\0\0\0\377\202\0\0\0\0\223\377\377\377\0\2\0\0"
+  "\0\377\252\0\0\377\203\0\0\0\377\202\0\0\0\0\221\377\377\377\0\1\0\0"
+  "\0\377\203\252\0\0\377\203\0\0\0\377\202\0\0\0\0\203\377\377\377\0\202"
+  "\0\0\0\0\212\377\377\377\0\3\0\0\0\377\252\0\0\377\377\0\0\377\203\252"
+  "\0\0\377\203\0\0\0\377\202\0\0\0\0\3\377\377\377\0\0\0\0\0\377\377\377"
+  "\0\202\0\0\0\0\210\377\377\377\0\2\0\0\0\377\252\0\0\377\203\377\0\0"
+  "\377\203\252\0\0\377\203\0\0\0\377\202\0\0\0\0\213\377\377\377\0\2\0"
+  "\0\0\377\252\0\0\377\205\377\0\0\377\203\252\0\0\377\203\0\0\0\377\203"
+  "\0\0\0\0\210\377\377\377\0\2\0\0\0\377\252\0\0\377\207\377\0\0\377\203"
+  "\252\0\0\377\203\0\0\0\377\203\0\0\0\0\206\377\377\377\0\2\0\0\0\377"
+  "\252\0\0\377\211\377\0\0\377\203\252\0\0\377\203\0\0\0\377\202\0\0\0"
+  "\0\205\377\377\377\0\2\0\0\0\377\252\0\0\377\213\377\0\0\377\203\252"
+  "\0\0\377\202\0\0\0\377\202\0\0\0\0\204\377\377\377\0\2\0\0\0\377\252"
+  "\0\0\377\211\377\0\0\377\203\252\0\0\377\203\0\0\0\377\202\0\0\0\0\205"
+  "\377\377\377\0\2\0\0\0\377\252\0\0\377\207\377\0\0\377\203\252\0\0\377"
+  "\203\0\0\0\377\202\0\0\0\0\207\377\377\377\0\2\0\0\0\377\252\0\0\377"
+  "\205\377\0\0\377\203\252\0\0\377\203\0\0\0\377\1\0\0\0\1\202\0\0\0\0"
+  "\210\377\377\377\0\2\0\0\0\377\252\0\0\377\203\377\0\0\377\203\252\0"
+  "\0\377\203\0\0\0\377\202\0\0\0\0\3\0\0\0\4\377\377\377\0\0\0\0\0\210"
+  "\377\377\377\0\3\0\0\0\377\252\0\0\377\377\0\0\377\203\252\0\0\377\203"
+  "\0\0\0\377\202\0\0\0\0\215\377\377\377\0\1\0\0\0\377\203\252\0\0\377"
+  "\203\0\0\0\377\202\0\0\0\0\217\377\377\377\0\2\0\0\0\377\252\0\0\377"
+  "\203\0\0\0\377\202\0\0\0\0\2\377\377\377\0\0\0\0\0\202\377\377\377\0"
+  "\2\0\0\0\0\377\377\377\0\202\0\0\0\0\211\377\377\377\0\203\0\0\0\377"
+  "\202\0\0\0\0\202\377\377\377\0\203\0\0\0\0\202\377\377\377\0\1\0\0\0"
+  "\0\350\377\377\377\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (halt_icon)
+#endif
+#ifdef __GNUC__
+const guint8 halt_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 halt_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (944) */
+  "\0\0\3\310"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\315\0\0\0\0\206\0\0\0\377\202\0\0\0\0\206\0\0\0\377\212\0\0\0\0\1\0"
+  "\0\0\377\203\252\0\0\377\2\254\6\6\371\0\0\0\377\202\0\0\0\0\1\0\0\0"
+  "\377\204\252\0\0\377\1\0\0\0\377\212\0\0\0\0\2\0\0\0\377\252\0\0\377"
+  "\202\377\0\0\377\2\261\30\27\354\0\0\0\377\202\0\0\0\0\2\0\0\0\377\252"
+  "\0\0\377\202\377\0\0\377\2\252\0\0\377\0\0\0\377\212\0\0\0\0\2\0\0\0"
+  "\377\252\0\0\377\202\377\0\0\377\6\257\20\20\362\0\0\0\377\377\377\377"
+  "\2\0\0\0\0\0\0\0\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0"
+  "\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377"
+  "\6\254\10\7\371\0\0\0\377\377\377\377\12\0\0\0\0\0\0\0\377\252\0\0\377"
+  "\202\377\0\0\377\3\252\0\0\377\0\0\0\377\377\377\377\0\211\0\0\0\0\2"
+  "\0\0\0\377\252\0\0\377\202\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377"
+  "\377\12\0\0\0\0\0\0\0\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0"
+  "\0\0\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0"
+  "\0\377\6\252\0\0\377\0\0\0\377\377\377\377\0\0\0\0\0\0\0\0\377\252\0"
+  "\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\377\377\377\377\0\211\0\0"
+  "\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377\6\252\0\0\377\0\0\0\377"
+  "\377\377\377\0\0\0\0\0\0\0\0\377\254\10\7\371\202\377\0\0\377\3\252\0"
+  "\0\377\0\0\0\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377\202"
+  "\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377\377\0\0\0\0\0\0\0\0\377"
+  "\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\377\377\377\377\0\211"
+  "\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377\6\252\0\0\377\0\0\0"
+  "\377\377\377\377\0\0\0\0\0\0\0\0\377\252\0\0\377\202\377\0\0\377\3\252"
+  "\0\0\377\0\0\0\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377"
+  "\202\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377\377\0\0\0\0\0\0\0\0"
+  "\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\377\377\377\377"
+  "\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377\6\252\0\0\377"
+  "\0\0\0\377\377\377\377\0\0\0\0\0\0\0\0\377\252\0\0\377\202\377\0\0\377"
+  "\3\252\0\0\377\0\0\0\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377\252\0"
+  "\0\377\202\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377\377\0\0\0\0\0"
+  "\0\0\0\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\377\377\377"
+  "\377\0\211\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377\6\252\0\0"
+  "\377\0\0\0\377\377\377\377\0\0\0\0\0\0\0\0\377\252\0\0\377\202\377\0"
+  "\0\377\3\252\0\0\377\0\0\0\377\377\377\377\0\211\0\0\0\0\2\0\0\0\377"
+  "\252\0\0\377\202\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377\377\0\0"
+  "\0\0\0\0\0\0\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\377"
+  "\377\377\377\0\211\0\0\0\0\1\0\0\0\377\204\252\0\0\377\4\0\0\0\377\377"
+  "\377\377\0\0\0\0\0\0\0\0\377\204\252\0\0\377\2\0\0\0\377\377\377\377"
+  "\0\211\0\0\0\0\206\0\0\0\377\2\377\377\377\0\0\0\0\0\206\0\0\0\377\1"
+  "\377\377\377\0\344\0\0\0\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (step_icon)
+#endif
+#ifdef __GNUC__
+const guint8 step_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 step_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (1265) */
+  "\0\0\5\11"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\262\0\0\0\0\203\0\0\0\377\210\0\0\0\0\204\0\0\0\377\1\0\0\0\0\204\0"
+  "\0\0\377\204\0\0\0\0\1\0\0\0\377\202\252\0\0\377\1\0\0\0\377\206\0\0"
+  "\0\0\2\377\377\377\0\0\0\0\377\202\252\0\0\377\3\0\0\0\377\377\377\377"
+  "\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\5\0\0\0\377\252"
+  "\0\0\377\377\0\0\377\252\0\0\377\0\0\0\377\205\0\0\0\0\2\377\377\377"
+  "\0\0\0\0\377\202\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0"
+  "\0\377\1\0\0\0\377\204\0\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377"
+  "\2\252\0\0\377\0\0\0\377\204\0\0\0\0\2\377\377\377\0\0\0\0\377\202\252"
+  "\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204"
+  "\0\0\0\0\2\0\0\0\377\252\0\0\377\203\377\0\0\377\4\252\0\0\377\0\0\0"
+  "\377\377\377\377\4\0\0\0\0\202\377\377\377\0\1\0\0\0\377\202\252\0\0"
+  "\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0"
+  "\0\0\0\2\0\0\0\377\252\0\0\377\204\377\0\0\377\6\252\0\0\377\0\0\0\377"
+  "\377\377\377\2\0\0\0\0\377\377\377\0\0\0\0\377\202\252\0\0\377\3\0\0"
+  "\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\2\0"
+  "\0\0\377\252\0\0\377\203\377\0\0\377\4\376\3\2\377\377\0\0\377\252\0"
+  "\0\377\0\0\0\377\202\377\377\377\0\1\0\0\0\371\202\252\0\0\377\3\0\0"
+  "\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\2\0"
+  "\0\0\377\252\0\0\377\203\377\0\0\377\1\376\14\13\375\202\377\0\0\377"
+  "\4\252\0\0\377\0\0\0\377\377\377\377\0\0\0\0\323\202\252\0\0\377\3\0"
+  "\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\2"
+  "\0\0\0\377\252\0\0\377\207\377\0\0\377\1\252\0\0\377\202\0\0\0\377\202"
+  "\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377"
+  "\204\0\0\0\0\2\0\0\0\377\252\0\0\377\206\377\0\0\377\4\376\33\32\376"
+  "\377\0\0\377\252\0\0\377\0\0\0\377\202\252\0\0\377\3\0\0\0\377\0\0\0"
+  "\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\2\0\0\0\377\252"
+  "\0\0\377\207\377\0\0\377\3\252\0\0\377$$$\362\0\0\0\377\202\252\0\0\377"
+  "\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0\0\0"
+  "\0\2\0\0\0\377\252\0\0\377\206\377\0\0\377\4\252\0\0\377\23\23\23\367"
+  "\377\377\377\0\0\0\0\377\202\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377"
+  "\202\252\0\0\377\1\0\0\0\377\204\0\0\0\0\2\0\0\0\377\252\0\0\377\205"
+  "\377\0\0\377\5\252\0\0\377\5\5\5\376\377\377\377\1\377\377\377\0\0\0"
+  "\0\377\202\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377"
+  "\1\0\0\0\377\204\0\0\0\0\2\0\0\0\377\252\0\0\377\204\377\0\0\377\6\252"
+  "\0\0\377\0\0\0\377\377\377\3772\0\0\0\0\377\377\377\0\0\0\0\377\202\252"
+  "\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204"
+  "\0\0\0\0\2\0\0\0\377\252\0\0\377\203\377\0\0\377\4\252\0\0\377\0\0\0"
+  "\377\377\377\377\0\0\0\0\0\202\377\377\377\0\1\0\0\0\377\202\252\0\0"
+  "\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0\0\377\204\0"
+  "\0\0\0\2\0\0\0\377\252\0\0\377\202\377\0\0\377\10\252\0\0\377\0\0\0\377"
+  "\377\377\377\0\0\0\0\0\377\377\377\0\0\0\0\0\377\377\377\0\0\0\0\377"
+  "\202\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0\0\377\1\0\0"
+  "\0\377\204\0\0\0\0\10\0\0\0\377\252\0\0\377\377\0\0\377\252\0\0\377\0"
+  "\0\0\377\377\377\377\0\0\0\0\0\377\377\377\0\202\0\0\0\0\2\377\377\377"
+  "\0\0\0\0\377\202\252\0\0\377\3\0\0\0\377\0\0\0\0\0\0\0\377\202\252\0"
+  "\0\377\1\0\0\0\377\204\0\0\0\0\1\0\0\0\377\202\252\0\0\377\4\0\0\0\377"
+  "\377\377\377\0\0\0\0\0\377\377\377\0\203\0\0\0\0\2\377\377\377\0\0\0"
+  "\0\377\202\252\0\0\377\3\0\0\0\377\377\377\377\0\0\0\0\377\202\252\0"
+  "\0\377\1\0\0\0\377\204\0\0\0\0\203\0\0\0\377\3\377\377\377\0\0\0\0\0"
+  "\377\377\377\0\205\0\0\0\0\204\0\0\0\377\1\0\0\0\0\204\0\0\0\377\312"
+  "\0\0\0\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (stepover_icon)
+#endif
+#ifdef __GNUC__
+const guint8 stepover_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 stepover_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (1098) */
+  "\0\0\4b"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\263\0\0\0\0\1\0\0\0\377\210\0\0\0\0\1\0\0\0\377\216\0\0\0\0\202\0\0"
+  "\0\377\207\0\0\0\0\202\0\0\0\377\215\0\0\0\0\3\0\0\0\377\252\0\0\377"
+  "\0\0\0\377\206\0\0\0\0\3\0\0\0\377\252\0\0\377\0\0\0\377\213\0\0\0\0"
+  "\2\377\377\377\12\0\0\0\377\202\252\0\0\377\2\0\0\0\377\377\377\377\3"
+  "\203\0\0\0\0\6\377\377\377\0\0\0\0\377\263\34\33\373\252\0\0\377\0\0"
+  "\0\377\377\377\3772\211\0\0\0\0\21\377\377\377\12\0\0\0\377\252\0\0\377"
+  "\377\0\0\377\252\0\0\377\0\0\0\377\377\377\377\1\377\377\377\12\0\0\0"
+  "\0\377\377\377\0\0\0\0\377\263\34\34\375\377\0\0\377\252\0\0\377\0\0"
+  "\0\377\377\377\377\40\377\377\377!\207\0\0\0\0\3\377\377\377\12\0\0\0"
+  "\377\252\0\0\377\202\377\0\0\377\3\252\0\0\377\0\0\0\341\355\377\355"
+  "\1\202\377\377\377\0\2\0\0\0\377\261\30\30\375\202\377\0\0\377\4\252"
+  "\0\0\377\0\0\0\377\355\377\355\15\377\377\377\0\206\0\0\0\0\3\377\377"
+  "\377\12\0\0\0\377\252\0\0\377\203\377\0\0\377\6\252\0\0\377\0\0\0\273"
+  "\377\377\377\2\377\377\377\0\0\0\0\377\260\23\23\375\203\377\0\0\377"
+  "\4\252\0\0\377\0\0\0\377\377\377\377\33\377\377\377\23\205\0\0\0\0\3"
+  "\377\377\377\12\0\0\0\377\252\0\0\377\204\377\0\0\377\5\252\0\0\377\0"
+  "\0\0\377\377\377\377\0\0\0\0\377\261\27\26\375\204\377\0\0\377\4\252"
+  "\0\0\377\0\0\0\377\377\377\377\16\377\377\377\5\204\0\0\0\0\3\377\377"
+  "\377\12\0\0\0\377\252\0\0\377\205\377\0\0\377\1\252\0\0\377\202\0\0\0"
+  "\377\1\254\11\10\376\205\377\0\0\377\4\252\0\0\377\0\0\0\377\377\377"
+  "\372\3\377\377\377\5\203\0\0\0\0\3\377\377\377\12\0\0\0\377\252\0\0\377"
+  "\206\377\0\0\377\3\252\0\0\377\0\0\0\377\252\0\0\377\206\377\0\0\377"
+  "\4\252\0\0\377\0\0\0\377\377\377\377\4\377\377\377\3\202\0\0\0\0\3\377"
+  "\377\377\12\0\0\0\377\252\0\0\377\205\377\0\0\377\4\252\0\0\377\24\25"
+  "\24\362\0\0\0\377\252\0\0\377\205\377\0\0\377\4\252\0\0\377\22\23\22"
+  "\360\377\377\371\1\377\377\377\0\203\0\0\0\0\3\377\377\377\10\0\0\0\377"
+  "\252\0\0\377\204\377\0\0\377\5\252\0\0\377\7\7\6\372\373\377\373\0\0"
+  "\0\0\377\252\0\0\377\204\377\0\0\377\4\252\0\0\377\7\7\6\372\370\377"
+  "\370\0\377\377\377\0\204\0\0\0\0\3\377\377\377\0\0\0\0\377\252\0\0\377"
+  "\203\377\0\0\377\6\252\0\0\377\0\0\0\377\377\377\377\3\377\377\377\0"
+  "\0\0\0\377\252\0\0\377\203\377\0\0\377\4\252\0\0\377\0\0\0\377\377\377"
+  "\377\0\377\377\377\1\205\0\0\0\0\3\377\377\377\2\0\0\0\377\252\0\0\377"
+  "\202\377\0\0\377\7\252\0\0\377\0\0\0\377\370\377\370\10\377\377\377\5"
+  "\377\377\377\0\0\0\0\377\252\0\0\377\202\377\0\0\377\4\252\0\0\377\0"
+  "\0\0\377\370\377\370\0\377\377\377\0\206\0\0\0\0\21\377\377\3770\0\0"
+  "\0\377\252\0\0\377\377\0\0\377\252\0\0\377\0\0\0\330\377\377\377\2\377"
+  "\377\377\0\0\0\0\0\377\377\377\0\0\0\0\377\252\0\0\377\377\0\0\377\252"
+  "\0\0\377\0\0\0\377\377\377\377\2\377\377\377\1\207\0\0\0\0\2\377\377"
+  "\377\22\0\0\0\377\202\252\0\0\377\3\0\0\0\377\377\377\377\6\377\377\377"
+  "\0\202\0\0\0\0\2\377\377\377\0\0\0\0\377\202\252\0\0\377\3\0\0\0\377"
+  "\377\377\377\7\377\377\377\1\210\0\0\0\0\6\377\377\377\"\0\0\0\377\252"
+  "\0\0\377\0\0\0\377\377\377\377\5\377\377\377\1\203\0\0\0\0\6\377\377"
+  "\377\0\0\0\0\377\252\0\0\377\0\0\0\377\377\377\377\4\377\377\377\1\211"
+  "\0\0\0\0\1\377\377\377\0\202\0\0\0\377\2\377\377\377\14\377\377\377\5"
+  "\204\0\0\0\0\1\377\377\377\0\202\0\0\0\377\2\377\377\377\16\377\377\377"
+  "\2\212\0\0\0\0\2\377\377\377\0\0\0\0\377\202\377\377\377\1\205\0\0\0"
+  "\0\4\377\377\377\0\0\0\0\377\377\377\377\7\377\377\377\1\321\0\0\0\0"};
+
+
+/* GdkPixbuf RGBA C-Source image dump 1-byte-run-length-encoded */
+
+#ifdef __SUNPRO_C
+#pragma align 4 (stop_icon)
+#endif
+#ifdef __GNUC__
+const guint8 stop_icon[] __attribute__ ((__aligned__ (4))) = 
+#else
+const guint8 stop_icon[] = 
+#endif
+{ ""
+  /* Pixbuf magic (0x47646b50) */
+  "GdkP"
+  /* length: header (24) + pixel_data (435) */
+  "\0\0\1\313"
+  /* pixdata_type (0x2010002) */
+  "\2\1\0\2"
+  /* rowstride (96) */
+  "\0\0\0`"
+  /* width (24) */
+  "\0\0\0\30"
+  /* height (24) */
+  "\0\0\0\30"
+  /* pixel_data: */
+  "\344\0\0\0\0\213\0\0\0\377\5\10\0\0\373\22\0\0\366\35\0\0\361'\0\0\355"
+  "\11\0\0\372\210\0\0\0\0\1\0\0\0\377\216\252\0\0\377\1+\0\0\353\210\0"
+  "\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0\0\377\2\252\0\0\377/\0\0\351"
+  "\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0\0\377\2\252\0\0\3775\0"
+  "\0\347\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0\0\377\2\252\0\0"
+  "\3779\0\0\346\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0\0\377\2\252"
+  "\0\0\377:\0\0\345\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0\0\377"
+  "\2\252\0\0\377;\0\0\344\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214\377\0"
+  "\0\377\2\252\0\0\377;\0\0\344\210\0\0\0\0\2\0\0\0\377\252\0\0\377\214"
+  "\377\0\0\377\2\252\0\0\377:\0\0\345\210\0\0\0\0\2\0\0\0\377\252\0\0\377"
+  "\214\377\0\0\377\2\252\0\0\3779\0\0\346\210\0\0\0\0\2\0\0\0\377\252\0"
+  "\0\377\214\377\0\0\377\2\252\0\0\3775\0\0\347\210\0\0\0\0\2\0\0\0\377"
+  "\252\0\0\377\214\377\0\0\377\2\252\0\0\3770\0\0\351\210\0\0\0\0\2\0\0"
+  "\0\377\252\0\0\377\214\377\0\0\377\2\252\0\0\377+\0\0\353\210\0\0\0\0"
+  "\2\0\0\0\377\252\0\0\377\214\377\0\0\377\2\252\0\0\377%\0\0\355\210\0"
+  "\0\0\0\1\0\0\0\377\216\252\0\0\377\1\36\0\0\360\210\0\0\0\0\215\0\0\0"
+  "\377\3\7\0\0\373\20\0\0\367\2\0\0\376\344\0\0\0\0"};
+
+
diff --git a/ihex.c b/ihex.c
new file mode 100644
index 0000000..39d3b94
--- /dev/null
+++ b/ihex.c
@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+
+int main (int argc, char **argv) {
+	int i,s=0,t;  
+	for (i = 1; i < argc; i++){ 
+		sscanf(argv[i], "%X", &t);
+		s+=t;
+	}	
+	printf("checksum=%02X\n",(-s)&0xff);
+	return 0;
+}
+
diff --git a/instructions.h b/instructions.h
new file mode 100644
index 0000000..bb96aa0
--- /dev/null
+++ b/instructions.h
@@ -0,0 +1,99 @@
+// programmer instructions v0.12.0
+#define NOP 				0x00
+#define PROG_RST 			0x01	//		->10B
+#define PROG_ID 			0x02	//		->6B
+#define CHECK_INS 			0x03	//+1B 	->1B
+#define FLUSH				0x04	//no echo
+#define VREG_EN				0x05
+#define VREG_DIS			0x06
+#define SET_PARAMETER		0x07	//+3B: 1B parameter, 2B data
+	#define SET_T1T2 	0	//T1, T2
+	#define SET_T3		1 	//T3(H,L)
+	#define SET_timeout	2	//timeout(H,L)
+	#define SET_MN		3	//M, N
+#define WAIT_T1				0x08
+#define WAIT_T2				0x09
+#define WAIT_T3				0x0A
+#define WAIT_US				0x0B	//+1B
+#define READ_ADC			0x0C	//		->2B
+#define SET_VPP				0x0D	//+1B 	->1B
+#define EN_VPP_VCC			0x0E	//+1B
+#define SET_CK_D			0x0F	//+1B
+#define READ_PINS			0x10	//		->1B
+#define LOAD_CONF			0x11	//+2B			000000
+#define LOAD_DATA_PROG		0x12	//+2B			000010
+#define LOAD_DATA_DATA		0x13	//+2B			000011
+#define READ_DATA_PROG		0x14	//  	->2B	000100
+#define READ_DATA_DATA		0x15	//  	->1B	000101
+#define INC_ADDR			0x16	//				000110
+#define INC_ADDR_N			0x17	//+1B			000110
+#define BEGIN_PROG			0x18	//				001000
+#define BULK_ERASE_PROG		0x19	//				001001
+#define END_PROG			0x1A	//				001010
+#define BULK_ERASE_DATA		0x1B	//				001011
+#define END_PROG2			0x1C	//				001110
+#define ROW_ERASE_PROG		0x1D	//				010001
+#define BEGIN_PROG2 		0x1E	//				011000
+#define	CUST_CMD			0x1F	//+1B
+#define	PROG_C				0x20	//+2B	->1B	001000&001110
+#define CORE_INS			0x21	//+2B			0000
+#define SHIFT_TABLAT		0x22	//		->1B	0010
+#define TABLE_READ			0x23	//		->1B	1000
+#define TBLR_INC_N  		0x24	//+1B	->1+NB	1001
+#define TABLE_WRITE			0x25	//+2B			1100
+#define TBLW_INC_N  		0x26	//+1+2NB		1101
+#define TBLW_PROG			0x27	//+4B			1111
+#define TBLW_PROG_INC		0x28	//+4B			1110
+#define SEND_DATA			0x29	//+3B
+#define READ_DATA			0x2A	//+1B	->1B
+#define I2C_INIT			0x2B	//+1B
+#define I2C_READ			0x2C	//+3B	->1+NB
+#define I2C_WRITE			0x2D	//+3+NB ->1B
+#define I2C_READ2			0x2E	//+4B	->1+NB
+#define SPI_INIT			0x2F	//+1B
+#define SPI_READ			0x30	//+1B	->1+NB
+#define SPI_WRITE			0x31	//+1+NB ->1B
+#define EXT_PORT			0x32	//+2B
+#define AT_READ_DATA		0x33	//+3B 	->1+2NB
+#define AT_LOAD_DATA		0x34	//+3+2NB ->1B
+#define CLOCK_GEN			0x35	//+1B
+#define SIX					0x36	//+3B
+#define REGOUT				0x37	//		->2B
+#define ICSP_NOP			0x38	//
+#define TX16				0x39	//+1+2NB
+#define RX16				0x3A	//+1B	->1+2NB
+#define uW_INIT				0x3B	//
+#define uWTX				0x3C	//+1+NB
+#define uWRX				0x3D	//+1B   ->+1+NB
+#define SIX_LONG			0x3E	//+3B
+#define SIX_N				0x3F	//+1+3NB ->1B
+#define OW_RESET			0x40	//      ->1B
+#define OW_WRITE			0x41	//+1+NB
+#define OW_READ				0x42	//+1B   ->1+NB
+#define UNIO_STBY			0x43	//
+#define UNIO_COM			0x44	//+2+NB ->1+NB
+#define SET_PORT_DIR		0x45	//+2B
+#define READ_B				0x46	//      ->1B
+#define READ_AC				0x47	//      ->1B
+#define AT_HV_RTX			0x48	//+1+NB ->1B
+#define SIX_LONG5			0x49	//+3B
+#define LOAD_PC  			0x50	//+2B		 011101
+#define LOAD_DATA_INC		0x51	//+2B		 100010
+#define READ_DATA_INC		0x52	//      ->2B 100100
+#define JTAG_SET_MODE		0x53	//+1B
+#define JTAG_SEND_CMD		0x54	//+1B
+#define JTAG_XFER_DATA		0x55	//+4B -> 4B
+#define JTAG_XFER_F_DATA	0x56	//+4B -> 4B
+#define ICSP8_SHORT  		0x57	//+1B
+#define ICSP8_READ  		0x58	//+1B -> 2B
+#define ICSP8_LOAD  		0x59	//+3B
+// special ins.
+#define SPI_TEST			0xEF	//+2B	->2B
+#define READ_RAM			0xF0	//+2B	->3B
+#define WRITE_RAM			0xF1	//+3B	->3B
+#define LOOP				0xF2
+#define TBLRD				0xF3	//+3B	->2B
+#define TBLWT				0xF4	//+5B
+#define REPEAT				0xF5	//+1B
+#define REPEAT_END			0xF6
+#define MAX_INS 			0x59	//last instruction
diff --git a/op.c b/op.c
new file mode 100644
index 0000000..3e55dbc
--- /dev/null
+++ b/op.c
@@ -0,0 +1,1358 @@
+/*
+ * op.c - control program for the open programmer
+ * Copyright (C) 2009-2020 Alberto Maccioni
+ * for detailed info see:
+ * http://openprog.altervista.org/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+
+#include "common.h"
+#include "I2CSPI.h"
+#include "deviceRW.h"
+#include "fileIO.h"
+#include "progAVR.h"
+
+
+#if !defined _WIN32 && !defined __CYGWIN__
+DWORD GetTickCount();
+#include <sys/select.h>
+int kbhit()
+{
+	struct timeval tv;
+	fd_set read_fd;
+	tv.tv_sec=0;
+	tv.tv_usec=0;
+	FD_ZERO(&read_fd);
+	FD_SET(0,&read_fd);
+	if(select(1, &read_fd, NULL, NULL, &tv) == -1) return 0;
+	if(FD_ISSET(0,&read_fd)) return 1;
+	return 0;
+}
+#define getch getchar
+#else
+#include "conio.h"
+#endif
+#define MinDly 0
+
+void msDelay(double delay);
+void TestHw();
+int StartHVReg(double V);
+void ProgID();
+void DisplayEE();
+int FindDevice();
+int CheckS1();
+
+char** strings;
+int saveLog=0,programID=0,load_osccal=0,load_BKosccal=0;
+int use_osccal=1,use_BKosccal=0;
+int load_calibword=0,max_err=200;
+int AVRlock=0x100,AVRfuse=0x100,AVRfuse_h=0x100,AVRfuse_x=0x100;
+int ICDenable=0,ICDaddr=0x1FF0;
+int FWVersion=0,HwID=0;
+
+FILE* logfile=0;
+char LogFileName[512]="";
+char loadfile[512]="",savefile[512]="";
+char loadfileEE[512]="",savefileEE[512]="";
+int info=0;
+int vid=0x1209,pid=0x5432;
+int new_vid=0x1209,new_pid=0x5432;
+int old_vid=0x04D8,old_pid=0x0100;
+
+WORD *memCODE_W=0;
+int size=0,sizeW=0,sizeEE=0,sizeCONFIG=0,sizeUSERID=0;
+unsigned char *memCODE=0,*memEE=0,memID[64],memCONFIG[48],memUSERID[8];
+double hvreg=0;
+int DeviceDetected=0;
+int skipV33check=0;
+int progress=0;
+int RWstop=0;
+int forceConfig=0;
+char dev[64]="";
+int devType=0x10000;
+char str[4096];
+
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	int fd = -1;
+	struct hiddev_report_info rep_info_i,rep_info_u;
+	struct hiddev_usage_ref_multi ref_multi_i,ref_multi_u;
+	char path[512]="";
+	unsigned char bufferU[128],bufferI[128];
+#else	//Windows
+	unsigned char bufferU0[128],bufferI0[128];
+	unsigned char *bufferU,*bufferI;
+	DWORD NumberOfBytesRead,BytesWritten;
+	ULONG Result;
+	HANDLE WriteHandle,ReadHandle;
+	OVERLAPPED HIDOverlapped;
+	HANDLE hEventObject;
+#endif
+
+
+
+int main (int argc, char **argv) {
+
+	int ee=0,r=0,ver=0,c=0,support=0,i2c=0,spi_mode=0,i,j,testhw=0,s1=0;
+	int spi_speed=0,command=0,langfile=0,help=0;
+	char lang[32]="";
+	unsigned char tmpbuf[128];
+	opterr = 0;
+	int option_index = 0;
+	int fuse3k=0;
+	char* langid=0;
+	int cw1,cw2,cw3,cw4,cw5,cw6,cw7;
+	cw1=cw2=cw3=cw4=cw5=cw6=cw7=0x10000;
+#if defined _WIN32 || defined __CYGWIN__	//Windows
+	bufferI=bufferI0+1;
+	bufferU=bufferU0+1;
+	bufferI0[0]=0;
+	bufferU0[0]=0;
+#endif
+
+	struct option long_options[] =
+	{
+		{"BKosccal",      no_argument,  &load_BKosccal, 1},
+		{"calib",         no_argument, &load_calibword, 1},
+		{"command",       no_argument,        &command, 1},
+		{"cw1",           required_argument,       0, '1'},
+		{"cw2",           required_argument,       0, '2'},
+		{"cw3",           required_argument,       0, '3'},
+		{"cw4",           required_argument,       0, '4'},
+		{"cw5",           required_argument,       0, '5'},
+		{"cw6",           required_argument,       0, '6'},
+		{"cw7",           required_argument,       0, '7'},
+		{"d",             required_argument,       0, 'd'},
+		{"device",        required_argument,       0, 'd'},
+		{"ee",            no_argument,             &ee, 1},
+		{"err",           required_argument,       0, 'e'},
+		{"fuse",          required_argument,       0, 'f'},
+		{"fuseh",         required_argument,       0, 'F'},
+		{"fusex",         required_argument,       0, 'X'},
+		{"fuse3k",        required_argument,       0, 'k'},
+		{"h",             no_argument,            &help,1},
+		{"help",          no_argument,            &help,1},
+		{"HWtest",        no_argument,         &testhw, 1},
+		{"info",          no_argument,           &info, 1},
+		{"i",             no_argument,           &info, 1},
+		{"i2c_r",         no_argument,            &i2c, 1},
+		{"i2c_r2",        no_argument,            &i2c, 2},
+		{"i2c_w",         no_argument,            &i2c, 3},
+		{"i2c_w2",        no_argument,            &i2c, 4},
+		{"i2cspeed",      required_argument,       0, 'D'},
+		{"id",            no_argument,      &programID, 1},
+		{"icd",           required_argument,       0, 'I'},
+		{"l",             optional_argument,       0, 'l'}, //-l=val
+		{"log",           optional_argument,       0, 'l'},
+		{"lang",          required_argument,       0, 'n'},
+		{"langfile",      no_argument,       &langfile, 1},
+		{"lock",          required_argument,       0, 'L'},
+		{"mode",          required_argument,       0, 'm'},
+		{"nolvcheck",     no_argument,   &skipV33check, 1},
+		{"osccal",        no_argument,    &load_osccal, 1},
+#if !defined _WIN32 && !defined __CYGWIN__
+		{"p",             required_argument,       0, 'p'},
+		{"path",          required_argument,       0, 'p'},
+#endif
+		{"pid",           required_argument,       0, 'P'},
+		{"rep" ,          required_argument,       0, 'R'},
+		{"reserved",      no_argument,              &r, 1},
+		{"r",             no_argument,              &r, 1},
+		{"s1",            no_argument,             &s1, 1},
+		{"S1",            no_argument,             &s1, 1},
+		{"s",             required_argument,       0, 's'},
+		{"save",          required_argument,       0, 's'},
+		{"saveEE",        required_argument,       0, 'S'},
+		{"se",            required_argument,       0, 'S'},
+		{"spi_r",         no_argument,            &i2c, 5},
+		{"spi_w",         no_argument,            &i2c, 6},
+		{"spispeed",      required_argument,       0, 'D'},
+		{"support",       no_argument,        &support, 1},
+		{"use_BKosccal",  no_argument,   &use_BKosccal, 1},
+		{"version",       no_argument,            &ver, 1},
+		{"v",             no_argument,            &ver, 1},
+		{"vid",           required_argument,       0, 'V'},
+		{"w",             required_argument,       0, 'w'},
+		{"write",         required_argument,       0, 'w'},
+		{"we",            required_argument,       0, 'W'},
+		{"writeEE",       required_argument,       0, 'W'},
+		{0, 0, 0, 0}
+	};
+	while ((c = getopt_long_only (argc, argv, "",long_options,&option_index)) != -1)
+	/*{	printf("optarg=%X\n",optarg);
+		if(optarg) printf("%s\n",optarg);
+		printf("c=%X %c\noption_index=%d name=%s\n",c,c,option_index,long_options[option_index].name);	}
+		exit(0);*/
+		switch (c)
+		{
+			case '1':	//force config word 1
+				i=sscanf(optarg, "%x", &cw1);
+				if(i!=1||cw1<0||cw1>0x3FFF) cw1=0x10000;
+				break;
+			case '2':	//force config word 2
+				i=sscanf(optarg, "%x", &cw2);
+				if(i!=1||cw2<0||cw2>0x3FFF) cw2=0x10000;
+				break;
+			case '3':	//force config word 3
+				i=sscanf(optarg, "%x", &cw3);
+				if(i!=1||cw3<0||cw3>0x3FFF) cw3=0x10000;
+				break;
+			case '4':	//force config word 4
+				i=sscanf(optarg, "%x", &cw4);
+				if(i!=1||cw4<0||cw4>0x3FFF) cw4=0x10000;
+				break;
+			case '5':	//force config word 5
+				i=sscanf(optarg, "%x", &cw5);
+				if(i!=1||cw5<0||cw5>0x3FFF) cw5=0x10000;
+				break;
+			case '6':	//force config word 6
+				i=sscanf(optarg, "%x", &cw6);
+				if(i!=1||cw6<0||cw6>0x3FFF) cw6=0x10000;
+				break;
+			case '7':	//force config word 7
+				i=sscanf(optarg, "%x", &cw7);
+				if(i!=1||cw7<0||cw7>0x3FFF) cw7=0x10000;
+				break;
+			case 'd':	//device
+				strncpy(dev,optarg,sizeof(dev)-1);
+				break;
+			case 'e':	//max write errors
+				max_err = atoi(optarg);
+				break;
+			case 'D':	//spi speed
+				spi_speed = atoi(optarg);
+				if(spi_speed<0)spi_speed=0;
+				if(spi_speed>3)spi_speed=3;
+				break;
+			case 'f':	//Atmel FUSE low
+				i=sscanf(optarg, "%x", &AVRfuse);
+				if(i!=1||AVRfuse<0||AVRfuse>0xFF) AVRfuse=0x100;
+				break;
+			case 'F':	//Atmel FUSE high
+				i=sscanf(optarg, "%x", &AVRfuse_h);
+				if(i!=1||AVRfuse_h<0||AVRfuse_h>0xFF) AVRfuse_h=0x100;
+				break;
+			case 'I':	//ICD routine address
+				i=sscanf(optarg, "%x", &ICDaddr);
+				if(i!=1||ICDaddr<0||ICDaddr>0xFFFF) ICDaddr=0x1F00;
+				ICDenable=1;
+				break;
+			case 'k':	//Atmel FUSE low @ 3kHz
+				i=sscanf(optarg, "%x", &AVRfuse);
+				if(i!=1||AVRfuse<0||AVRfuse>0xFF) AVRfuse=0x100;
+				else fuse3k=1;
+				break;
+			case 'l':	//save Log
+				saveLog=1;
+				if(optarg) strncpy(LogFileName,optarg,sizeof(LogFileName));
+				break;
+			case 'L':	//Atmel LOCK
+				i=sscanf(optarg, "%x", &AVRlock);
+				if(i!=1||AVRlock<0||AVRlock>0xFF) AVRlock=0x100;
+				break;
+			case 'm':	//SPI mode
+				spi_mode = atoi(optarg);
+				if(spi_mode<0) spi_mode=0;
+				if(spi_mode>3) spi_mode=3;
+				break;
+			case 'n':	//language
+				strncpy(lang,optarg,sizeof(lang)-1);
+				break;
+#if !defined _WIN32 && !defined __CYGWIN__
+			case 'p':	//hiddev path
+				strncpy(path,optarg,sizeof(path)-1);
+				break;
+#endif
+			case 'P':	//pid
+				sscanf(optarg, "%x", &pid);
+				break;
+			case 'R':	//USB HID report size
+				//DIMBUF = atoi(optarg);
+				break;
+			case 's':	//save
+				strncpy(savefile,optarg,sizeof(savefile)-1);
+				break;
+			case 'S':	//save EE
+				strncpy(savefileEE,optarg,sizeof(savefileEE)-1);
+				break;
+			case 'V':	//vid
+				sscanf(optarg, "%x", &vid);
+				break;
+			case 'X':	//Atmel extended FUSE
+				i=sscanf(optarg, "%x", &AVRfuse_x);
+				if(i!=1||AVRfuse_x<0||AVRfuse_x>0xFF) AVRfuse_x=0x100;
+				break;
+			case 'w':	//write file
+				strncpy(loadfile,optarg,sizeof(loadfile)-1);
+				break;
+			case 'W':	//write EE file
+				strncpy(loadfileEE,optarg,sizeof(loadfileEE)-1);
+				break;
+			case '?':
+				fprintf (stderr,strings[L_OPTERR]);		//errore opzioni
+				return 1;
+			default:
+
+				break;
+		}
+
+	for(j=0,i = optind; i < argc&&i<128; i++,j++) sscanf(argv[i], "%x", &tmpbuf[j]);
+	for(;j<128;j++) tmpbuf[j]=0;
+
+	strinit();
+	i=0;
+	if(lang[0]){	//explicit language selection
+		if(lang[0]=='i'&&langid[1]=='t'){  //built-in
+			strings=strings_it;
+			i=1;
+		}
+		else if(lang[0]=='e'&&lang[1]=='n'){  //built-in
+			strings=strings_en;
+			i=1;
+		}
+		else i=strfind(lang,"languages.rc"); //file look-up
+	}
+	if(i==0){
+		#if defined _WIN32
+		langid=malloc(19);
+		int n=GetLocaleInfo(LOCALE_USER_DEFAULT,LOCALE_SISO639LANGNAME,langid,9);
+		langid[n-1] = '-';
+		GetLocaleInfo(LOCALE_USER_DEFAULT,LOCALE_SISO3166CTRYNAME,langid+n, 9);
+		//printf("%d >%s<\n",n,langid);
+		#else
+		langid=getenv("LANG");
+		#endif
+		if(langid){
+			if(langid[0]=='i'&&langid[1]=='t') strings=strings_it;
+			else if(langid[0]=='e'&&langid[1]=='n') strings=strings_en;
+			else if(strfind(langid,"languages.rc")); //first try full code
+			else {	//then only first language code
+				char* p=strchr(langid,'-');
+				if(p) *p=0;
+				if(!strfind(langid,"languages.rc")) strings=strings_en;
+			}
+		}
+		else strings=strings_en;
+	}
+
+	strncpy(LogFileName,strings[S_LogFile],sizeof(LogFileName));
+	if(argc==1){
+		printf(strings[L_HELP]);
+		exit(1);
+	}
+
+	if(help){
+		printf(strings[L_HELP]);
+		return 1;
+	}
+
+	if(langfile) GenerateLangFile(langid,"languages.rc");
+
+	if (ver){
+		printf("OP v%s\nCopyright (C) Alberto Maccioni 2009-2022\
+\n	For detailed info see http://openprog.altervista.org/\
+\nThis program is free software; you can redistribute it and/or modify it under \
+the terms of the GNU General Public License as published by the Free Software \
+Foundation; either version 2 of the License, or (at your option) any later version.\
+			\n",VERSION);
+		return 0;
+	}
+	if (support){
+		char list[20000]; //make sure list is long enough!!
+		AddDevices(list);
+		printf("%s\n",list);
+		return 0;
+	}
+	DeviceDetected=FindDevice(vid,pid);	//connect to USB programmer
+	if(!DeviceDetected){
+		DeviceDetected=FindDevice(new_vid,new_pid);	//try default
+		if(DeviceDetected){
+			vid=new_vid;
+			pid=new_pid;
+		}
+	}
+	if(!DeviceDetected) DeviceDetected=FindDevice(old_vid,old_pid); //try old one
+	if(!DeviceDetected) exit(1);
+	ProgID();		//get firmware version and reset
+
+#if !defined _WIN32 && !defined __CYGWIN__
+	if(info){
+		#ifndef hiddevIO	//use raw USB device
+			struct hidraw_devinfo device_info;
+			char name[256],path[256];
+			ioctl(fd, HIDIOCGRAWINFO, &device_info);
+			ioctl(fd, HIDIOCGRAWNAME(256), name);
+			ioctl(fd, HIDIOCGRAWPHYS(256), path);
+			printf("VID 0x%04X PID 0x%04X\n",device_info.vendor, device_info.product);
+			printf(strings[L_NAME], path, name);//"The device on %s says its name is %s\n"
+		#else		//use hiddev device (old method)
+			struct hiddev_devinfo device_info;
+			ioctl(fd, HIDIOCGDEVINFO, &device_info);
+			printf(strings[L_INFO1],device_info.vendor, device_info.product, device_info.version);
+			printf(strings[L_INFO2],device_info.busnum, device_info.devnum, device_info.ifnum);
+			char name[256];
+			strcpy(name,strings[L_UNKNOWN]);//"Unknown"
+			if(ioctl(fd, HIDIOCGNAME(sizeof(name)), name) < 0) perror("evdev ioctl");
+			printf(strings[L_NAME], path, name);//"The device on %s says its name is %s\n"
+		#endif
+		return 0;
+	}
+#endif
+
+	DWORD t0,t;
+	t=t0=GetTickCount();
+	if(testhw){
+		TestHw();
+		return 0;
+	}
+
+	if(command){
+		//bufferU[0]=0;
+		for(i=0;i<DIMBUF;i++) bufferU[i]=(char) tmpbuf[i];
+		PacketIO(100);
+		printf("> ");
+		for(i=0;i<DIMBUF;i++) printf("%02X ",bufferU[i]);
+		printf("\n< ");
+		for(i=0;i<DIMBUF;i++) printf("%02X ",bufferI[i]);
+		printf("\n");
+		return 0;
+	}
+
+#define CS 8
+#define HLD 16
+	if(i2c){	//I2C, SPI
+		if(i2c==1){							//I2C receive 8 bit mode
+			I2CReceive(0,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		else if(i2c==2){					//I2C receive 16 bit mode
+			I2CReceive(1,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		else if(i2c==3){					//I2C transmit 8 bit mode
+			I2CSend(0,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		else if(i2c==4){					//I2C transmit 16 bit mode
+			I2CSend(1,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		else if(i2c==5){					//SPI receive
+			I2CReceive(2+spi_mode,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		else if(i2c==6){					//SPI receive
+			I2CSend(2+spi_mode,spi_speed,tmpbuf[0],tmpbuf+1);
+		}
+		return 0 ;
+	}
+
+	struct DevInfo info;
+	info=GetDevInfo(dev);
+	devType=info.family;
+
+	if(fuse3k){ //write fuse low @ 3kHz
+		if(AVRfuse<0x100) WriteATfuseSlow(AVRfuse);
+		return 0;
+	}
+
+	if(loadfile[0]){ 		//write
+		if(Load(dev,loadfile)==-1){
+			PrintMessage(strings[S_NoCode2]);
+			PrintMessage("\n");
+			exit(-1);
+		}
+		if(!strncmp(dev,"AT",2)&&loadfileEE[0]) LoadEE(dev,loadfileEE);
+		//force config words
+		if(devType==PIC16){
+			if((!strncmp(dev,"16F1",4)||!strncmp(dev,"12F1",4))&&sizeW>0x8008){		//16F1xxx
+				if(cw1<=0x3FFF){
+					memCODE_W[0x8007]=cw1;
+					PrintMessage3(strings[S_ForceConfigWx],1,0x8007,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+				if(cw2<=0x3FFF){
+					memCODE_W[0x8008]=cw2;
+					PrintMessage3(strings[S_ForceConfigWx],2,0x8008,cw2); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+			}
+			else{	//16Fxxx
+				if(cw1<=0x3FFF&&sizeW>0x2007){
+					memCODE_W[0x2007]=cw1;
+					PrintMessage3(strings[S_ForceConfigWx],1,0x2007,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+				if(cw2<=0x3FFF&&sizeW>0x2008){
+					memCODE_W[0x2008]=cw2;
+					printf("2\n");
+					PrintMessage3(strings[S_ForceConfigWx],2,0x2008,cw2); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+			}
+		}
+		else if(devType==PIC12){	//12Fxxx
+			if(cw1<=0xFFF&&sizeW>0xFFF){
+				memCODE_W[0xFFF]=cw1;
+				PrintMessage3(strings[S_ForceConfigWx],1,0xFFF,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+			}
+		}
+		else if(devType==PIC18){	//18Fxxx
+			if(cw1<=0xFFFF){
+				memCONFIG[0]=cw1&0xFF;
+				memCONFIG[1]=(cw1>>8)&0xFF;
+			}
+			if(cw2<=0xFFFF){
+				memCONFIG[2]=cw2&0xFF;
+				memCONFIG[3]=(cw2>>8)&0xFF;
+			}
+			if(cw3<=0xFFFF){
+				memCONFIG[4]=cw3&0xFF;
+				memCONFIG[5]=(cw3>>8)&0xFF;
+			}
+			if(cw4<=0xFFFF){
+				memCONFIG[6]=cw4&0xFF;
+				memCONFIG[7]=(cw4>>8)&0xFF;
+			}
+			if(cw5<=0xFFFF){
+				memCONFIG[8]=cw5&0xFF;
+				memCONFIG[9]=(cw5>>8)&0xFF;
+			}
+			if(cw6<=0xFFFF){
+				memCONFIG[10]=cw6&0xFF;
+				memCONFIG[11]=(cw6>>8)&0xFF;
+			}
+			if(cw7<=0xFFFF){
+				memCONFIG[12]=cw7&0xFF;
+				memCONFIG[13]=(cw7>>8)&0xFF;
+			}
+			PrintMessage(strings[S_ForceConfigW]); //"forcing config words"
+			for(i=0;i<7;i++){
+				PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]);	//"CONFIG%dH: 0x%02X\t"
+				PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]);	//"CONFIG%dL: 0x%02X\r\n"
+			}
+		}
+/*		if(CW1_force!=-1||CW2_force!=-1){
+			if((!strncmp(dev,"16F1",4)||!strncmp(dev,"12F1",4))){		//16F1xxx
+				if(CW1_force!=-1&&sizeW>0x8007) memCODE_W[0x8007]=CW1_force;
+				if(CW2_force!=-1&&sizeW>0x8008) memCODE_W[0x8008]=CW2_force;
+			}
+			else if((!strncmp(dev,"16F",3)||!strncmp(dev,"12F6",4))&&strncmp(dev,"16F5",4)){	//16Fxxx
+				if(CW1_force!=-1&&sizeW>0x2007) memCODE_W[0x2007]=CW1_force;
+				if(CW2_force!=-1&&sizeW>0x2008) memCODE_W[0x2008]=CW2_force;
+			}
+			else if((!strncmp(dev,"12F",3)||!strncmp(dev,"10F",3)||!strncmp(dev,"16F5",4))){	//12Fxxx
+				if(CW1_force!=-1&&sizeW>0xFFF) memCODE_W[0xFFF]=CW1_force&0xFFF;
+			}
+			if(CW1_force!=-1) PrintMessage1(strings[S_ForceConfigWx],CW1_force); //"forcing config word1 (0x%04X)"
+			if(CW2_force!=-1) PrintMessage1(strings[S_ForceConfigWx],CW2_force); //"forcing config word2 (0x%04X)"
+		}
+*/
+		//Start with button
+		if(s1){
+			PrintMessage(strings[S_WaitS1W]);	//"Press S1 to program, any key to exit"
+			fflush(stdout);
+			for(;!kbhit();msDelay(50)){
+				if(CheckS1()){	//wait for S1
+					Write(dev,ee);	//choose the right function
+					PrintMessage(strings[S_WaitS1W]);	//"Press S1 to program, any key to exit"
+					fflush(stdout);
+					for(;CheckS1();msDelay(50));	//wait for S1 open
+				}
+			}
+			getch();
+		}
+		else Write(dev,ee);	//choose the right function
+	}
+	else{		//read
+		if(s1){
+			PrintMessage(strings[S_WaitS1R]);	//"Press S1 to read, any key to exit"
+			fflush(stdout);
+			for(;!kbhit();msDelay(50)){
+				if(CheckS1()){	//wait for S1
+					Read(dev,ee,r);	//choose the right function
+					PrintMessage(strings[S_WaitS1R]);	//"Press S1 to read, any key to exit"
+					fflush(stdout);
+					for(;CheckS1();msDelay(50));	//wait for S1 open
+				}
+			}
+			getch();
+		}
+		else Read(dev,ee,r);	//choose the right function
+
+		if(savefile[0]) Save(dev,savefile);
+		if(!strncmp(dev,"AT",2)&&savefileEE[0]) SaveEE(dev,savefileEE);
+	}
+
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	close(fd);
+#endif
+	return 0 ;
+}
+
+
+///
+///Display contents of EEprom memory
+void DisplayEE(){
+	char s[256],t[256],v[256];
+	int valid=0,empty=1;
+	int i,j;
+	s[0]=0;
+	v[0]=0;
+	PrintMessage(strings[S_EEMem]);	//"\r\nmemoria EEPROM:\r\n"
+	for(i=0;i<sizeEE;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<sizeEE;j++){
+			sprintf(t,"%02X ",memEE[j]);
+			strcat(s,t);
+			sprintf(t,"%c",isprint(memEE[j])?memEE[j]:'.');
+			strcat(v,t);
+			if(memEE[j]<0xff) valid=1;
+		}
+		if(valid){
+			PrintMessage3("%04X: %s %s\r\n",i,s,v);
+			empty=0;
+		}
+		s[0]=0;
+		v[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+}
+
+///
+///Start HV regulator
+int StartHVReg(double V){
+	int j=0,z;
+	int vreg=(int)(V*10.0);
+	if(saveLog&&logfile) fprintf(logfile,"StartHVReg(%.2f)\n",V);
+	DWORD t0,t;
+	if(V==-1){
+		bufferU[j++]=VREG_DIS;			//disable HV regulator
+		bufferU[j++]=FLUSH;
+		PacketIO(5);
+		msDelay(40);
+		return -1;
+	}
+	t=t0=GetTickCount();
+	bufferU[j++]=VREG_EN;			//enable HV regulator
+	bufferU[j++]=SET_VPP;
+	bufferU[j++]=vreg;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=READ_ADC;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	msDelay(20);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_ADC;z++);
+	int v=(bufferI[z+1]<<8)+bufferI[z+2];
+//	PrintMessage2("v=%d=%fV\n",v,v/G);
+	if(v==0){
+		PrintMessage(strings[S_lowUsbV]);	//"Tensione USB troppo bassa (VUSB<4.5V)\r\n"
+		return 0;
+	}
+		j=0;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=READ_ADC;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	for(;(v<(vreg/10.0-1)*G||v>(vreg/10.0+1)*G)&&t<t0+1500;t=GetTickCount()){
+		PacketIO(5);
+		msDelay(20);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_ADC;z++);
+		v=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(HwID==3) v>>=2;		//if 12 bit ADC
+//		PrintMessage2("v=%d=%fV\n",v,v/G);
+	}
+	if(v>(vreg/10.0+1)*G){
+		PrintMessage(strings[S_HiVPP]);	//"Attenzione: tensione regolatore troppo alta\r\n\r\n"
+		return 0;
+	}
+	else if(v<(vreg/10.0-1)*G){
+		PrintMessage(strings[S_LowVPP]);	//"Attenzione: tensione regolatore troppo bassa\r\n\r\n"
+		return 0;
+	}
+	else if(v==0){
+		PrintMessage(strings[S_lowUsbV]);	//"Tensione USB troppo bassa (VUSB<4.5V)\r\n"
+		return 0;
+	}
+	else{
+		PrintMessage2(strings[S_reg],t-t0,v/G);	//"Regolatore avviato e funzionante dopo T=%d ms VPP=%.1f\r\n\r\n"
+		if(saveLog&&logfile) fprintf(logfile,strings[S_reg],t-t0,v/G);
+		return vreg;
+	}
+}
+
+///
+///Read programmer ID
+void ProgID()
+{
+	if(DeviceDetected!=1) return;
+	int j=0;
+	bufferU[j++]=PROG_RST;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	for(j=0;j<DIMBUF-7&&bufferI[j]!=PROG_RST;j++);
+	PrintMessage3(strings[S_progver],bufferI[j+1],bufferI[j+2],bufferI[j+3]); //"FW versione %d.%d.%d\r\n"
+	FWVersion=(bufferI[j+1]<<16)+(bufferI[j+2]<<8)+bufferI[j+3];
+	PrintMessage3(strings[S_progid],bufferI[j+4],bufferI[j+5],bufferI[j+6]);	//"ID Hw: %d.%d.%d"
+	HwID=bufferI[j+6];
+	if(HwID==1) PrintMessage(" (18F2550)\r\n\r\n");
+	else if(HwID==2) PrintMessage(" (18F2450)\r\n\r\n");
+	else if(HwID==3) PrintMessage(" (18F2458/2553)\r\n\r\n");
+	else if(HwID==4) PrintMessage(" (18F25K50)\r\n\r\n");
+	else PrintMessage(" (?)\r\n\r\n");
+}
+
+///
+///Check if a 3.3V regulator is present
+int CheckV33Regulator()
+{
+	int i,j=0;
+	if(skipV33check) return 1;
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x93;
+	bufferU[j++]=0xFE;	//B0 = output
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x01;	//B0=1
+	bufferU[j++]=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x81;	//Check if B1=1
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x00;	//B0=0
+	bufferU[j++]=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x81;	//Check if B1=0
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x93;
+	bufferU[j++]=0xFF;	//BX = input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(j=0;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	i=bufferI[j+3]&0x2;		//B1 should be high
+	for(j+=3;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	return (i+(bufferI[j+3]&0x2))==2?1:0;
+}
+
+///
+///Check if S1 is pressed
+int CheckS1()
+{
+	int i,j=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x84;	//READ PORTE
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(j=0;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	i=bufferI[j+3]&0x8;		//i=E3
+	return i?0:1;			//S1 open -> E3=1
+}
+
+///
+///Execute hardware test
+void TestHw()
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	char str[256];
+	StartHVReg(13);
+	int j=0;
+	PrintMessage(strings[I_TestHW]);		//"Test hardware ..."
+	fflush(stdout);
+	getchar();
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDD=5V\n VPP=13V\n PGD(RB5)=0V\n PGC(RB6)=0V\n PGM(RB7)=0V");
+	PrintMessage(str);
+	fflush(stdout);
+	getchar();
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x15;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;			//VDD
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDD=5V\n VPP=0V\n PGD(RB5)=5V\n PGC(RB6)=5V\n PGM(RB7)=5V");
+	PrintMessage(str);
+	fflush(stdout);
+	getchar();
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x4;			//VPP
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDD=0V\n VPP=13V\n PGD(RB5)=5V\n PGC(RB6)=0V\n PGM(RB7)=0V");
+	PrintMessage(str);
+	fflush(stdout);
+	getchar();
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDD=0V\n VPP=0V\n PGD(RB5)=0V\n PGC(RB6)=5V\n PGM(RB7)=0V");
+	PrintMessage(str);
+	fflush(stdout);
+	getchar();
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	if(FWVersion>=0x900){	//IO test
+		int j=0,i,x,r;
+		strcpy(str,"0000000000000");
+		PrintMessage("IO test\nRC|RA|--RB--|\n");
+		for(i=0;i<13;i++){
+			x=1<<i;
+			j=0;
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x0;
+			bufferU[j++]=SET_PORT_DIR;
+			bufferU[j++]=0x0;	//TRISB
+			bufferU[j++]=0x0;	//TRISA-C  (RC7:RC6:RA5:RA4:RA3:X:X:X)
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=x&0xFF;	//PORTB
+			bufferU[j++]=(x>>5)&0xFF;	//PORTA-C
+			bufferU[j++]=READ_B;
+			bufferU[j++]=READ_AC;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+			r=bufferI[j+1];
+			for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_AC;j++);
+			r+=(bufferI[j+1]&0xF8)<<5;
+			for(j=0;j<13;j++) str[12-j]=x&(1<<j)?'1':'0';
+			PrintMessage(str);
+			PrintMessage1(" (%s)\n",r==x?"OK":strings[S_ErrSing]);
+		}
+	}
+}
+
+///
+///Wait for X milliseconds
+void msDelay(double delay)
+{
+#if !defined _WIN32 && !defined __CYGWIN__
+	long x=(int)(delay*1000.0);
+	usleep(x>MinDly?x:MinDly);
+#else
+//	Sleep((long)ceil(delay)>MinDly?(long)ceil(delay):MinDly);
+	__int64 stop,freq,timeout;
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+	timeout=stop+delay*freq/1000.0;
+	while(stop<timeout) QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+#endif
+}
+
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+///
+/// Get system time
+DWORD GetTickCount(){
+	struct timeb now;
+	ftime(&now);
+	return now.time*1000+now.millitm;
+}
+#endif
+
+///
+///Write data packet, wait for X milliseconds, read response
+void PacketIO(double delay){
+	#define TIMEOUT 50
+	if(saveLog&&logfile) fprintf(logfile,"PacketIO(%.2f)\n",delay);
+	int delay0=delay;
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	struct timespec ts;
+	uint64_t start,stop;
+	fd_set set;
+	struct timeval timeout;
+	int rv,i;
+	FD_ZERO(&set); /* clear the set */
+	FD_SET(fd, &set); /* add our file descriptor to the set */
+	timeout.tv_sec = 0;
+	timeout.tv_usec = TIMEOUT*1000;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	start=ts.tv_nsec/1000;
+	delay-=TIMEOUT-10;	//shorter delays are covered by 50ms timeout
+	if(delay<MinDly) delay=MinDly;
+	#ifndef hiddevIO	//use raw USB device
+	//wait before writing
+/*	rv = select(fd + 1, NULL, &set, NULL, &timeout); //wait for write event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	//error
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+		return;
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	//"comm timeout\r\n"
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+		return;
+	}*/
+	//write
+	int res = write(fd,bufferU,DIMBUF);
+	if (res < 0) {
+		printf("Error: %d\n", errno);
+		perror("write");
+	}
+	usleep((int)(delay*1000.0));
+	//wait before reading
+	rv = select(fd + 1, &set, NULL, NULL, &timeout); //wait for event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	/*error*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+		return;
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+		return;
+	}
+	//read
+	res = read(fd, bufferI, DIMBUF);
+	if (res < 0) {
+		perror("read");
+	}
+	#else		//use hiddev device (old method)
+	struct hiddev_event ev[80];
+	int n=DIMBUF;
+	for(i=0;i<DIMBUF;i++) ref_multi_u.values[i]=bufferU[i];
+	//write
+	ioctl(fd, HIDIOCSUSAGES, &ref_multi_u);
+	ioctl(fd,HIDIOCSREPORT, &rep_info_u);
+	usleep((int)(delay*1000.0));
+	//read
+	rv = select(fd + 1, &set, NULL, NULL, &timeout); //wait for event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	/*error*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+	}
+	else{
+	//		ioctl(fd, HIDIOCGUSAGES, &ref_multi_i);
+	//		ioctl(fd,HIDIOCGREPORT, &rep_info_i);
+	#undef read()
+		rv=read(fd, ev,sizeof(struct hiddev_event) *n);
+		for(i=0;(ev[0].value!=bufferU[0])&&i<40;i++){		//read too early; try again after 5ms
+			msDelay(5);
+			rv=read(fd, ev,sizeof(struct hiddev_event) *n);
+			if(saveLog&&logfile) fprintf(logfile,"Packet not ready, wait extra time\n");
+		}
+		if(i==40) fprintf(logfile,"Cannot read correct packet!!\n");
+		for(i=0;i<n;i++) bufferI[i]=ev[i].value&0xFF;
+	}
+	#endif
+	clock_gettime( CLOCK_REALTIME, &ts );
+	stop  = ts.tv_nsec / 1000;
+	if(saveLog&&logfile){
+		WriteLogIO();
+		fprintf(logfile,"T=%.2f ms (%+.2f ms)\n",(stop-start)/1000.0,(stop-start)/1000.0-delay0);
+		if(bufferU[0]!=bufferI[0]) fprintf(logfile,"Cannot read correct packet!!\n");
+	}
+#else	//Windows
+	__int64 start,stop,freq,timeout;
+	QueryPerformanceCounter((LARGE_INTEGER *)&start);
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+	delay-=TIMEOUT-10;	//shorter delays are covered by 50ms timeout
+	if(delay<MinDly) delay=MinDly;
+	//write
+	Result = WriteFile(WriteHandle,bufferU0,DIMBUF+1,&BytesWritten,NULL);
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	timeout=stop+delay*freq/1000.0;
+	while(stop<timeout) QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	//read
+	Result = ReadFile(ReadHandle,bufferI0,DIMBUF+1,&NumberOfBytesRead,(LPOVERLAPPED) &HIDOverlapped);
+	Result = WaitForSingleObject(hEventObject,TIMEOUT);
+	if(saveLog&&logfile) WriteLogIO();
+	ResetEvent(hEventObject);
+	if(Result!=WAIT_OBJECT_0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+	}
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	if(saveLog&&logfile) fprintf(logfile,"T=%.2f ms (%+.2f ms)\n",(stop-start)*1000.0/freq,(stop-start)*1000.0/freq-delay0);
+#endif
+}
+
+///
+///Find the USB peripheral with proper vid&pid code
+/// return 0 if not found
+	#define FALSE 0
+int FindDevice(int vid,int pid){
+	int MyDeviceDetected = FALSE;
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	#ifndef hiddevIO	//use raw USB device
+	struct hidraw_devinfo device_info;
+	int i=-1;
+	if(path[0]==0){	//search all devices
+		if((fd = open("/dev/openprogrammer", O_RDWR|O_NONBLOCK))>0){ //try with this first
+			sprintf(path,"/dev/openprogrammer");
+			ioctl(fd, HIDIOCGRAWINFO, &device_info);
+			if(device_info.vendor==vid&&device_info.product==pid) i=0;
+			else{
+				close(fd);
+				i=-1;
+			}
+		}
+		if(i){
+			for(i=0;i<16;i++){
+				sprintf(path,"/dev/hidraw%d",i);
+				if((fd = open(path, O_RDWR|O_NONBLOCK))>0){
+					ioctl(fd, HIDIOCGRAWINFO, &device_info);
+					if(device_info.vendor==vid&&device_info.product==pid) break;
+					else close(fd);
+				}
+			}
+		}
+		if(i==16){
+			PrintMessage(strings[S_noprog]);
+			path[0]=0;
+			return 0;
+		}
+	}
+	else{	//user supplied path
+		if((fd = open(path, O_RDWR|O_NONBLOCK)) < 0) {
+			PrintMessage1(strings[S_DevPermission],path); //"cannot open %s, make sure you have read permission on it",path);
+			return 0;
+		}
+		ioctl(fd, HIDIOCGRAWINFO, &device_info);
+		if(device_info.vendor!=vid||device_info.product!=pid){
+			PrintMessage(strings[S_noprog]);
+			return 0;
+		}
+	}
+	printf(strings[S_progDev],path);
+	return 1;
+	#else		//use hiddev device (old method)
+	struct hiddev_devinfo device_info;
+	int i=-1;
+	if(path[0]==0){	//search all devices
+		if((fd = open("/dev/openprogrammer", O_RDONLY ))>0){ //try with this first
+			ioctl(fd, HIDIOCGDEVINFO, &device_info);
+			if(device_info.vendor==vid&&device_info.product==pid) i=0;
+			else{
+				close(fd);
+				i=-1;
+			}
+		}
+		if(i){
+		for(i=0;i<16;i++){
+			sprintf(path,"/dev/usb/hiddev%d",i);
+			if((fd = open(path, O_RDONLY ))>0){
+				ioctl(fd, HIDIOCGDEVINFO, &device_info);
+				if(device_info.vendor==vid&&device_info.product==pid) break;
+				else close(fd);
+				}
+			}
+		}
+		if(i==16){
+			PrintMessage(strings[S_noprog]);
+			path[0]=0;
+			return 0;
+		}
+	}
+	else{	//user supplied path
+		if ((fd = open(path, O_RDONLY )) < 0) {
+			PrintMessage1(strings[S_DevPermission],path); //"cannot open %s, make sure you have read permission on it",path);
+			return 0;
+		}
+		ioctl(fd, HIDIOCGDEVINFO, &device_info);
+		if(device_info.vendor!=vid||device_info.product!=pid){
+			PrintMessage(strings[S_noprog]);
+			return 0;
+		}
+	}
+	printf(strings[S_progDev],path);
+	MyDeviceDetected = TRUE;
+	rep_info_u.report_type=HID_REPORT_TYPE_OUTPUT;
+	rep_info_i.report_type=HID_REPORT_TYPE_INPUT;
+	rep_info_u.report_id=rep_info_i.report_id=HID_REPORT_ID_FIRST;
+	rep_info_u.num_fields=rep_info_i.num_fields=1;
+	ref_multi_u.uref.report_type=HID_REPORT_TYPE_OUTPUT;
+	ref_multi_i.uref.report_type=HID_REPORT_TYPE_INPUT;
+	ref_multi_u.uref.report_id=ref_multi_i.uref.report_id=HID_REPORT_ID_FIRST;
+	ref_multi_u.uref.field_index=ref_multi_i.uref.field_index=0;
+	ref_multi_u.uref.usage_index=ref_multi_i.uref.usage_index=0;
+	ref_multi_u.num_values=ref_multi_i.num_values=DIMBUF;
+	#endif
+#else		//Windows
+	PSP_DEVICE_INTERFACE_DETAIL_DATA detailData;
+	HANDLE DeviceHandle;
+	HANDLE hDevInfo;
+	GUID HidGuid;
+	char MyDevicePathName[1024];
+	ULONG Length;
+	ULONG Required;
+	typedef struct _HIDD_ATTRIBUTES {
+	    ULONG   Size;
+	    USHORT  VendorID;
+	    USHORT  ProductID;
+	    USHORT  VersionNumber;
+	} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+	typedef void (__stdcall*GETHIDGUID) (OUT LPGUID HidGuid);
+	typedef BOOLEAN (__stdcall*GETATTRIBUTES)(IN HANDLE HidDeviceObject,OUT PHIDD_ATTRIBUTES Attributes);
+	typedef BOOLEAN (__stdcall*SETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT ULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT PULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETFEATURE) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETFEATURE) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETREPORT) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETREPORT) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETMANUFACTURERSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETPRODUCTSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETINDEXEDSTRING) (IN  HANDLE HidDeviceObject, IN ULONG  StringIndex, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	HIDD_ATTRIBUTES Attributes;
+	SP_DEVICE_INTERFACE_DATA devInfoData;
+	int LastDevice = FALSE;
+	int MemberIndex = 0;
+	LONG Result;
+	Length=0;
+	detailData=NULL;
+	DeviceHandle=NULL;
+	HMODULE hHID=0;
+	GETHIDGUID HidD_GetHidGuid=0;
+	GETATTRIBUTES HidD_GetAttributes=0;
+	SETNUMINPUTBUFFERS HidD_SetNumInputBuffers=0;
+	GETNUMINPUTBUFFERS HidD_GetNumInputBuffers=0;
+	GETFEATURE HidD_GetFeature=0;
+	SETFEATURE HidD_SetFeature=0;
+	GETREPORT HidD_GetInputReport=0;
+	SETREPORT HidD_SetOutputReport=0;
+	GETMANUFACTURERSTRING HidD_GetManufacturerString=0;
+	GETPRODUCTSTRING HidD_GetProductString=0;
+	hHID = LoadLibrary("hid.dll");
+	if(!hHID){
+		PrintMessage("Can't find hid.dll");
+		return 0;
+	}
+	HidD_GetHidGuid=(GETHIDGUID)GetProcAddress(hHID,"HidD_GetHidGuid");
+	HidD_GetAttributes=(GETATTRIBUTES)GetProcAddress(hHID,"HidD_GetAttributes");
+	HidD_SetNumInputBuffers=(SETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_SetNumInputBuffers");
+	HidD_GetNumInputBuffers=(GETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_GetNumInputBuffers");
+	HidD_GetFeature=(GETFEATURE)GetProcAddress(hHID,"HidD_GetFeature");
+	HidD_SetFeature=(SETFEATURE)GetProcAddress(hHID,"HidD_SetFeature");
+	HidD_GetInputReport=(GETREPORT)GetProcAddress(hHID,"HidD_GetInputReport");
+	HidD_SetOutputReport=(SETREPORT)GetProcAddress(hHID,"HidD_SetOutputReport");
+	HidD_GetManufacturerString=(GETMANUFACTURERSTRING)GetProcAddress(hHID,"HidD_GetManufacturerString");
+	HidD_GetProductString=(GETPRODUCTSTRING)GetProcAddress(hHID,"HidD_GetProductString");
+	if(HidD_GetHidGuid==NULL\
+		||HidD_GetAttributes==NULL\
+		||HidD_GetFeature==NULL\
+		||HidD_SetFeature==NULL\
+		||HidD_GetInputReport==NULL\
+		||HidD_SetOutputReport==NULL\
+		||HidD_GetManufacturerString==NULL\
+		||HidD_GetProductString==NULL\
+		||HidD_SetNumInputBuffers==NULL\
+		||HidD_GetNumInputBuffers==NULL) return 0;
+	HMODULE hSAPI=0;
+	hSAPI = LoadLibrary("setupapi.dll");
+	if(!hSAPI){
+		PrintMessage("Can't find setupapi.dll");
+		return 0;
+	}
+	typedef HDEVINFO (WINAPI* SETUPDIGETCLASSDEVS) (CONST GUID*,PCSTR,HWND,DWORD);
+	typedef BOOL (WINAPI* SETUPDIENUMDEVICEINTERFACES) (HDEVINFO,PSP_DEVINFO_DATA,CONST GUID*,DWORD,PSP_DEVICE_INTERFACE_DATA);
+	typedef BOOL (WINAPI* SETUPDIGETDEVICEINTERFACEDETAIL) (HDEVINFO,PSP_DEVICE_INTERFACE_DATA,PSP_DEVICE_INTERFACE_DETAIL_DATA_A,DWORD,PDWORD,PSP_DEVINFO_DATA);
+	typedef BOOL (WINAPI* SETUPDIDESTROYDEVICEINFOLIST) (HDEVINFO);
+	SETUPDIGETCLASSDEVS SetupDiGetClassDevsA=0;
+	SETUPDIENUMDEVICEINTERFACES SetupDiEnumDeviceInterfaces=0;
+	SETUPDIGETDEVICEINTERFACEDETAIL SetupDiGetDeviceInterfaceDetailA=0;
+	SETUPDIDESTROYDEVICEINFOLIST SetupDiDestroyDeviceInfoList=0;
+	SetupDiGetClassDevsA=(SETUPDIGETCLASSDEVS) GetProcAddress(hSAPI,"SetupDiGetClassDevsA");
+	SetupDiEnumDeviceInterfaces=(SETUPDIENUMDEVICEINTERFACES) GetProcAddress(hSAPI,"SetupDiEnumDeviceInterfaces");
+	SetupDiGetDeviceInterfaceDetailA=(SETUPDIGETDEVICEINTERFACEDETAIL) GetProcAddress(hSAPI,"SetupDiGetDeviceInterfaceDetailA");
+	SetupDiDestroyDeviceInfoList=(SETUPDIDESTROYDEVICEINFOLIST) GetProcAddress(hSAPI,"SetupDiDestroyDeviceInfoList");
+	if(SetupDiGetClassDevsA==NULL\
+		||SetupDiEnumDeviceInterfaces==NULL\
+		||SetupDiDestroyDeviceInfoList==NULL\
+		||SetupDiGetDeviceInterfaceDetailA==NULL) return 0;
+	/*
+	The following code is adapted from Usbhidio_vc6 application example by Jan Axelson
+	for more information see see http://www.lvr.com/hidpage.htm
+	*/
+	/*
+	API function: HidD_GetHidGuid
+	Get the GUID for all system HIDs.
+	Returns: the GUID in HidGuid.
+	*/
+	HidD_GetHidGuid(&HidGuid);
+	/*
+	API function: SetupDiGetClassDevs
+	Returns: a handle to a device information set for all installed devices.
+	Requires: the GUID returned by GetHidGuid.
+	*/
+	hDevInfo=SetupDiGetClassDevs(&HidGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);
+	devInfoData.cbSize = sizeof(devInfoData);
+	//Step through the available devices looking for the one we want.
+	//Quit on detecting the desired device or checking all available devices without success.
+	MemberIndex = 0;
+	LastDevice = FALSE;
+	do
+	{
+		/*
+		API function: SetupDiEnumDeviceInterfaces
+		On return, MyDeviceInterfaceData contains the handle to a
+		SP_DEVICE_INTERFACE_DATA structure for a detected device.
+		Requires:
+		The DeviceInfoSet returned in SetupDiGetClassDevs.
+		The HidGuid returned in GetHidGuid.
+		An index to specify a device.
+		*/
+		Result=SetupDiEnumDeviceInterfaces (hDevInfo, 0, &HidGuid, MemberIndex, &devInfoData);
+		if (Result != 0)
+		{
+			//A device has been detected, so get more information about it.
+			/*
+			API function: SetupDiGetDeviceInterfaceDetail
+			Returns: an SP_DEVICE_INTERFACE_DETAIL_DATA structure
+			containing information about a device.
+			To retrieve the information, call this function twice.
+			The first time returns the size of the structure in Length.
+			The second time returns a pointer to the data in DeviceInfoSet.
+			Requires:
+			A DeviceInfoSet returned by SetupDiGetClassDevs
+			The SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces.
+			The final parameter is an optional pointer to an SP_DEV_INFO_DATA structure.
+			This application doesn't retrieve or use the structure.
+			If retrieving the structure, set
+			MyDeviceInfoData.cbSize = length of MyDeviceInfoData.
+			and pass the structure's address.
+			*/
+			//Get the Length value.
+			//The call will return with a "buffer too small" error which can be ignored.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, NULL, 0, &Length, NULL);
+			//Allocate memory for the hDevInfo structure, using the returned Length.
+			detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(Length);
+			//Set cbSize in the detailData structure.
+			detailData -> cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+			//Call the function again, this time passing it the returned buffer size.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, detailData, Length,&Required, NULL);
+			// Open a handle to the device.
+			// To enable retrieving information about a system mouse or keyboard,
+			// don't request Read or Write access for this handle.
+			/*
+			API function: CreateFile
+			Returns: a handle that enables reading and writing to the device.
+			Requires:
+			The DevicePath in the detailData structure
+			returned by SetupDiGetDeviceInterfaceDetail.
+			*/
+			DeviceHandle=CreateFile(detailData->DevicePath,
+				0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+				(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING, 0, NULL);
+			/*
+			API function: HidD_GetAttributes
+			Requests information from the device.
+			Requires: the handle returned by CreateFile.
+			Returns: a HIDD_ATTRIBUTES structure containing
+			the Vendor ID, Product ID, and Product Version Number.
+			Use this information to decide if the detected device is
+			the one we're looking for.
+			*/
+			//Set the Size to the number of bytes in the structure.
+			Attributes.Size = sizeof(Attributes);
+			Result = HidD_GetAttributes(DeviceHandle,&Attributes);
+			//Is it the desired device?
+			MyDeviceDetected = FALSE;
+			if (Attributes.VendorID == vid)
+			{
+				if (Attributes.ProductID == pid)
+				{
+					//Both the Vendor ID and Product ID match.
+					MyDeviceDetected = TRUE;
+					strcpy(MyDevicePathName,detailData->DevicePath);
+					// Get a handle for writing Output reports.
+					WriteHandle=CreateFile(detailData->DevicePath,
+						GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
+						(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING,0,NULL);
+					//Get a handle to the device for the overlapped ReadFiles.
+					ReadHandle=CreateFile(detailData->DevicePath,
+						GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)NULL,
+						OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
+					if (hEventObject) CloseHandle(hEventObject);
+					hEventObject = CreateEvent(NULL,TRUE,TRUE,"");
+					//Set the members of the overlapped structure.
+					HIDOverlapped.hEvent = hEventObject;
+					HIDOverlapped.Offset = 0;
+					HIDOverlapped.OffsetHigh = 0;
+					Result=HidD_SetNumInputBuffers(DeviceHandle,64);
+				}
+				else
+					//The Product ID doesn't match.
+					CloseHandle(DeviceHandle);
+			}
+			else
+				//The Vendor ID doesn't match.
+				CloseHandle(DeviceHandle);
+		//Free the memory used by the detailData structure (no longer needed).
+		free(detailData);
+		}
+		else
+			//SetupDiEnumDeviceInterfaces returned 0, so there are no more devices to check.
+			LastDevice=TRUE;
+		//If we haven't found the device yet, and haven't tried every available device,
+		//try the next one.
+		MemberIndex = MemberIndex + 1;
+	} //do
+	while ((LastDevice == FALSE) && (MyDeviceDetected == FALSE));
+	//Free the memory reserved for hDevInfo by SetupDiClassDevs.
+	SetupDiDestroyDeviceInfoList(hDevInfo);
+
+	if(info&&MyDeviceDetected == TRUE){
+		char string[1024];
+		PrintMessage3("Device detected: vid=0x%04X pid=0x%04X\nPath: %s\n",vid,pid,MyDevicePathName);
+		if(HidD_GetManufacturerString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Manufacturer string: %s\n",string);
+		if(HidD_GetProductString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Product string: %s\n",string);
+	}
+#endif
+	if (MyDeviceDetected == FALSE){
+		PrintMessage(strings[S_noprog]);	//"Programmer not detected\r\n"
+		//gtk_statusbar_push(status_bar,statusID,strings[S_noprog]);
+	}
+	else{
+		PrintMessage(strings[S_prog]);	//"Programmer detected\r\n");
+		//gtk_statusbar_push(status_bar,statusID,strings[S_prog]);
+	}
+	return MyDeviceDetected;
+}
\ No newline at end of file
diff --git a/opgui.c b/opgui.c
new file mode 100644
index 0000000..1268901
--- /dev/null
+++ b/opgui.c
@@ -0,0 +1,2503 @@
+/**
+ * \file opgui.c
+ * main control program for the open programmer
+ *
+ * Copyright (C) 2009-2023 Alberto Maccioni
+ * for detailed info see:
+ * http://openprog.altervista.org/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+#include "common.h"
+#include "I2CSPI.h"
+#include "coff.h"
+#include "icd.h"
+#include "deviceRW.h"
+#include "fileIO.h"
+#include "progAVR.h"
+#include <string.h>
+
+#define MAXLINES 600
+#define  CONFIG_FILE "opgui.ini"
+#define  CONFIG_DIR ".opgui"
+#define MinDly 0
+void Connect(GtkWidget *widget,GtkWidget *window);
+void Quit(GtkWidget *widget,GtkWidget *window) { gtk_main_quit(); }
+void I2cspiR();
+void I2cspiS();
+void ProgID();
+void PrintMessageI2C(const char *msg);
+void ShowContext();
+int FindDevice(int vid,int pid);
+void TestHw();
+int CheckS1();
+char** strings;	//!localized strings
+int cmdline=0;
+int saveLog=0,programID=0,load_osccal=0,load_BKosccal=0;
+int use_osccal=1,use_BKosccal=0;
+int load_calibword=0,max_err=200;
+int AVRlock=0x100,AVRfuse=0x100,AVRfuse_h=0x100,AVRfuse_x=0x100;
+int ICDenable=0,ICDaddr=0x1FF0;
+int FWVersion=0,HwID=0;
+FILE* logfile=0;
+char LogFileName[512]="";
+char loadfile[512]="",savefile[512]="";
+char loadfileEE[512]="",savefileEE[512]="";
+char CoffFileName[512]="";
+int vid=0x1209,pid=0x5432;
+int new_vid=0x1209,new_pid=0x5432;
+int old_vid=0x04D8,old_pid=0x0100;
+WORD *memCODE_W=0;
+int size=0,sizeW=0,sizeEE=0,sizeCONFIG=0,sizeUSERID=0;
+unsigned char *memCODE=0,*memEE=0,memID[64],memCONFIG[48],memUSERID[8];
+double hvreg=0;
+int DeviceDetected=0;
+int IOTimer=0;
+int skipV33check=0;
+int waitS1=0,waitingS1=0;
+int progress=0;
+int RWstop=0;
+int forceConfig=0;
+#ifdef DEBUG
+	int addrDebug=0;
+	unsigned short dataDebug=0;
+	unsigned short statusDebug=0x3FFF;
+#endif
+//List of gtk controls
+GtkTextBuffer * dataBuf;
+GtkWidget * data,*data_scroll;
+GtkWidget * window;
+GtkWidget * toolbar;
+GtkWidget * button;
+GtkWidget * b_open;
+GtkWidget * b_save;
+GtkWidget * b_read;
+GtkWidget * b_write;
+GtkWidget * notebook;
+GtkWidget * label;
+GtkWidget * status_bar;
+GtkWidget * img;
+GtkWidget * devTree;
+GtkWidget * devTypeCombo;
+GtkWidget * devFramePIC;
+GtkWidget * ICD_check;
+GtkWidget * ICD_addr_entry;
+GtkWidget * EEPROM_RW;
+GtkWidget * ReadReserved;
+GtkWidget * Write_ID_BKCal;
+GtkWidget * WriteCalib12;
+GtkWidget * UseOSCCAL;
+GtkWidget * UseBKOSCCAL;
+GtkWidget * UseFileCal;
+GtkWidget * devFrameAVR;
+GtkWidget * AVR_FuseLow,* AVR_FuseLowWrite,* AVR_FuseHigh,* AVR_FuseHighWrite,* AVR_FuseExt;
+GtkWidget * AVR_FuseExtWrite,* AVR_Lock,* AVR_LockWrite;
+GtkWidget * b_WfuseLF;
+GtkWidget * b_connect;
+GtkWidget * b_testhw;
+GtkWidget * b_log;
+GtkWidget * VID_entry;
+GtkWidget * PID_entry;
+GtkWidget * Errors_entry;
+GtkWidget * I2C8bit;
+GtkWidget * I2C16bit;
+GtkWidget * SPI00;
+GtkWidget * SPI01;
+GtkWidget * SPI10;
+GtkWidget * SPI11;
+GtkWidget * I2CDataSend;
+GtkWidget * I2CDataReceive;
+GtkWidget * I2CSendBtn;
+GtkWidget * I2CReceiveBtn;
+GtkWidget * I2CNbyte;
+GtkWidget * I2CSpeed;
+GtkWidget * DCDC_ON;
+GtkWidget * DCDC_voltage;
+GtkWidget * VPP_ON;
+GtkWidget * VDD_ON;
+GtkWidget * b_io_active;
+GtkWidget * commandSend;
+GtkWidget * commandTransfer;
+GtkWidget * b_V33check;
+GtkWidget * Hex_entry;
+GtkWidget * Address_entry;
+GtkWidget * Data_entry;
+GtkWidget * Hex_data;
+GtkWidget * Hex_data2;
+GtkWidget * CW1_entry;
+GtkWidget * CW2_entry;
+GtkWidget * CW3_entry;
+GtkWidget * CW4_entry;
+GtkWidget * CW5_entry;
+GtkWidget * CW6_entry;
+GtkWidget * CW7_entry;
+GtkWidget * ConfigForce;
+GtkWidget * b_WaitS1;
+GtkWidget * devFrameConfigW;
+GtkWidget * devFrameICD;
+GtkWidget * devFrameOsc;
+GtkWidget * devPIC_CW1;
+GtkWidget * devPIC_CW2;
+GtkWidget * devPIC_CW3;
+GtkWidget * devPIC_CW4;
+GtkWidget * devPIC_CW5;
+GtkWidget * devPIC_CW6;
+GtkWidget * devPIC_CW7;
+GtkWidget * devPIC_CW8;
+GtkWidget * devinfo;
+GtkWidget* stopBtn;
+GtkWidget* readBtn;
+GtkWidget* writeBtn;
+GtkListStore *devStore;
+GtkWidget *devTree, *devFiltEntry, *devFrame;
+GtkTreeSelection *devSel;
+///array of radio buttons for IO manual control
+struct io_btn {	char * name;
+				int x;
+				int y;
+				GtkWidget * r_0;	//radio button 0
+				GtkWidget * r_1;	//radio button 1
+				GtkWidget * r_I;	//radio button I
+				GtkWidget * e_I;	//entry
+				} ioButtons[13];
+int statusID;
+int ee = 0;
+int readRes=0;
+char dev[64]="";
+int devType=-1;
+char str[4096]="";
+char* cur_path=0;
+char* cur_pathEE=0;
+enum dev_column_t {
+  DEVICE_ID_COLUMN = 0,
+  DEVICE_NAME_COLUMN,
+  DEVICE_GROUP_COLUMN,
+  DEVICE_N_COLUMNS
+};
+enum sort_type_t {
+  SORT_STRING_NAME = 0,
+  SORT_STRING_GROUP
+};
+enum sort_data_type_t { SDT_STRING = 0 };
+char *groupNames[NUM_GROUPS] = {
+	"PIC10/12",
+	"PIC16",
+	"PIC18",
+	"PIC24",
+	"PIC30/33",
+	"ATMEL AVR",
+	"MEMORY"
+};
+char *GROUP_ALL="*";
+
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	int fd = -1;
+#ifdef hiddevIO	
+	struct hiddev_report_info rep_info_i,rep_info_u;
+	struct hiddev_usage_ref_multi ref_multi_i,ref_multi_u;
+#endif
+	char path[512]="";
+	unsigned char bufferU[128],bufferI[128];
+#else	//Windows
+	unsigned char bufferU0[128],bufferI0[128];
+	unsigned char *bufferU,*bufferI;
+	DWORD NumberOfBytesRead,BytesWritten;
+	ULONG Result;
+	HANDLE WriteHandle,ReadHandle;
+	OVERLAPPED HIDOverlapped;
+	HANDLE hEventObject;
+#endif
+///
+///Exit
+gint delete_event( GtkWidget *widget,GdkEvent *event,gpointer data )
+{
+gtk_main_quit ();
+return FALSE;
+}
+///
+///Show program info window
+void info(GtkWidget *widget,GtkWidget *window)
+{
+  const gchar *license =
+    "This program is free software; you can redistribute it and/or\n"
+    "modify it under the terms of the GNU Library General Public License as\n"
+    "published by the Free Software Foundation; either version 2 of the\n"
+    "License, or (at your option) any later version.\n"
+    "\n"
+    "This program is distributed in the hope that it will be useful,\n"
+    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
+    "Library General Public License for more details.\n"
+    "\n"
+    "You should have received a copy of the GNU Library General Public\n"
+    "License along with the Gnome Library; see the file COPYING.LIB.  If not,\n"
+    "write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\n"
+    "Boston, MA 02111-1307, USA.\n";
+	gtk_show_about_dialog (NULL,
+		//"artists"                  GStrv*                : Read / Write
+		//"authors"                  GStrv*                : Read / Write
+		//"authors","Alberto Maccioni",NULL,
+		"comments", "A graphical interface for the Open Programmer",
+		"copyright",
+		"Copyright (C) Alberto Maccioni 2009-2022\n\n"
+		"This program is free software; you can \n"
+		"redistribute it and/or modify it under \n"
+		"the terms of the GNU General Public License \n"
+		"as published by the Free Software Foundation;\n"
+		"either version 2 of the License, or \n"
+		"(at your option) any later version.",
+		//"documenters"              GStrv*                : Read / Write
+		"license",license,
+		"logo",gdk_pixbuf_new_from_resource("/res/sys.png", NULL),
+		//  "logo-icon-name"           gchar*                : Read / Write
+		"program-name", "OPGUI",
+		//  "translator-credits"       gchar*                : Read / Write
+		"version",VERSION,
+		"website","www.openprog.altervista.org",
+		//  "website-label"            gchar*                : Read / Write
+  		"wrap-license",TRUE,
+		"title","Info about OPGUI",
+		NULL);
+}
+///
+///Append a message on the data tab; shorten the length of the entry field to MAXLINES
+void PrintMessage(const char *msg){
+	if(cmdline) return;	//do not print anything if using command line mode
+	GtkTextIter iter,iter2;
+	gtk_text_buffer_get_end_iter(dataBuf,&iter);
+	gtk_text_buffer_insert(dataBuf,&iter,msg,-1);
+	gtk_text_buffer_get_start_iter(dataBuf,&iter2);
+	gtk_text_buffer_get_end_iter(dataBuf,&iter);
+	int l=gtk_text_buffer_get_line_count(dataBuf);
+	if(l>MAXLINES+10){ 	//MAXLINES
+		gtk_text_iter_set_line(&iter,l-MAXLINES);
+		gtk_text_buffer_delete(dataBuf,&iter2,&iter);
+	}
+	while (gtk_events_pending ()) gtk_main_iteration();
+	gtk_text_buffer_get_end_iter(dataBuf,&iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(data),&iter,0.0,FALSE,0,0);
+}
+///
+///Print a message on the I2C data field
+void PrintMessageI2C(const char *msg){
+	GtkTextIter iter;
+	GtkTextBuffer * dataBuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(I2CDataReceive));
+	gtk_text_buffer_set_text(dataBuf,msg,-1);
+	gtk_text_buffer_get_end_iter(dataBuf,&iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(I2CDataReceive),&iter,0.0,FALSE,0,0);
+	while (gtk_events_pending ()) gtk_main_iteration();
+}
+///
+///Print a message on the "command" data field
+void PrintMessageCMD(const char *msg){
+	GtkTextIter iter;
+	GtkTextBuffer * dataBuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(commandTransfer));
+	gtk_text_buffer_set_text(dataBuf,msg,-1);
+	gtk_text_buffer_get_end_iter(dataBuf,&iter);
+	gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(commandTransfer),&iter,0.0,FALSE,0,0);
+}
+///
+///Update option variables according to actual control values
+void getOptions()
+{
+	vid=htoi(gtk_entry_get_text(GTK_ENTRY(VID_entry)),4);
+	pid=htoi(gtk_entry_get_text(GTK_ENTRY(PID_entry)),4);
+	saveLog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_log));
+	ee = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(EEPROM_RW))?0xFFFF:0;
+	programID = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Write_ID_BKCal));
+	max_err=atoi(gtk_entry_get_text(GTK_ENTRY(Errors_entry)));
+	load_calibword= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(WriteCalib12));
+	load_osccal= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseOSCCAL));
+	load_BKosccal= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseBKOSCCAL));
+	ICDenable= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ICD_check));
+	readRes= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ReadReserved));
+	skipV33check=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_V33check));
+	waitS1=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_WaitS1));
+	int i=sscanf(gtk_entry_get_text(GTK_ENTRY(ICD_addr_entry)),"%x",&ICDaddr);
+	if(i!=1||ICDaddr<0||ICDaddr>0xFFFF) ICDaddr=0x1FF0;
+	char *str=0;//gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(devCombo));
+	if(str) strncpy(dev,str,sizeof(dev)-1);
+	g_free(str);
+	AVRfuse=AVRfuse_h=AVRfuse_x=AVRlock=0x100;
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(AVR_FuseLowWrite))){
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(AVR_FuseLow)),"%x",&AVRfuse);
+		if(i!=1||AVRfuse<0||AVRfuse>0xFF) AVRfuse=0x100;
+	}
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(AVR_FuseHighWrite))){
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(AVR_FuseHigh)),"%x",&AVRfuse_h);
+		if(i!=1||AVRfuse_h<0||AVRfuse_h>0xFF) AVRfuse_h=0x100;
+	}
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(AVR_FuseExtWrite))){
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(AVR_FuseExt)),"%x",&AVRfuse_x);
+		if(i!=1||AVRfuse_x<0||AVRfuse_x>0xFF) AVRfuse_x=0x100;
+	}
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(AVR_LockWrite))){
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(AVR_Lock)),"%x",&AVRlock);
+		if(i!=1||AVRlock<0||AVRlock>0xFF) AVRlock=0x100;
+	}
+	str=malloc(128);
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ConfigForce))){
+		int cw1,cw2,cw3,cw4,cw5,cw6,cw7;
+		cw1=cw2=cw3=cw4=cw5=cw6=cw7=0x10000;
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW1_entry)),"%x",&cw1);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW2_entry)),"%x",&cw2);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW3_entry)),"%x",&cw3);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW4_entry)),"%x",&cw4);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW5_entry)),"%x",&cw5);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW6_entry)),"%x",&cw6);
+		i=sscanf(gtk_entry_get_text(GTK_ENTRY(CW7_entry)),"%x",&cw7);
+		if(devType==PIC16){
+			if((!strncmp(dev,"16F1",4)||!strncmp(dev,"12F1",4))&&sizeW>0x8008){		//16F1xxx
+				if(cw1<=0x3FFF){
+					memCODE_W[0x8007]=cw1;
+					PrintMessage3(strings[S_ForceConfigWx],1,0x8007,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+				if(cw2<=0x3FFF){
+					memCODE_W[0x8008]=cw2;
+					PrintMessage3(strings[S_ForceConfigWx],2,0x8008,cw2); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+			}
+			else{	//16Fxxx
+				if(cw1<=0x3FFF&&sizeW>0x2007){
+					memCODE_W[0x2007]=cw1;
+					PrintMessage3(strings[S_ForceConfigWx],1,0x2007,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+				if(cw2<=0x3FFF&&sizeW>0x2008){
+					memCODE_W[0x2008]=cw2;
+					printf("2\n");
+					PrintMessage3(strings[S_ForceConfigWx],2,0x2008,cw2); //"forcing config word%d [0x%04X]=0x%04X"
+				}
+			}
+		}
+		else if(devType==PIC12){	//12Fxxx
+			if(cw1<=0xFFF&&sizeW>0xFFF){
+				memCODE_W[0xFFF]=cw1;
+				PrintMessage3(strings[S_ForceConfigWx],1,0xFFF,cw1); //"forcing config word%d [0x%04X]=0x%04X"
+			}
+		}
+		else if(devType==PIC18){	//18Fxxx
+			if(cw1<=0xFFFF){
+				memCONFIG[0]=cw1&0xFF;
+				memCONFIG[1]=(cw1>>8)&0xFF;
+			}
+			if(cw2<=0xFFFF){
+				memCONFIG[2]=cw2&0xFF;
+				memCONFIG[3]=(cw2>>8)&0xFF;
+			}
+			if(cw3<=0xFFFF){
+				memCONFIG[4]=cw3&0xFF;
+				memCONFIG[5]=(cw3>>8)&0xFF;
+			}
+			if(cw4<=0xFFFF){
+				memCONFIG[6]=cw4&0xFF;
+				memCONFIG[7]=(cw4>>8)&0xFF;
+			}
+			if(cw5<=0xFFFF){
+				memCONFIG[8]=cw5&0xFF;
+				memCONFIG[9]=(cw5>>8)&0xFF;
+			}
+			if(cw6<=0xFFFF){
+				memCONFIG[10]=cw6&0xFF;
+				memCONFIG[11]=(cw6>>8)&0xFF;
+			}
+			if(cw7<=0xFFFF){
+				memCONFIG[12]=cw7&0xFF;
+				memCONFIG[13]=(cw7>>8)&0xFF;
+			}
+			PrintMessage(strings[S_ForceConfigW]); //"forcing config words"
+			for(i=0;i<7;i++){
+				PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]);	//"CONFIG%dH: 0x%02X\t"
+				PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]);	//"CONFIG%dL: 0x%02X\r\n"
+			}
+		}
+	}
+	free(str);
+}
+///
+///Check GUI for selected device and put in variable 'dev'. Also enable/disable R/W buttons
+void GetSelectedDevice() {
+	GtkTreeModel *tmpModel;
+	GtkTreeIter tmpIter;
+	char *devName;
+	if (!GTK_IS_TREE_SELECTION(devSel)) { // Not initialised yet
+		return;
+	}
+	if (gtk_tree_selection_get_selected(devSel, &tmpModel, &tmpIter)) {
+		gtk_tree_model_get(tmpModel, &tmpIter, DEVICE_NAME_COLUMN, &devName, -1);
+		strcpy(dev,devName);
+		gtk_widget_set_sensitive(GTK_WIDGET(readBtn), TRUE);
+		gtk_widget_set_sensitive(GTK_WIDGET(writeBtn), TRUE);
+		g_free(devName);
+	} else { // Shouldn't ever happen, but just in case
+		dev[0] = '\0';
+		gtk_widget_set_sensitive(GTK_WIDGET(readBtn), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(writeBtn), FALSE);
+	}
+}
+///
+///Choose a file to open and call Load()
+void Fopen(GtkWidget *widget,GtkWidget *window)
+{
+	GetSelectedDevice();
+	if(progress) return;
+	progress=1;
+	GtkFileChooser *dialog;
+	dialog = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[I_Fopen], //"Open File"
+					GTK_WINDOW(window),
+					GTK_FILE_CHOOSER_ACTION_OPEN,
+					strings[I_CANCEL], GTK_RESPONSE_CANCEL,
+					strings[I_OPEN], GTK_RESPONSE_ACCEPT,
+					NULL);
+	if(cur_path) gtk_file_chooser_set_current_folder(dialog,cur_path);
+    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT){
+	    char *filename;
+	    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+		if(cur_path) free(cur_path);
+		cur_path = gtk_file_chooser_get_current_folder(dialog);
+	    Load(dev,filename);
+	    g_free (filename);
+		if(!strncmp(dev,"AT",2)){	//load EEPROM from separate file for ATMEL chips
+			GtkFileChooser *dialog2;
+			dialog2 = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[S_openEEfile],
+							GTK_WINDOW(window),
+							GTK_FILE_CHOOSER_ACTION_OPEN,
+							strings[I_CANCEL],GTK_RESPONSE_CANCEL,
+							strings[I_OPEN],GTK_RESPONSE_ACCEPT,
+							NULL);
+			if(!cur_pathEE) cur_pathEE = gtk_file_chooser_get_current_folder(dialog);
+			if(cur_pathEE) gtk_file_chooser_set_current_folder(dialog2,cur_pathEE);
+			if (gtk_dialog_run (GTK_DIALOG (dialog2)) == GTK_RESPONSE_ACCEPT){
+			    char *filename2;
+			    filename2 = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog2));
+				if(cur_pathEE) free(cur_pathEE);
+				cur_pathEE = gtk_file_chooser_get_current_folder(dialog2);
+				LoadEE(dev,filename2);
+				g_free (filename2);
+			}
+			gtk_widget_destroy(GTK_WIDGET(dialog2));
+		}
+	}
+	gtk_widget_destroy (GTK_WIDGET(dialog));
+	progress=0;
+}
+///
+///Choose a file to save and call Save()
+void Fsave(GtkWidget *widget,GtkWidget *window)
+{
+	if(progress) return;
+	progress=1;
+	GtkFileChooser *dialog;
+	dialog = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[I_Fsave], //"Save File",
+						GTK_WINDOW(window),
+						GTK_FILE_CHOOSER_ACTION_SAVE,
+						strings[I_CANCEL], GTK_RESPONSE_CANCEL,
+						strings[I_SAVE], GTK_RESPONSE_ACCEPT,
+						NULL);
+	if(cur_path) gtk_file_chooser_set_current_folder(dialog,cur_path);
+	gtk_file_chooser_set_do_overwrite_confirmation(dialog,TRUE);
+	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+	  {
+	    char *filename;
+	    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+		if(cur_path) free(cur_path);
+		cur_path = gtk_file_chooser_get_current_folder(dialog);
+   		Save(dev,filename);
+		PrintMessage1(strings[S_FileSaved],filename);
+	    g_free (filename);
+		if(!strncmp(dev,"AT",2)&&sizeEE){	//save EEPROM on separate file for ATMEL chips
+			GtkFileChooser *dialog2;
+			dialog2 = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[S_saveEEfile],
+								GTK_WINDOW(window),
+								GTK_FILE_CHOOSER_ACTION_SAVE,
+								strings[I_CANCEL], GTK_RESPONSE_CANCEL,
+								strings[I_SAVE], GTK_RESPONSE_ACCEPT,
+								NULL);
+			if(!cur_pathEE) cur_pathEE = gtk_file_chooser_get_current_folder(dialog);
+			if(cur_pathEE) gtk_file_chooser_set_current_folder(dialog2,cur_pathEE);
+			gtk_file_chooser_set_do_overwrite_confirmation(dialog2,TRUE);
+			if (gtk_dialog_run (GTK_DIALOG (dialog2)) == GTK_RESPONSE_ACCEPT){
+			    char *filename2;
+			    filename2 = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog2));
+				if(cur_pathEE) free(cur_pathEE);
+				cur_pathEE = gtk_file_chooser_get_current_folder(dialog2);
+				SaveEE(dev,filename2);
+				PrintMessage1(strings[S_FileSaved],filename2);
+				g_free (filename2);
+			}
+			gtk_widget_destroy(GTK_WIDGET(dialog2));
+		}
+	  }
+	gtk_widget_destroy (GTK_WIDGET(dialog));
+	progress=0;
+}
+///
+///Select data tab
+void selectDataTab() { gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0); }
+///
+///Call device write function
+void DevWrite(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	selectDataTab();
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+	RWstop=0;
+	getOptions();
+	if(!waitingS1&&waitS1){
+		waitingS1=1;
+		int i,S1=0;
+		PrintMessage(strings[I_PRESSS1]); //"press S1 to start"
+		for(i=0;!S1&&waitS1&&waitingS1;i++){
+			S1=CheckS1();
+			msDelay(50);
+			PrintMessage(".");
+			if(i%64==63) PrintMessage(strings[S_NL]); //"\n"
+			while (gtk_events_pending ()) gtk_main_iteration(); //handle UI events, including write button
+			msDelay(50);
+		}
+		PrintMessage(strings[S_NL]); //"\n"
+		if(!progress&&S1){
+			gtk_widget_set_sensitive(stopBtn,TRUE);
+			progress=1;
+			Write(dev,ee);	//choose the right function
+			progress=0;
+			gtk_widget_set_sensitive(stopBtn,FALSE);
+		}
+		waitingS1=0;
+	}
+	else if(waitingS1) waitingS1=0;
+	else if(!progress){
+		gtk_widget_set_sensitive(stopBtn,TRUE);
+		progress=1;
+		Write(dev,ee);	//choose the right function
+		progress=0;
+		gtk_widget_set_sensitive(stopBtn,FALSE);
+	}
+}
+///
+///Call device read function
+void DevRead(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	selectDataTab();
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+	getOptions();
+	RWstop=0;
+	if(!waitingS1&&waitS1){
+		waitingS1=1;
+		int i,S1=0;
+		PrintMessage(strings[I_PRESSS1]); //"press S1 to start"
+		for(i=0;!S1&&waitS1&&waitingS1;i++){
+			S1=CheckS1();
+			msDelay(50);
+			PrintMessage(".");
+			if(i%64==63) PrintMessage(strings[S_NL]); //"\n"
+			while (gtk_events_pending ()) gtk_main_iteration(); //handle UI events, including write button
+			msDelay(50);
+		}
+		PrintMessage(strings[S_NL]); //"\n"
+		if(!progress&&S1){
+			gtk_widget_set_sensitive(stopBtn,TRUE);
+			progress=1;
+			Read(dev,ee,readRes);	//choose the right function
+			progress=0;
+			gtk_widget_set_sensitive(stopBtn,FALSE);
+		}
+		waitingS1=0;
+	}
+	else if(waitingS1) waitingS1=0;
+	else if(!progress){
+		gtk_widget_set_sensitive(stopBtn,TRUE);
+		progress=1;
+		Read(dev,ee,readRes);	//choose the right function
+		progress=0;
+		gtk_widget_set_sensitive(stopBtn,FALSE);
+	}
+}
+///
+/// Write fuse low byte at low frequency
+void WriteATfuseLowLF(GtkWidget *widget,GtkWidget *window){
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(progress) return;
+	getOptions();
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(AVR_FuseLowWrite))){
+		progress=1;
+		if(AVRfuse<0x100) WriteATfuseSlow(AVRfuse);
+		progress=0;
+	}
+}
+///
+///Callback function to set available options for each device type
+void onDevSel_Changed(GtkWidget *widget,GtkWidget *window)
+{
+	struct DevInfo info;
+	char str2[256],str3[64],strF[32];
+	double x;
+	GetSelectedDevice();
+	if (strlen(dev) == 0) return; // None selected
+	info=GetDevInfo(dev);
+	sprintf(str, "<b>%s: %s</b>", strings[I_Dev], dev);
+	gtk_label_set_markup(GTK_LABEL(devFrame), str);
+	devType=info.family;
+	gtk_label_set_text(GTK_LABEL(devinfo),info.features);
+	if(devType==PIC12||devType==PIC16||devType==PIC18||devType==PIC24){
+		gtk_widget_show_all(GTK_WIDGET(devFramePIC));
+		gtk_widget_hide(GTK_WIDGET(devFrameAVR));
+		gtk_widget_show_all(GTK_WIDGET(EEPROM_RW));
+	}
+	else if(devType==AVR){	//ATMEL
+		gtk_widget_hide(GTK_WIDGET(devFramePIC));
+		gtk_widget_show_all(GTK_WIDGET(devFrameAVR));
+		gtk_widget_show_all(GTK_WIDGET(EEPROM_RW));
+	}
+	else{
+		gtk_widget_hide(GTK_WIDGET(devFramePIC));
+		gtk_widget_hide(GTK_WIDGET(devFrameAVR));
+		gtk_widget_hide(GTK_WIDGET(EEPROM_RW));
+	}
+	if(devType==PIC16)		//ICD
+		gtk_widget_show_all(GTK_WIDGET(devFrameICD));
+	else gtk_widget_hide(GTK_WIDGET(devFrameICD));
+	if(devType==PIC12||devType==PIC16)	//Osc options
+		gtk_widget_show_all(GTK_WIDGET(devFrameOsc));
+	else gtk_widget_hide(GTK_WIDGET(devFrameOsc));
+	if(devType==PIC12||devType==PIC16||devType==PIC18)	//program ID
+		gtk_widget_show_all(GTK_WIDGET(Write_ID_BKCal));
+	else gtk_widget_hide(GTK_WIDGET(Write_ID_BKCal));
+	if(devType==PIC16)	//Program Calib
+		gtk_widget_show_all(GTK_WIDGET(WriteCalib12));
+	else gtk_widget_hide(GTK_WIDGET(WriteCalib12));
+	if(devType==PIC12||devType==PIC16||devType==PIC18){	//Force config
+		gtk_widget_show_all(GTK_WIDGET(devFrameConfigW));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW2));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW3));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW4));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW5));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW6));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW7));
+		gtk_widget_hide(GTK_WIDGET(devPIC_CW8));
+		if(devType==PIC16){
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW2));
+		}
+		else if(devType==PIC18){
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW2));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW3));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW4));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW5));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW6));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW7));
+			gtk_widget_show_all(GTK_WIDGET(devPIC_CW8));
+		}
+	}
+	else{
+		gtk_widget_hide(GTK_WIDGET(devFrameConfigW));
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ConfigForce),FALSE);
+	}
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,dev);
+}
+/// Walk the TreeModel until we find an entry with the passed device name
+/// Select that entry and then stop walking
+gboolean selectDev_ForeachFunc(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, char *devNameToSelect) {
+	char *thisEntryDevName;
+	gtk_tree_model_get(model, iter, DEVICE_NAME_COLUMN, &thisEntryDevName, -1);
+	int matched = (strcmp(thisEntryDevName, devNameToSelect) == 0);
+	if (matched) gtk_tree_selection_select_iter(devSel, iter);
+	g_free(thisEntryDevName);
+	return matched;
+}
+///
+/// Comparison function used when sorting the device tree
+int sortIterCompareFunc(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata) {
+	enum sort_type_t sortcol = GPOINTER_TO_INT(userdata);
+	int ret = 0;
+	enum sort_data_type_t sortDataType;
+	int dataCol;
+	switch (sortcol) {
+		case SORT_STRING_NAME:
+			sortDataType = SDT_STRING;
+			dataCol = DEVICE_NAME_COLUMN;
+			break;
+		case SORT_STRING_GROUP:
+			sortDataType = SDT_STRING;
+			dataCol = DEVICE_GROUP_COLUMN;
+			break;
+		default:
+			return 0;
+	}
+	switch (sortDataType) {
+		case SDT_STRING:
+			{
+			char *nameA, *nameB;
+			gtk_tree_model_get(model, a, dataCol, &nameA, -1);
+			gtk_tree_model_get(model, b, dataCol, &nameB, -1);
+			if (nameA == NULL || nameB == NULL) {
+				if (nameA == NULL && nameB == NULL) break; // Both null. return 0 (no need to free)
+				ret = (nameA == NULL) ? -1 : 1;
+			}
+			else {
+				ret = g_utf8_collate(nameA,nameB);
+			}
+			g_free(nameA);
+			g_free(nameB);
+			break;
+			}
+		default:
+			g_return_val_if_reached(0);
+	}
+	return ret;
+}
+///
+///Add devices to the device ListStore (which may not have been created)
+///groupFilter: add devices in this group (-1 for all)
+///textFilter: only add devices containing this string (NULL for all)
+void AddDevices(enum group_t groupFilter, const char *textFilter) {
+	if (GTK_IS_TREE_SELECTION(devSel))
+		g_signal_handlers_disconnect_by_func(G_OBJECT(devSel),G_CALLBACK(onDevSel_Changed),NULL);
+	if (!GTK_IS_LIST_STORE(devStore)) {
+		devStore = gtk_list_store_new (DEVICE_N_COLUMNS,
+	  						  G_TYPE_UINT,
+                              G_TYPE_STRING,
+                              G_TYPE_STRING);
+		gtk_tree_view_set_model(GTK_TREE_VIEW(devTree), GTK_TREE_MODEL(devStore));
+		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(devStore), SORT_STRING_NAME,
+			sortIterCompareFunc, GINT_TO_POINTER(SORT_STRING_NAME), NULL);
+		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(devStore), SORT_STRING_GROUP,
+			sortIterCompareFunc, GINT_TO_POINTER(SORT_STRING_GROUP), NULL);
+	 	gtk_tree_view_column_set_sort_column_id(
+			gtk_tree_view_get_column(GTK_TREE_VIEW(devTree), 0), SORT_STRING_NAME);
+		gtk_tree_view_column_set_sort_column_id(
+			gtk_tree_view_get_column(GTK_TREE_VIEW(devTree), 1), SORT_STRING_GROUP);
+		g_object_unref (G_OBJECT(devStore));
+	}
+	else gtk_list_store_clear(devStore);
+	int i,j=0;
+	char *devices=0,*tok;
+	for(i=0;i<NDEVLIST;i++) {
+		if(devices) free(devices);
+		devices=malloc(strlen(DEVLIST[i].device)+1);
+		strcpy(devices,DEVLIST[i].device);
+		struct DevInfo info;
+		populateDevInfo(&info, &(DEVLIST[i]));
+		for(tok=strtok(devices,", \t");tok;tok=strtok(NULL,", \t")) {
+			//info.device=malloc(strlen(tok)+1);
+			//strcpy(info.device,tok);
+			info.group=nameToGroup(tok);
+			if(info.group!=-1&&(!textFilter || strlen(textFilter) == 0 || strstr(tok, textFilter)) &&
+				(groupFilter == -1 || info.group == groupFilter)) {
+					gtk_list_store_insert_with_values(devStore, NULL, -1,
+						DEVICE_ID_COLUMN, j++,
+						DEVICE_NAME_COLUMN, tok,
+						DEVICE_GROUP_COLUMN, groupNames[info.group], -1);
+			}
+		}
+	}
+	free(devices);
+	if(GTK_IS_TREE_SELECTION(devSel)) {
+		gtk_tree_selection_unselect_all(devSel);
+	}
+	else {
+		devSel = gtk_tree_view_get_selection(GTK_TREE_VIEW(devTree));
+		gtk_tree_selection_set_mode(devSel, GTK_SELECTION_SINGLE);
+	}	
+	g_signal_connect(G_OBJECT(devSel),"changed",G_CALLBACK(onDevSel_Changed),NULL);
+	gtk_tree_model_foreach(GTK_TREE_MODEL(devStore),
+		(GtkTreeModelForeachFunc)selectDev_ForeachFunc,
+	 	dev);
+}
+///
+///Filter device list (in gtk_tree) according to type selected
+void FilterDevType(GtkWidget *widget,GtkWidget *window)
+{
+	char *selGroupName = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(devTypeCombo));
+	const char *filtText = gtk_entry_get_text(GTK_ENTRY(devFiltEntry));
+	enum group_t selGroup = -1;
+	for (int i=0; i<NUM_GROUPS; i++) {
+		if (strcmp(selGroupName, groupNames[i]) == 0) {
+			selGroup = i;
+			i = NUM_GROUPS;
+		}
+	}
+	// If no specific group selected, ALL should be selected
+	if (selGroup == -1 && strcmp(GROUP_ALL, selGroupName)) {
+		PrintMessage1("ERR: group name '%s' invalid", selGroupName);
+		return;
+	}
+	AddDevices(selGroup, filtText);
+	g_free(selGroupName);
+	onDevSel_Changed(NULL, NULL);
+}
+///
+/// Check or set IO signals according to IO tab controls
+void IOchanged(GtkWidget *widget,GtkWidget *window)
+{
+	if(progress) return;
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_io_active))) return;
+	int i,j=0;
+	int trisa=1,trisb=0,trisc=0x30,latac=0,latb=0;
+	int port=0,z;
+	//char str[128]="IO:";
+	char s2[64];
+	str[0]=0;
+	for(i=0;i<sizeof(ioButtons)/sizeof(ioButtons[0]);i++){
+		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ioButtons[i].r_0))){
+			//strcat(str,"0");
+		}
+		else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ioButtons[i].r_1))){
+			//strcat(str,"1");
+			if(i<8) latb|=1<<i;
+			else if(i==8) latac|=0x80; //RC7
+			else if(i==9) latac|=0x40; //RC6
+			else if(i==10) latac|=0x20; //RA5
+			else if(i==11) latac|=0x10; //RA4
+			else if(i==12) latac|=0x08; //RA3
+		}
+		else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ioButtons[i].r_I))){
+			//strcat(str,"I");
+			if(i<8)	trisb|=1<<i;
+			else if(i==8) trisc|=0x80; //RC7
+			else if(i==9) trisc|=0x40; //RC6
+			else if(i==10) trisa|=0x20; //RA5
+			else if(i==11) trisa|=0x10; //RA4
+			else if(i==12) trisa|=0x8; //RA3
+		}
+	}
+	//sprintf(s2," trisb=%02X latb=%02X trisc=%02X trisa=%02X latac=%02X",trisb,latb,trisc,trisa,latac);
+	//strcat(str,s2);
+	//gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x80;	//PORTA
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x81;	//PORTB
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x82;	//PORTC
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x92;	//TRISA
+	bufferU[j++]=trisa;
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x93;	//TRISB
+	bufferU[j++]=trisb;
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x94;	//TRISC
+	bufferU[j++]=trisc;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=latb;
+	bufferU[j++]=latac;
+	bufferU[j++]=READ_ADC;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	for(z=0;z<DIMBUF-3&&bufferI[z]!=READ_RAM;z++);
+	port=bufferI[z+3];	//PORTA
+	//sprintf(s2," porta=%02X",port);
+	//strcat(str,s2);
+	//gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);
+	gtk_label_set_text(GTK_LABEL(ioButtons[10].e_I),(port&0x20)?"1":"0");
+	gtk_label_set_text(GTK_LABEL(ioButtons[11].e_I),(port&0x10)?"1":"0");
+	gtk_label_set_text(GTK_LABEL(ioButtons[12].e_I),(port&0x8)?"1":"0");
+	for(z+=4;z<DIMBUF-3&&bufferI[z]!=READ_RAM;z++);
+	port=bufferI[z+3];	//PORTB
+	for(i=0;i<8;i++) gtk_label_set_text(GTK_LABEL(ioButtons[i].e_I),(port&(1<<i))?"1":"0");
+	for(z+=4;z<DIMBUF-3&&bufferI[z]!=READ_RAM;z++);
+	port=bufferI[z+3];	//PORTC
+	gtk_label_set_text(GTK_LABEL(ioButtons[8].e_I),(port&0x80)?"1":"0");
+	gtk_label_set_text(GTK_LABEL(ioButtons[9].e_I),(port&0x40)?"1":"0");
+	for(z+=4;z<DIMBUF-2&&bufferI[z]!=READ_ADC;z++);
+	double vpp=((bufferI[z+1]<<8)+bufferI[z+2])/1024.0*5*34/12;	//VPP
+	sprintf(str,"VPP=%.2fV",vpp);
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);
+	return;
+}
+///
+/// Start/stop timer to check for IO status
+void IOactive(GtkWidget *widget,GtkWidget *window)
+{
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_io_active))&&!icdTimer){
+		IOTimer=g_timeout_add(100,(GSourceFunc)IOchanged,NULL);
+	}
+	else if(IOTimer){
+		g_source_remove(IOTimer);
+	}
+}
+///
+/// Enable/disable VPP and VCC from IO tab
+void VPPVDDactive(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	int j=0,vdd_vpp=0;
+	char str[16]="";
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(VPP_ON))){
+		vdd_vpp+=4;
+		strcat(str,"VPP ");
+	}
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(VDD_ON))){
+		vdd_vpp+=1;
+		strcat(str,"VDD ");
+	}
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=vdd_vpp;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+}
+///
+/// Enable/disable DCDC from IO tab or update DCDC voltage
+void DCDCactive(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(DCDC_ON))){
+		int j=0,vreg=0;
+		char str[16];
+		double voltage=gtk_range_get_value(GTK_RANGE(DCDC_voltage));
+		vreg=voltage*10.0;
+		sprintf(str,"DCDC %.1fV",voltage);
+		gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,str);
+		bufferU[j++]=VREG_EN;			//enable HV regulator
+		bufferU[j++]=SET_VPP;
+		bufferU[j++]=vreg;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+	}
+	else{
+		int j=0;
+		bufferU[j++]=VREG_DIS;			//disable HV regulator
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+	}
+}
+///
+/// convert hex line
+void HexConvert(GtkWidget *widget,GtkWidget *window)
+{
+	char hex[256],str[256],s2[32];
+	int i,address,length,sum=0;
+	strncpy(hex,(const char *)gtk_entry_get_text(GTK_ENTRY(Hex_entry)),sizeof(hex));
+	if(strlen(hex)>0){
+		if(hex[0]==':'&&strlen(hex)>8){
+			length=htoi(hex+1,2);
+			address=htoi(hex+3,4);
+			if(strlen(hex)<11+length*2) gtk_entry_set_text(GTK_ENTRY(Hex_data),"__line too short");
+			else{
+				for (i=1;i<=length*2+9;i+=2) sum += htoi(hex+i,2);
+				if ((sum & 0xff)!=0){
+					sprintf(str,"__checksum error, expected 0x%02X",(-sum+htoi(hex+9+length*2,2))&0xFF);
+					gtk_entry_set_text(GTK_ENTRY(Hex_data),str);
+				}
+				else{
+					switch(htoi(hex+7,2)){
+						case 0:		//Data record
+							sprintf(str,"address: 0x%04X ",address);
+							if(i&&length) strcat(str,"data: 0x");
+							for (i=0;i<length;i++){
+								sprintf(s2,"%02X",htoi(hex+9+i*2,2));
+								strcat(str,s2);
+							}
+							gtk_entry_set_text(GTK_ENTRY(Hex_data),str);
+							break;
+						case 4:		//extended linear address record
+							if(strlen(hex)>14){
+								sprintf(str,"extended linear address = %04X",htoi(hex+9,4));
+								gtk_entry_set_text(GTK_ENTRY(Hex_data),str);
+							}
+							break;
+						default:
+							gtk_entry_set_text(GTK_ENTRY(Hex_data),"__unknown record type");
+							break;
+					}
+				}
+			}
+		}
+		else gtk_entry_set_text(GTK_ENTRY(Hex_data),"__invalid line");
+	}
+	else gtk_entry_set_text(GTK_ENTRY(Hex_entry),"");
+}
+///
+/// convert address & data to hex line
+void DataToHexConvert(GtkWidget *widget,GtkWidget *window)
+{
+	char hex[256],str[256],s2[32];
+	int i,address,length,sum=0,x;
+	i=sscanf(gtk_entry_get_text(GTK_ENTRY(Address_entry)),"%x",&address);
+	if(i!=1) address=0;
+	strncpy(hex,(const char *)gtk_entry_get_text(GTK_ENTRY(Data_entry)),sizeof(hex));
+	length=strlen(hex);
+	length&=0xFF;
+	if(length>0){
+		sprintf(str,":--%04X00",address&0xFFFF);
+		for(i=0;i+1<length;i+=2){
+			x=htoi(hex+i,2);
+			//x&=0xFF;
+			sum+=x;
+			sprintf(s2,"%02X",x);
+			strcat(str,s2);
+		}
+		sprintf(s2,"%02X",i/2);
+		str[1]=s2[0];
+		str[2]=s2[1];
+		x=sum;
+		sum+=i/2+(address&0xff)+((address>>8)&0xff);
+		sprintf(s2,"%02X",(-sum)&0xFF);
+		strcat(str,s2);
+		gtk_entry_set_text(GTK_ENTRY(Hex_data2),str);
+	}
+}
+///
+///Choose a file to save a hex line
+void HexSave(GtkWidget *widget,GtkWidget *window)
+{
+	GtkFileChooser *dialog;
+	if(strlen((const char *)gtk_entry_get_text(GTK_ENTRY(Hex_data2)))<11) return;
+	dialog = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[I_Fsave], //"Save File",
+						GTK_WINDOW(window),
+						GTK_FILE_CHOOSER_ACTION_SAVE,
+						strings[I_CANCEL], GTK_RESPONSE_CANCEL,
+						strings[I_SAVE], GTK_RESPONSE_ACCEPT,
+						NULL);
+	if(cur_path) gtk_file_chooser_set_current_folder(dialog,cur_path);
+	gtk_file_chooser_set_do_overwrite_confirmation(dialog,TRUE);
+	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+	  {
+	    char *filename;
+		filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+		if(cur_path) free(cur_path);
+		cur_path = gtk_file_chooser_get_current_folder(dialog);
+		FILE* f=fopen(filename,"w");
+		if(f){
+			fprintf(f,(const char *)gtk_entry_get_text(GTK_ENTRY(Hex_data2)));
+			fclose(f);
+		}
+	    g_free (filename);
+	  }
+	gtk_widget_destroy (GTK_WIDGET(dialog));
+}
+///
+/// Stop read or write
+void Stop(GtkWidget *widget,GtkWidget *window)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	if(progress==1&&RWstop==0){
+		RWstop=1;
+		PrintMessage(strings[I_STOP]);
+	}
+}
+///
+///Close program
+void Xclose(){
+//	char *str=gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(devCombo));
+//	if(str) strncpy(dev,str,sizeof(dev)-1);
+	gtk_main_quit();
+}
+///
+/// Show a message box
+void MsgBox(const char* msg)
+{
+	GtkWidget * dialog = gtk_message_dialog_new (GTK_WINDOW(window),
+                                 GTK_DIALOG_DESTROY_WITH_PARENT,
+                                 GTK_MESSAGE_INFO,
+                                 GTK_BUTTONS_OK,
+                                 msg);
+    gtk_window_set_title(GTK_WINDOW(dialog)," ");
+	gtk_dialog_run (GTK_DIALOG (dialog));
+	gtk_widget_destroy (dialog);
+}
+///
+/// Find the programmer and setup communication
+void Connect(GtkWidget *widget,GtkWidget *window){
+	vid=htoi(gtk_entry_get_text(GTK_ENTRY(VID_entry)),4);
+	pid=htoi(gtk_entry_get_text(GTK_ENTRY(PID_entry)),4);
+	DeviceDetected=FindDevice(vid,pid);	//connect to USB programmer
+	if(!DeviceDetected){
+		DeviceDetected=FindDevice(new_vid,new_pid);	//try default
+		if(DeviceDetected){
+			vid=new_vid;
+			pid=new_pid;
+		}
+	}
+	if(!DeviceDetected) DeviceDetected=FindDevice(old_vid,old_pid); //try old one
+	hvreg=0;
+	ProgID();
+}
+///
+/// I2C/SPI receive
+void I2cspiR()
+{
+	//if(DeviceDetected!=1) return;
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+	saveLog = (int) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_log));
+	int nbyte=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(I2CNbyte));
+	if(nbyte<0) nbyte=0;
+	if(nbyte>60) nbyte=60;
+	int mode=0;
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(I2C16bit))) mode=1;	//I2C mode
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI00))) mode=2;	//SPI mode 00
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI01))) mode=3;	//SPI mode 01
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI10))) mode=4;	//SPI mode 10
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI11))) mode=5;	//SPI mode 11
+	char* tok;
+    char tokbuf[512];
+	BYTE tmpbuf[128];
+	int i=0,x;
+    strncpy(tokbuf, (const char *)gtk_entry_get_text(GTK_ENTRY(I2CDataSend)), sizeof(tokbuf));
+	for(tok=strtok(tokbuf," ");tok&&i<128;tok=strtok(NULL," ")){
+		if(sscanf(tok,"%x",&x)){
+			tmpbuf[i] = (BYTE)x;
+			i++;
+		}
+	}
+	for(;i<128;i++) tmpbuf[i]=0;
+	I2CReceive(mode,gtk_combo_box_get_active(GTK_COMBO_BOX(I2CSpeed)),nbyte,tmpbuf);
+}
+///
+/// I2C/SPI send
+void I2cspiS()
+{
+	//if(DeviceDetected!=1) return;
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+	saveLog = (int) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_log));
+	int nbyte=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(I2CNbyte));
+	if(nbyte<0) nbyte=0;
+	if(nbyte>57) nbyte=57;
+	int mode=0;
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(I2C16bit))) mode=1;	//I2C mode
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI00))) mode=2;	//SPI mode 00
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI01))) mode=3;	//SPI mode 01
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI10))) mode=4;	//SPI mode 10
+	if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(SPI11))) mode=5;	//SPI mode 11
+	char* tok;
+    char tokbuf[512];
+	BYTE tmpbuf[128];
+	int i=0,x;
+    strncpy(tokbuf, (const char *)gtk_entry_get_text(GTK_ENTRY(I2CDataSend)), sizeof(tokbuf));
+	for(tok=strtok(tokbuf," ");tok&&i<128;tok=strtok(NULL," ")){
+		if(sscanf(tok,"%x",&x)){
+			tmpbuf[i] = (BYTE)x;
+			i++;
+		}
+	}
+	for(;i<128;i++) tmpbuf[i]=0;
+	I2CSend(mode,gtk_combo_box_get_active(GTK_COMBO_BOX(I2CSpeed)),nbyte,tmpbuf);
+}
+///
+/// send manual command
+void CommandIO()
+{
+	if(DeviceDetected!=1) return;
+	gtk_statusbar_push(GTK_STATUSBAR(status_bar),statusID,"");
+	saveLog = (int) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(b_log));
+	char* tok;
+    char tokbuf[512],str[16];
+	int i=0,x;
+    strncpy(tokbuf, (const char *)gtk_entry_get_text(GTK_ENTRY(commandSend)), sizeof(tokbuf));
+	for(tok=strtok(tokbuf," ");tok&&i<DIMBUF;tok=strtok(NULL," ")){
+		if(sscanf(tok,"%x",&x)){
+			bufferU[i] = (BYTE)x;
+			i++;
+		}
+	}
+	for(;i<DIMBUF;i++) bufferU[i]=0x0;
+	PacketIO(150);
+	sprintf(tokbuf,">[");
+	for(i=0;i<DIMBUF;i++){
+		sprintf(str," %02X",bufferU[i]);
+		strcat(tokbuf,str);
+		if(i%32==31&&i!=DIMBUF-1)strcat(tokbuf,"\n    ");
+	}
+	strcat(tokbuf," ]\n<[");
+	for(i=0;i<DIMBUF;i++){
+		sprintf(str," %02X",bufferI[i]);
+		strcat(tokbuf,str);
+		if(i%32==31&&i!=DIMBUF-1)strcat(tokbuf,"\n     ");
+	}
+	strcat(tokbuf," ]");
+	PrintMessageCMD(tokbuf);
+}
+///
+///Display contents of EEprom memory
+void DisplayEE(){
+	char s[256],t[256],v[256],*aux,*g;
+	int valid=0,empty=1,lines=0;
+	int i,j,max;
+	s[0]=0;
+	v[0]=0;
+	aux=malloc((sizeEE/COL+1)*(16+COL*5));
+	aux[0]=0;
+	PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+	max=sizeEE>7000?7000:sizeEE;
+	for(i=0;i<max;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<sizeEE;j++){
+			sprintf(t,"%02X ",memEE[j]);
+			strcat(s,t);
+			sprintf(t,"%c",isprint(memEE[j])&&(memEE[j]<0xFF)?memEE[j]:'.');
+			g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+			if(g) strcat(v,g);
+			g_free(g);
+			if(memEE[j]<0xff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s %s\r\n",i,s,v);
+			strcat(aux,t);
+			empty=0;
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=max-COL*2;
+				lines=490;
+			}
+		}
+		s[0]=0;
+		v[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else{
+		PrintMessage(aux);
+		if(sizeEE>max) PrintMessage("(...)\r\n");
+	}
+	free(aux);
+}
+///
+///Start HV regulator
+int StartHVReg(double V){
+	int j=0,z;
+	int vreg=(int)(V*10.0);
+	if(saveLog&&logfile) fprintf(logfile,"StartHVReg(%.2f)\n",V);
+	DWORD t0,t;
+	if(V==-1){
+		bufferU[j++]=VREG_DIS;			//disable HV regulator
+		bufferU[j++]=FLUSH;
+		PacketIO(5);
+		msDelay(40);
+		return -1;
+	}
+	t=t0=GetTickCount();
+	bufferU[j++]=VREG_EN;			//enable HV regulator
+	bufferU[j++]=SET_VPP;
+	bufferU[j++]=vreg;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=READ_ADC;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	msDelay(20);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_ADC;z++);
+	int v=(bufferI[z+1]<<8)+bufferI[z+2];
+//	PrintMessage2("v=%d=%fV\n",v,v/G);
+	if(v==0){
+		PrintMessage(strings[S_lowUsbV]);	//"Tensione USB troppo bassa (VUSB<4.5V)\r\n"
+		return 0;
+	}
+		j=0;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=READ_ADC;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	for(;(v<(vreg/10.0-1)*G||v>(vreg/10.0+1)*G)&&t<t0+1500;t=GetTickCount()){
+		PacketIO(5);
+		msDelay(20);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_ADC;z++);
+		v=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(HwID==3) v>>=2;		//if 12 bit ADC
+//		PrintMessage2("v=%d=%fV\n",v,v/G);
+	}
+	if(v>(vreg/10.0+1)*G){
+		PrintMessage(strings[S_HiVPP]);	//"Attenzione: tensione regolatore troppo alta\r\n\r\n"
+		return 0;
+	}
+	else if(v<(vreg/10.0-1)*G){
+		PrintMessage(strings[S_LowVPP]);	//"Attenzione: tensione regolatore troppo bassa\r\n\r\n"
+		return 0;
+	}
+	else if(v==0){
+		PrintMessage(strings[S_lowUsbV]);	//"Tensione USB troppo bassa (VUSB<4.5V)\r\n"
+		return 0;
+	}
+	else{
+		PrintMessage2(strings[S_reg],t-t0,v/G);	//"Regolatore avviato e funzionante dopo T=%d ms VPP=%.1f\r\n\r\n"
+		if(saveLog&&logfile) fprintf(logfile,strings[S_reg],t-t0,v/G);
+		return vreg;
+	}
+}
+///
+///Read programmer ID
+void ProgID()
+{
+	if(DeviceDetected!=1) return;
+	int j=0;
+	bufferU[j++]=PROG_RST;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	for(j=0;j<DIMBUF-7&&bufferI[j]!=PROG_RST;j++);
+	PrintMessage3(strings[S_progver],bufferI[j+1],bufferI[j+2],bufferI[j+3]); //"FW versione %d.%d.%d\r\n"
+	FWVersion=(bufferI[j+1]<<16)+(bufferI[j+2]<<8)+bufferI[j+3];
+	PrintMessage3(strings[S_progid],bufferI[j+4],bufferI[j+5],bufferI[j+6]);	//"ID Hw: %d.%d.%d"
+	HwID=bufferI[j+6];
+	if(HwID==1) PrintMessage(" (18F2550)\r\n\r\n");
+	else if(HwID==2) PrintMessage(" (18F2450)\r\n\r\n");
+	else if(HwID==3) PrintMessage(" (18F2458/2553)\r\n\r\n");
+	else if(HwID==4) PrintMessage(" (18F25K50)\r\n\r\n");
+	else PrintMessage(" (?)\r\n\r\n");
+}
+///
+///Check if a 3.3V regulator is present
+int CheckV33Regulator()
+{
+	int i,j=0;
+	if(skipV33check) return 1;
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x93;
+	bufferU[j++]=0xFE;	//B0 = output
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x01;	//B0=1
+	bufferU[j++]=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x81;	//Check if B1=1
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x00;	//B0=0
+	bufferU[j++]=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x81;	//Check if B1=0
+	bufferU[j++]=WRITE_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x93;
+	bufferU[j++]=0xFF;	//BX = input
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(j=0;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	i=bufferI[j+3]&0x2;		//B1 should be high
+	for(j+=3;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	return (i+(bufferI[j+3]&0x2))==2?1:0;
+}
+///
+///Check if S1 is pressed
+int CheckS1()
+{
+	int i,j=0;
+	bufferU[j++]=READ_RAM;
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0x84;	//READ PORTE
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(j=0;j<DIMBUF-3&&bufferI[j]!=READ_RAM;j++);
+	i=bufferI[j+3]&0x8;		//i=E3
+	return i?0:1;			//S1 open -> E3=1
+}
+///
+///Execute hardware test
+void TestHw(GtkWidget *widget,GtkWindow* parent)
+{
+#ifndef DEBUG
+	if(DeviceDetected!=1) return;
+#endif
+	char str[256];
+	StartHVReg(13);
+	int j=0;
+	MsgBox(strings[I_TestHW]);		//"Test hardware ..."
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDDU=5V\n VPPU=13V\n PGD(RB5)=0V\n PGC(RB6)=0V\n PGM(RB7)=0V");
+	MsgBox(str);
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x15;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;			//VDD
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDDU=5V\n VPPU=0V\n PGD(RB5)=5V\n PGC(RB6)=5V\n PGM(RB7)=5V");
+	MsgBox(str);
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x4;			//VPP
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDDU=0V\n VPPU=13V\n PGD(RB5)=5V\n PGC(RB6)=0V\n PGM(RB7)=0V");
+	MsgBox(str);
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	strcpy(str,strings[I_TestMSG]);
+	strcat(str,"\n VDDU=0V\n VPPU=0V\n PGD(RB5)=0V\n PGC(RB6)=5V\n PGM(RB7)=0V");
+	MsgBox(str);
+	j=0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	if(FWVersion>=0x900){	//IO test
+		int j=0,i,x,r;
+		strcpy(str,"0000000000000");
+		PrintMessage("IO test\nRC|RA|--RB--|\n");
+		for(i=0;i<13;i++){
+			x=1<<i;
+			j=0;
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x0;
+			bufferU[j++]=SET_PORT_DIR;
+			bufferU[j++]=0x0;	//TRISB
+			bufferU[j++]=0x0;	//TRISA-C  (RC7:RC6:RA5:RA4:RA3:X:X:X)
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=x&0xFF;	//PORTB
+			bufferU[j++]=(x>>5)&0xFF;	//PORTA-C
+			bufferU[j++]=READ_B;
+			bufferU[j++]=READ_AC;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+			r=bufferI[j+1];
+			for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_AC;j++);
+			r+=(bufferI[j+1]&0xF8)<<5;
+			for(j=0;j<13;j++) str[12-j]=x&(1<<j)?'1':'0';
+			PrintMessage(str);
+			PrintMessage1(" (%s)\n",r==x?"OK":strings[S_ErrSing]);
+		}
+	}
+}
+///
+///Wait for X milliseconds
+void msDelay(double delay)
+{
+#if !defined _WIN32 && !defined __CYGWIN__
+	long x=(int)(delay*1000.0);
+	usleep(x>MinDly?x:MinDly);
+#else
+//	Sleep((long)ceil(delay)>MinDly?(long)ceil(delay):MinDly);
+	__int64 stop,freq,timeout;
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+	timeout=stop+delay*freq/1000.0;
+	while(stop<timeout) QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+#endif
+}
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+///
+/// Get system time
+DWORD GetTickCount(){
+	struct timeb now;
+	ftime(&now);
+	return now.time*1000+now.millitm;
+}
+#endif
+
+///
+///Write data packet, wait for X milliseconds, read response
+///real waiting happens only if the desired delay is greater than 40ms; 
+///in case of smaller delays the function simply waits for a response (up to 50ms) 
+///
+void PacketIO(double delay){
+	#define TIMEOUT 50
+	if(saveLog&&logfile) fprintf(logfile,"PacketIO(%.2f)\n",delay);
+	int delay0=delay;
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	struct timespec ts;
+	uint64_t start,stop;
+	fd_set set;
+	struct timeval timeout;
+	int rv,i;
+	FD_ZERO(&set); /* clear the set */
+	FD_SET(fd, &set); /* add our file descriptor to the set */
+	timeout.tv_sec = 0;
+	timeout.tv_usec = TIMEOUT*1000;
+	clock_gettime( CLOCK_REALTIME, &ts );
+	start=ts.tv_nsec/1000;
+	delay-=TIMEOUT-10;	//shorter delays are covered by 50ms timeout
+	if(delay<MinDly) delay=MinDly;
+	#ifndef hiddevIO	//use raw USB device
+	//wait before writing
+/*	rv = select(fd + 1, NULL, &set, NULL, &timeout); //wait for write event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	//error
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+		return;
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	//"comm timeout\r\n"
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+		return;
+	}*/
+	//write
+	int res = write(fd,bufferU,DIMBUF);
+	if (res < 0) {
+		printf("Error: %d\n", errno);
+		perror("write");
+	}
+	usleep((int)(delay*1000.0));
+	//wait before reading
+	rv = select(fd + 1, &set, NULL, NULL, &timeout); //wait for event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	/*error*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+		return;
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+		return;
+	}
+	//read
+	res = read(fd, bufferI, DIMBUF);
+	if (res < 0) {
+		perror("read");
+	}
+	#else		//use hiddev device (old method)
+	struct hiddev_event ev[80];
+	int n=DIMBUF;
+	for(i=0;i<DIMBUF;i++) ref_multi_u.values[i]=bufferU[i];
+	//write
+	ioctl(fd, HIDIOCSUSAGES, &ref_multi_u);
+	ioctl(fd,HIDIOCSREPORT, &rep_info_u);
+	usleep((int)(delay*1000.0));
+	//read
+	rv = select(fd + 1, &set, NULL, NULL, &timeout); //wait for event
+	if(rv == -1){
+		PrintMessage(strings[S_ErrSing]);	/*error*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_ErrSing]);
+	}
+	else if(rv == 0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+	}
+	else{
+	//		ioctl(fd, HIDIOCGUSAGES, &ref_multi_i);
+	//		ioctl(fd,HIDIOCGREPORT, &rep_info_i);
+	#undef read()
+		rv=read(fd, ev,sizeof(struct hiddev_event) *n);
+		for(i=0;(ev[0].value!=bufferU[0])&&i<40;i++){		//read too early; try again after 5ms
+			msDelay(5);
+			rv=read(fd, ev,sizeof(struct hiddev_event) *n);
+			if(saveLog&&logfile) fprintf(logfile,"Packet not ready, wait extra time\n");
+		}
+		if(i==40) fprintf(logfile,"Cannot read correct packet!!\n");
+		for(i=0;i<n;i++) bufferI[i]=ev[i].value&0xFF;
+	}
+	#endif
+	clock_gettime( CLOCK_REALTIME, &ts );
+	stop  = ts.tv_nsec / 1000;
+	if(saveLog&&logfile){
+		WriteLogIO();
+		fprintf(logfile,"T=%.2f ms (%+.2f ms)\n",(stop-start)/1000.0,(stop-start)/1000.0-delay0);
+		if(bufferU[0]!=bufferI[0]) fprintf(logfile,"Cannot read correct packet!!\n");
+	}
+#else	//Windows
+	__int64 start,stop,freq,timeout;
+	QueryPerformanceCounter((LARGE_INTEGER *)&start);
+	QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+	delay-=TIMEOUT-10;	//shorter delays are covered by 50ms timeout
+	if(delay<MinDly) delay=MinDly;
+	//write
+	Result = WriteFile(WriteHandle,bufferU0,DIMBUF+1,&BytesWritten,NULL);
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	timeout=stop+delay*freq/1000.0;
+	while(stop<timeout) QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	//read
+	Result = ReadFile(ReadHandle,bufferI0,DIMBUF+1,&NumberOfBytesRead,(LPOVERLAPPED) &HIDOverlapped);
+	Result = WaitForSingleObject(hEventObject,TIMEOUT);
+	if(saveLog&&logfile) WriteLogIO();
+	ResetEvent(hEventObject);
+	if(Result!=WAIT_OBJECT_0){
+		PrintMessage(strings[S_comTimeout]);	/*"comm timeout\r\n"*/
+		if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+	}
+	QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+	if(saveLog&&logfile) fprintf(logfile,"T=%.2f ms (%+.2f ms)\n",(stop-start)*1000.0/freq,(stop-start)*1000.0/freq-delay0);
+#endif
+}
+
+///-----------------------------------
+///Main function
+///-----------------------------------
+int main( int argc, char *argv[])
+{
+	//int langID=GetUserDefaultLangID();
+	DWORD t0=GetTickCount();
+	FILE *f;
+	gchar *homedir,*config_dir,*fname=0;
+	char lang[32]="";
+	int langfile=0;
+	homedir = (gchar *) g_get_home_dir ();
+	if(homedir){
+		config_dir=g_build_path(G_DIR_SEPARATOR_S,homedir,CONFIG_DIR, NULL);
+		if(!g_file_test(config_dir,G_FILE_TEST_IS_DIR))
+	#if defined _WIN32
+		mkdir(config_dir);
+	#else
+		mkdir(config_dir,0755);
+	#endif
+		fname = g_build_path(G_DIR_SEPARATOR_S,config_dir,CONFIG_FILE, NULL);
+		f=fopen(fname,"r");
+		if(f){
+			char temp[256],line[256];
+			int X;
+			for(;fgets(line,256,f);){
+				if(sscanf(line,"device %s",temp)>0) strcpy(dev,temp);
+				else if(sscanf(line,"vid %X",&X)>0) vid=X;
+				else if(sscanf(line,"pid %X",&X)>0) pid=X;
+				else sscanf(line,"maxerr %d",&max_err);
+			}
+			fclose(f);
+		}
+	}
+	char dev_ini[64];
+	strncpy(dev_ini,dev,sizeof(dev_ini));
+	int vid_ini=vid,pid_ini=pid,max_err_ini=max_err;
+	vid_ini=vid;
+	pid_ini=pid;
+	max_err_ini=max_err;
+#if defined _WIN32 || defined __CYGWIN__	//Windows
+	bufferI=bufferI0+1;
+	bufferU=bufferU0+1;
+	bufferI0[0]=0;
+	bufferU0[0]=0;
+#endif
+	gtk_init(&argc, &argv);
+	unsigned int tmpbuf[128];
+	opterr = 0;
+	int option_index = 0;
+	int help=0,command=0,i,j;
+	char c;
+	struct option long_options[] =
+	{
+		{"?",             no_argument,           &help, 1},
+		{"h",             no_argument,           &help, 1},
+		{"help",          no_argument,           &help, 1},
+		{"c",             no_argument,         &command, 1},
+		{"command",       no_argument,         &command, 1},
+		{"lang",          required_argument,       0, 'l'},
+		{"langfile",      no_argument,       &langfile, 1},
+		{0, 0, 0, 0}
+	};
+	while ((j = getopt_long_only (argc, argv, "",long_options,&option_index)) != -1){
+		if(j=='l'){ //language
+			strncpy(lang,optarg,sizeof(lang)-1);
+		}
+	}
+	for(j=0,i = optind; i < argc&&i<128; i++,j++) sscanf(argv[i], "%x", &tmpbuf[j]);
+	for(;j<128;j++) tmpbuf[j]=0;
+	strinit();
+	char* langid=0;
+	i=0;
+	if(lang[0]){	//explicit language selection
+		if(lang[0]=='i'&&langid[1]=='t'){  //built-in
+			strings=strings_it;
+			i=1;
+		}
+		else if(lang[0]=='e'&&lang[1]=='n'){  //built-in
+			strings=strings_en;
+			i=1;
+		}
+		else i=strfind(lang,"languages.rc"); //file look-up
+	}
+	if(i==0){
+		#if defined _WIN32
+		langid=malloc(19);
+		int n=GetLocaleInfo(LOCALE_USER_DEFAULT,LOCALE_SISO639LANGNAME,langid,9);
+		langid[n-1] = '-';
+		GetLocaleInfo(LOCALE_USER_DEFAULT,LOCALE_SISO3166CTRYNAME,langid+n, 9);
+		//printf("%d >%s<\n",n,langid);
+		#else
+		langid=getenv("LANG");
+		#endif
+		if(langid){
+			if(langid[0]=='i'&&langid[1]=='t') strings=strings_it;
+			else if(langid[0]=='e'&&langid[1]=='n') strings=strings_en;
+			else if(strfind(langid,"languages.rc")); //first try full code
+			else {	//then only first language code
+				char* p=strchr(langid,'-');
+				if(p) *p=0;
+				if(!strfind(langid,"languages.rc")) strings=strings_en;
+			}
+		}
+		else strings=strings_en;
+	}
+	if(langfile) GenerateLangFile(langid,"languages.rc");
+	if(help){
+		printf(strings[I_GUI_CMD_HELP]);
+		exit(0);
+	}
+	if(command){
+		cmdline=1;
+		DeviceDetected=FindDevice(vid,pid);	//connect to USB programmer
+		if(!DeviceDetected){
+			DeviceDetected=FindDevice(new_vid,new_pid);	//try default
+			if(DeviceDetected){
+				vid=new_vid;
+				pid=new_pid;
+			}
+		}
+		if(!DeviceDetected) DeviceDetected=FindDevice(old_vid,old_pid); //try old one
+		if(DeviceDetected){
+			bufferU[0]=0;
+			for(i=1;i<DIMBUF;i++) bufferU[i]=(char) tmpbuf[i-1];
+			PacketIO(100);
+			printf("> ");
+			for(i=1;i<DIMBUF;i++) printf("%02X ",bufferU[i]);
+			printf("\n< ");
+			for(i=1;i<DIMBUF;i++) printf("%02X ",bufferI[i]);
+			printf("\n");
+		}
+		else printf(strings[S_noprog]);
+		exit(0);
+	}
+
+	GtkBuilder *builder = NULL;
+	builder=gtk_builder_new_from_resource ("/res/opgui.glade");
+	window  = GTK_WIDGET(gtk_builder_get_object (builder,"window"));
+	g_signal_connect (window, "destroy", G_CALLBACK (Xclose), NULL);
+	gtk_window_set_icon(GTK_WINDOW(window),gdk_pixbuf_new_from_resource("/res/sys.png", NULL));
+	GtkCssProvider *cssProvider = gtk_css_provider_new();
+	gtk_css_provider_load_from_resource(cssProvider, "/res/style.css");
+	gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),GTK_STYLE_PROVIDER(cssProvider),GTK_STYLE_PROVIDER_PRIORITY_USER);
+	GtkWidget* w=NULL;
+	sprintf(str,"opgui v%s",VERSION);
+	gtk_window_set_title(GTK_WINDOW(window),str);
+	notebook = GTK_WIDGET(gtk_builder_get_object(builder,"NOTEBOOK"));
+//------toolbar-------------
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"OPEN_T"));
+	gtk_widget_set_tooltip_text(w,strings[I_Fopen]);//"Open File"
+	g_signal_connect(w,"clicked",G_CALLBACK(Fopen), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"SAVE_T"));
+	gtk_widget_set_tooltip_text(w,strings[I_Fsave]);//"Save File"
+	g_signal_connect(w,"clicked",G_CALLBACK(Fsave), NULL);
+	readBtn=GTK_WIDGET(gtk_builder_get_object(builder,"READ_T"));
+	gtk_widget_set_tooltip_text(readBtn,strings[I_DevR]);//"Read device"
+	g_signal_connect(readBtn,"clicked",G_CALLBACK(DevRead), NULL);
+	writeBtn=GTK_WIDGET(gtk_builder_get_object(builder,"WRITE_T"));
+	gtk_widget_set_tooltip_text(writeBtn,strings[I_DevW]);//"Write device"
+	g_signal_connect(writeBtn,"clicked",G_CALLBACK(DevWrite), NULL);
+	stopBtn=GTK_WIDGET(gtk_builder_get_object(builder,"STOP_T"));
+	gtk_widget_set_tooltip_text(stopBtn,strings[I_ICD_STOP]);//"Stop"
+	g_signal_connect(stopBtn,"clicked",G_CALLBACK(Stop), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"CONNECT_T"));
+	gtk_widget_set_tooltip_text(w,strings[I_CONN]);//"Reconnect"
+	g_signal_connect(w,"clicked",G_CALLBACK(Connect), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"INFO_T"));
+	gtk_widget_set_tooltip_text(w,strings[I_Info]);//"Info"
+	g_signal_connect(w,"clicked",G_CALLBACK(info), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"QUIT_T"));
+	gtk_widget_set_tooltip_text(w,strings[I_QUIT]);//"Quit"
+	g_signal_connect(w,"clicked",G_CALLBACK(Quit), NULL);
+//------data tab-------------
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"DATA_T_L"))),strings[I_Data]);	//"Data"
+	data=GTK_WIDGET(gtk_builder_get_object(builder,"DATA"));
+	dataBuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(data));
+//------device tab-------------
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"DEVICE_L"))),strings[I_Dev]);	//"Device"
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"TYPE_L"))),strings[I_Type]);	//"Type"
+	devTypeCombo=GTK_WIDGET(gtk_builder_get_object(builder,"TYPE_C"));
+	g_signal_connect(G_OBJECT(devTypeCombo),"changed",G_CALLBACK(FilterDevType),NULL);
+	devFiltEntry=GTK_WIDGET(gtk_builder_get_object(builder,"DEV_SRC_E"));
+ 	g_signal_connect(G_OBJECT(devFiltEntry),"changed",G_CALLBACK(FilterDevType),NULL);
+ 	devTree = GTK_WIDGET(gtk_builder_get_object(builder,"DEV_TREE"));
+	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(devTree),
+		-1, strings[I_Dev], gtk_cell_renderer_text_new(), "text", DEVICE_NAME_COLUMN, NULL);
+	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(devTree),
+		-1, strings[I_Type], gtk_cell_renderer_text_new(), "text", DEVICE_GROUP_COLUMN, NULL);
+	// AddDevices() gets called when an entry in devTypeCombo is selected during init
+	devFrame = GTK_WIDGET(gtk_builder_get_object(builder,"DEVICE_NAME"));
+	devinfo = GTK_WIDGET(gtk_builder_get_object(builder,"DEV_INFO"));
+	EEPROM_RW = GTK_WIDGET(gtk_builder_get_object(builder,"EE_RW"));
+	gtk_button_set_label(GTK_BUTTON(EEPROM_RW),strings[I_EE]);	//"Read and write EEPROM"
+	ReadReserved = GTK_WIDGET(gtk_builder_get_object(builder,"RES_READ"));
+	gtk_button_set_label(GTK_BUTTON(ReadReserved),strings[I_ReadRes]);	//"Read reserved area"
+	Write_ID_BKCal = GTK_WIDGET(gtk_builder_get_object(builder,"PROG_ID"));
+	gtk_button_set_label(GTK_BUTTON(Write_ID_BKCal),strings[I_ID_BKo_W]);	//"Write ID and BKOscCal"
+	WriteCalib12 = GTK_WIDGET(gtk_builder_get_object(builder,"PROG_CAL12"));
+	gtk_button_set_label(GTK_BUTTON(WriteCalib12),strings[I_CalW]);	//"Write Calib 1 and 2"
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"OSCCAL_L"))),strings[I_OSCW]);	//"Write OscCal"
+	UseOSCCAL = GTK_WIDGET(gtk_builder_get_object(builder,"OSCCAL"));
+	gtk_button_set_label(GTK_BUTTON(UseOSCCAL),strings[I_OSC]);	//"OSCCal"
+	UseBKOSCCAL = GTK_WIDGET(gtk_builder_get_object(builder,"BKOSCCAL"));
+	gtk_button_set_label(GTK_BUTTON(UseBKOSCCAL),strings[I_BKOSC]);	//"Backup OSCCal"
+	UseFileCal = GTK_WIDGET(gtk_builder_get_object(builder,"FILECAL"));
+	gtk_button_set_label(GTK_BUTTON(UseFileCal),strings[I_OSCF]);	//"From file"
+	ICD_check = GTK_WIDGET(gtk_builder_get_object(builder,"ICD"));
+	gtk_button_set_label(GTK_BUTTON(ICD_check),strings[I_ICD_ENABLE]);	//"Enable ICD"
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"ICD_ADDR_L"))),strings[I_ICD_ADDRESS]);	//"ICD routine address"
+	ICD_addr_entry = GTK_WIDGET(gtk_builder_get_object(builder,"ICD_ADDR"));
+	ConfigForce = GTK_WIDGET(gtk_builder_get_object(builder,"FORCE_CW"));
+	gtk_button_set_label(GTK_BUTTON(ConfigForce),strings[I_PIC_FORCECW]); //"force config word"
+	CW1_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW1"));
+	CW2_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW2"));
+	CW3_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW3"));
+	CW4_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW4"));
+	CW5_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW5"));
+	CW6_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW6"));
+	CW7_entry = GTK_WIDGET(gtk_builder_get_object(builder,"CW7"));
+	AVR_FuseLow = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEL"));
+	AVR_FuseLowWrite = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEL_C"));
+	gtk_button_set_label(GTK_BUTTON(AVR_FuseLowWrite),strings[I_AT_FUSE]);	//"Write Fuse Low"
+	AVR_FuseHigh = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEH"));
+	AVR_FuseHighWrite = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEH_C"));
+	gtk_button_set_label(GTK_BUTTON(AVR_FuseHighWrite),strings[I_AT_FUSEH]);	//"Write Fuse High"
+	AVR_FuseExt = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEX"));
+	AVR_FuseExtWrite = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEX_C"));
+	gtk_button_set_label(GTK_BUTTON(AVR_FuseExtWrite),strings[I_AT_FUSEX]);	//"Write Extended Fuse"
+	AVR_Lock = GTK_WIDGET(gtk_builder_get_object(builder,"FUSELCK"));
+	AVR_LockWrite = GTK_WIDGET(gtk_builder_get_object(builder,"FUSELCK_C"));
+	gtk_button_set_label(GTK_BUTTON(AVR_LockWrite),strings[I_AT_LOCK]);	//"Write Lock"
+	b_WfuseLF = GTK_WIDGET(gtk_builder_get_object(builder,"FUSEL_W3K"));
+	gtk_button_set_label(GTK_BUTTON(b_WfuseLF),strings[I_AT_FUSELF]);		//"Write Fuse Low @3kHz"
+	g_signal_connect(G_OBJECT(b_WfuseLF),"clicked",G_CALLBACK(WriteATfuseLowLF),window);
+	devFramePIC = GTK_WIDGET(gtk_builder_get_object(builder,"PIC_OPT"));
+	devFrameAVR = GTK_WIDGET(gtk_builder_get_object(builder,"AVR_OPT"));
+	devFrameConfigW = GTK_WIDGET(gtk_builder_get_object(builder,"CW_OPT"));
+	devFrameICD = GTK_WIDGET(gtk_builder_get_object(builder,"ICD_OPT"));
+	devFrameOsc = GTK_WIDGET(gtk_builder_get_object(builder,"OSC_OPT"));
+	devPIC_CW1 = GTK_WIDGET(gtk_builder_get_object(builder,"CW1_OPT"));
+	devPIC_CW2 = GTK_WIDGET(gtk_builder_get_object(builder,"CW2_OPT"));
+	devPIC_CW3 = GTK_WIDGET(gtk_builder_get_object(builder,"CW3_OPT"));
+	devPIC_CW4 = GTK_WIDGET(gtk_builder_get_object(builder,"CW4_OPT"));
+	devPIC_CW5 = GTK_WIDGET(gtk_builder_get_object(builder,"CW5_OPT"));
+	devPIC_CW6 = GTK_WIDGET(gtk_builder_get_object(builder,"CW6_OPT"));
+	devPIC_CW7 = GTK_WIDGET(gtk_builder_get_object(builder,"CW7_OPT"));
+	devPIC_CW8 = GTK_WIDGET(gtk_builder_get_object(builder,"CW8_OPT"));
+	gtk_widget_hide(GTK_WIDGET(devFrameAVR));
+	gtk_widget_hide(GTK_WIDGET(devFramePIC));
+//------options tab-------------
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"OPTIONS_L"))),strings[I_Opt]);	//"Options"
+	VID_entry=GTK_WIDGET(gtk_builder_get_object(builder,"VID"));
+	PID_entry=GTK_WIDGET(gtk_builder_get_object(builder,"PID"));
+	Errors_entry=GTK_WIDGET(gtk_builder_get_object(builder,"MAXERR"));
+	b_connect = GTK_WIDGET(gtk_builder_get_object(builder,"CONNECT"));
+	gtk_button_set_label(GTK_BUTTON(b_connect),strings[I_CONN]);	//"Reconnect"
+	g_signal_connect(G_OBJECT(b_connect),"clicked",G_CALLBACK(Connect),window);
+	b_testhw = GTK_WIDGET(gtk_builder_get_object(builder,"TEST"));
+	gtk_button_set_label(GTK_BUTTON(b_testhw),strings[I_TestHWB]);	//"Hardware test"
+	g_signal_connect(G_OBJECT(b_testhw),"clicked",G_CALLBACK(TestHw),window);
+	b_log = GTK_WIDGET(gtk_builder_get_object(builder,"LOG"));
+	gtk_button_set_label(GTK_BUTTON(b_log),strings[I_LOG]);	//"Log activity"
+	b_V33check = GTK_WIDGET(gtk_builder_get_object(builder,"3VCHECK"));
+	gtk_button_set_label(GTK_BUTTON(b_V33check),strings[I_CK_V33]);	//"Don't check for 3.3V regulator"
+	b_WaitS1 = GTK_WIDGET(gtk_builder_get_object(builder,"S1"));
+	gtk_button_set_label(GTK_BUTTON(b_WaitS1),strings[I_WAITS1]);	//"Wait for S1 before read/write"
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"MAXERR_L"))),strings[I_MAXERR]);	//"Max errors"
+//------I2C tab-------------
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"I2CMODE"))),strings[I_I2CMode]);	//"Mode"
+	I2C8bit = GTK_WIDGET(gtk_builder_get_object(builder,"I2C8BIT"));
+	I2C16bit = GTK_WIDGET(gtk_builder_get_object(builder,"I2C16BIT"));
+	SPI00 = GTK_WIDGET(gtk_builder_get_object(builder,"SPI00"));
+	SPI01 = GTK_WIDGET(gtk_builder_get_object(builder,"SPI01"));
+	SPI10 = GTK_WIDGET(gtk_builder_get_object(builder,"SPI10"));
+	SPI11 = GTK_WIDGET(gtk_builder_get_object(builder,"SPI11"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"DATASEND_L"))),strings[I_I2CDATAOUT]);	//"Data to send"
+	I2CDataSend = GTK_WIDGET(gtk_builder_get_object(builder,"DATASEND"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"DATATR_L"))),strings[I_I2CDATATR]);	//"Data transferred"
+	I2CDataReceive = GTK_WIDGET(gtk_builder_get_object(builder,"DATATR"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"NBYTE_L"))),strings[I_I2C_NB]);	//"Byes to read/write"
+	I2CNbyte = GTK_WIDGET(gtk_builder_get_object(builder,"NBYTE_S"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"SPEED_L"))),strings[I_Speed]);	//"Speed"
+	I2CSpeed = GTK_WIDGET(gtk_builder_get_object(builder,"SPEED_C"));
+	I2CSendBtn = GTK_WIDGET(gtk_builder_get_object(builder,"SEND_B"));
+	gtk_button_set_label(GTK_BUTTON(I2CSendBtn),strings[I_I2CSend]);	//"Send"
+	g_signal_connect(G_OBJECT(I2CSendBtn),"clicked",G_CALLBACK(I2cspiS),window);
+	I2CReceiveBtn = GTK_WIDGET(gtk_builder_get_object(builder,"RECEIVE_B"));
+	gtk_button_set_label(GTK_BUTTON(I2CReceiveBtn),strings[I_I2CReceive]);	//"Receive"
+	g_signal_connect(G_OBJECT(I2CReceiveBtn),"clicked",G_CALLBACK(I2cspiR),window);
+//------ICD tab-------------
+	GtkWidget* loadCoffBtn = GTK_WIDGET(gtk_builder_get_object(builder,"LOADCOFF_B"));
+	gtk_tool_button_set_label(GTK_TOOL_BUTTON(loadCoffBtn),strings[I_LOAD_COFF]); //"load COFF file..."
+	g_signal_connect(G_OBJECT(loadCoffBtn),"clicked",G_CALLBACK(loadCoff),window);
+	g_signal_connect(GTK_WIDGET(gtk_builder_get_object(builder,"ICD_TAB")),"key_press_event",G_CALLBACK(icd_key_event),NULL);
+	//menu
+	gtk_menu_item_set_label(GTK_MENU_ITEM(gtk_builder_get_object(builder,"OPTIONS_M")),strings[I_Opt]); //"Options";
+	icdMenuPC = GTK_WIDGET(gtk_builder_get_object(builder,"PCOUNT_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuPC),strings[I_SHOW_PC]); //"show Program Counter"
+	icdMenuSTAT = GTK_WIDGET(gtk_builder_get_object(builder,"STATUS_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuSTAT),strings[I_SHOW_STATUS]); //"show status registers"
+	icdMenuBank0 = GTK_WIDGET(gtk_builder_get_object(builder,"BANK0_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuBank0),strings[I_SHOW_BANK0]); //"show memory bank 0"
+	icdMenuBank1 = GTK_WIDGET(gtk_builder_get_object(builder,"BANK1_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuBank1),strings[I_SHOW_BANK1]); //"show memory bank 1"
+	icdMenuBank2 = GTK_WIDGET(gtk_builder_get_object(builder,"BANK2_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuBank2),strings[I_SHOW_BANK2]); //"show memory bank 2"
+	icdMenuBank3 = GTK_WIDGET(gtk_builder_get_object(builder,"BANK3_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuBank3),strings[I_SHOW_BANK3]); //"show memory bank 3"
+	icdMenuEE = GTK_WIDGET(gtk_builder_get_object(builder,"EE_M"));
+	gtk_menu_item_set_label(GTK_MENU_ITEM(icdMenuEE),strings[I_SHOW_EE]); //"show EEPROM"
+	//toolbar
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_RUN"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_RUN]);
+	g_signal_connect(w,"clicked",G_CALLBACK(icdRun), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_HALT"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_HALT]);
+	g_signal_connect(w,"clicked",G_CALLBACK(icdHalt), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_STEP"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_STEP]);
+	g_signal_connect(w,"clicked",G_CALLBACK(icdStep), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_STEPOVER"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_STEPOVER]);
+	g_signal_connect(w,"clicked",G_CALLBACK(icdStepOver), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_STOP"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_STOP]);
+	g_signal_connect(w,"clicked",G_CALLBACK(icdStop), NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_REFRESH"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_REFRESH]);//"refresh"
+	g_signal_connect(w,"clicked",G_CALLBACK(icdRefresh), NULL);
+	icdCommand = GTK_WIDGET(gtk_builder_get_object(builder,"ICD_CMD_E"));
+	gtk_widget_set_tooltip_text(icdCommand,strings[I_ICD_CMD]);//"command-line"
+	g_signal_connect(G_OBJECT(icdCommand),"key_press_event",G_CALLBACK(icdCommand_key_event),NULL);
+	w=GTK_WIDGET(gtk_builder_get_object(builder,"ICD_HELP"));
+	gtk_widget_set_tooltip_text(w,strings[I_ICD_HELP]);//"help"
+	g_signal_connect(w,"clicked",G_CALLBACK(ICDHelp), NULL);
+	//source
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"ICD_SOURCE_L"))),strings[I_ICD_SOURCE]);	//"Source"
+	sourceTxt = GTK_WIDGET(gtk_builder_get_object(builder,"ICD_SOURCE"));
+	sourceBuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sourceTxt));
+	g_signal_connect(G_OBJECT(sourceTxt),"button_press_event",G_CALLBACK(source_mouse_event),NULL);
+	//status
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"ICD_STAT_L"))),strings[I_ICD_STATUS]);	//"Status"
+	statusTxt = GTK_WIDGET(gtk_builder_get_object(builder,"ICD_STATUS"));
+	statusBuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(statusTxt));
+	g_signal_connect(G_OBJECT(statusTxt),"button_press_event",G_CALLBACK(icdStatus_mouse_event),NULL);
+//------IO tab-------------
+	b_io_active = GTK_WIDGET(gtk_builder_get_object(builder,"IOEN"));
+	gtk_button_set_label(GTK_BUTTON(b_io_active),strings[I_IO_Enable]);	//"Enable IO"
+	g_signal_connect(G_OBJECT(b_io_active),"toggled",G_CALLBACK(IOactive),NULL);
+	ioButtons[0].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB0_0"));
+	ioButtons[0].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB0_1"));
+	ioButtons[0].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB0_I"));
+	ioButtons[0].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB0_L"));
+	ioButtons[1].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB1_0"));
+	ioButtons[1].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB1_1"));
+	ioButtons[1].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB1_I"));
+	ioButtons[1].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB1_L"));
+	ioButtons[2].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB2_0"));
+	ioButtons[2].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB2_1"));
+	ioButtons[2].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB2_I"));
+	ioButtons[2].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB2_L"));
+	ioButtons[3].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB3_0"));
+	ioButtons[3].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB3_1"));
+	ioButtons[3].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB3_I"));
+	ioButtons[3].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB3_L"));
+	ioButtons[4].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB4_0"));
+	ioButtons[4].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB4_1"));
+	ioButtons[4].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB4_I"));
+	ioButtons[4].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB4_L"));
+	ioButtons[5].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB5_0"));
+	ioButtons[5].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB5_1"));
+	ioButtons[5].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB5_I"));
+	ioButtons[5].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB5_L"));
+	ioButtons[6].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB6_0"));
+	ioButtons[6].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB6_1"));
+	ioButtons[6].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB6_I"));
+	ioButtons[6].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB6_L"));
+	ioButtons[7].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RB7_0"));
+	ioButtons[7].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RB7_1"));
+	ioButtons[7].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB7_I"));
+	ioButtons[7].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RB7_L"));
+	ioButtons[8].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RC7_0"));
+	ioButtons[8].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RC7_1"));
+	ioButtons[8].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RC7_I"));
+	ioButtons[8].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RC7_L"));
+	ioButtons[9].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RC6_0"));
+	ioButtons[9].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RC6_1"));
+	ioButtons[9].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RC6_I"));
+	ioButtons[9].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RC6_L"));
+	ioButtons[10].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RA5_0"));
+	ioButtons[10].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RA5_1"));
+	ioButtons[10].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA5_I"));
+	ioButtons[10].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA5_L"));
+	ioButtons[11].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RA4_0"));
+	ioButtons[11].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RA4_1"));
+	ioButtons[11].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA4_I"));
+	ioButtons[11].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA4_L"));
+	ioButtons[12].r_0 = GTK_WIDGET(gtk_builder_get_object(builder,"RA3_0"));
+	ioButtons[12].r_1 = GTK_WIDGET(gtk_builder_get_object(builder,"RA3_1"));
+	ioButtons[12].r_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA3_I"));
+	ioButtons[12].e_I = GTK_WIDGET(gtk_builder_get_object(builder,"RA3_L"));
+	for(int ii=0;ii<sizeof(ioButtons)/sizeof(ioButtons[0]);ii++){
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ioButtons[ii].r_I),TRUE);
+		g_signal_connect(G_OBJECT(ioButtons[ii].r_0),"toggled",G_CALLBACK(IOchanged),NULL);
+		g_signal_connect(G_OBJECT(ioButtons[ii].r_1),"toggled",G_CALLBACK(IOchanged),NULL);
+		g_signal_connect(G_OBJECT(ioButtons[ii].r_I),"toggled",G_CALLBACK(IOchanged),NULL);
+	}
+	VDD_ON = GTK_WIDGET(gtk_builder_get_object(builder,"VDDUEN"));
+	VPP_ON = GTK_WIDGET(gtk_builder_get_object(builder,"VPPUEN"));
+	DCDC_ON = GTK_WIDGET(gtk_builder_get_object(builder,"DCDCEN"));
+	DCDC_voltage = GTK_WIDGET(gtk_builder_get_object(builder,"DCDC_S"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"CMD_L"))),strings[I_IO_Commands]);	//"Manual commands"
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"CMDSEND_L"))),strings[I_I2CDATAOUT]);	//"Data to send"
+	commandSend = GTK_WIDGET(gtk_builder_get_object(builder,"CMDSEND"));
+	gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"CMDTR_L"))),strings[I_I2CDATATR]);	//"Data transferred"
+	commandTransfer = GTK_WIDGET(gtk_builder_get_object(builder,"CMDTR"));
+	w = GTK_WIDGET(gtk_builder_get_object(builder,"CMDTR_B"));
+	gtk_button_set_label(GTK_BUTTON(w),strings[I_I2CSend]);	//"Send"
+	g_signal_connect(w,"clicked",G_CALLBACK(CommandIO),window);
+	g_signal_connect(G_OBJECT(VDD_ON),"toggled",G_CALLBACK(VPPVDDactive),NULL);
+	g_signal_connect(G_OBJECT(VPP_ON),"toggled",G_CALLBACK(VPPVDDactive),NULL);
+	g_signal_connect(G_OBJECT(DCDC_ON),"toggled",G_CALLBACK(DCDCactive),NULL);
+	g_signal_connect(G_OBJECT(DCDC_voltage),"value_changed",G_CALLBACK(DCDCactive),NULL);
+//------Utility tab-------------
+	Hex_entry = GTK_WIDGET(gtk_builder_get_object(builder,"HEXIN"));
+	Hex_data = GTK_WIDGET(gtk_builder_get_object(builder,"DATAOUT"));
+	Address_entry = GTK_WIDGET(gtk_builder_get_object(builder,"ADDRIN"));
+	Data_entry = GTK_WIDGET(gtk_builder_get_object(builder,"DATAIN"));
+	Hex_data2 = GTK_WIDGET(gtk_builder_get_object(builder,"HEXOUT"));
+	w = GTK_WIDGET(gtk_builder_get_object(builder,"HEXSAVE"));
+	gtk_button_set_label(GTK_BUTTON(w),strings[I_Fsave]);
+	g_signal_connect(w,"clicked",G_CALLBACK(HexSave),window);
+	g_signal_connect(G_OBJECT(Hex_entry),"changed",G_CALLBACK(HexConvert),NULL);
+	g_signal_connect(G_OBJECT(Address_entry),"changed",G_CALLBACK(DataToHexConvert),NULL);
+	g_signal_connect(G_OBJECT(Data_entry),"changed",G_CALLBACK(DataToHexConvert),NULL);
+//------status bar-------------
+	status_bar = GTK_WIDGET(gtk_builder_get_object(builder,"STATUS_B"));
+	statusID=gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar),"ID");
+	//printf("load time: %dms\n",GetTickCount()-t0);fflush(stdout);
+	gtk_widget_show_all(window);
+	
+//********Init*************
+	char text[16];
+	sprintf(text,"%04X",vid);
+	gtk_entry_set_text(GTK_ENTRY(VID_entry),text);
+	sprintf(text,"%04X",pid);
+	gtk_entry_set_text(GTK_ENTRY(PID_entry),text);
+	sprintf(text,"%d",max_err);
+	gtk_entry_set_text(GTK_ENTRY(Errors_entry),text);
+	sizeW=0x8400;
+	memCODE_W=malloc(sizeW*sizeof(WORD));
+	initVar();
+	for(i=0;i<0x8400;i++) memCODE_W[i]=0x3fff;
+	strncpy(LogFileName,strings[S_LogFile],sizeof(LogFileName));
+	gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devTypeCombo), GROUP_ALL, GROUP_ALL);
+	for (int i=0;i<NUM_GROUPS;i++)
+		gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(devTypeCombo), groupNames[i], groupNames[i]);
+	// These will trigger AddDevices to populate the device tree
+	if (strlen(dev)>0) {
+		struct DevInfo info = GetDevInfo(dev);
+		gtk_combo_box_set_active_id(GTK_COMBO_BOX(devTypeCombo), groupNames[info.group]);
+	}
+	else {
+		gtk_combo_box_set_active_id(GTK_COMBO_BOX(devTypeCombo), GROUP_ALL);
+	}
+	DeviceDetected=FindDevice(vid,pid);	//connect to USB programmer
+	if(!DeviceDetected){
+		DeviceDetected=FindDevice(new_vid,new_pid);	//try default
+		if(DeviceDetected){
+			vid=new_vid;
+			pid=new_pid;
+		}
+	}
+	if(!DeviceDetected) DeviceDetected=FindDevice(old_vid,old_pid); //try old one
+	ProgID();		//get firmware version and reset
+	gtk_main();
+//	printf(ListDevices());
+//******Save ini file******
+// only if parameters are changed
+	if(strcmp(dev_ini,dev)||vid_ini!=vid||pid_ini!=pid||max_err_ini!=max_err){
+		if(homedir){
+			f=fopen(fname,"w");
+			if(f){
+				fprintf(f,"device %s\n",dev);
+				fprintf(f,"maxerr %d\n",max_err);
+				fprintf(f,"vid %X\n",vid);
+				fprintf(f,"pid %X\n",pid);
+			}
+			fclose(f);
+		}
+	}
+	return 0;
+}
+
+///
+///Find the USB peripheral with proper vid&pid code
+/// return 0 if not found
+int FindDevice(int vid,int pid){
+	int MyDeviceDetected = FALSE;
+#if !defined _WIN32 && !defined __CYGWIN__	//Linux
+	#ifndef hiddevIO	//use raw USB device
+	struct hidraw_devinfo device_info;
+	int i=-1;
+	if(path[0]==0){	//search all devices
+		if((fd = open("/dev/openprogrammer", O_RDWR|O_NONBLOCK))>0){ //try with this first
+			sprintf(path,"/dev/openprogrammer");
+			ioctl(fd, HIDIOCGRAWINFO, &device_info);
+			if(device_info.vendor==vid&&device_info.product==pid) i=0;
+			else{
+				close(fd);
+				i=-1;
+			}
+		}
+		if(i){
+			for(i=0;i<16;i++){
+				sprintf(path,"/dev/hidraw%d",i);
+				if((fd = open(path, O_RDWR|O_NONBLOCK))>0){
+					ioctl(fd, HIDIOCGRAWINFO, &device_info);
+					if(device_info.vendor==vid&&device_info.product==pid) break;
+					else close(fd);
+				}
+			}
+		}
+		if(i==16){
+			PrintMessage(strings[S_noprog]);
+			path[0]=0;
+			return 0;
+		}
+	}
+	else{	//user supplied path
+		if((fd = open(path, O_RDWR|O_NONBLOCK)) < 0) {
+			PrintMessage1(strings[S_DevPermission],path); //"cannot open %s, make sure you have read permission on it",path);
+			return 0;
+		}
+		ioctl(fd, HIDIOCGRAWINFO, &device_info);
+		if(device_info.vendor!=vid||device_info.product!=pid){
+			PrintMessage(strings[S_noprog]);
+			return 0;
+		}
+	}
+	printf(strings[S_progDev],path);
+	return 1;
+	#else		//use hiddev device (old method)
+	struct hiddev_devinfo device_info;
+	int i=-1;
+	if(path[0]==0){	//search all devices
+		if((fd = open("/dev/openprogrammer", O_RDONLY ))>0){ //try with this first
+			ioctl(fd, HIDIOCGDEVINFO, &device_info);
+			if(device_info.vendor==vid&&device_info.product==pid) i=0;
+			else{
+				close(fd);
+				i=-1;
+			}
+		}
+		if(i){
+		for(i=0;i<16;i++){
+			sprintf(path,"/dev/usb/hiddev%d",i);
+			if((fd = open(path, O_RDONLY ))>0){
+				ioctl(fd, HIDIOCGDEVINFO, &device_info);
+				if(device_info.vendor==vid&&device_info.product==pid) break;
+				else close(fd);
+				}
+			}
+		}
+		if(i==16){
+			PrintMessage(strings[S_noprog]);
+			path[0]=0;
+			return 0;
+		}
+	}
+	else{	//user supplied path
+		if ((fd = open(path, O_RDONLY )) < 0) {
+			PrintMessage1(strings[S_DevPermission],path); //"cannot open %s, make sure you have read permission on it",path);
+			return 0;
+		}
+		ioctl(fd, HIDIOCGDEVINFO, &device_info);
+		if(device_info.vendor!=vid||device_info.product!=pid){
+			PrintMessage(strings[S_noprog]);
+			return 0;
+		}
+	}
+	MyDeviceDetected = TRUE;
+	rep_info_u.report_type=HID_REPORT_TYPE_OUTPUT;
+	rep_info_i.report_type=HID_REPORT_TYPE_INPUT;
+	rep_info_u.report_id=rep_info_i.report_id=HID_REPORT_ID_FIRST;
+	rep_info_u.num_fields=rep_info_i.num_fields=1;
+	ref_multi_u.uref.report_type=HID_REPORT_TYPE_OUTPUT;
+	ref_multi_i.uref.report_type=HID_REPORT_TYPE_INPUT;
+	ref_multi_u.uref.report_id=ref_multi_i.uref.report_id=HID_REPORT_ID_FIRST;
+	ref_multi_u.uref.field_index=ref_multi_i.uref.field_index=0;
+	ref_multi_u.uref.usage_index=ref_multi_i.uref.usage_index=0;
+	ref_multi_u.num_values=ref_multi_i.num_values=DIMBUF;
+	#endif
+#else		//Windows
+	PSP_DEVICE_INTERFACE_DETAIL_DATA detailData;
+	HANDLE DeviceHandle;
+	HANDLE hDevInfo;
+	GUID HidGuid;
+	char MyDevicePathName[1024];
+	ULONG Length;
+	ULONG Required;
+	typedef struct _HIDD_ATTRIBUTES {
+	    ULONG   Size;
+	    USHORT  VendorID;
+	    USHORT  ProductID;
+	    USHORT  VersionNumber;
+	} HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
+	typedef void (__stdcall*GETHIDGUID) (OUT LPGUID HidGuid);
+	typedef BOOLEAN (__stdcall*GETATTRIBUTES)(IN HANDLE HidDeviceObject,OUT PHIDD_ATTRIBUTES Attributes);
+	typedef BOOLEAN (__stdcall*SETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT ULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETNUMINPUTBUFFERS)(IN  HANDLE HidDeviceObject,OUT PULONG  NumberBuffers);
+	typedef BOOLEAN (__stdcall*GETFEATURE) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETFEATURE) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETREPORT) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*SETREPORT) (IN  HANDLE HidDeviceObject, IN PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETMANUFACTURERSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETPRODUCTSTRING) (IN  HANDLE HidDeviceObject, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	typedef BOOLEAN (__stdcall*GETINDEXEDSTRING) (IN  HANDLE HidDeviceObject, IN ULONG  StringIndex, OUT PVOID ReportBuffer, IN ULONG ReportBufferLength);
+	HIDD_ATTRIBUTES Attributes;
+	SP_DEVICE_INTERFACE_DATA devInfoData;
+	int LastDevice = FALSE;
+	int MemberIndex = 0;
+	LONG Result;
+	Length=0;
+	detailData=NULL;
+	DeviceHandle=NULL;
+	HMODULE hHID=0;
+	GETHIDGUID HidD_GetHidGuid=0;
+	GETATTRIBUTES HidD_GetAttributes=0;
+	SETNUMINPUTBUFFERS HidD_SetNumInputBuffers=0;
+	GETNUMINPUTBUFFERS HidD_GetNumInputBuffers=0;
+	GETFEATURE HidD_GetFeature=0;
+	SETFEATURE HidD_SetFeature=0;
+	GETREPORT HidD_GetInputReport=0;
+	SETREPORT HidD_SetOutputReport=0;
+	GETMANUFACTURERSTRING HidD_GetManufacturerString=0;
+	GETPRODUCTSTRING HidD_GetProductString=0;
+	hHID = LoadLibrary("hid.dll");
+	if(!hHID){
+		PrintMessage("Can't find hid.dll");
+		return 0;
+	}
+	HidD_GetHidGuid=(GETHIDGUID)GetProcAddress(hHID,"HidD_GetHidGuid");
+	HidD_GetAttributes=(GETATTRIBUTES)GetProcAddress(hHID,"HidD_GetAttributes");
+	HidD_SetNumInputBuffers=(SETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_SetNumInputBuffers");
+	HidD_GetNumInputBuffers=(GETNUMINPUTBUFFERS)GetProcAddress(hHID,"HidD_GetNumInputBuffers");
+	HidD_GetFeature=(GETFEATURE)GetProcAddress(hHID,"HidD_GetFeature");
+	HidD_SetFeature=(SETFEATURE)GetProcAddress(hHID,"HidD_SetFeature");
+	HidD_GetInputReport=(GETREPORT)GetProcAddress(hHID,"HidD_GetInputReport");
+	HidD_SetOutputReport=(SETREPORT)GetProcAddress(hHID,"HidD_SetOutputReport");
+	HidD_GetManufacturerString=(GETMANUFACTURERSTRING)GetProcAddress(hHID,"HidD_GetManufacturerString");
+	HidD_GetProductString=(GETPRODUCTSTRING)GetProcAddress(hHID,"HidD_GetProductString");
+	if(HidD_GetHidGuid==NULL\
+		||HidD_GetAttributes==NULL\
+		||HidD_GetFeature==NULL\
+		||HidD_SetFeature==NULL\
+		||HidD_GetInputReport==NULL\
+		||HidD_SetOutputReport==NULL\
+		||HidD_GetManufacturerString==NULL\
+		||HidD_GetProductString==NULL\
+		||HidD_SetNumInputBuffers==NULL\
+		||HidD_GetNumInputBuffers==NULL) return 0;
+	HMODULE hSAPI=0;
+	hSAPI = LoadLibrary("setupapi.dll");
+	if(!hSAPI){
+		PrintMessage("Can't find setupapi.dll");
+		return 0;
+	}
+	typedef HDEVINFO (WINAPI* SETUPDIGETCLASSDEVS) (CONST GUID*,PCSTR,HWND,DWORD);
+	typedef BOOL (WINAPI* SETUPDIENUMDEVICEINTERFACES) (HDEVINFO,PSP_DEVINFO_DATA,CONST GUID*,DWORD,PSP_DEVICE_INTERFACE_DATA);
+	typedef BOOL (WINAPI* SETUPDIGETDEVICEINTERFACEDETAIL) (HDEVINFO,PSP_DEVICE_INTERFACE_DATA,PSP_DEVICE_INTERFACE_DETAIL_DATA_A,DWORD,PDWORD,PSP_DEVINFO_DATA);
+	typedef BOOL (WINAPI* SETUPDIDESTROYDEVICEINFOLIST) (HDEVINFO);
+	SETUPDIGETCLASSDEVS SetupDiGetClassDevsA=0;
+	SETUPDIENUMDEVICEINTERFACES SetupDiEnumDeviceInterfaces=0;
+	SETUPDIGETDEVICEINTERFACEDETAIL SetupDiGetDeviceInterfaceDetailA=0;
+	SETUPDIDESTROYDEVICEINFOLIST SetupDiDestroyDeviceInfoList=0;
+	SetupDiGetClassDevsA=(SETUPDIGETCLASSDEVS) GetProcAddress(hSAPI,"SetupDiGetClassDevsA");
+	SetupDiEnumDeviceInterfaces=(SETUPDIENUMDEVICEINTERFACES) GetProcAddress(hSAPI,"SetupDiEnumDeviceInterfaces");
+	SetupDiGetDeviceInterfaceDetailA=(SETUPDIGETDEVICEINTERFACEDETAIL) GetProcAddress(hSAPI,"SetupDiGetDeviceInterfaceDetailA");
+	SetupDiDestroyDeviceInfoList=(SETUPDIDESTROYDEVICEINFOLIST) GetProcAddress(hSAPI,"SetupDiDestroyDeviceInfoList");
+	if(SetupDiGetClassDevsA==NULL\
+		||SetupDiEnumDeviceInterfaces==NULL\
+		||SetupDiDestroyDeviceInfoList==NULL\
+		||SetupDiGetDeviceInterfaceDetailA==NULL) return 0;
+	/*
+	The following code is adapted from Usbhidio_vc6 application example by Jan Axelson
+	for more information see see http://www.lvr.com/hidpage.htm
+	*/
+	/*
+	API function: HidD_GetHidGuid
+	Get the GUID for all system HIDs.
+	Returns: the GUID in HidGuid.
+	*/
+	HidD_GetHidGuid(&HidGuid);
+	/*
+	API function: SetupDiGetClassDevs
+	Returns: a handle to a device information set for all installed devices.
+	Requires: the GUID returned by GetHidGuid.
+	*/
+	hDevInfo=SetupDiGetClassDevs(&HidGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_INTERFACEDEVICE);
+	devInfoData.cbSize = sizeof(devInfoData);
+	//Step through the available devices looking for the one we want.
+	//Quit on detecting the desired device or checking all available devices without success.
+	MemberIndex = 0;
+	LastDevice = FALSE;
+	do
+	{
+		/*
+		API function: SetupDiEnumDeviceInterfaces
+		On return, MyDeviceInterfaceData contains the handle to a
+		SP_DEVICE_INTERFACE_DATA structure for a detected device.
+		Requires:
+		The DeviceInfoSet returned in SetupDiGetClassDevs.
+		The HidGuid returned in GetHidGuid.
+		An index to specify a device.
+		*/
+		Result=SetupDiEnumDeviceInterfaces (hDevInfo, 0, &HidGuid, MemberIndex, &devInfoData);
+		if (Result != 0)
+		{
+			//A device has been detected, so get more information about it.
+			/*
+			API function: SetupDiGetDeviceInterfaceDetail
+			Returns: an SP_DEVICE_INTERFACE_DETAIL_DATA structure
+			containing information about a device.
+			To retrieve the information, call this function twice.
+			The first time returns the size of the structure in Length.
+			The second time returns a pointer to the data in DeviceInfoSet.
+			Requires:
+			A DeviceInfoSet returned by SetupDiGetClassDevs
+			The SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces.
+			The final parameter is an optional pointer to an SP_DEV_INFO_DATA structure.
+			This application doesn't retrieve or use the structure.
+			If retrieving the structure, set
+			MyDeviceInfoData.cbSize = length of MyDeviceInfoData.
+			and pass the structure's address.
+			*/
+			//Get the Length value.
+			//The call will return with a "buffer too small" error which can be ignored.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, NULL, 0, &Length, NULL);
+			//Allocate memory for the hDevInfo structure, using the returned Length.
+			detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(Length);
+			//Set cbSize in the detailData structure.
+			detailData -> cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+			//Call the function again, this time passing it the returned buffer size.
+			Result = SetupDiGetDeviceInterfaceDetail(hDevInfo, &devInfoData, detailData, Length,&Required, NULL);
+			// Open a handle to the device.
+			// To enable retrieving information about a system mouse or keyboard,
+			// don't request Read or Write access for this handle.
+			/*
+			API function: CreateFile
+			Returns: a handle that enables reading and writing to the device.
+			Requires:
+			The DevicePath in the detailData structure
+			returned by SetupDiGetDeviceInterfaceDetail.
+			*/
+			DeviceHandle=CreateFile(detailData->DevicePath,
+				0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+				(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING, 0, NULL);
+			/*
+			API function: HidD_GetAttributes
+			Requests information from the device.
+			Requires: the handle returned by CreateFile.
+			Returns: a HIDD_ATTRIBUTES structure containing
+			the Vendor ID, Product ID, and Product Version Number.
+			Use this information to decide if the detected device is
+			the one we're looking for.
+			*/
+			//Set the Size to the number of bytes in the structure.
+			Attributes.Size = sizeof(Attributes);
+			Result = HidD_GetAttributes(DeviceHandle,&Attributes);
+			//Is it the desired device?
+			MyDeviceDetected = FALSE;
+			if (Attributes.VendorID == vid)
+			{
+				if (Attributes.ProductID == pid)
+				{
+					//Both the Vendor ID and Product ID match.
+					MyDeviceDetected = TRUE;
+					strcpy(MyDevicePathName,detailData->DevicePath);
+					// Get a handle for writing Output reports.
+					WriteHandle=CreateFile(detailData->DevicePath,
+						GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
+						(LPSECURITY_ATTRIBUTES)NULL,OPEN_EXISTING,0,NULL);
+					//Get a handle to the device for the overlapped ReadFiles.
+					ReadHandle=CreateFile(detailData->DevicePath,
+						GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,(LPSECURITY_ATTRIBUTES)NULL,
+						OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);
+					if (hEventObject) CloseHandle(hEventObject);
+					hEventObject = CreateEvent(NULL,TRUE,TRUE,"");
+					//Set the members of the overlapped structure.
+					HIDOverlapped.hEvent = hEventObject;
+					HIDOverlapped.Offset = 0;
+					HIDOverlapped.OffsetHigh = 0;
+					Result=HidD_SetNumInputBuffers(DeviceHandle,64);
+				}
+				else
+					//The Product ID doesn't match.
+					CloseHandle(DeviceHandle);
+			}
+			else
+				//The Vendor ID doesn't match.
+				CloseHandle(DeviceHandle);
+		//Free the memory used by the detailData structure (no longer needed).
+		free(detailData);
+		}
+		else
+			//SetupDiEnumDeviceInterfaces returned 0, so there are no more devices to check.
+			LastDevice=TRUE;
+		//If we haven't found the device yet, and haven't tried every available device,
+		//try the next one.
+		MemberIndex = MemberIndex + 1;
+	} //do
+	while ((LastDevice == FALSE) && (MyDeviceDetected == FALSE));
+	//Free the memory reserved for hDevInfo by SetupDiClassDevs.
+	SetupDiDestroyDeviceInfoList(hDevInfo);
+/*	if(info){
+		PrintMessage3("Device detected: vid=0x%04X pid=0x%04X\nPath: %s\n",vid,pid,MyDevicePathName);
+		if(HidD_GetManufacturerString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Manufacturer string: %s\n",string);
+		if(HidD_GetProductString(DeviceHandle,string,sizeof(string))==TRUE) wprintf(L"Product string: %s\n",string);
+	}*/
+#endif
+	if (MyDeviceDetected == FALSE){
+		PrintMessage(strings[S_noprog]);	//"Programmer not detected\r\n"
+		//gtk_statusbar_push(status_bar,statusID,strings[S_noprog]);
+	}
+	else{
+		PrintMessage(strings[S_prog]);	//"Programmer detected\r\n");
+		PrintMessage2("VID=0x%04X PID=0x%04X\r\n",vid,pid);
+		//gtk_statusbar_push(status_bar,statusID,strings[S_prog]);
+	}
+	return MyDeviceDetected;
+}
diff --git a/opgui.glade b/opgui.glade
new file mode 100644
index 0000000..60b9c1a
--- /dev/null
+++ b/opgui.glade
@@ -0,0 +1,3797 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.38.2 -->
+<interface>
+  <requires lib="gtk+" version="3.12"/>
+  <object class="GtkAdjustment" id="I2C_adj">
+    <property name="upper">100</property>
+    <property name="value">1</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+  </object>
+  <object class="GtkAdjustment" id="VPP_adj">
+    <property name="lower">5</property>
+    <property name="upper">15</property>
+    <property name="value">5</property>
+    <property name="step-increment">1</property>
+    <property name="page-increment">10</property>
+  </object>
+  <object class="GtkImage" id="imageRead">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="resource">/res/read.png</property>
+  </object>
+  <object class="GtkImage" id="imageWrite">
+    <property name="visible">True</property>
+    <property name="can-focus">False</property>
+    <property name="resource">/res/write.png</property>
+  </object>
+  <object class="GtkWindow" id="window">
+    <property name="can-focus">False</property>
+    <property name="window-position">center</property>
+    <property name="default-width">850</property>
+    <property name="default-height">250</property>
+    <signal name="destroy" handler="G_CALLBACK(Xclose)" swapped="no"/>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can-focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkStatusbar" id="STATUS_B">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <property name="margin-start">10</property>
+            <property name="margin-end">10</property>
+            <property name="margin-top">6</property>
+            <property name="margin-bottom">6</property>
+            <property name="spacing">2</property>
+            <property name="baseline-position">bottom</property>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="pack-type">end</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkToolbar">
+            <property name="visible">True</property>
+            <property name="can-focus">False</property>
+            <child>
+              <object class="GtkToolButton" id="OPEN_T">
+                <property name="name">OPEN_T</property>
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">document-open-symbolic</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="SAVE_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">document-save-symbolic</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkSeparatorToolItem">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="READ_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="use-underline">True</property>
+                <property name="icon-widget">imageRead</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="WRITE_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="use-underline">True</property>
+                <property name="icon-widget">imageWrite</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkSeparatorToolItem">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="STOP_T">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">stop</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">media-playback-stop-symbolic</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="CONNECT_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">reconn</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">gtk-connect</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="INFO_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">info</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">help-browser-symbolic</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkToolButton" id="QUIT_T">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">quit</property>
+                <property name="use-underline">True</property>
+                <property name="icon-name">application-exit-symbolic</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="homogeneous">True</property>
+              </packing>
+            </child>
+		  </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkNotebook" id="NOTEBOOK">
+            <property name="visible">True</property>
+            <property name="can-focus">True</property>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="visible">True</property>
+                <property name="can-focus">True</property>
+                <property name="shadow-type">in</property>
+                <child>
+                  <object class="GtkTextView" id="DATA">
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="margin-start">5</property>
+                    <property name="margin-top">5</property>
+                    <style>
+                      <class name="mono"/>
+                    </style>
+                  </object>
+                </child>
+              </object>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel" id="DATA_T_L">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">dati</property>
+              </object>
+              <packing>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="DEVICE_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">5</property>
+                <property name="margin-top">5</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="orientation">vertical</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="margin-start">5</property>
+                        <child>
+                          <object class="GtkLabel" id="TYPE_L">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">_tipo</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkComboBoxText" id="TYPE_C">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <child>
+                          <object class="GtkLabel" id="DEV_SRC_L">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">label</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="DEV_SRC_E">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkScrolledWindow">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="shadow-type">in</property>
+                        <child>
+                          <object class="GtkTreeView" id="DEV_TREE">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="halign">start</property>
+                            <property name="valign">start</property>
+                            <property name="fixed-height-mode">True</property>
+                            <child internal-child="selection">
+                              <object class="GtkTreeSelection"/>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="valign">start</property>
+                    <property name="margin-start">8</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="margin-start">6</property>
+                        <property name="margin-end">6</property>
+                        <property name="margin-top">3</property>
+                        <property name="margin-bottom">6</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkLabel" id="DEV_INFO">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkCheckButton" id="EE_RW">
+                            <property name="label" translatable="yes">ee</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="halign">start</property>
+                            <property name="margin-start">5</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkBox" id="PIC_OPT">
+                            <property name="can-focus">False</property>
+                            <property name="margin-start">5</property>
+                            <property name="orientation">vertical</property>
+                            <property name="spacing">1</property>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="orientation">vertical</property>
+                                    <property name="spacing">5</property>
+                                    <child>
+                                      <object class="GtkCheckButton" id="RES_READ">
+                                        <property name="label" translatable="yes">_reserved</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkCheckButton" id="PROG_ID">
+                                        <property name="label" translatable="yes">_progID</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkCheckButton" id="PROG_CAL12">
+                                        <property name="label" translatable="yes">_progCal</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkFrame" id="OSC_OPT">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label-xalign">0</property>
+                                        <property name="shadow-type">in</property>
+                                        <child>
+                                          <object class="GtkBox">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="margin-start">5</property>
+                                            <property name="margin-end">5</property>
+                                            <property name="margin-bottom">5</property>
+                                            <property name="orientation">vertical</property>
+                                            <child>
+                                              <object class="GtkRadioButton" id="OSCCAL">
+                                                <property name="label" translatable="yes">_osccal</property>
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">True</property>
+                                                <property name="receives-default">False</property>
+                                                <property name="draw-indicator">True</property>
+                                                <property name="group">FILECAL</property>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">0</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkRadioButton" id="BKOSCCAL">
+                                                <property name="label" translatable="yes">_bkosccal</property>
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">True</property>
+                                                <property name="receives-default">False</property>
+                                                <property name="draw-indicator">True</property>
+                                                <property name="group">FILECAL</property>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">1</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkRadioButton" id="FILECAL">
+                                                <property name="label" translatable="yes">_file</property>
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">True</property>
+                                                <property name="receives-default">False</property>
+                                                <property name="draw-indicator">True</property>
+                                                <property name="group">OSCCAL</property>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">2</property>
+                                              </packing>
+                                            </child>
+                                          </object>
+                                        </child>
+                                        <child type="label">
+                                          <object class="GtkLabel" id="OSCCAL_L">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">__osccal</property>
+                                          </object>
+                                        </child>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkFrame" id="CW_OPT">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="margin-start">6</property>
+                                    <property name="label-xalign">0</property>
+                                    <property name="shadow-type">in</property>
+                                    <child>
+                                      <object class="GtkBox">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="margin-start">5</property>
+                                        <property name="margin-end">5</property>
+                                        <property name="margin-bottom">5</property>
+                                        <property name="orientation">vertical</property>
+                                        <property name="spacing">5</property>
+                                        <child>
+                                          <object class="GtkCheckButton" id="FORCE_CW">
+                                            <property name="label" translatable="yes">_forcecw</property>
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">True</property>
+                                            <property name="receives-default">False</property>
+                                            <property name="draw-indicator">True</property>
+                                          </object>
+                                          <packing>
+                                            <property name="expand">False</property>
+                                            <property name="fill">True</property>
+                                            <property name="position">0</property>
+                                          </packing>
+                                        </child>
+                                        <child>
+                                          <object class="GtkBox">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <child>
+                                              <object class="GtkBox" id="CW1_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW1</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW1">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">0</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW2_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW2</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW2">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">1</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW3_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW3</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW3">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">2</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW4_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW4">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">3</property>
+                                              </packing>
+                                            </child>
+                                          </object>
+                                          <packing>
+                                            <property name="expand">False</property>
+                                            <property name="fill">True</property>
+                                            <property name="position">1</property>
+                                          </packing>
+                                        </child>
+                                        <child>
+                                          <object class="GtkBox">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <child>
+                                              <object class="GtkBox" id="CW5_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW5</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW5">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">0</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW6_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW6</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW6">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">1</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW7_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW7</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW7">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">2</property>
+                                              </packing>
+                                            </child>
+                                            <child>
+                                              <object class="GtkBox" id="CW8_OPT">
+                                                <property name="visible">True</property>
+                                                <property name="can-focus">False</property>
+                                                <child>
+                                                  <object class="GtkLabel">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">False</property>
+                                                    <property name="label" translatable="yes">CW8</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">0</property>
+                                                  </packing>
+                                                </child>
+                                                <child>
+                                                  <object class="GtkEntry" id="CW8">
+                                                    <property name="visible">True</property>
+                                                    <property name="can-focus">True</property>
+                                                    <property name="width-chars">4</property>
+                                                    <property name="max-width-chars">4</property>
+                                                  </object>
+                                                  <packing>
+                                                    <property name="expand">False</property>
+                                                    <property name="fill">True</property>
+                                                    <property name="position">1</property>
+                                                  </packing>
+                                                </child>
+                                              </object>
+                                              <packing>
+                                                <property name="expand">False</property>
+                                                <property name="fill">True</property>
+                                                <property name="position">3</property>
+                                              </packing>
+                                            </child>
+                                          </object>
+                                          <packing>
+                                            <property name="expand">False</property>
+                                            <property name="fill">True</property>
+                                            <property name="position">2</property>
+                                          </packing>
+                                        </child>
+                                      </object>
+                                    </child>
+                                    <child type="label">
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">Config Word</property>
+                                      </object>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">False</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="padding">5</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkFrame" id="ICD_OPT">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="halign">start</property>
+                                <property name="label-xalign">0</property>
+                                <property name="shadow-type">in</property>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="margin-start">5</property>
+                                    <property name="margin-end">5</property>
+                                    <property name="margin-bottom">5</property>
+                                    <property name="spacing">48</property>
+                                    <child>
+                                      <object class="GtkCheckButton" id="ICD">
+                                        <property name="label" translatable="yes">_icd</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkBox">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <child>
+                                          <object class="GtkLabel" id="ICD_ADDR_L">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_address</property>
+                                          </object>
+                                          <packing>
+                                            <property name="expand">False</property>
+                                            <property name="fill">True</property>
+                                            <property name="position">0</property>
+                                          </packing>
+                                        </child>
+                                        <child>
+                                          <object class="GtkEntry" id="ICD_ADDR">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">True</property>
+                                            <property name="width-chars">5</property>
+                                          </object>
+                                          <packing>
+                                            <property name="expand">False</property>
+                                            <property name="fill">True</property>
+                                            <property name="position">1</property>
+                                          </packing>
+                                        </child>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                </child>
+                                <child type="label">
+                                  <object class="GtkLabel">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label" translatable="yes">ICD</property>
+                                  </object>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="padding">5</property>
+                            <property name="position">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkBox" id="AVR_OPT">
+                            <property name="can-focus">False</property>
+                            <property name="margin-start">5</property>
+                            <property name="orientation">vertical</property>
+                            <property name="spacing">5</property>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkEntry" id="FUSEL">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="width-chars">2</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkCheckButton" id="FUSEL_C">
+                                    <property name="label" translatable="yes">_fuselow</property>
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="draw-indicator">True</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkEntry" id="FUSEH">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="width-chars">2</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkCheckButton" id="FUSEH_C">
+                                    <property name="label" translatable="yes">_fusehigh</property>
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="draw-indicator">True</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkEntry" id="FUSEX">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="width-chars">2</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkCheckButton" id="FUSEX_C">
+                                    <property name="label" translatable="yes">_fuseext</property>
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="draw-indicator">True</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">2</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkEntry" id="FUSELCK">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="width-chars">2</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkCheckButton" id="FUSELCK_C">
+                                    <property name="label" translatable="yes">_fuselock</property>
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="receives-default">False</property>
+                                    <property name="draw-indicator">True</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">3</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="FUSEL_W3K">
+                                <property name="label" translatable="yes">_writefuselow3k</property>
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="receives-default">True</property>
+                                <property name="halign">start</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">False</property>
+                                <property name="position">4</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">3</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel" id="DEVICE_NAME">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_dev</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel" id="DEVICE_L">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">_dev</property>
+              </object>
+              <packing>
+                <property name="position">1</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="OPTIONS_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">5</property>
+                <property name="margin-top">5</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">5</property>
+                <child>
+                  <object class="GtkButton" id="CONNECT">
+                    <property name="label" translatable="yes">_connect</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">True</property>
+                    <property name="halign">start</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">VID</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="VID">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="width-chars">4</property>
+                            <property name="max-width-chars">4</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">PID</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="PID">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="width-chars">4</property>
+                            <property name="max-width-chars">4</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="padding">20</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="TEST">
+                    <property name="label" translatable="yes">_test</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">True</property>
+                    <property name="halign">start</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkCheckButton" id="LOG">
+                    <property name="label" translatable="yes">_log</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
+                    <property name="halign">start</property>
+                    <property name="draw-indicator">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkCheckButton" id="3VCHECK">
+                    <property name="label" translatable="yes">3v3nocheck</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
+                    <property name="halign">start</property>
+                    <property name="draw-indicator">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">4</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkCheckButton" id="S1">
+                    <property name="label" translatable="yes">_s1</property>
+                    <property name="visible">True</property>
+                    <property name="can-focus">True</property>
+                    <property name="receives-default">False</property>
+                    <property name="halign">start</property>
+                    <property name="draw-indicator">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">5</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <child>
+                      <object class="GtkLabel" id="MAXERR_L">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_maxerr</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="MAXERR">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="width-chars">4</property>
+                        <property name="max-width-chars">4</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">6</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">2</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel" id="OPTIONS_L">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">_options</property>
+              </object>
+              <packing>
+                <property name="position">2</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="I2CSPI_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">10</property>
+                <property name="margin-top">5</property>
+                <property name="spacing">15</property>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="valign">start</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkRadioButton" id="I2C8BIT">
+                            <property name="label" translatable="yes">I2C 8 Bit</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkRadioButton" id="I2C16BIT">
+                            <property name="label" translatable="yes">I2C 16 Bit</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                            <property name="group">I2C8BIT</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSeparator">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkRadioButton" id="SPI00">
+                            <property name="label" translatable="yes">SPI(00)</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                            <property name="group">I2C8BIT</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">3</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkRadioButton" id="SPI01">
+                            <property name="label" translatable="yes">SPI(01)</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                            <property name="group">I2C8BIT</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">4</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkRadioButton" id="SPI10">
+                            <property name="label" translatable="yes">SPI(10)</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                            <property name="group">I2C8BIT</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">5</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkRadioButton" id="SPI11">
+                            <property name="label" translatable="yes">SPI(11)</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw-indicator">True</property>
+                            <property name="group">I2C8BIT</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">6</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel" id="I2CMODE">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_mode</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkLabel" id="NBYTE_L">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">_byte</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSpinButton" id="NBYTE_S">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="max-length">3</property>
+                            <property name="input-purpose">number</property>
+                            <property name="adjustment">I2C_adj</property>
+                            <property name="climb-rate">1</property>
+                            <property name="numeric">True</property>
+                            <property name="value">1</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkLabel" id="SPEED_L">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">_speed</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkComboBoxText" id="SPEED_C">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="active">0</property>
+                            <items>
+                              <item translatable="yes">100 kbps</item>
+                              <item translatable="yes">200 kbps</item>
+                              <item translatable="yes">300/400 kbps</item>
+                              <item translatable="yes">500/800 kbps</item>
+                            </items>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="spacing">5</property>
+                        <property name="homogeneous">True</property>
+                        <child>
+                          <object class="GtkButton" id="SEND_B">
+                            <property name="label" translatable="yes">_send</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkButton" id="RECEIVE_B">
+                            <property name="label" translatable="yes">_receive</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="DATASEND_L">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_datasend</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkEntry" id="DATASEND">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">4</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="DATATR_L">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_datatransferred</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">5</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkFrame">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label-xalign">0</property>
+                        <property name="shadow-type">out</property>
+                        <child>
+                          <object class="GtkTextView" id="DATATR">
+                            <property name="width-request">250</property>
+                            <property name="height-request">60</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="editable">False</property>
+                          </object>
+                        </child>
+                        <child type="label">
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">6</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">3</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">I2C/SPI</property>
+              </object>
+              <packing>
+                <property name="position">3</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="ICD_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">5</property>
+                <property name="orientation">vertical</property>
+                <child>
+                  <object class="GtkToolbar">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_RUN">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">go-next-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_HALT">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">media-playback-pause-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_STEP">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">go-last-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_STEPOVER">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">media-seek-forward-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSeparatorToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_STOP">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">media-playback-stop-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSeparatorToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_REFRESH">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">media-playlist-repeat-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSeparatorToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="LOADCOFF_B">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_loadcoff</property>
+                        <property name="use-underline">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSeparatorToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <child>
+                          <object class="GtkEntry" id="ICD_CMD_E">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="width-chars">10</property>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">False</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkSeparatorToolItem">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">False</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkToolButton" id="ICD_HELP">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">help</property>
+                        <property name="use-underline">True</property>
+                        <property name="icon-name">help-browser-symbolic</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="homogeneous">True</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="homogeneous">True</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkLabel" id="ICD_SOURCE_L">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="label" translatable="yes">_source</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="padding">7</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkScrolledWindow">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="shadow-type">in</property>
+                            <child>
+                              <object class="GtkTextView" id="ICD_SOURCE">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="editable">False</property>
+                              </object>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">True</property>
+                            <property name="fill">True</property>
+                            <property name="position">2</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="homogeneous">True</property>
+                            <child>
+                              <object class="GtkLabel" id="ICD_STAT_L">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">_status</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkMenuBar">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <child>
+                                  <object class="GtkMenuItem" id="OPTIONS_M">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label" translatable="yes">_opt</property>
+                                    <property name="use-underline">True</property>
+                                    <child type="submenu">
+                                      <object class="GtkMenu">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="PCOUNT_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_counter</property>
+                                            <property name="use-underline">True</property>
+                                            <property name="active">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="STATUS_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_status</property>
+                                            <property name="use-underline">True</property>
+                                            <property name="active">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="BANK0_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_b0</property>
+                                            <property name="use-underline">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="BANK1_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_b1</property>
+                                            <property name="use-underline">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="BANK2_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_b2</property>
+                                            <property name="use-underline">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="BANK3_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_b3</property>
+                                            <property name="use-underline">True</property>
+                                          </object>
+                                        </child>
+                                        <child>
+                                          <object class="GtkCheckMenuItem" id="EE_M">
+                                            <property name="visible">True</property>
+                                            <property name="can-focus">False</property>
+                                            <property name="label" translatable="yes">_ee</property>
+                                            <property name="use-underline">True</property>
+                                          </object>
+                                        </child>
+                                      </object>
+                                    </child>
+                                  </object>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">3</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkScrolledWindow">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="shadow-type">in</property>
+                            <child>
+                              <object class="GtkTextView" id="ICD_STATUS">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="editable">False</property>
+                              </object>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">True</property>
+                            <property name="fill">True</property>
+                            <property name="position">2</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">4</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">ICD</property>
+              </object>
+              <packing>
+                <property name="position">4</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="IO_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">5</property>
+                <property name="margin-top">5</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">10</property>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="halign">start</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkCheckButton" id="IOEN">
+                            <property name="label" translatable="yes">_io</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">False</property>
+                            <property name="halign">start</property>
+                            <property name="draw-indicator">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="margin-start">5</property>
+                            <property name="margin-end">5</property>
+                            <property name="margin-bottom">5</property>
+                            <property name="spacing">30</property>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="orientation">vertical</property>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB7</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB7_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB7_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB7_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB7_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB7_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB7_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB6</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB6_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB6_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB6_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB6_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB6_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB6_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB5</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB5_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB5_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB5_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB5_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB5_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB5_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">2</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB4</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB4_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB4_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB4_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB4_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB4_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB4_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">3</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB3</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB3_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB3_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB3_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB3_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB3_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB3_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">4</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB2_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB2_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB2_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB2_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB2_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB2_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">5</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB1</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB1_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB1_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB1_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB1_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB1_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB1_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">6</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RB0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB0_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB0_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB0_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RB0_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RB0_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RB0_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">7</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="orientation">vertical</property>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RC7</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC7_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC7_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RC7_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC7_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RC7_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RC7_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RC6</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC6_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC6_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RC6_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RC6_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RC6_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RC6_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RA5</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA5_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA5_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA5_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA5_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA5_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RA5_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">2</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RA4</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA4_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA4_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA4_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA4_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA4_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RA4_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">3</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkBox">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="spacing">4</property>
+                                    <child>
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="label" translatable="yes">RA3</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">0</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA3_0">
+                                        <property name="label" translatable="yes">0</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">1</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA3_1">
+                                        <property name="label" translatable="yes">1</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA3_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">2</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkRadioButton" id="RA3_I">
+                                        <property name="label" translatable="yes">INPUT:</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="receives-default">False</property>
+                                        <property name="active">True</property>
+                                        <property name="draw-indicator">True</property>
+                                        <property name="group">RA3_0</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">3</property>
+                                      </packing>
+                                    </child>
+                                    <child>
+                                      <object class="GtkLabel" id="RA3_L">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                        <property name="width-chars">2</property>
+                                      </object>
+                                      <packing>
+                                        <property name="expand">False</property>
+                                        <property name="fill">True</property>
+                                        <property name="position">4</property>
+                                      </packing>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">4</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">I/O</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="spacing">10</property>
+                    <child>
+                      <object class="GtkCheckButton" id="VDDUEN">
+                        <property name="label" translatable="yes">VDDU</property>
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">False</property>
+                        <property name="draw-indicator">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkCheckButton" id="VPPUEN">
+                        <property name="label" translatable="yes">VPPU</property>
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">False</property>
+                        <property name="draw-indicator">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkCheckButton" id="DCDCEN">
+                        <property name="label" translatable="yes">DCDC</property>
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="receives-default">False</property>
+                        <property name="draw-indicator">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkScale" id="DCDC_S">
+                        <property name="visible">True</property>
+                        <property name="can-focus">True</property>
+                        <property name="hexpand">False</property>
+                        <property name="adjustment">VPP_adj</property>
+                        <property name="restrict-to-fill-level">False</property>
+                        <property name="fill-level">0</property>
+                        <property name="round-digits">1</property>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">3</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="margin-start">5</property>
+                    <property name="margin-end">5</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">5</property>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="halign">start</property>
+                                <property name="orientation">vertical</property>
+                                <child>
+                                  <object class="GtkLabel" id="CMDSEND_L">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label" translatable="yes">_datasend</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkEntry" id="CMDSEND">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">True</property>
+                                    <property name="margin-start">5</property>
+                                    <property name="margin-top">10</property>
+                                    <property name="width-chars">35</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkBox">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="margin-end">5</property>
+                                <property name="orientation">vertical</property>
+                                <child>
+                                  <object class="GtkLabel" id="CMDTR_L">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label" translatable="yes">_datatransferred</property>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">True</property>
+                                    <property name="position">0</property>
+                                  </packing>
+                                </child>
+                                <child>
+                                  <object class="GtkFrame">
+                                    <property name="visible">True</property>
+                                    <property name="can-focus">False</property>
+                                    <property name="label-xalign">0</property>
+                                    <property name="shadow-type">out</property>
+                                    <child>
+                                      <object class="GtkTextView" id="CMDTR">
+                                        <property name="width-request">200</property>
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">True</property>
+                                        <property name="editable">False</property>
+                                        <property name="input-purpose">number</property>
+                                      </object>
+                                    </child>
+                                    <child type="label">
+                                      <object class="GtkLabel">
+                                        <property name="visible">True</property>
+                                        <property name="can-focus">False</property>
+                                      </object>
+                                    </child>
+                                  </object>
+                                  <packing>
+                                    <property name="expand">False</property>
+                                    <property name="fill">False</property>
+                                    <property name="position">1</property>
+                                  </packing>
+                                </child>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkButton" id="CMDTR_B">
+                            <property name="label" translatable="yes">_send</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">True</property>
+                            <property name="halign">start</property>
+                            <property name="margin-start">5</property>
+                            <property name="margin-bottom">5</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel" id="CMD_L">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">_cmd</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">5</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">I/O</property>
+              </object>
+              <packing>
+                <property name="position">5</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkBox" id="UTILITY_TAB">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="margin-start">5</property>
+                <property name="margin-top">5</property>
+                <property name="orientation">vertical</property>
+                <property name="spacing">10</property>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="margin-end">5</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="margin-start">5</property>
+                        <property name="margin-end">5</property>
+                        <property name="margin-bottom">5</property>
+                        <property name="orientation">vertical</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">10</property>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">Hex</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkEntry" id="HEXIN">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">True</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="DATAOUT">
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="editable">False</property>
+                          </object>
+                          <packing>
+                            <property name="expand">True</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">HEX -&gt; DATA</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkFrame">
+                    <property name="visible">True</property>
+                    <property name="can-focus">False</property>
+                    <property name="margin-end">5</property>
+                    <property name="label-xalign">0</property>
+                    <property name="shadow-type">in</property>
+                    <child>
+                      <object class="GtkBox">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="margin-start">5</property>
+                        <property name="margin-end">5</property>
+                        <property name="margin-bottom">5</property>
+                        <property name="orientation">vertical</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">10</property>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">_addr</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkEntry" id="ADDRIN">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">10</property>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">_data</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkEntry" id="DATAIN">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                              </object>
+                              <packing>
+                                <property name="expand">True</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkBox">
+                            <property name="visible">True</property>
+                            <property name="can-focus">False</property>
+                            <property name="spacing">10</property>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can-focus">False</property>
+                                <property name="label" translatable="yes">Hex</property>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">True</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkEntry" id="HEXOUT">
+                                <property name="visible">True</property>
+                                <property name="can-focus">True</property>
+                                <property name="editable">False</property>
+                              </object>
+                              <packing>
+                                <property name="expand">True</property>
+                                <property name="fill">True</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkButton" id="HEXSAVE">
+                            <property name="label" translatable="yes">_save</property>
+                            <property name="visible">True</property>
+                            <property name="can-focus">True</property>
+                            <property name="receives-default">True</property>
+                            <property name="halign">start</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">3</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                    <child type="label">
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can-focus">False</property>
+                        <property name="label" translatable="yes">DATA -&gt; HEX</property>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">6</property>
+              </packing>
+            </child>
+            <child type="tab">
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can-focus">False</property>
+                <property name="label" translatable="yes">Utility</property>
+              </object>
+              <packing>
+                <property name="position">6</property>
+                <property name="tab-fill">False</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>
diff --git a/progAVR.c b/progAVR.c
new file mode 100644
index 0000000..47fdcc4
--- /dev/null
+++ b/progAVR.c
@@ -0,0 +1,2450 @@
+/*
+ * progAVR.c - algorithms to program the Atmel AVR family of microcontrollers
+ * Copyright (C) 2009-2021 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+#include "common.h"
+
+#define  LOCK	1
+#define  FUSE	2
+#define  FUSE_H 4
+#define  FUSE_X	8
+#define  CAL	16
+#define  SLOW	256
+#define  RST 0x40
+
+struct AVRID{
+	int id;
+	char *device;
+} AVRLIST[]={
+	//1K
+	{0x9001,"AT90S1200"},
+	{0x9004,"ATtiny11"},
+	{0x9005,"ATtiny12"},
+	{0x9007,"ATtiny13"},
+	//2K
+	{0x9101,"AT90S2313"},
+	{0x9109,"ATtiny26"},
+	{0x910A,"ATtiny2313"},
+	{0x910B,"ATtiny24"},
+	{0x910C,"ATtiny261"},
+	//4K
+	{0x9205,"ATmega48"},
+	{0x920A,"ATmega48PA"},
+	{0x9207,"ATtiny44"},
+	{0x9208,"ATtiny461"},
+	{0x9209,"ATtiny48"},
+	{0x920D,"ATtiny4313"},
+	//8K
+	{0x9301,"AT90S8515"},
+	{0x9303,"AT90S8535"},
+	{0x9306,"ATmega8515"},
+	{0x9307,"ATmega8"},
+	{0x9308,"ATmega8535"},
+	{0x930A,"ATmega88"},
+	{0x930C,"ATtiny84"},
+	{0x930D,"ATtiny861"},
+	{0x930F,"ATmega88PA"},
+	{0x9311,"ATtiny88"},
+	//16K
+	{0x9403,"ATmega16"},
+	{0x9406,"ATmega168"},
+	{0x940A,"ATmega164PA"},
+	{0x940B,"ATmega168PA"},
+	{0x940F,"ATmega164A"},
+	//32K
+	{0x950F,"ATmega328P"},
+	{0x9511,"ATmega324PA"},
+	{0x9514,"ATmega328"},
+	{0x9515,"ATmega324A"},
+	//64K
+	{0x9602,"ATmega64"},
+	{0x9609,"ATmega644A"},
+	{0x960A,"ATmega644PA"},
+	//128K
+	{0x9705,"ATmega1284P"},
+	{0x9706,"ATmega1284"},
+};
+
+void AtmelID(BYTE id[])
+{
+	char str[128]="";
+	int i,idw=(id[1]<<8)+id[2];
+	if(id[0]==0&&id[1]==1&&id[2]==2){
+		PrintMessage(strings[S_Protected]);		//"Device protected"
+		return;
+	}
+	if(id[0]==0x1E) strcat(str,"Atmel ");
+	for(i=0;i<sizeof(AVRLIST)/sizeof(AVRLIST[0]);i++){
+		if(idw==AVRLIST[i].id){
+			strcat(str,AVRLIST[i].device);
+			i=1000;
+		}
+	}
+	switch(id[1]){
+		case 0x90:
+			strcat(str," 1KB Flash");
+			break;
+		case 0x91:
+			strcat(str," 2KB Flash");
+			break;
+		case 0x92:
+			strcat(str," 4KB Flash");
+			break;
+		case 0x93:
+			strcat(str," 8KB Flash");
+			break;
+		case 0x94:
+			strcat(str," 16KB Flash");
+			break;
+		case 0x95:
+			strcat(str," 32KB Flash");
+			break;
+		case 0x96:
+			strcat(str," 64KB Flash");
+			break;
+		case 0x97:
+			strcat(str," 128KB Flash");
+			break;
+	}
+	if(i!=1001) strcat(str,strings[S_nodev]); //"Unknown device\r\n");
+	else strcat(str,"\r\n");
+	PrintMessage(str);
+}
+
+void DisplayCODEAVR(int dim){
+// display AVR CODE memory
+	char s[256]="",t[256]="";
+	int valid=0,empty=1,i,j,lines=0;
+	char* aux=(char*)malloc((dim/COL+1)*(16+COL*6));
+	aux[0]=0;
+	s[0]=0;
+	for(i=0;i<dim&&i<size;i+=COL*2){
+		valid=0;
+		for(j=i;j<i+COL*2&&j<dim;j++){
+			sprintf(t,"%02X ",memCODE[j]);
+			strcat(s,t);
+			if(memCODE[j]<0xff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s\r\n",i,s);
+			strcat(aux,t);
+			empty=0;
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=(dim<size?dim:size)-COL*4;
+				lines=490;
+			}
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+//Software SPI for very slow speed
+//RB1=CLK, RB0=MISO, RC7=MOSI, RC6=RESET
+//speed in bit/s  min 10
+int SWSPI(int data, int speed){
+	int i,j,din=0;
+	double Tbit=1.0/speed*1e6;		//Tbit in us
+	if(saveLog)	fprintf(logfile,"SWSPI(0x%X,%d)\n",data,speed);
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=(int)(Tbit/2)>>8;
+	bufferU[j++]=(int)(Tbit/2)&0xff;
+	bufferU[j++]=SET_PORT_DIR;
+	bufferU[j++]=0xF5;	//TRISB
+	bufferU[j++]=0x3F;	//TRISA-C  (RC7:RC6:RA5:RA4:RA3:X:X:X)
+	for(i=0;i<4;i++){	//first nibble
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;			//PORTB CLK=0
+		bufferU[j++]=data&0x80;	//PORTA-C
+		bufferU[j++]=WAIT_T3;	//half bit delay
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=2;			//PORTB CLK=1
+		bufferU[j++]=data&0x80;	//PORTA-C
+		bufferU[j++]=READ_B;
+		bufferU[j++]=WAIT_T3;	//half bit delay
+		data<<=1;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+4*(Tbit/1000.0+0.5));
+	for(j=0;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	j=0;
+	for(i=0;i<4;i++){	//second nibble
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;			//PORTB CLK=0
+		bufferU[j++]=data&0x80;	//PORTA-C
+		bufferU[j++]=WAIT_T3;	//half bit delay
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=2;			//PORTB CLK=1
+		bufferU[j++]=data&0x80;	//PORTA-C
+		bufferU[j++]=READ_B;
+		bufferU[j++]=WAIT_T3;	//half bit delay
+		data<<=1;
+	}
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;			//PORTB CLK=0
+	bufferU[j++]=0;			//PORTA-C
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+4*(Tbit/1000.0+0.5));
+	for(j=0;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	din<<=1;
+	for(j+=2;j<DIMBUF-1&&bufferI[j]!=READ_B;j++);
+	din+=bufferI[j+1]&1;
+	if(saveLog)	fprintf(logfile,"Read 0x%X\n",din);
+	return din;
+}
+
+//Write fuse at low speed
+//speed in bit/s  min 10
+void WriteATfuseSlow(int fuse){
+#define SPEED 3000
+	int j,d;
+	fuse&=0xFF;
+	if(FWVersion<0x900){
+		PrintMessage1(strings[S_FWver2old],"0.9.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteATfuseSlow(0x%X)\n",fuse);
+	}
+	PrintMessage(strings[S_FuseAreaW]);	//"Write Fuse ... "
+	j=0;
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PORT_DIR;
+	bufferU[j++]=0xF5;	//TRISB
+	bufferU[j++]=0x3F;	//TRISA-C  (RC7:RC6:RA5:RA4:RA3:X:X:X)
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=1;				//0=100k,200k,500k,1M,2M,3M
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	msDelay(20);	//min 20ms from VDD
+	SWSPI(0xAC,SPEED);
+	SWSPI(0x53,SPEED);
+	d=SWSPI(0,SPEED);
+	SWSPI(0,SPEED);
+	if(d!=0x53){	//does not respond
+		j=0;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x0;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		PrintMessage(strings[S_SyncErr]);	//"Synchronization error\r\n"
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	SWSPI(0xAC,SPEED);		//Write fuse
+	SWSPI(0xA0,SPEED);
+	SWSPI(0x00,SPEED);
+	SWSPI(fuse,SPEED);
+	msDelay(9);
+	SWSPI(0x50,SPEED);		//Read fuse
+	SWSPI(0x00,SPEED);
+	SWSPI(0x00,SPEED);
+	d=SWSPI(0,SPEED);
+	if(d!=fuse){
+		PrintMessage3(strings[S_WErr1],"fuse",fuse,d);	//"Error writing %s: written %02X, read %02X" NL;
+	}
+	j=0;
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+}
+
+//Find right SPI speed to enter
+//test mode and synchronize with AVR
+//return Tbyte or 0 when sync was not found
+double SyncSPI(){
+	int z=0,i,j;
+	double Tbyte;	//byte delay in ms
+	j=0;
+	bufferU[j++]=SPI_INIT;
+	bufferU[j++]=2;				//0~=100k, 1~=200k, 2~=300k but really is 200k
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	for(i=1;i<256;i++){		//increase T more than linearly; Tmin=1
+		if(i>10) i++;
+		if(i>20) i+=2;
+		if(i>40) i+=4;
+		if(i>80) i+=4;
+		if(i>160) i+=8;
+		Tbyte=(20+i*4)/1000.0;  //from firmware simulation
+		j=0;
+		bufferU[j++]=CLOCK_GEN;	//reset with clock at 0
+		bufferU[j++]=0xFF;
+		bufferU[j++]=EN_VPP_VCC;	//VDD=0
+		bufferU[j++]=0x0;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T1T2;
+		bufferU[j++]=i;			//force T
+		bufferU[j++]=0;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=RST;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=CLOCK_GEN;
+		bufferU[j++]=5;				//0=100k,200k,500k,1M,2M,3M
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(9);
+		msDelay(20); 	//min 20ms from reset
+		j=0;
+		bufferU[j++]=SPI_WRITE;		//Programming enable
+		bufferU[j++]=2;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0x53;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=2;
+		bufferU[j++]=SPI_WRITE;		//just to test communication
+		bufferU[j++]=11;
+		bufferU[j++]=0x55;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0xAA;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x55;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0xAA;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;		//Programming enable
+		bufferU[j++]=2;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0x53;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=2;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x30;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1.5+32*Tbyte*1.1);
+		int d0,d1,d2,d3,d4,d5,d6,d7;
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		//if(bufferI[z+2]==0x53) break;
+		d0=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d1=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d2=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d3=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d4=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d5=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d6=bufferI[z+2];
+		for(z+=bufferI[z+1]+1;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		d7=bufferI[z+2];
+		//verify that received data is correct
+		if(d0==0x53&&d6==0x53&&d1==d2&&d1==d3&&d1==d4&&d1==d5&&d1==d7) break;
+	}
+	if(i>256){
+		PrintMessage(strings[S_SyncErr]);	//"Synchronization error\r\n"
+		if(saveLog) fprintf(logfile,strings[S_SyncErr]);
+		return 0;
+	}
+	//Add some margin
+	i++;
+	i+=i/10;
+	if(i>255) i=255;
+	Tbyte=(20+i*4)/1000.0;  //from firmware simulation
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=i;			//force T
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	sprintf(str,strings_it[I_AT_COMM],8/Tbyte);	//"Communicating @ %.0f kbps\r\n"
+	PrintMessage(str);
+	if(saveLog)	fprintf(logfile,str);
+	return Tbyte;
+}
+
+void ReadAT(int dim, int dim2, int options)
+// read ATMEL AVR
+// dim=FLASH size in bytes, dim2=EEPROM size
+// options: LOCK,FUSE,FUSE_H,FUSE_X,CAL
+{
+	int k=0,k2=0,z=0,i,j;
+	double Tbyte;	//byte delay in ms
+	BYTE signature[]={0,0,0};
+	if(dim>0x20000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x1000||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"ReadAT(0x%X,0x%X,0x%X)\n",dim,dim2,options);
+	}
+	size=dim;
+	sizeEE=dim2;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(dim);		//CODE
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim2);			//EEPROM
+	for(j=0;j<size;j++) memCODE[j]=0xFF;
+	for(j=0;j<sizeEE;j++) memEE[j]=0xFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	Tbyte=SyncSPI();
+	if(Tbyte==0){
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	j=0;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=2;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	if(options&LOCK){			//LOCK byte
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x58;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+	}
+	if(options&FUSE){			//FUSE byte
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x50;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+	}
+	if(options&FUSE_H){			//FUSE high byte
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x58;
+		bufferU[j++]=8;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+	}
+	if(options&FUSE_X){			//extended FUSE byte
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x50;
+		bufferU[j++]=8;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1.5+7*4.5*Tbyte);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[0]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[1]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[2]=bufferI[z+2];
+	PrintMessage3("CHIP ID:%02X%02X%02X\r\n",signature[0],signature[1],signature[2]);
+	AtmelID(signature);
+	if(options&LOCK){			//LOCK byte
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1("LOCK bits:\t  0x%02X\r\n",bufferI[z+2]);
+	}
+	if(options&FUSE){			//FUSE byte
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1("FUSE bits:\t  0x%02X\r\n",bufferI[z+2]);
+	}
+	if(options&FUSE_H){			//FUSE high byte
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1("FUSE HIGH bits:\t  0x%02X\r\n",bufferI[z+2]);
+	}
+	if(options&FUSE_X){			//extended FUSE byte
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1("Extended FUSE bits: 0x%02X\r\n",bufferI[z+2]);
+	}
+	if(options&CAL){			//calibration byte
+		j=0;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0;
+		bufferU[j++]=2;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0;
+		bufferU[j++]=3;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1.5+4.5*4*Tbyte);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1("Calibration bits:\t  0x%02X",bufferI[z+2]);
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1(",0x%02X",bufferI[z+2]);
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1(",0x%02X",bufferI[z+2]);
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		PrintMessage1(",0x%02X\r\n",bufferI[z+2]);
+	}
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	int c=(DIMBUF-5)/2;
+	for(i=0,j=0;i<dim;i+=c*2){
+		bufferU[j++]=AT_READ_DATA;
+		bufferU[j++]=i<(dim-2*c)?c:(dim-i)/2;
+		bufferU[j++]=i>>9;
+		bufferU[j++]=i>>1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1.5+240*Tbyte);
+		if(bufferI[0]==AT_READ_DATA){	//static references, verify!!
+			for(z=2;z<bufferI[1]*2+2&&z<DIMBUF;z++) memCODE[k++]=bufferI[z];
+		}
+		PrintStatus(strings[S_CodeReading],i*100/(dim+dim2),i);	//"Reading: %3d%%, add. %03X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog) fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Errore in lettura area programma, richiesti %d byte, letti %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** read eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_ReadEE]);		//read EE ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		PrintStatusSetup();
+		int n=0;
+		for(k2=0,i=0,j=0;i<dim2;i++){
+			bufferU[j++]=SPI_WRITE;		//Read eeprom memory
+			bufferU[j++]=3;
+			bufferU[j++]=0xA0;
+			bufferU[j++]=i>>8;
+			bufferU[j++]=i;
+			bufferU[j++]=SPI_READ;
+			bufferU[j++]=1;
+			n++;
+			if(j>DIMBUF-9||i==dim-1){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(1.5+4*n*Tbyte*1.3);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==SPI_READ&&bufferI[z+1]==1){
+						memEE[k2++]=bufferI[z+2];
+						z+=3;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i+dim)*100/(dim+dim2),i);	//"Reading: %3d%%, add. %03X"
+				if(RWstop) i=dim2;
+				j=0;
+				n=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k2!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,k2);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);	//"completed\r\n"
+	}
+//****************** exit program mode ********************
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=SPI_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	PrintMessage(strings[S_CodeMem]);	//"\r\nProgram memory\r\n"
+	DisplayCODEAVR(dim);
+	if(dim2){
+		DisplayEE();	//visualize EE
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+// function 18F ATtiny1x ATtiny84
+// SCI (I)  RC6   PB3      PB0
+// SII (I)  RB0   PB1      PA5
+// SDI (I)  RC7   PB0      PA6
+// SDO (O)  RB1   PB2      PA4
+#define SDI 0x10
+#define SII 0x1
+#define SDO 0x2
+#define SCI 0x8
+/// read ATMEL AVR using HV serial programming
+/// dim=FLASH size in bytes, dim2=EEPROM size
+/// options: LOCK,FUSE,FUSE_H,FUSE_X,CAL
+void ReadAT_HV(int dim, int dim2, int options)
+{
+	int k=0,z=0,i,j;
+	BYTE signature[]={0,0,0};
+	if(FWVersion<0x900){
+		PrintMessage1(strings[S_FWver2old],"0.9.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(dim>0x20000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"ReadAT_HV(0x%X,0x%X,0x%X)\n",dim,dim2,options);
+	}
+	size=dim;
+	sizeEE=dim2;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(dim);		//CODE
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim2);			//EEPROM
+	for(j=0;j<size;j++) memCODE[j]=0xFF;
+	for(j=0;j<sizeEE;j++) memEE[j]=0xFF;
+	if(!StartHVReg(12)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PORT_DIR;
+	bufferU[j++]=0xFC;
+	bufferU[j++]=0x7;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;	//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PORT_DIR;	//RELEASE SDO
+	bufferU[j++]=0xFE;
+	bufferU[j++]=0x7;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x01;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	if(options&LOCK){			//LOCK byte
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x00;
+	}
+	if(options&FUSE){			//FUSE byte
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x68;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6C;
+		bufferU[j++]=0x00;
+	}
+	if(options&FUSE_H){			//FUSE high byte
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x7A;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7E;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[0]=bufferI[z+1];
+	for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[1]=bufferI[z+1];
+	for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[2]=bufferI[z+1];
+	PrintMessage3("CHIP ID:%02X%02X%02X\r\n",signature[0],signature[1],signature[2]);
+	AtmelID(signature);
+	if(options&LOCK){			//LOCK byte
+		for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		PrintMessage1("LOCK byte:\t  0x%02X\r\n",bufferI[z+1]);
+	}
+	if(options&FUSE){			//FUSE byte
+		for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		PrintMessage1("FUSE byte:\t  0x%02X\r\n",bufferI[z+1]);
+	}
+	if(options&FUSE_H){			//FUSE high byte
+		for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		PrintMessage1("FUSE HIGH byte:\t  0x%02X\r\n",bufferI[z+1]);
+	}
+	if(options&FUSE_X){			//extended FUSE byte
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x6A;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6E;
+		bufferU[j++]=0x00;
+	}
+	if(options&CAL){			//calibration byte
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=4;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x08;
+		bufferU[j++]=0x0C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	PacketIO(2);
+	z=0;
+	if(options&FUSE_X){			//extended FUSE byte
+		for(;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		PrintMessage1("Extended FUSE byte: 0x%02X\r\n",bufferI[z+1]);
+		z+=2;
+	}
+	if(options&CAL){			//calibration byte
+		for(;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		PrintMessage1("Calibration byte: 0x%02X\r\n",bufferI[z+1]);
+	}
+//****************** read code ********************
+	if(saveLog)fprintf(logfile,"READ CODE\n");
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	j=0;
+	bufferU[j++]=AT_HV_RTX;		//Read FLASH
+	bufferU[j++]=1;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x02;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(i=0;i<dim;){
+		if((i&511)==0){ //change high address after 256 words
+			bufferU[j++]=AT_HV_RTX;
+			bufferU[j++]=1;
+			bufferU[j++]=0x1C;
+			bufferU[j++]=i>>9;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+		}
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x0C;
+		bufferU[j++]=(i>>1)&0xFF;
+		bufferU[j++]=0x68;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=2;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x00;
+		i+=2;
+		if(j>DIMBUF-14||i>=dim-2){
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1;z++){
+				if(bufferI[z]==AT_HV_RTX){
+					memCODE[k++]=bufferI[z+1];
+					z+=1;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],i*100/(dim+dim2),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr],dim,k);	//"Error reading code area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read eeprom ********************
+	if(dim2){
+		if(saveLog)fprintf(logfile,"READ EEPROM\n");
+		PrintMessage(strings[S_ReadEE]);		//read EE ...
+		PrintStatusSetup();
+		j=0;
+		k=0;
+		bufferU[j++]=AT_HV_RTX;		//Read EEPROM
+		bufferU[j++]=1;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x03;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(i=0;i<dim2;i++){
+			if((i&255)==0){
+				bufferU[j++]=AT_HV_RTX;
+				bufferU[j++]=1;
+				bufferU[j++]=0x1C;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+			}
+			bufferU[j++]=AT_HV_RTX;
+			bufferU[j++]=3;
+			bufferU[j++]=0x0C;
+			bufferU[j++]=i&0xFF;
+			bufferU[j++]=0x68;
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x6C;
+			bufferU[j++]=0x00;
+			if(j>DIMBUF-8||i>=dim2-2){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==AT_HV_RTX){
+						memEE[k++]=bufferI[z+1];
+						z+=1;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],i*100/(dim+dim2),i);	//"Read: %d%%, addr. %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+//****************** exit program mode ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PORT_DIR; //All input
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	PrintMessage(strings[S_CodeMem]);	//"\r\nProgram memory\r\n"
+	DisplayCODEAVR(dim);
+	if(dim2){
+		DisplayEE();	//visualize EE
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void WriteAT(int dim, int dim2, int dummy1, int dummy2)
+// write ATMEL micro
+// dim=FLASH size in bytes, dim2=EEPROM size
+{
+	int k=0,z=0,i,j;
+	int err=0;//,Rtry=0,maxTry=0;
+	double Tbyte;
+	BYTE signature[]={0,0,0};
+	if(dim>0x8000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteAT(0x%X,0x%X)\n",dim,dim2);
+	}
+	if(dim>size) dim=size;
+	if(dim2>sizeEE) dim2=sizeEE;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	Tbyte=SyncSPI();
+	if(Tbyte==0){
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	j=0;
+
+/*	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=20000>>8;
+	bufferU[j++]=20000&0xff;
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=SPI_INIT;
+	bufferU[j++]=1;
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=5;
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=WAIT_T3;		//20ms
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;		//20ms
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(50);
+	readP();
+	if(saveLog)WriteLogIO();
+	for(i=0;i<32;i++){
+		j=0;
+		bufferU[j++]=CLOCK_GEN;
+		bufferU[j++]=0xFF;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=RST;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=CLOCK_GEN;
+		bufferU[j++]=5;
+		bufferU[j++]=WAIT_T3;		//20ms
+		bufferU[j++]=SPI_WRITE;		//Programming enable
+		bufferU[j++]=2;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0x53;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=2;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(25);
+		readP();
+		if(saveLog)WriteLogIO();
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		//PrintMessage("i=%d z=%d   rx:%02X%02X\r\n",i,z,bufferI[z+2],bufferI[z+3]);
+		if(bufferI[z+2]==0x53) i=32;
+	}
+	if(i<33){
+		j=0;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x0;
+		bufferU[j++]=SPI_INIT;
+		bufferU[j++]=0xFF;
+		bufferU[j++]=CLOCK_GEN;
+		bufferU[j++]=0xFF;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(1);
+		readP();
+		if(saveLog)WriteLogIO();
+		PrintMessage(strings[S_SyncErr]);	//"Synchronization error\r\n"
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	j=0;*/
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=2;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+3*4*Tbyte);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[0]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[1]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[2]=bufferI[z+2];
+	PrintMessage3("CHIP ID:%02X%02X%02X\r\n",signature[0],signature[1],signature[2]);
+	AtmelID(signature);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartErase]);
+	j=0;
+	bufferU[j++]=SPI_WRITE;		//Chip erase
+	bufferU[j++]=4;
+	bufferU[j++]=0xAC;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+4*Tbyte);
+	msDelay(25);	//Erase time
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i++){
+		if(memCODE[i]!=0xFF){
+			bufferU[j++]=SPI_WRITE;		//Write program memory
+			bufferU[j++]=4;
+			bufferU[j++]=0x40+(i&1?8:0);
+			bufferU[j++]=i>>9;
+			bufferU[j++]=i>>1;
+			bufferU[j++]=memCODE[i];
+			bufferU[j++]=WAIT_T3;		//6ms
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=SPI_WRITE;		//Read program memory
+			bufferU[j++]=3;
+			bufferU[j++]=0x20+(i&1?8:0);
+			bufferU[j++]=i>>9;
+			bufferU[j++]=i>>1;
+			bufferU[j++]=SPI_READ;
+			bufferU[j++]=1;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			j=0;
+			PacketIO(7+2*4*Tbyte);
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, addr. %03X"
+			for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+			if(z==DIMBUF-2||memCODE[i]!=bufferI[z+2]){
+					err++;
+			}
+			if(max_err&&err>max_err){
+				PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+				PrintMessage(strings[S_IntW]);	//"Write interrupted"
+				i=dim;
+			}
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEAreaW]);
+		PrintStatusSetup();
+		int errEE=0;
+		for(i=0,j=0;i<dim2;i++){
+			if(memEE[i]!=0xFF){
+				bufferU[j++]=SPI_WRITE;		//Write EEPROM memory
+				bufferU[j++]=4;
+				bufferU[j++]=0xC0;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=i;
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=WAIT_T3;		//6ms
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=SPI_WRITE;		//Read EEPROM memory
+				bufferU[j++]=3;
+				bufferU[j++]=0xA0;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=i;
+				bufferU[j++]=SPI_READ;
+				bufferU[j++]=1;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				PacketIO(7+2*4*Tbyte);
+				PrintStatus(strings[S_CodeWriting],i*100/dim2,i);	//"Write: %d%%, addr. %03X"
+				for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+				if(z==DIMBUF-2||memEE[i]!=bufferI[z+2]){
+						errEE++;
+				}
+				if(max_err&&err+errEE>max_err){
+					PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+					PrintMessage(strings[S_IntW]);	//"Write interrupted"
+					i=dim2;
+				}
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, err=%d\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+		err+=errEE;
+	}
+//	if(maxTry) PrintMessage1(strings[S_MaxRetry],maxTry); 	//"Max retries in writing: %d\r\n"
+//****************** write FUSE ********************
+	if(AVRlock<0x100){
+		PrintMessage(strings[S_FuseAreaW]);	//"Write Fuse ... "
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_FuseAreaW]);
+		bufferU[j++]=SPI_WRITE;		//Write lock
+		bufferU[j++]=4;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0xF9+(AVRlock&0x06);
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=WAIT_T3;		//9ms
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(3+4*Tbyte);
+		msDelay(15);
+		PrintMessage(strings[S_Compl]);	//"completed\r\n"
+	}
+//****************** exit program mode ********************
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();
+}
+
+
+void WriteATmega(int dim, int dim2, int page, int options)
+// write ATMEL micro
+// dim=FLASH size in bytes, dim2=EEPROM, page=FLASH page size in bytes
+{
+	int k=0,z=0,i,j;
+	double Tbyte;	//byte delay in ms
+	int err=0,Rtry=0,maxTry=0;
+	BYTE signature[]={0,0,0};
+	if(dim>0x20000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x1000||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteATmega(0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,page,options);
+	}
+	if(dim>size) dim=size;
+	else{
+		size=dim;
+		memCODE=(unsigned char*)realloc(memCODE,dim);
+	}
+	if(size%(page*2)){	//grow to an integer number of pages
+		j=size;
+		dim=(j/(page*2)+1)*page*2;
+		memCODE=(unsigned char*)realloc(memCODE,dim);
+		for(;j<dim;j++) memCODE[j]=0xFF;
+	}
+	if(dim2>sizeEE) dim2=sizeEE;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=VREG_DIS;		//Disable HV reg
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	Tbyte=SyncSPI();
+	if(Tbyte==0){
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	j=0;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=SPI_WRITE;		//Read signature bytes
+	bufferU[j++]=3;
+	bufferU[j++]=0x30;
+	bufferU[j++]=0;
+	bufferU[j++]=2;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1.5+3*4.5*Tbyte);
+	if(saveLog)WriteLogIO();
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[0]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[1]=bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+	signature[2]=bufferI[z+2];
+	PrintMessage3("CHIP ID:%02X%02X%02X\r\n",signature[0],signature[1],signature[2]);
+	AtmelID(signature);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartErase]);
+	j=0;
+	bufferU[j++]=SPI_WRITE;		//Chip erase
+	bufferU[j++]=4;
+	bufferU[j++]=0xAC;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=5000>>8;
+	bufferU[j++]=5000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1+4*Tbyte);
+	msDelay(15);	//erase time 9ms min
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
+	PrintStatusSetup();
+	int w=0,v,c;
+	for(i=0;i<dim;i+=page*2){
+		for(z=i,v=0;z<i+page*2;z++) if(memCODE[z]<0xFF)v=1;
+		if(v){
+			for(k=0,j=0,v=0;k<page;k+=w){
+				w=(page-k)<(DIMBUF-6)/2?(page-k):(DIMBUF-6)/2;
+				bufferU[j++]=AT_LOAD_DATA;
+				bufferU[j++]=w;
+				bufferU[j++]=k>>8;
+				bufferU[j++]=k;
+				for(z=0;z<w*2;z++)	bufferU[j++]=memCODE[i+k*2+z];
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				PacketIO(1.5+w*9*Tbyte);
+			}
+			bufferU[j++]=SPI_WRITE;		//Write program memory page
+			bufferU[j++]=4;
+			bufferU[j++]=0x4C;
+			bufferU[j++]=i>>9;
+			bufferU[j++]=i>>1;
+			bufferU[j++]=0;
+			bufferU[j++]=WAIT_T3;		//5ms
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			j=0;
+			PacketIO(6+4*Tbyte);
+			//msDelay(5);
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, addr. %03X"
+			if(RWstop) i=dim;
+			//write verification
+			c=(DIMBUF-5)/2;
+			for(k=0,j=0;k<page;k+=c){
+				for(Rtry=0;Rtry<5;Rtry++){		//Try to read a few times
+					bufferU[j++]=AT_READ_DATA;
+					bufferU[j++]=k<(page-c)?c:page-k;
+					bufferU[j++]=(i+k*2)>>9;
+					bufferU[j++]=(i+k*2)>>1;
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					PacketIO(1.5+240*Tbyte);
+					if(bufferI[0]==AT_READ_DATA){	//Fixed reference!!
+						for(w=0,z=2;z<bufferI[1]*2+2&&z<DIMBUF;z++){
+							if(memCODE[i+k*2+w]!=bufferI[z]){
+								if(Rtry<4)	z=DIMBUF;
+								else err++;
+							}
+							w++;
+						}
+						if(z<DIMBUF) Rtry=100;
+					}
+					j=0;
+				}
+			}
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,w,w,err);	//"i=%d, k=%d, err=%d\n"
+			}
+			if(max_err&&err>max_err){
+				PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+				PrintMessage(strings[S_IntW]);	//"Write interrupted"
+				i=dim;
+			}
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEAreaW]);
+		PrintStatusSetup();
+		int errEE=0;
+		for(i=0,j=0;i<dim2;i++){
+			if(memEE[i]!=0xFF){
+				bufferU[j++]=SPI_WRITE;		//Write EEPROM memory
+				bufferU[j++]=4;
+				bufferU[j++]=0xC0;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=i;
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=WAIT_T3;		//5ms
+				bufferU[j++]=WAIT_T3;		//5ms
+				bufferU[j++]=SPI_WRITE;		//Read EEPROM memory
+				bufferU[j++]=3;
+				bufferU[j++]=0xA0;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=i;
+				bufferU[j++]=SPI_READ;
+				bufferU[j++]=1;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				PacketIO(11+8.5*Tbyte);
+				PrintStatus(strings[S_CodeWriting],i*100/dim2,i);	//"Write: %d%%, addr. %03X"
+				for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+				if(z==DIMBUF-2||memEE[i]!=bufferI[z+2]){
+					if(Rtry<4){
+						Rtry++;
+						if (Rtry>maxTry) maxTry=Rtry;
+						i--;
+					}
+					else{
+						errEE++;
+						Rtry=0;
+					}
+				}
+				if(max_err&&err+errEE>max_err){
+					PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+					PrintMessage(strings[S_IntW]);	//"Write interrupted"
+					i=dim2;
+				}
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, err=%d\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+		err+=errEE;
+	}
+//****************** write FUSE ********************
+	int err_f=0;
+	if(AVRlock<0x100||AVRfuse<0x100||AVRfuse_h<0x100||AVRfuse_x<0x100){
+		PrintMessage(strings[S_FuseAreaW]);	//"Write Fuse ... "
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_FuseAreaW]);
+	}
+	if(AVRfuse<0x100){
+		bufferU[j++]=SPI_WRITE;		//Write fuse
+		bufferU[j++]=4;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0xA0;
+		bufferU[j++]=0;
+		bufferU[j++]=AVRfuse;
+		bufferU[j++]=WAIT_T3;		//5ms
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x50;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(6+8.5*Tbyte);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		if(z==DIMBUF-2||AVRfuse!=bufferI[z+2]) err_f++;
+	}
+	if(AVRfuse_h<0x100){
+		bufferU[j++]=SPI_WRITE;		//Write fuse_h
+		bufferU[j++]=4;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0;
+		bufferU[j++]=AVRfuse_h;
+		bufferU[j++]=WAIT_T3;		//5ms
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x58;
+		bufferU[j++]=8;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(6+8.5*Tbyte);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		if(z==DIMBUF-2||AVRfuse_h!=bufferI[z+2]) err_f++;
+	}
+	if(AVRfuse_x<0x100){
+		bufferU[j++]=SPI_WRITE;		//Write ext fuse
+		bufferU[j++]=4;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0xA4;
+		bufferU[j++]=0;
+		bufferU[j++]=AVRfuse_x;
+		bufferU[j++]=WAIT_T3;		//5ms
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x50;
+		bufferU[j++]=8;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(6+8.5*Tbyte);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		if(z==DIMBUF-2||AVRfuse_x!=bufferI[z+2]) err_f++;
+	}
+	if(AVRlock<0x100){
+		bufferU[j++]=SPI_WRITE;		//Write lock
+		bufferU[j++]=4;
+		bufferU[j++]=0xAC;
+		bufferU[j++]=0xE0;
+		bufferU[j++]=0;
+		bufferU[j++]=AVRlock;
+		bufferU[j++]=WAIT_T3;		//5ms
+		bufferU[j++]=SPI_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=0x58;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(6+8.5*Tbyte);
+		for(z=0;z<DIMBUF-2&&bufferI[z]!=SPI_READ;z++);
+		if(z==DIMBUF-2||AVRlock!=bufferI[z+2]) err_f++;
+	}
+	err+=err_f;
+	if(AVRlock<0x100||AVRfuse<0x100||AVRfuse_h<0x100||AVRfuse_x<0x100){
+		PrintMessage1(strings[S_ComplErr],err_f);	//"completed, %d errors\r\n"
+	}
+//	if(maxTry) PrintMessage(strings[S_MaxRetry],maxTry); 	//"Max retries in writing: %d\r\n"
+//****************** exit program mode ********************
+	bufferU[j++]=CLOCK_GEN;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=SPI_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();
+}
+
+/// Write ATMEL AVR using HV serial programming
+/// dim=FLASH size in bytes, dim2=EEPROM, page=FLASH page size in words (0 if page write not supported)
+/// options: not used
+void WriteAT_HV(int dim, int dim2, int page, int options)
+{
+	int k=0,z=0,i,j,t,sdo,err=0;
+	BYTE signature[]={0,0,0};
+	if(FWVersion<0x900){
+		PrintMessage1(strings[S_FWver2old],"0.9.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(dim>0x10000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteAT_HV(0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,page,options);
+	}
+	if(dim>size) dim=size;
+	else{
+		size=dim;
+		memCODE=(unsigned char*)realloc(memCODE,dim);
+	}
+	if(page&&(size%(page*2))){	//grow to an integer number of pages
+		j=size;
+		dim=(j/(page*2)+1)*page*2;
+		memCODE=(unsigned char*)realloc(memCODE,dim);
+		for(;j<dim;j++) memCODE[j]=0xFF;
+	}
+	if(dim2>sizeEE) dim2=sizeEE;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	if(!StartHVReg(12)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PORT_DIR;
+	bufferU[j++]=0xFC;
+	bufferU[j++]=0x7;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=SCI;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;	//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PORT_DIR;	//RELEASE SDO
+	bufferU[j++]=0xFE;
+	bufferU[j++]=0x7;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x01;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=AT_HV_RTX;		//Read signature bytes
+	bufferU[j++]=4;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x0C;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x68;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(8);
+	for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[0]=bufferI[z+1];
+	for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[1]=bufferI[z+1];
+	for(z+=2;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+	signature[2]=bufferI[z+1];
+	PrintMessage3("CHIP ID:%02X%02X%02X\r\n",signature[0],signature[1],signature[2]);
+	AtmelID(signature);
+//****************** erase memory ********************
+	if(saveLog)fprintf(logfile,"CHIP ERASE\n");
+	j=0;
+	bufferU[j++]=AT_HV_RTX;	//Chip erase
+	bufferU[j++]=3;
+	bufferU[j++]=0x4C;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x64;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x6C;
+	bufferU[j++]=0x00;
+	bufferU[j++]=READ_B;	//check SDO
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	bufferU[j++]=READ_B;	//check SDO
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	for(t=0,sdo=0;t<20&&sdo==0;t++){
+		PacketIO(2);
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+		sdo=bufferI[z+1]&2;
+	}
+	if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	if(saveLog)fprintf(logfile,"WRITE CODE\n");
+	int currPage=-1;
+	j=0;
+	if(page==0){		//byte write
+		for(i=0,k=0;i<dim;i+=2){
+			if(memCODE[i]!=0xFF||memCODE[i+1]!=0xFF){
+				bufferU[j++]=AT_HV_RTX;
+				bufferU[j++]=6;
+				bufferU[j++]=0x4C;	//Write FLASH
+				bufferU[j++]=0x10;
+				bufferU[j++]=0x1C;
+				bufferU[j++]=i>>9;
+				bufferU[j++]=0x0C;
+				bufferU[j++]=(i/2)&0xFF;
+				bufferU[j++]=0x2C;
+				bufferU[j++]=memCODE[i];
+				bufferU[j++]=0x64;		//write data low
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x6C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				for(t=0,sdo=0;t<20&&sdo==0;t++){
+					PacketIO(2);
+					for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+					sdo=bufferI[z+1]&2;
+				}
+				if(saveLog&&sdo==0) fprintf(logfile,"SDO=0\r\n");
+				bufferU[j++]=AT_HV_RTX;
+				bufferU[j++]=3;
+				bufferU[j++]=0x3C;
+				bufferU[j++]=memCODE[i+1];
+				bufferU[j++]=0x74;		//write data high
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x7C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				for(t=0,sdo=0;t<20&&sdo==0;t++){
+					PacketIO(2);
+					for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+					sdo=bufferI[z+1]&2;
+				}
+				if(saveLog&&sdo==0) fprintf(logfile,"SDO=0\r\n");
+				PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, addr. %03X"
+				//write verification
+				bufferU[j++]=AT_HV_RTX;		//Read FLASH
+				bufferU[j++]=3;
+				bufferU[j++]=0x4C;
+				bufferU[j++]=0x02;
+				bufferU[j++]=0x68;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x6C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=AT_HV_RTX;
+				bufferU[j++]=2;
+				bufferU[j++]=0x78;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x7C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+				k=i;
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==AT_HV_RTX){
+						if(memCODE[k]!=bufferI[z+1]){
+							PrintMessage4(strings[S_CodeVError],k,k,memCODE[k],bufferI[z+1]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err++;
+						}
+						k++;
+						z++;
+					}
+				}
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+				}
+				if(max_err&&err>max_err){
+					PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+					PrintMessage(strings[S_IntW]);	//"Write interrupted"
+					i=dim;
+				}
+			}
+		}
+	}
+	else{		//page write
+		for(i=0;i<dim;i+=page*2){	//page in words
+			for(k=0;k<page;k++){
+				if(memCODE[i+k*2]!=0xFF||memCODE[i+k*2+1]!=0xFF) k=page;
+			}
+			if(k>page){	//only pages with data!=0xFF
+				bufferU[j++]=AT_HV_RTX;
+				bufferU[j++]=1;
+				bufferU[j++]=0x4C;	//Write FLASH
+				bufferU[j++]=0x10;
+				for(k=0;k<page;k++){
+					bufferU[j++]=AT_HV_RTX;
+					bufferU[j++]=5;
+					bufferU[j++]=0x0C;
+					bufferU[j++]=(i/2+k)&0xFF;
+					bufferU[j++]=0x2C;
+					bufferU[j++]=memCODE[i+k*2];	//data low
+					bufferU[j++]=0x3C;
+					bufferU[j++]=memCODE[i+k*2+1];	//data high
+					bufferU[j++]=0x7D;
+					bufferU[j++]=0x00;
+					bufferU[j++]=0x7C;
+					bufferU[j++]=0x00;
+					if(j>DIMBUF-13||k>=page||i>=dim-2){
+						bufferU[j++]=FLUSH;
+						for(;j<DIMBUF;j++) bufferU[j]=0x0;
+						PacketIO(2);
+						j=0;
+						if(saveLog){
+							fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+						}
+					}
+				}
+				if((i>>9)!=currPage){	//change high address if changed
+					bufferU[j++]=AT_HV_RTX;
+					bufferU[j++]=1;
+					bufferU[j++]=0x1C;
+					bufferU[j++]=i>>9;
+					currPage=i>>9;
+				}
+				bufferU[j++]=AT_HV_RTX;	//write page
+				bufferU[j++]=2;
+				bufferU[j++]=0x64;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x6C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				for(t=0,sdo=0;t<20&&sdo==0;t++){
+					PacketIO(2);
+					for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+					sdo=bufferI[z+1]&2;
+				}
+				if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+				PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, addr. %03X"
+				j=0;
+				//write verification
+				int m=0;
+				for(k=0;k<page;k++){
+					if(k==0){
+						bufferU[j++]=AT_HV_RTX;		//Read FLASH
+						bufferU[j++]=4;
+						bufferU[j++]=0x4C;
+						bufferU[j++]=0x02;
+					}
+					else{
+						bufferU[j++]=AT_HV_RTX;
+						bufferU[j++]=3;
+					}
+					bufferU[j++]=0x0C;
+					bufferU[j++]=(i/2+k)&0xFF;
+					bufferU[j++]=0x68;
+					bufferU[j++]=0x00;
+					bufferU[j++]=0x6C;
+					bufferU[j++]=0x00;
+					bufferU[j++]=AT_HV_RTX;
+					bufferU[j++]=2;
+					bufferU[j++]=0x78;
+					bufferU[j++]=0x00;
+					bufferU[j++]=0x7C;
+					bufferU[j++]=0x00;
+					if(j>DIMBUF-14||k>=page||i>=dim-2){
+						bufferU[j++]=FLUSH;
+						for(;j<DIMBUF;j++) bufferU[j]=0x0;
+						PacketIO(2);
+						j=0;
+						for(z=0;z<DIMBUF-1;z++){
+							if(bufferI[z]==AT_HV_RTX){
+								if(memCODE[i+m]!=bufferI[z+1]){
+									PrintMessage4(strings[S_CodeVError],i+m,i+m,memCODE[i+m],bufferI[z+1]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+									err++;
+								}
+								m++;
+								z++;
+							}
+						}
+						if(saveLog){
+							fprintf(logfile,strings[S_Log8],i,i,m,m,err);	//"i=%d, k=%d, err=%d\n"
+						}
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+						}
+					}
+				}
+			}
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		int errEE=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)fprintf(logfile,"WRITE EEPROM\n");
+		j=0;
+		for(i=0;i<dim2;i++){
+			if(memEE[i]!=0xFF){
+				bufferU[j++]=AT_HV_RTX;		//Write EEPROM
+				bufferU[j++]=7;
+				bufferU[j++]=0x4C;
+				bufferU[j++]=0x11;
+				bufferU[j++]=0x0C;
+				bufferU[j++]=i&0xFF;
+				bufferU[j++]=0x1C;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=0x2C;
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=0x6D;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x64;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x6C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				PacketIO(2);
+				PrintStatus(strings[S_CodeWriting],i*100/dim2,i);	//"Write: %d%%, addr. %03X"
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+				bufferU[j++]=READ_B;	//check SDO
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				j=0;
+				for(t=0,sdo=0;t<20&&sdo==0;t++){
+					PacketIO(2);
+					for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+					sdo=bufferI[z+1]&2;
+				}
+				if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+				//write verification
+				bufferU[j++]=AT_HV_RTX;		//Read EEPROM
+				bufferU[j++]=5;
+				bufferU[j++]=0x4C;
+				bufferU[j++]=0x03;
+				bufferU[j++]=0x1C;
+				bufferU[j++]=i>>8;
+				bufferU[j++]=0x0C;
+				bufferU[j++]=i&0xFF;
+				bufferU[j++]=0x68;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x6C;
+				bufferU[j++]=0x00;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+				if(memEE[i]!=bufferI[z+1]){
+					PrintMessage4(strings[S_CodeVError],i,i,memEE[i],bufferI[z+1]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+					errEE++;
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d\n"
+				}
+				if(err+errEE>=max_err) break;
+			}
+		}
+		PrintStatusEnd();
+		err+=errEE;
+		if(err>=max_err){
+			PrintMessage("\r\n");
+			PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+		}
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed: %d errors\r\n"
+	}
+//****************** write FUSE ********************
+	int err_f=0;
+	if(AVRlock<0x100||AVRfuse<0x100||AVRfuse_h<0x100||AVRfuse_x<0x100)PrintMessage(strings[S_FuseAreaW]);	//"Write Fuse ... "
+	if(AVRfuse<0x100){
+		if(saveLog)fprintf(logfile,"WRITE FUSE\n");
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=4;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x40;
+		bufferU[j++]=0x2C;
+		bufferU[j++]=AVRfuse;
+		bufferU[j++]=0x64;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(2);
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+		sdo=bufferI[z+1]&2;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(i=0;i<20&&sdo==0;i++){
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+			sdo=bufferI[z+1]&2;
+		}
+		if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+		j=0;
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x68;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		if(z==DIMBUF-1||AVRfuse!=bufferI[z+1]){
+			PrintMessage3(strings[S_WErr1],"fuse",AVRfuse,bufferI[z+1]);	//"Error writing %s: written %02X, read %02X"
+			err_f++;
+		}
+	}
+	if(AVRfuse_h<0x100){
+		if(saveLog)fprintf(logfile,"WRITE FUSEH\n");
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=4;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x40;
+		bufferU[j++]=0x2C;
+		bufferU[j++]=AVRfuse_h;
+		bufferU[j++]=0x74;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(2);
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+		sdo=bufferI[z+1]&2;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(i=0;i<20&&sdo==0;i++){
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+			sdo=bufferI[z+1]&2;
+		}
+		if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+		j=0;
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x7A;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7E;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		if(z==DIMBUF-1||AVRfuse_h!=bufferI[z+1]){
+			PrintMessage3(strings[S_WErr1],"fuseH",AVRfuse_h,bufferI[z+1]);	//"Error writing %s: written %02X, read %02X"
+			err_f++;
+		}
+	}
+	if(AVRfuse_x<0x100){
+		if(saveLog)fprintf(logfile,"WRITE FUSEX\n");
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=4;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x40;
+		bufferU[j++]=0x2C;
+		bufferU[j++]=AVRfuse_x;
+		bufferU[j++]=0x66;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6E;
+		bufferU[j++]=0x00;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(2);
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+		sdo=bufferI[z+1]&2;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(i=0;i<20&&sdo==0;i++){
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+			sdo=bufferI[z+1]&2;
+		}
+		if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+		j=0;
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x6A;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6E;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		if(z==DIMBUF-1||AVRfuse_x!=bufferI[z+1]){
+			PrintMessage3(strings[S_WErr1],"fuseX",AVRfuse_x,bufferI[z+1]);	//"Error writing %s: written %02X, read %02X"
+			err_f++;
+		}
+	}
+	if(AVRlock<0x100){
+		if(saveLog)fprintf(logfile,"WRITE LOCK\n");
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=4;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x20;
+		bufferU[j++]=0x2C;
+		bufferU[j++]=AVRlock;
+		bufferU[j++]=0x64;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x6C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(2);
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+		sdo=bufferI[z+1]&2;
+		bufferU[j++]=READ_B;	//check SDO
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(i=0;i<20&&sdo==0;i++){
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=READ_B;z++);
+			sdo=bufferI[z+1]&2;
+		}
+		if(sdo==0&&saveLog) fprintf(logfile,"SDO=0\r\n");
+		j=0;
+		bufferU[j++]=AT_HV_RTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0x4C;
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(z=0;z<DIMBUF-1&&bufferI[z]!=AT_HV_RTX;z++);
+		if(z==DIMBUF-1||AVRlock!=bufferI[z+1]){
+			PrintMessage3(strings[S_WErr1],"lock",AVRlock,bufferI[z+1]);	//"Error writing %s: written %02X, read %02X"
+			err_f++;
+		}
+	}
+	err+=err_f;
+	if(AVRlock<0x100||AVRfuse<0x100||AVRfuse_h<0x100||AVRfuse_x<0x100){
+		PrintMessage1(strings[S_ComplErr],err_f);	//"completed, %d errors\r\n"
+	}
+//****************** exit program mode ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=SET_PORT_DIR; //All input
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();
+}
diff --git a/progAVR.h b/progAVR.h
new file mode 100644
index 0000000..df793c5
--- /dev/null
+++ b/progAVR.h
@@ -0,0 +1,8 @@
+void ReadAT(int dim, int dim2, int options);
+void ReadAT_HV(int dim, int dim2, int options);
+void WriteAT(int dim, int dim2, int dummy1, int dummy2);
+void WriteATmega(int dim, int dim2, int page, int options);
+void WriteAT_HV(int dim, int dim2, int page, int options);
+void DisplayCODEAVR(int dim);
+void WriteATfuseSlow(int fuse);
+#define  SLOW	256
diff --git a/progEEPROM.c b/progEEPROM.c
new file mode 100644
index 0000000..f0e8259
--- /dev/null
+++ b/progEEPROM.c
@@ -0,0 +1,2311 @@
+/**
+ * \file progEEPROM.c
+ * algorithms to program various EEPROM types
+ * Copyright (C) 2009-2022 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+#include "common.h"
+
+void ReadI2C(int dim,int addr)
+// read I2C memories
+// dim=size in bytes
+// addr:
+//      [3:0]  =0: 1 byte address        =1: 2 byte address
+//      [7:4]  A2:A0 value
+//      [11:8] 17th address bit location (added to control byte)
+{
+	int k=0,z=0,i,j;
+	int AX=(addr>>4)&7;
+	int addr17=(addr>>8)&0xF;
+	addr&=1;
+	if(dim>0x30000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"ReadI2C(%d,%d)    (0x%X,0x%X)\n",dim,addr,dim,addr);
+	}
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	hvreg=0;
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=I2C_INIT;
+	bufferU[j++]=AX;			//100k
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+//****************** read ********************
+	PrintMessage(strings[S_ReadEE]);		//read EEPROM ...
+	PrintStatusSetup();
+	int inc;
+	for(i=0,j=0;i<dim;i+=inc){
+		if(i<0x10000&&i>0x10000-(DIMBUF-4)) inc=0x10000-i;	//do not cross 64KB boundary
+		else inc=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		if(!addr){									//1 byte address
+			bufferU[j++]=I2C_READ;
+			bufferU[j++]=inc;
+			bufferU[j++]=0xA0+((i>>7)&0x0E);
+			bufferU[j++]=i&0xFF;
+		}
+		else{										//2 byte address
+			bufferU[j++]=I2C_READ2;
+			bufferU[j++]=inc;
+			bufferU[j++]=0xA0+(i>0xFFFF?addr17:0); //17th bit if>64K
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=i&0xFF;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(8);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=I2C_READ&&bufferI[j]!=I2C_READ2;j++);
+		if(j<DIMBUF-1&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++) memEE[k++]=bufferI[z];
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/(dim),i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void WriteI2C(int dim,int addr,int page)
+// write I2C memories
+// dim=size in bytes
+// addr:
+//      [3:0]  =0: 1 byte address        =1: 2 byte address
+//      [7:4]  A2:A0 value
+//      [11:8] 17th address bit location (added to control byte)
+// page=page size
+{
+	int k=0,z=0,i,j;
+	int err=0;
+	int AX=(addr>>4)&7;
+	int addr17=(addr>>8)&0xF;
+	addr&=1;
+	hvreg=0;
+	if(dim>0x30000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteI2C(%d,%d,%d)    (0x%X,0x%X)\n",dim,addr,page,dim,addr);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=I2C_INIT;
+	bufferU[j++]=AX;			//100k
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	PrintStatusSetup();
+	for(;page>=DIMBUF-6;page>>=1);
+	for(i=0,j=0;i<dim;i+=page){
+		bufferU[j++]=I2C_WRITE;
+		if(!addr){									//1 byte address
+			bufferU[j++]=page;
+			bufferU[j++]=0xA0+((i>>7)&0x0E);
+			bufferU[j++]=i&0xFF;
+		}
+		else{										//2 byte address
+			bufferU[j++]=page+1;
+			bufferU[j++]=0xA0+(i>0xFFFF?addr17:0); //17th bit if>64K
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=i&0xFF;
+		}
+		for(k=0;k<page;k++) bufferU[j++]=memEE[i+k];
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=I2C_WRITE;j++);
+		if(bufferI[j]!=I2C_WRITE||bufferI[j+1]>=0xFA) i=dim+10;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		bufferU[j++]=I2C_WRITE;
+		bufferU[j++]=0;
+		bufferU[j++]=0xA0; 	//ACK polling
+		bufferU[j++]=0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		int ack=0xFD;
+		for(j=0;ack==0xFD&&j<20;j++){	//ACK polling until write complete
+			PacketIO(2);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=I2C_WRITE;j++);
+			if(bufferI[j]!=I2C_WRITE||bufferI[j+1]>=0xFA) ack=0xFD;
+			else ack=bufferI[j+1];
+		}
+		j=0;
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	k=0;
+	int inc;
+	for(i=0,j=0;i<dim;i+=inc){
+		if(i<0x10000&&i>0x10000-(DIMBUF-4)) inc=0x10000-i;	//do not cross 64KB boundary
+		else inc=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		if(!addr){									//1 byte address
+			bufferU[j++]=I2C_READ;
+			bufferU[j++]=inc;
+			bufferU[j++]=0xA0+((i>>7)&0x0E);
+			bufferU[j++]=i&0xFF;
+		}
+		else{										//2 byte address
+			bufferU[j++]=I2C_READ2;
+			bufferU[j++]=inc;
+			bufferU[j++]=0xA0+(i>0xFFFF?addr17:0); //17th bit if>64K
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=i&0xFF;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(8);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=I2C_READ&&bufferI[j]!=I2C_READ2;j++);
+		if((bufferI[j]==I2C_READ||bufferI[j]==I2C_READ2)&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<(j+2+bufferI[j+1])&&z<DIMBUF;z++){
+				if(memEE[k++]!=bufferI[z]){
+					PrintMessage("\r\n");
+					PrintMessage4(strings[S_CodeVError],i+z-3,i+z-3,memEE[k-1],bufferI[z]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim),i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+#define PRE 0x08	//RB3
+#define S 0x10		//RB4
+#define W 0x20		//RB5
+#define ORG 0x20	//RB5
+
+void Read93x(int dim,int na,int options)
+// read 93Sx6 uW memories
+// dim=size in bytes
+// na=address bits
+// options=0: x16 organization     =1: x8 organization
+{
+	int k=0,z=0,i,j,x8;
+	hvreg=0;
+	if(dim>0x3000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(na>13) na=13;
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read93x(%d,%d,%d)    (0x%X,0x%X)\n",dim,na,options,dim,na);
+	}
+	x8=options&1;
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=uW_INIT;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=x8?S:S+ORG;
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+//****************** read ********************
+	PrintMessage(strings[S_ReadEE]);		//read EEPROM ...
+	PrintStatusSetup();
+	int dim2=x8?dim:dim/2;
+	for(i=0;i<dim2;){
+		for(j=0;j<DIMBUF-14&&i<dim2;){
+			bufferU[j++]=uWTX;
+			bufferU[j++]=na+3;				//READ
+			bufferU[j++]=0xC0+((i>>(na-5))&0x1F);				//110aaaaa aaax0000
+			bufferU[j++]=(i<<(13-na))&0xFF;
+			bufferU[j++]=uWRX;
+			bufferU[j++]=x8?8:16;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=x8?0:ORG;
+			bufferU[j++]=0;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=x8?S:S+ORG;
+			bufferU[j++]=0;
+			i++;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		for(z=0;z<DIMBUF-3;z++){
+			for(;bufferI[z]!=uWRX&&z<DIMBUF-3;z++);
+			if(bufferI[z]==uWRX){
+				if(x8) memEE[k++]=bufferI[z+2];
+				else{
+					memEE[k+1]=bufferI[z+2];
+					memEE[k]=bufferI[z+3];
+					k+=2;
+				}
+				z+=3;
+			}
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/dim2,i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** exit ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Write93Sx(int dim,int na,int page)
+// write 93Sx6 uW memories
+// dim=size in bytes
+// na=address bits
+// page=page size (bytes)
+// automatic write delay
+{
+	int k=0,z=0,i,j;
+	int err=0;
+	hvreg=0;
+	if(dim>0x1000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(na>13) na=13;
+	if(page>48) page=48;
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write93Sx(%d,%d,%d)    (0x%X,0x%X)\n",dim,na,page,dim,na);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=uW_INIT;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S+W;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0x98;				//100 11xxx write enable
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=W;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S+W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0x98;				//100 11xxx Prot. reg. enable
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S+W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0xFF;				//111 11111111 Prot. reg. clear
+	bufferU[j++]=0xF0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S+W;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0x98;				//100 11xxx write enable
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=W;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S+W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0xC0;				//110 xxxxx Prot. reg. read
+	bufferU[j++]=0;
+	bufferU[j++]=uWRX;
+	bufferU[j++]=10;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=W+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	PrintStatusSetup();
+	int addr=0;
+	for(i=0,j=0;i<dim;i+=page,addr+=(0x10000>>na)*page/2){
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=W;				//make sure to start with S=0
+		bufferU[j++]=0;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=S+W;
+		bufferU[j++]=0;
+		bufferU[j++]=uWTX;
+		bufferU[j++]=3;
+		bufferU[j++]=0xE0;			//111aaaaa aaa(a) D page write
+		bufferU[j++]=uWTX;
+		bufferU[j++]=na;
+		bufferU[j++]=addr>>8;
+		if(na>8) bufferU[j++]=addr&0xFF;
+		bufferU[j++]=uWTX;
+		bufferU[j++]=8*page;
+		for(k=0;k<page;k+=2){
+			bufferU[j++]=memEE[i+k+1];
+			bufferU[j++]=memEE[i+k];
+		}
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=W;
+		bufferU[j++]=0;
+		bufferU[j++]=EXT_PORT;
+		bufferU[j++]=S+W;		//S=1 to check status
+		bufferU[j++]=0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=uWTX;j++);
+		if(bufferI[j]!=uWTX||bufferI[j+1]>=0xFA) i=dim+10;
+		bufferU[j++]=uWRX;
+		bufferU[j++]=1;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(z=0,k=0;z<30&&!k;z++){		//Wait until ready
+			PacketIO(2);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=uWRX;j++);
+			if(bufferI[j]==uWRX) k=bufferI[j+2];
+		}
+		j=0;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	j=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=S;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;				//READ (16bit)
+	bufferU[j++]=0xC0;				//110aaaaa aaax0000
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	k=0;
+	int n=(DIMBUF-2);
+	if(n>30) n=30;	//max 240 bit = 30 Byte
+	for(i=0,j=0;i<dim;i+=n){
+		bufferU[j++]=uWRX;
+		bufferU[j++]=i<(dim-n)?n*8:(dim-i)*8;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		for(j=0;bufferI[j]!=uWRX&&j<DIMBUF-1;j++);
+		if(bufferI[j]==uWRX){
+			for(z=j+2;z<j+2+bufferI[j+1]/8&&z<DIMBUF;z+=2,k+=2){
+				if(memEE[k+1]!=bufferI[z]){
+					PrintMessage("\r\n");
+					PrintMessage4(strings[S_CodeVError],i+z-3,i+z-3,memEE[k+1],bufferI[z]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+				if(memEE[k]!=bufferI[z+1]){
+					PrintMessage("\r\n");
+					PrintMessage4(strings[S_CodeVError],i+z-3,i+z-3,memEE[k],bufferI[z+1]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim),i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Write93Cx(int dim,int na, int options)
+// write 93Cx6 uW memories
+// dim=size in bytes
+// na=address bits
+// options=0: x16 organization     =1: x8 organization
+{
+	int k=0,z=0,i,j;
+	int err=0;
+	hvreg=0;
+	if(dim>0x1000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(na>13) na=13;
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write93Cx(%d,%d,%d)    (0x%X,0x%X)\n",dim,na,options,dim,na);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=uW_INIT;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0x98;				//100 11xxx EWEN
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?ORG+PRE:PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWTX;
+	bufferU[j++]=na+3;
+	bufferU[j++]=0x90;				//100 10xxx ERAL
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?ORG+PRE:PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=uWRX;
+	bufferU[j++]=1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	bufferU[j++]=uWRX;
+	bufferU[j++]=1;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	for(i=0,k=0;i<30&&!k;i++){		//Wait until ready
+		PacketIO(2);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=uWRX;j++);
+		if(bufferI[j]==uWRX) k=bufferI[j+2];
+	}
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	PrintStatusSetup();
+	int addr=0;
+	j=0;
+	for(i=0;i<dim;i+=options==0?2:1,addr+=0x10000>>na){
+		if(memEE[i]<0xFF||(options==0&&memEE[i+1]<0xFF)){
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?ORG+PRE:PRE;
+			bufferU[j++]=0;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+			bufferU[j++]=0;
+			bufferU[j++]=uWTX;
+			bufferU[j++]=3;
+			bufferU[j++]=0xA0;			//101aaaaa aaa(a) write
+			bufferU[j++]=uWTX;
+			bufferU[j++]=na;
+			bufferU[j++]=addr>>8;
+			if(na>8) bufferU[j++]=addr&0xFF;
+			bufferU[j++]=uWTX;
+			if(options==0){		//x16
+				bufferU[j++]=16;
+				bufferU[j++]=memEE[i+1];
+				bufferU[j++]=memEE[i];
+			}
+			else{				//x8
+				bufferU[j++]=8;
+				bufferU[j++]=memEE[i];
+			}
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?ORG+PRE:PRE;
+			bufferU[j++]=0;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+			bufferU[j++]=0;
+			bufferU[j++]=uWRX;
+			bufferU[j++]=1;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+			if(RWstop) i=dim;
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+			bufferU[j++]=uWRX;
+			bufferU[j++]=1;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			for(z=0,k=0;z<30&&!k;z++){		//Wait until ready
+				PacketIO(2);
+				for(j=0;j<DIMBUF-1&&bufferI[j]!=uWRX;j++);
+				if(bufferI[j]==uWRX) k=bufferI[j+2];
+			}
+			j=0;
+		}
+	}
+	msDelay(2);
+	PrintStatusEnd();
+	if(i!=dim){
+		PrintMessage2(strings[S_CodeWError4],i,dim);	//"Error writing code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	j=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?ORG+PRE:PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=options==0?S+ORG+PRE:S+PRE;
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	k=0;
+	int dim2=options==0?dim/2:dim;
+	for(i=0;i<dim2;){
+		for(j=0;j<DIMBUF-14&&i<dim2;){
+			bufferU[j++]=uWTX;
+			bufferU[j++]=na+3;				//READ
+			bufferU[j++]=0xC0+((i>>(na-5))&0x1F);				//110aaaaa aaax0000
+			bufferU[j++]=(i<<(13-na))&0xFF;
+			bufferU[j++]=uWRX;
+			bufferU[j++]=options==0?16:8;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?ORG:0;
+			bufferU[j++]=0;
+			bufferU[j++]=EXT_PORT;
+			bufferU[j++]=options==0?S+ORG:S;
+			bufferU[j++]=0;
+			i++;
+		}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+		for(z=0;z<DIMBUF-3;z++){
+			for(;bufferI[z]!=uWRX&&z<DIMBUF-3;z++);
+			if(bufferI[z]==uWRX){
+				if(options==1){		//x8
+					if(memEE[k]!=bufferI[z+2]){
+						PrintMessage("\r\n");
+						PrintMessage4(strings[S_CodeVError],k,k,memEE[k],bufferI[z+2]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+						err++;
+					}
+					k++;
+				}
+				else{				//x16
+					if(memEE[k]!=bufferI[z+3]){
+						PrintMessage("\r\n");
+						PrintMessage4(strings[S_CodeVError],k,k,memEE[k],bufferI[z+3]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+						err++;
+					}
+					if(memEE[k+1]!=bufferI[z+2]){
+						PrintMessage("\r\n");
+						PrintMessage4(strings[S_CodeVError],k+1,k+1,memEE[k+1],bufferI[z+2]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+						err++;
+					}
+					k+=2;
+				}
+				z+=3;
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/dim2,i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+#define CS 8
+#define HLD 16		//Hold
+#define WP 0x40		//Write protect
+
+void Read25xx(int dim)
+// read 25xx SPI memories
+// dim=size in bytes
+{
+	int k=0,z=0,i,j,ID;
+	hvreg=0;
+	if(dim>0x1000000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read25xx(%d)    (0x%X)\n",dim,dim);
+	}
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=SPI_INIT;
+	bufferU[j++]=3;				//0=100k, 1=200k, 2=300k, 3=500k (in reality 200k)
+//	bufferU[j++]=SET_T1T2;
+//	bufferU[j++]=2;			//force T=28us -> 286 kbps
+//	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=0
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+	bufferU[j++]=HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_WRITE;		//READ ID
+	bufferU[j++]=1;
+	bufferU[j++]=0x9F;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=0
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+	bufferU[j++]=HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_WRITE;		//Read
+	if(dim>0x10000){				//24 bit address
+		bufferU[j++]=4;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else if(dim>0x200){				//16 bit address
+		bufferU[j++]=3;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else{						//8 bit address
+		bufferU[j++]=2;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(z=0;z<DIMBUF-4&&bufferI[z]!=SPI_READ;z++);
+	ID=(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	if(ID>0&&ID!=0xFFFFFF) 	PrintMessage1("DEVICE ID=0x%06X\r\n",ID);
+//****************** read ********************
+	PrintMessage(strings[S_ReadEE]);		//read EEPROM ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(4);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=SPI_READ;j++);
+		if(bufferI[j]==SPI_READ&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++) memEE[k++]=bufferI[z];
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/(dim),i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** exit ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+/*void Read25xxFast(int dim)
+// read 25xx SPI memories
+// dim=size in bytes
+{
+	int k=0,z=0,i,j,ID;
+	hvreg=0;
+	if(dim>0x1000000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read25xxF(%d)    (0x%X)\n",dim,dim);
+	}
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=SPI_INIT;
+	bufferU[j++]=3;				//0=100k, 1=200k, 2=300k, 3=500k (in reality 200k)
+//	bufferU[j++]=SET_T1T2;
+//	bufferU[j++]=2;			//force T=28us -> 286 kbps
+//	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=0
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+	bufferU[j++]=HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=SPI_WRITE;		//READ ID
+	bufferU[j++]=1;
+	bufferU[j++]=0x9F;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+	bufferU[j++]=HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_WRITE;		//Read
+	if(dim>0x10000){				//24 bit address
+		bufferU[j++]=4;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else if(dim>0x200){				//16 bit address
+		bufferU[j++]=3;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else{						//8 bit address
+		bufferU[j++]=2;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	for(z=0;z<DIMBUF-4&&bufferI[z]!=SPI_READ;z++);
+	ID=(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	if(ID>0&&ID!=0xFFFFFF) 	PrintMessage1("DEVICE ID=0x%06X\r\n",ID);
+//****************** read ********************
+	PrintMessage(strings[S_ReadEE]);		//read EEPROM ...
+	PrintStatusSetup();
+	#define rSize (DIMBUF-5-2)
+	#define npack 255
+	j=0;
+	bufferU[j++]=0xF6;
+	bufferU[j++]=npack;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=rSize;
+	bufferU[j++]=0xF7;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	for(i=0;i<dim;i+=rSize*npack){
+	#define TIMEOUT 50
+		ULONG Result;
+		__int64 start,stop,freq,timeout;
+		QueryPerformanceCounter((LARGE_INTEGER *)&start);
+		QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
+		//write
+		Result = WriteFile(WriteHandle,bufferU0,DIMBUF+1,&BytesWritten,NULL);
+//		QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+//		timeout=stop+delay*freq/1000.0;
+//		while(stop<timeout) QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+		//read
+	fprintf(logfile,"bufferU=[");
+	for(int i=0;i<DIMBUF;i++){
+		if(i%32==0) fprintf(logfile,"\n");
+		fprintf(logfile,"%02X ",bufferU[i]);
+	}
+	fprintf(logfile,"]\n");
+		for(int r=0;r<npack;r++){
+			Result = ReadFile(ReadHandle,bufferI0,DIMBUF+1,&NumberOfBytesRead,(LPOVERLAPPED) &HIDOverlapped);
+			Result = WaitForSingleObject(hEventObject,TIMEOUT);
+//			if(saveLog&&logfile) WriteLogIO();
+	fprintf(logfile,"bufferI=[");
+		for(int i=0;i<DIMBUF;i++){
+		if(i%32==0) fprintf(logfile,"\n");
+		fprintf(logfile,"%02X ",bufferI[i]);
+	}
+	fprintf(logfile,"]\n");
+			ResetEvent(hEventObject);
+			if(Result!=WAIT_OBJECT_0){
+				PrintMessage(strings[S_comTimeout]);	//"comm timeout\r\n"
+				if(saveLog&&logfile) fprintf(logfile,strings[S_comTimeout]);
+			}
+			QueryPerformanceCounter((LARGE_INTEGER *)&stop);
+			if(saveLog&&logfile) fprintf(logfile,"T=%.2f ms (%+.2f ms)\n",(stop-start)*1000.0/freq,(stop-start)*1000.0/freq);
+			QueryPerformanceCounter((LARGE_INTEGER *)&start);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=SPI_READ;j++);
+			if(bufferI[j]==SPI_READ&&bufferI[j+1]<0xFA){
+				for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF&&k<dim;z++) memEE[k++]=bufferI[z];
+			}
+			PrintStatus(strings[S_CodeReading2],i*100/(dim),i);	//"Read: %d%%, addr. %05X"
+			if(RWstop) i=dim;
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** exit ********************
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+*/ 
+
+void Write25xx(int dim,int options)
+// write SPI memories
+// dim=size in bytes
+// options:
+//        [11:0]=page size
+//        [12]=erase before write
+//        [13]=use status register 2
+// automatic write delay
+{
+	int k=0,z=0,i,j,ID;
+	int err=0;
+	hvreg=0;
+	int page=options&0xFFF;
+	if(dim>0x1000000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write25xx(%d,%d)    (0x%X,0x%X)\n",dim,options,dim,options);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=SPI_INIT;
+	bufferU[j++]=3;				//0=100k, 1=200k, 2=300k, 3=500k
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=0
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+	bufferU[j++]=HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_WRITE;		//READ ID
+	bufferU[j++]=1;
+	bufferU[j++]=0x9F;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=3;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+	bufferU[j++]=HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=SPI_WRITE;		//READ STATUS
+	bufferU[j++]=1;
+	bufferU[j++]=5;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	if(options&0x2000){
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//READ STATUS2
+		bufferU[j++]=1;
+		bufferU[j++]=0x35;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	for(z=0;z<DIMBUF-4&&bufferI[z]!=SPI_READ;z++);
+	ID=(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	if(ID>0&&ID!=0xFFFFFF){
+		PrintMessage1("DEVICE ID=0x%06X\r\n",ID);
+		if(saveLog) fprintf(logfile,"DEVICE ID=0x%06X\n",ID);
+	}
+	msDelay(10);	//wait power-up timer in some devices
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+	bufferU[j++]=HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=SPI_WRITE;		//WRITE ENABLE
+	bufferU[j++]=1;
+	bufferU[j++]=6;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+	bufferU[j++]=HLD;
+	bufferU[j++]=WP;
+	if(options&0x2000){		//status 1+2
+		bufferU[j++]=SPI_WRITE;		//WRITE STATUS
+		bufferU[j++]=3;
+		bufferU[j++]=1;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else{
+		bufferU[j++]=SPI_WRITE;		//WRITE STATUS
+		bufferU[j++]=2;
+		bufferU[j++]=1;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+	bufferU[j++]=HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=SPI_WRITE;		//READ STATUS
+	bufferU[j++]=1;
+	bufferU[j++]=5;
+	bufferU[j++]=SPI_READ;
+	bufferU[j++]=1;
+	bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+	bufferU[j++]=CS+HLD;
+	bufferU[j++]=WP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	if(options&0x1000){		//erase before write
+		PrintMessage(strings[S_StartErase]);	//"Erasing ... "
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);	//"Erasing ... "
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//READ STATUS
+		bufferU[j++]=1;
+		bufferU[j++]=5;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		if(options&0x2000){
+			bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+			bufferU[j++]=HLD;
+			bufferU[j++]=WP;
+			bufferU[j++]=SPI_WRITE;		//READ STATUS2
+			bufferU[j++]=1;
+			bufferU[j++]=0x35;
+			bufferU[j++]=SPI_READ;
+			bufferU[j++]=1;
+			bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+			bufferU[j++]=CS+HLD;
+			bufferU[j++]=WP;
+		}
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//WRITE ENABLE
+		bufferU[j++]=1;
+		bufferU[j++]=6;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//CHIP ERASE
+		bufferU[j++]=1;
+		bufferU[j++]=0xC7;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//READ STATUS
+		bufferU[j++]=1;
+		bufferU[j++]=5;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		int pp;
+		for(pp=1,j=0;pp&&j<400;j++){	//wait for erase completion max 40s
+			PacketIO(2);
+			msDelay(100);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=SPI_READ;z++);
+			pp=bufferI[z+2]&1;	//WIP bit
+			PrintStatus(strings[S_StartErase],0,0);	//"Erasing ... "	Also allows the gui loop to run
+		}
+		if(saveLog) fprintf(logfile,"Erase time %d ms\n",j*100);
+		PrintMessage(strings[S_Compl]);	//"completed"
+		PrintStatus(strings[S_Compl],0,0);	//"completed"
+//		msDelay(100);
+	}
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);	//"Write EEPROM ... "
+	int pp;
+	for(i=0,j=0;i<dim;i+=page){
+		if(options&0x1000){		//if chip erase skip empty pages
+			for(k=page;k==page&&i<dim-page;){
+				for(k=0;k<page;k++){ if(memEE[i+k]<0xFF) k=page;}
+				if(k==page) i+=page;
+			}
+		}
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//WRITE ENABLE
+		bufferU[j++]=1;
+		bufferU[j++]=6;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//WRITE
+		if(dim>0x10000){				//24 bit address
+			bufferU[j++]=4;
+			bufferU[j++]=2;
+			bufferU[j++]=i>>16;
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=i&0xFF;
+		}
+		else if(dim>0x200){				//16 bit address
+			bufferU[j++]=3;
+			bufferU[j++]=2;
+			bufferU[j++]=i>>8;
+			bufferU[j++]=i&0xFF;
+		}
+		else{						//8 bit address
+			bufferU[j++]=2;
+			bufferU[j++]=2+(i&0x100?8:0);
+			bufferU[j++]=i&0xFF;
+		}
+		pp=page<DIMBUF-j-4?page:DIMBUF-j-4;
+		for(k=0;k<page;){
+			bufferU[j++]=SPI_WRITE;
+			bufferU[j++]=pp;
+			for(;k<page&&pp;k++,pp--) bufferU[j++]=memEE[i+k];
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=SPI_WRITE;z++);
+			if(bufferI[z+1]>=0xFA) k=i=dim+10;
+			pp=(page-k)<DIMBUF-4?page-k:DIMBUF-4;
+			j=0;
+		}
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//READ STATUS
+		bufferU[j++]=1;
+		bufferU[j++]=5;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=1
+		bufferU[j++]=HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=SPI_WRITE;		//READ STATUS
+		bufferU[j++]=1;
+		bufferU[j++]=5;
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+		bufferU[j++]=CS+HLD;
+		bufferU[j++]=WP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		for(pp=1,j=0;pp&&j<50;j++){	//wait for write completion
+			PacketIO(2);
+			for(z=0;z<DIMBUF-1&&bufferI[z]!=SPI_READ;z++);
+			pp=bufferI[z+2]&1;	//WIP bit
+		}
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	j=0;
+	bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+	bufferU[j++]=HLD;
+	bufferU[j++]=0;
+	bufferU[j++]=SPI_WRITE;		//Read
+	if(dim>0x10000){				//24 bit address
+		bufferU[j++]=4;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else if(dim>0x200){				//16 bit address
+		bufferU[j++]=3;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+		bufferU[j++]=0;
+	}
+	else{						//8 bit address
+		bufferU[j++]=2;
+		bufferU[j++]=3;
+		bufferU[j++]=0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	int i0,k2,valid;
+	k=0;
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		if(options&0x1000){		//skip empty space if erase before write
+			i0=i;
+			for(valid=0;!valid&&i<dim;i+=valid?0:DIMBUF-4){		//skip verification if 0xFF
+				for(k2=0;k2<DIMBUF-4&&!valid&&i+k2<dim;k2++) if(memEE[i+k2]<0xFF) valid=1;
+			}
+			if(i>=dim) break;
+			if(i>i0){				//some data was skipped; update current address
+				j=0;
+				bufferU[j++]=EXT_PORT;	//CS=1, HLD=1, WP=1
+				bufferU[j++]=CS+HLD;
+				bufferU[j++]=WP;
+				bufferU[j++]=EXT_PORT;	//CS=0, HLD=1, WP=0
+				bufferU[j++]=HLD;
+				bufferU[j++]=0;
+				bufferU[j++]=SPI_WRITE;		//Read
+				if(dim>0x10000){				//24 bit address
+					bufferU[j++]=4;
+					bufferU[j++]=3;
+					bufferU[j++]=i>>16;
+					bufferU[j++]=(i>>8)&0xFF;
+					bufferU[j++]=i&0xFF;
+				}
+				else if(dim>0x200){				//16 bit address
+					bufferU[j++]=3;
+					bufferU[j++]=3;
+					bufferU[j++]=i>>8;
+					bufferU[j++]=i&0xFF;
+				}
+				else{						//8 bit address
+					bufferU[j++]=2;
+					bufferU[j++]=3+(i&0x100?8:0);
+					bufferU[j++]=i&0xFF;
+				}
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+			}
+		}
+		bufferU[j++]=SPI_READ;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(4);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=SPI_READ;j++);
+		if(bufferI[j]==SPI_READ&&bufferI[j+1]<0xFA){
+			for(z=0;z<bufferI[j+1]&&z<DIMBUF;z++){
+				if(memEE[i+z]!=bufferI[z+j+2]){
+					PrintMessage4(strings[S_CodeVError],i+z,i+z,memEE[i+z],bufferI[z+3]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim),i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(i<dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,i);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+struct ID_OW{
+	int id;
+	char *device;
+} OW_LIST[]={
+	{0x10,"DS1820\r\n"},
+	{0x14,"DS2430\r\n"},
+	{0x23,"DS2433\r\n"},
+	{0x28,"DS18B20\r\n"},
+	{0x2D,"DS2431\r\n"},
+	{0x43,"DS28EC20\r\n"},
+};
+
+void OW_ID(int id)
+{
+	char s[64];
+	int i;
+	for(i=0;i<sizeof(OW_LIST)/sizeof(OW_LIST[0]);i++){
+		if(id==OW_LIST[i].id){
+			sprintf(s,OW_LIST[i].device,id);
+			PrintMessage(s);
+			return;
+		}
+	}
+	sprintf(s,"%s",strings[S_nodev]); //"Unknown device\r\n");
+	PrintMessage(s);
+}
+
+#define READ_ROM 0x33
+#define MATCH_ROM 0x55
+#define SKIP_ROM 0xCC
+#define SEARCH_ROM 0xF0
+#define WRITE_SCRATCHPAD 0x0F
+#define READ_SCRATCHPAD 0xAA
+#define COPY_SCRATCHPAD 0x55
+#define READ_MEMORY 0xF0
+#define WRITE_APP_REGISTER 0x99
+#define READ_STAT_REGISTER 0x66
+#define READ_APP_REGISTER 0xC3
+#define COPY_LOCK_APP_REGISTER 0x5A
+
+void ReadOneWireMem(int dim,int options)
+// read OneWire memories
+// dim=size in bytes
+// options:
+//          1=status register + application register
+//          2=protection bytes + ID after memory area
+{
+	int k=0,z=0,i,j;
+	hvreg=0;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(dim>0x10000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"ReadOneWireMem(%d)    (0x%X)\n",dim,dim);
+	}
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=uW_INIT;	//set RB1=0 to use as GND terminal beside RB0
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=READ_ROM;
+	bufferU[j++]=OW_READ;
+	bufferU[j++]=8;
+	if(dim<=32){	//1 byte address
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=2;
+		bufferU[j++]=READ_MEMORY;
+		bufferU[j++]=0;	//address
+	}
+	else{			//2 byte address
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=READ_MEMORY;
+		bufferU[j++]=0;	//address
+		bufferU[j++]=0;	//address
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(12);
+	j=0;
+	for(z=0;bufferI[z]!=OW_RESET&&z<DIMBUF;z++);
+	if(bufferI[z]==OW_RESET&&bufferI[z+1]==0){	//no presence pulse
+		PrintMessage(strings[S_ComErr]);		//communication error
+		bufferU[j++]=EN_VPP_VCC;		//turn off
+		bufferU[j++]=0x0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		return;
+	}
+	for(;bufferI[z]!=OW_READ&&z<DIMBUF;z++);
+	if(bufferI[z]==OW_READ&&z<DIMBUF-9){
+		PrintMessage1("Family code: 0x%02X ",bufferI[z+2]);
+		OW_ID(bufferI[z+2]);
+		PrintMessage3("Serial ID: 0x%02X%02X%02X",bufferI[z+3],bufferI[z+4],bufferI[z+5]);
+		PrintMessage3("%02X%02X%02X",bufferI[z+6],bufferI[z+7],bufferI[z+8]);
+		PrintMessage1("\r\nCRC: 0x%02X\r\n",bufferI[z+9]);
+	}
+//****************** read ********************
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		bufferU[j++]=OW_READ;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(37);
+		for(j=0;bufferI[j]!=OW_READ&&j<DIMBUF;j++);
+		if(bufferI[j]==OW_READ&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++) memEE[k++]=bufferI[z];
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/(dim),i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+		}
+	}
+	if(options==1){		//read status register + application register
+		bufferU[j++]=OW_RESET;
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=SKIP_ROM;
+		bufferU[j++]=READ_STAT_REGISTER;
+		bufferU[j++]=0;
+		bufferU[j++]=OW_READ;
+		bufferU[j++]=1;
+		bufferU[j++]=OW_RESET;
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=SKIP_ROM;
+		bufferU[j++]=READ_APP_REGISTER;
+		bufferU[j++]=0;
+		bufferU[j++]=OW_READ;
+		bufferU[j++]=8;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(15);
+		j=0;
+		for(z=0;bufferI[z]!=OW_READ&&z<DIMBUF-2;z++);
+		if(z<DIMBUF-2) PrintMessage1("Status register: 0x%02X\r\n",bufferI[z+2]);
+		for(z+=2;bufferI[z]!=OW_READ&&z<DIMBUF-10;z++);
+		PrintMessage("Application register: 0x");
+		for(i=z+2;i<z+10&&i<DIMBUF;i++) PrintMessage1("%02X",bufferI[i]);
+		PrintMessage("\r\n");
+	}
+	else if(options==2){		//read protection & ID bytes
+		bufferU[j++]=OW_READ;
+		if(dim==0xA00) bufferU[j++]=0x24;
+		else bufferU[j++]=8;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(25);
+		j=0;
+		for(z=0;bufferI[z]!=OW_READ&&z<DIMBUF-2;z++);
+		if(bufferI[z]==OW_READ&&bufferI[z+1]<0xFA){
+			if(dim==0xA00){
+				for(i=0;i<10;i++) PrintMessage2("Protection Control Byte Block %d: 0x%02X\r\n",i,bufferI[z+2+i]);
+				PrintMessage("User EEPROM:\r\n");
+				for(i=0;i<10;i++) PrintMessage1("%02X",bufferI[z+2+i+10]);
+				PrintMessage("\r\n");
+				for(i=0;i<10;i++) PrintMessage1("%02X",bufferI[z+2+i+20]);
+				PrintMessage1("\r\nMemory Block Lock: 0x%02X\r\n",bufferI[z+2+30]);
+				PrintMessage1("Register Page Lock: 0x%02X\r\n",bufferI[z+2+31]);
+				PrintMessage1("Factory Byte: 0x%02X\r\n",bufferI[z+2+32]);
+				PrintMessage2("Factory Trim Bytes: 0x%02X%02X\r\n",bufferI[z+2+33],bufferI[z+2+34]);
+				PrintMessage2("Manufacturer ID: 0x%02X%02X\r\n",bufferI[z+2+35],bufferI[z+2+36]);
+			}
+			else{
+				PrintMessage1("Protection Control Byte Page 0: 0x%02X\r\n",bufferI[z+2]);
+				PrintMessage1("Protection Control Byte Page 1: 0x%02X\r\n",bufferI[z+2+1]);
+				PrintMessage1("Protection Control Byte Page 2: 0x%02X\r\n",bufferI[z+2+2]);
+				PrintMessage1("Protection Control Byte Page 3: 0x%02X\r\n",bufferI[z+2+3]);
+				PrintMessage1("Copy Protection Byte: 0x%02X\r\n",bufferI[z+2+4]);
+				PrintMessage1("Factory Byte: 0x%02X\r\n",bufferI[z+2+5]);
+				PrintMessage2("User Bytes/Manufacturer ID: 0x%02X%02X\r\n",bufferI[z+2+6],bufferI[z+2+7]);
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//turn off
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void WriteOneWireMem(int dim,int options)
+// write OneWire memories
+// dim=size in bytes
+// options:
+//          0 = 8 byte scratchpad
+//          1 = 32 byte scratchpad
+{
+	int k=0,z=0,i,j;
+	int err=0;
+	hvreg=0;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(dim>0x10000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"WriteOneWireMem(%d,%d)    (0x%X,0x%X)\n",dim,options,dim,options);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=uW_INIT;	//set RB1=0 to use as GND terminal beside RB0
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=READ_ROM;
+	bufferU[j++]=OW_READ;
+	bufferU[j++]=8;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(12);
+	j=0;
+	for(z=0;bufferI[z]!=OW_RESET&&z<DIMBUF;z++);
+	if(bufferI[z]==OW_RESET&&bufferI[z+1]==0){	//no presence pulse
+		PrintMessage(strings[S_ComErr]);		//communication error
+		bufferU[j++]=EN_VPP_VCC;		//turn off
+		bufferU[j++]=0x0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	for(z=0;bufferI[z]!=OW_READ&&z<DIMBUF;z++);
+	if(bufferI[z]==OW_READ){
+		PrintMessage1("Family code: 0x%02X ",bufferI[z+2]);
+		OW_ID(bufferI[z+2]);
+		PrintMessage3("Serial ID: 0x%02X%02X%02X",bufferI[z+3],bufferI[z+4],bufferI[z+5]);
+		PrintMessage3("%02X%02X%02X",bufferI[z+6],bufferI[z+7],bufferI[z+8]);
+		PrintMessage1("\r\nCRC: 0x%02X\r\n",bufferI[z+9]);
+	}
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	int page=options==0?8:32;
+	for(i=0,j=0;i<dim;i+=page){
+		bufferU[j++]=OW_RESET;
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=page+(dim<=32?3:4);
+		bufferU[j++]=SKIP_ROM;
+		bufferU[j++]=WRITE_SCRATCHPAD;
+		bufferU[j++]=i&0xFF;
+		if(dim>32) bufferU[j++]=i>>8;
+		for(k=0;k<page;k++) bufferU[j++]=memEE[i+k];
+		bufferU[j++]=OW_RESET;
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=dim<=32?3:5;
+		bufferU[j++]=SKIP_ROM;
+		bufferU[j++]=COPY_SCRATCHPAD;
+		if(dim<=32) bufferU[j++]=0xA5;
+		else{
+			bufferU[j++]=i&0xFF;
+			bufferU[j++]=i>>8;
+			bufferU[j++]=page-1;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(6+0.8*page);
+		msDelay(10); //TPROG
+		j=0;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	k=0;
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=SKIP_ROM;
+	if(dim<=32){	//1 byte address
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=2;
+		bufferU[j++]=READ_MEMORY;
+		bufferU[j++]=0;	//address
+	}
+	else{			//2 byte address
+		bufferU[j++]=OW_WRITE;
+		bufferU[j++]=3;
+		bufferU[j++]=READ_MEMORY;
+		bufferU[j++]=0;	//address
+		bufferU[j++]=0;	//address
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(10);
+	j=0;
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		bufferU[j++]=OW_READ;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(37);
+		for(j=0;bufferI[j]!=OW_READ&&j<DIMBUF;j++);
+		if(bufferI[j]==OW_READ&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++){
+				if(memEE[k++]!=bufferI[z]){
+					PrintMessage("\r\n");
+					PrintMessage4(strings[S_CodeVError],i+z-(j+2),i+z-(j+2),memEE[k-1],bufferI[z]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim),i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//turn off
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+#define READ_SCRATCHPAD2 0xBE
+#define CONVERT_TEMP 0x44
+#define RECALL_EE 0xB8
+#define READ_PWSUP 0xB4
+
+void ReadDS1820()
+// read DS1820 one-wire digital thermometer
+{
+	int z=0,j;
+	double TLSB=0.5;
+	hvreg=0;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"ReadDS1820()\n");
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=uW_INIT;	//set RB1=0 to use as GND terminal beside RB0
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=1;
+	bufferU[j++]=READ_ROM;
+	bufferU[j++]=OW_READ;
+	bufferU[j++]=8;
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=2;
+	bufferU[j++]=SKIP_ROM;
+	bufferU[j++]=CONVERT_TEMP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(16);
+	j=0;
+	for(z=0;bufferI[z]!=OW_RESET&&z<DIMBUF;z++);
+	if(bufferI[z]==OW_RESET&&bufferI[z+1]==0){	//no presence pulse
+		PrintMessage(strings[S_ComErr]);		//communication error
+		bufferU[j++]=EN_VPP_VCC;		//turn off
+		bufferU[j++]=0x0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		if(saveLog) CloseLogFile();
+		return;
+	}
+	for(z=0;bufferI[z]!=OW_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-9){
+		PrintMessage1("Family code: 0x%02X ",bufferI[z+2]);
+		OW_ID(bufferI[z+2]);
+		if(bufferI[z+2]==0x10) TLSB=0.5;			//DS1820
+		else if(bufferI[z+2]==0x28) TLSB=0.0625;	//DS18B20
+		PrintMessage3("Serial ID: 0x%02X%02X%02X",bufferI[z+3],bufferI[z+4],bufferI[z+5]);
+		PrintMessage3("%02X%02X%02X",bufferI[z+6],bufferI[z+7],bufferI[z+8]);
+		PrintMessage1("\r\nCRC: 0x%02X\r\n",bufferI[z+9]);
+	}
+//****************** read ********************
+	msDelay(800);
+	bufferU[j++]=OW_RESET;
+	bufferU[j++]=OW_WRITE;
+	bufferU[j++]=2;
+	bufferU[j++]=SKIP_ROM;
+	bufferU[j++]=READ_SCRATCHPAD2;
+	bufferU[j++]=OW_READ;
+	bufferU[j++]=8;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(10);
+	j=0;
+	for(z=0;bufferI[z]!=OW_READ&&z<DIMBUF-2;z++);
+	//PrintMessage("0x");
+	//for(i=z+2;i<z+10&&i<DIMBUF;i++) PrintMessage1("%02X",bufferI[i]);
+	//PrintMessage("\r\n");
+	int T=bufferI[z+2]+(bufferI[z+3]<<8);
+	if(T>0xF000) T|=0xFFFF0000; //adjust negative value
+#ifdef _MSC_VER
+	PrintMessage2("T=%.4f°C  (0x%04X)\r\n",T*TLSB,T);
+#else
+	PrintMessage2("T=%.4f°C  (0x%04X)\r\n",T*TLSB,T);
+#endif
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//turn off
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+
+#define UNIO_READ 0x03
+#define UNIO_CRRD 0x06
+#define UNIO_WRITE 0x6C
+#define UNIO_WREN 0x96
+#define UNIO_WRDI 0x91
+#define UNIO_RDSR 0x05
+#define UNIO_WRSR 0x6E
+#define UNIO_ERAL 0x6D
+#define UNIO_SETAL 0x67
+
+void Read11xx(int dim)
+// read 11xx UNIO memories
+// dim=size in bytes
+{
+	int k=0,z=0,i,j;
+	hvreg=0;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(dim>=0x10000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read11xx(%d)    (0x%X)\n",dim,dim);
+	}
+	sizeEE=dim;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(dim);			//EEPROM
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=2;		//write x bytes
+	bufferU[j++]=1;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_RDSR;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+//****************** read ********************
+	PrintMessage(strings[S_ReadEE]);		//read EEPROM ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i+=DIMBUF-5){
+		bufferU[j++]=UNIO_COM;
+		bufferU[j++]=4;		//write x bytes
+		bufferU[j++]=i<dim-(DIMBUF-5)?DIMBUF-5:dim-i;		//read x bytes
+		bufferU[j++]=0xA0;
+		bufferU[j++]=UNIO_READ;
+		bufferU[j++]=i>>8;
+		bufferU[j++]=i&0xFF;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(14);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=UNIO_COM;j++);
+		if(bufferI[j]==UNIO_COM&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++) memEE[k++]=bufferI[z];
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/(dim),i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X) \n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		sizeEE=k;
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	DisplayEE();	//visualize
+	int sum=0;
+	for(i=0;i<sizeEE;i++) sum+=memEE[i];
+	PrintMessage1("Checksum: 0x%X\r\n",sum&0xFFFF);
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Write11xx(int dim,int page)
+// write 11xx UNIO memories
+// dim=size in bytes
+// page=page size
+{
+	int k=0,z=0,i,j;
+	int err=0;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	hvreg=0;
+	if(dim>=0x10000||dim<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write11xx(%d,%d)    (0x%X,0x%X)\n",dim,page,dim,page);
+	}
+	if(dim>sizeEE){
+		i=sizeEE;
+		memEE=(unsigned char*)realloc(memEE,dim);
+		for(;i<dim;i++) memEE[i]=0xFF;
+		sizeEE=dim;
+	}
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Data area is empty\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=VREG_DIS;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=UNIO_STBY;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=2;		//write x bytes
+	bufferU[j++]=0;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_WREN;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=2;		//write x bytes
+	bufferU[j++]=1;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_RDSR;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=3;		//write x bytes
+	bufferU[j++]=0;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_WRSR;
+	bufferU[j++]=0;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=2;		//write x bytes
+	bufferU[j++]=1;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_RDSR;
+	bufferU[j++]=UNIO_COM;
+	bufferU[j++]=2;		//write x bytes
+	bufferU[j++]=0;		//read x bytes
+	bufferU[j++]=0xA0;
+	bufferU[j++]=UNIO_WREN;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(25);
+//****************** write ********************
+	PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+	PrintStatusSetup();
+	for(;page>=DIMBUF-8;page>>=1);
+	for(i=0,j=0;i<dim;i+=page){
+		bufferU[j++]=UNIO_COM;
+		bufferU[j++]=4+page;	//write x bytes
+		bufferU[j++]=0;			//read x bytes
+		bufferU[j++]=0xA0;
+		bufferU[j++]=UNIO_WRITE;
+		bufferU[j++]=i>>8;
+		bufferU[j++]=i&0xFF;
+		for(k=0;k<page;k++) bufferU[j++]=memEE[i+k];
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO((5+page)*0.2+2);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=UNIO_COM;j++);
+		if(bufferI[j]!=UNIO_COM||bufferI[j+1]>=0xFA) i=dim+10;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim),i);	//"Write: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		bufferU[j++]=UNIO_COM;
+		bufferU[j++]=2;		//write x bytes
+		bufferU[j++]=1;		//read x bytes
+		bufferU[j++]=0xA0;
+		bufferU[j++]=UNIO_RDSR;
+		bufferU[j++]=UNIO_COM;
+		bufferU[j++]=2;		//write x bytes
+		bufferU[j++]=0;		//read x bytes
+		bufferU[j++]=0xA0;
+		bufferU[j++]=UNIO_WREN;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		int status=1;
+		for(k=0;status&&k<20;k++){	//status polling until write complete
+			PacketIO(2);
+			for(j=0;j<DIMBUF-1&&bufferI[j]!=UNIO_COM;j++);
+			if(bufferI[j]==UNIO_COM) status=bufferI[j+2]&1;
+		}
+		j=0;
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify EEPROM ********************
+	PrintMessage(strings[S_EEV]);	//"Verify EEPROM ... "
+	PrintStatusSetup();
+	k=0;
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		bufferU[j++]=UNIO_COM;
+		bufferU[j++]=4;		//write x bytes
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;		//read x bytes
+		bufferU[j++]=0xA0;
+		bufferU[j++]=UNIO_READ;
+		bufferU[j++]=i>>8;
+		bufferU[j++]=i&0xFF;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(14);
+		for(j=0;j<DIMBUF-1&&bufferI[j]!=UNIO_COM;j++);
+		if(bufferI[j]==UNIO_COM&&bufferI[j+1]<0xFA){
+			for(z=j+2;z<j+2+bufferI[j+1]&&z<DIMBUF;z++){
+				if(memEE[k++]!=bufferI[z]){
+					PrintMessage("\r\n");
+					PrintMessage4(strings[S_CodeVError],i+z-3,i+z-3,memEE[k-1],bufferI[z]);	//"Error verifying address %04X (%d), written %02X, read %02X\r\n"
+					err++;
+				}
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim),i);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, err=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadEEErr],dim,k);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
diff --git a/progEEPROM.h b/progEEPROM.h
new file mode 100644
index 0000000..bcd50d2
--- /dev/null
+++ b/progEEPROM.h
@@ -0,0 +1,12 @@
+void ReadI2C(int dim,int addr);
+void WriteI2C(int dim,int addr,int page);
+void Read93x(int dim,int na,int options);
+void Write93Sx(int dim,int na,int page);
+void Write93Cx(int dim,int na, int options);
+void Read25xx(int dim);
+void Write25xx(int dim,int options);
+void ReadOneWireMem(int dim,int options);
+void WriteOneWireMem(int dim,int options);
+void ReadDS1820();
+void Read11xx(int dim);
+void Write11xx(int dim,int page);
diff --git a/progP12.c b/progP12.c
new file mode 100644
index 0000000..f86a44a
--- /dev/null
+++ b/progP12.c
@@ -0,0 +1,666 @@
+/**
+ * \file progP12.c - algorithms to program the PIC12 (12 bit word) family of microcontrollers
+ * Copyright (C) 2009-2016 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+#include "common.h"
+
+void Read12F5xx(int dim,int dim2)
+// read 12 bit PIC
+// dim=program size 	dim2=config size
+// vdd before vpp
+// CONFIG @ 0x7FF (upon entering in program mode)
+// OSCCAL in last memory location
+// 4 ID + reserved area beyond code memory
+{
+	int k=0,z=0,i,j;
+	char s[256],t[256];
+	if(dim2<4) dim2=4;
+	sizeW=0x1000;
+	if(memCODE_W) free(memCODE_W);
+	memCODE_W=(WORD*)malloc(sizeof(WORD)*sizeW);
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read12F5xx(%d,%d)\n",dim,dim2);
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=READ_DATA_PROG;	//configuration word
+	bufferU[j++]=INC_ADDR;			// 7FF->000
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(z<DIMBUF-2){
+		memCODE_W[0xfff]=(bufferI[z+1]<<8)+bufferI[z+2];
+		PrintMessage("\r\n");
+		PrintMessage1(strings[S_ConfigWord],memCODE_W[0xfff]);	//"\r\nConfiguration word: 0x%03X\r\n"
+		switch(memCODE_W[0xfff]&0x03){
+			case 0:
+				PrintMessage(strings[S_LPOsc]);	//"LP oscillator\r\n"
+				break;
+			case 1:
+				PrintMessage(strings[S_XTOsc]);	//"XT oscillator\r\n"
+				break;
+			case 2:
+				PrintMessage(strings[S_IntOsc]);	//"Internal osc.\r\n"
+				break;
+			case 3:
+				PrintMessage(strings[S_RCOsc]);	//"RC oscillator\r\n"
+				break;
+		}
+		if(memCODE_W[0xfff]&0x04) PrintMessage(strings[S_WDTON]);	//"WDT ON\r\n"
+		else PrintMessage(strings[S_WDTOFF]);	//"WDT OFF\r\n"
+		if(memCODE_W[0xfff]&0x08) PrintMessage(strings[S_CPOFF]);	//"Code protection OFF\r\n"
+		else PrintMessage(strings[S_CPON]);	//"Code protection ON\r\n"
+		if(memCODE_W[0xfff]&0x10) PrintMessage(strings[S_MCLRON]);	//"Master clear ON\r\n"
+		else PrintMessage(strings[S_MCLROFF]);	//"Master clear OFF\r\n"
+	}
+	else PrintMessage(strings[S_NoConfigW]);	//"Impossible to read config word\r\n"
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//reading code ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim+dim2;i++){
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==dim+dim2-1){		//2 ins -> 4 ans
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==READ_DATA_PROG){
+					memCODE_W[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],i*100/(dim+dim2),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	unsigned int stop=GetTickCount();
+	for(i=k;i<0xfff;i++) memCODE_W[i]=0xfff;
+	if(k!=dim+dim2){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadErr],dim+dim2,k);	//"Error reading, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** visualize ********************
+	for(i=0;i<4;i+=2){
+		PrintMessage4(strings[S_ChipID],i,memCODE_W[dim+i],i+1,memCODE_W[dim+i+1]);	//"ID%d: 0x%03X   ID%d: 0x%03X\r\n"
+	}
+	if(dim2>4){
+		PrintMessage1(strings[S_BKOsccal],memCODE_W[dim+4]);	//"Backup OSCCAL: 0x%03X\r\n"
+	}
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory\r\n"
+	s[0]=0;
+	int valid=0,empty=1;
+	char* aux=(char*)malloc((dim/COL+1)*(16+COL*5));
+	aux[0]=0;
+	for(i=0;i<dim;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<dim;j++){
+			sprintf(t,"%03X ",memCODE_W[j]);
+			strcat(s,t);
+			if(memCODE_W[j]<0xfff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s\r\n",i,s);
+			empty=0;
+			strcat(aux,t);
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+	if(dim2>5){
+		aux=(char*)malloc((dim2/COL+1)*(16+COL*5));
+		aux[0]=0;
+		s[0]=0;
+		PrintMessage(strings[S_ConfigResMem]);	//"\r\nConfig and reserved memory:\r\n"
+		empty=1;
+		for(i=dim;i<dim+dim2;i+=COL){
+			valid=0;
+			for(j=i;j<i+COL&&j<dim+64;j++){
+				sprintf(t,"%03X ",memCODE_W[j]);
+				strcat(s,t);
+				if(memCODE_W[j]<0xfff) valid=1;
+			}
+			if(valid){
+				sprintf(t,"%04X: %s\r\n",i,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write12F5xx(int dim,int OscAddr)
+{
+// write 12 bit PIC
+// dim=program size     max~4300=10CC
+// OscAddr=OSCCAL address (saved at the beginning), -1 not to use it
+// vdd before vpp
+// CONFIG @ 0x7FF upon entering program mode
+// BACKUP OSCCAL @ dim+5 (saved at the beginning)
+// erase: BULK_ERASE_PROG (1001) +10ms
+// write: BEGIN_PROG (1000) + Tprogram 2ms + END_PROG2 (1110);
+	int k=0,z=0,i,j,w;
+	int err=0;
+	WORD osccal=-1,BKosccal=-1;
+	if(OscAddr>dim) OscAddr=dim-1;
+	if(OscAddr==-1) use_BKosccal=use_osccal=0;
+	if(sizeW<0x1000){
+		PrintMessage(strings[S_NoConfigW2]);	//"Can't find CONFIG (0xFFF)\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write12F5xx(%d,%d)\n",dim,OscAddr);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0xFFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	if(OscAddr!=-1){
+		for(i=-1;i<OscAddr-0xff;i+=0xff){
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=0xff;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=OscAddr-i;
+		bufferU[j++]=READ_DATA_PROG;	// OSCCAL
+		if(OscAddr<dim){
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=dim-OscAddr;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x4;				// 400->404
+		bufferU[j++]=READ_DATA_PROG;	// backup OSCCAL
+	}
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	if(OscAddr!=-1){
+		for(z=4;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(z<DIMBUF-2) osccal=(bufferI[z+1]<<8)+bufferI[z+2];
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(z<DIMBUF-2) BKosccal=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(osccal==-1||BKosccal==-1){
+			PrintMessage(strings[S_ErrOsccal]);	//"Error reading OSCCAL and BKOSCCAL"
+			PrintMessage("\r\n");
+			return;
+		}
+		PrintMessage1(strings[S_Osccal],osccal);	//"OSCCAL: 0x%03X\r\n"
+		PrintMessage1(strings[S_BKOsccal],BKosccal);	//"Backup OSCCAL: 0x%03X\r\n"
+ 	}
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;			// enter program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	if(dim>OscAddr+1){				//12F519 (Flash+EEPROM)
+		bufferU[j++]=BULK_ERASE_PROG;	// Bulk erase
+		bufferU[j++]=WAIT_T3;			// delay T3=10ms
+		for(i=-1;i<dim-0xff;i+=0xff){	// 0x43F
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=0xff;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=dim-i-1;
+		bufferU[j++]=BULK_ERASE_PROG;	// Bulk erase EEPROM
+		bufferU[j++]=WAIT_T3;			// delay T3=10ms
+		if(programID){
+			bufferU[j++]=INC_ADDR;
+			bufferU[j++]=BULK_ERASE_PROG;	// Bulk erase
+			bufferU[j++]=WAIT_T3;			// delay T3=10ms
+		}
+	}
+	else{							//12Fxxx
+		if(programID){
+			for(i=-1;i<dim-0xff;i+=0xff){
+				bufferU[j++]=INC_ADDR_N;
+				bufferU[j++]=0xff;
+			}
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=dim-i;
+			bufferU[j++]=BULK_ERASE_PROG;	// Bulk erase
+			bufferU[j++]=WAIT_T3;			// delay T3=10ms
+		}
+		else{
+			bufferU[j++]=BULK_ERASE_PROG;	// Bulk erase
+			bufferU[j++]=WAIT_T3;			// delay T3=10ms
+		}
+	}
+	bufferU[j++]=EN_VPP_VCC;		// exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms before entering program mode
+	bufferU[j++]=EN_VPP_VCC;		// enter program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=INC_ADDR;				// 7FF->000
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;				//T3=2ms
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO((dim>OscAddr+1)?50:30);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	int dim1=dim;
+	if(programID) dim1=dim+5;
+	if(memCODE_W[dim+4]>=0xFFF) memCODE_W[dim+4]=BKosccal;  //reload BKosccal if not present
+	if(use_BKosccal) memCODE_W[OscAddr]=BKosccal;
+	else if(use_osccal) memCODE_W[OscAddr]=osccal;
+	for(i=k=w=0,j=0;i<dim1;i++){
+		if(memCODE_W[i]<0xfff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;
+			bufferU[j++]=WAIT_T3;				//Tprogram 2ms
+			bufferU[j++]=END_PROG2;
+			bufferU[j++]=WAIT_T2;				//Tdischarge
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim1-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, ind. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*3+3);
+			w=0;
+			for(z=0;z<DIMBUF-7;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xfff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+5]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+6]<<8)+bufferI[z+7]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError],k,memCODE_W[k],(bufferI[z+6]<<8)+bufferI[z+7]);	//"Error writing address %3X: written %03X, read %03X"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"write interrupted"
+							i=dim1;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=8;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	err+=i-k;
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write CONFIG ********************
+	PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ... "
+	int err_c=0;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//10 ms tra uscita e rientro prog. mode
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=LOAD_DATA_PROG;	//config word
+	bufferU[j++]=memCODE_W[0xfff]>>8;			//MSB
+	bufferU[j++]=memCODE_W[0xfff]&0xff;			//LSB
+	bufferU[j++]=BEGIN_PROG;
+	bufferU[j++]=WAIT_T3;			//Tprogram 2ms
+	bufferU[j++]=END_PROG2;
+	bufferU[j++]=WAIT_T2;			//Tdischarge
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(20);
+	unsigned int stop=GetTickCount();
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if (~memCODE_W[0xfff]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr],memCODE_W[0xfff],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing CONFIG:\r\nwritten %03X, read %03X\r\n"
+		err_c++;
+	}
+	err+=err_c;
+	if (z>DIMBUF-2){
+		PrintMessage("\r\n");
+		PrintMessage(strings[S_ConfigWErr2]);	//"Error writing CONFIG"
+	}
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+	}
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write12C5xx(int dim,int dummy)
+{
+// write 12 bit PIC with OTP
+// dim=program size     max~4300=10CC
+// vdd before vpp
+// CONFIG @ 0x7FF upon entering program mode
+// write: BEGIN_PROG (1000) + Tprogram 100us + END_PROG2 (1110);
+// 8 pulses + 11N overpulses
+	int k=0,z=0,i,j;
+	int err=0;
+	WORD osccal=-1;
+	int OscAddr=dim-1;
+	if(FWVersion<0x800){
+		PrintMessage1(strings[S_FWver2old],"0.8.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(sizeW<0x1000){
+		PrintMessage(strings[S_NoConfigW2]);	//"Can't find CONFIG (0xFFF)\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write12C5xx(%d)\n",dim);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0xFFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_MN;
+	bufferU[j++]=8;						//M=8 pulses
+	bufferU[j++]=11;					//N=11 overpulses
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	for(i=-1;i<OscAddr-0xff;i+=0xff){
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0xff;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=OscAddr-i;
+	bufferU[j++]=READ_DATA_PROG;	// OSCCAL
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	j=0;
+	for(z=4;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(z<DIMBUF-2) osccal=(bufferI[z+1]<<8)+bufferI[z+2];
+	if(osccal==-1){
+		PrintMessage(strings[S_ErrOsccal]);	//"Error reading OSCCAL and BKOSCCAL"
+		PrintMessage("\r\n");
+		return;
+	}
+	PrintMessage1(strings[S_Osccal],osccal);	//"OSCCAL: 0x%03X\r\n"
+	bufferU[j++]=EN_VPP_VCC;		// enter program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=INC_ADDR;				// 7FF->000
+	bufferU[j++]=READ_ADC;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	int N,Nt=0,Nmin=255,Nmax=0,xN=0;
+	int dim1=dim;
+	if(programID) dim1=dim+5;
+	if(use_osccal) memCODE_W[OscAddr]=osccal;
+	for(i=k=0,j=0;i<dim1;i++){
+		if(memCODE_W[i]<0xfff){
+			bufferU[j++]=PROG_C;				//prog&verify with 8 pulses and 11N overpulses
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=READ_ADC;
+			bufferU[j++]=INC_ADDR;
+		}
+		else{
+			for(;memCODE_W[i]>=0xfff&&j<DIMBUF-1&&i<dim1;i++) bufferU[j++]=INC_ADDR;
+			i--;
+		}
+		PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Write: %d%%, ind. %03X"
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(10+3);			//Tprogram max 100u*96 ~ 10ms
+		j=0;
+		if(bufferI[1]==PROG_C&&bufferI[3]==READ_DATA_PROG){
+			N=bufferI[2];
+				if(N<0xF0){
+					Nt+=N;
+					xN++;
+					if(N<Nmin)Nmin=N;
+					if(N>Nmax)Nmax=N;
+				}
+			if(memCODE_W[k]!=(bufferI[4]<<8)+bufferI[5]){
+					PrintMessage("\r\n");
+				PrintMessage3(strings[S_CodeWError],k,memCODE_W[k],(bufferI[4]<<8)+bufferI[5]);	//"Error writing address %3X: written %03X, read %03X"
+					err++;
+					if(max_err&&err>max_err){
+						PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+						PrintMessage(strings[S_IntW]);	//"write interrupted"
+						i=dim1;
+						z=DIMBUF;
+					}
+				}
+				k++;
+				}
+		else for(z=0;z<DIMBUF;z++){
+			if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xfff) k++;
+		}
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+		}
+	}
+	PrintStatusEnd();
+	err+=i-k;
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+	if(saveLog && xN) fprintf(logfile,"Programming pulses: avg %.1f, min %d, max %d\r\n",(double)Nt/xN,Nmin,Nmax);
+//****************** write CONFIG ********************
+	if(memCODE_W[0xfff]<0xfff){
+	PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ... "
+	int err_c=0;
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//10 ms
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=LOAD_DATA_PROG;	//config word
+	bufferU[j++]=memCODE_W[0xfff]>>8;			//MSB
+	bufferU[j++]=memCODE_W[0xfff]&0xff;			//LSB
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(12);
+	j=0;
+	for(i=0;i<20;i++){		//20 pulses
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T2;			//Tprogram 100us
+		bufferU[j++]=END_PROG2;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	for(i=0;i<5;i++){		//20*5=100 pulses
+		PacketIO(3);
+	}
+	bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		if (~memCODE_W[0xfff]&((bufferI[2]<<8)+bufferI[3])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr],memCODE_W[0xfff],(bufferI[2]<<8)+bufferI[3]);	//"Error writing CONFIG:\r\nwritten %03X, read %03X\r\n"
+			err_c++;
+		}
+		err+=err_c;
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	unsigned int stop=GetTickCount();
+	if(saveLog){
+		fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+	}
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
diff --git a/progP12.h b/progP12.h
new file mode 100644
index 0000000..110c0a3
--- /dev/null
+++ b/progP12.h
@@ -0,0 +1,3 @@
+void Read12F5xx(int dim, int dim2);
+void Write12F5xx(int dim,int OscAddr);
+void Write12C5xx(int dim,int dummy);
\ No newline at end of file
diff --git a/progP16.c b/progP16.c
new file mode 100644
index 0000000..3871494
--- /dev/null
+++ b/progP16.c
@@ -0,0 +1,6546 @@
+/**
+ * \file progP16.c - algorithms to program the PIC16 (14 bit word) family of microcontrollers
+ * Copyright (C) 2009-2022 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+#include "common.h"
+
+struct ID16{
+	int id;
+	char *device;
+	int revmask;
+} PIC16LIST[]={
+	{0x00A>>1,"16F72 rev%d\r\n",0x1F},			//00 0000 101x xxxx
+	{0x046>>1,"12F683 rev%d\r\n",0x1F},			//00 0100 011x xxxx
+	{0x04A>>1,"16F685 rev%d\r\n",0x1F},			//00 0100 101x xxxx
+	{0x04C>>1,"16F818 rev%d\r\n",0x1F},			//00 0100 110x xxxx
+	{0x04E>>1,"16F819 rev%d\r\n",0x1F},			//00 0100 111x xxxx
+	{0x056>>1,"16F84A rev%d\r\n",0x1F}, 		//00 0101 011x xxxx
+	{0x060>>1,"16F73 rev%d\r\n",0x1F},  		//00 0110 000x xxxx
+	{0x062>>1,"16F74 rev%d\r\n",0x1F}, 	 		//00 0110 001x xxxx
+	{0x064>>1,"16F76 rev%d\r\n",0x1F},			//00 0110 010x xxxx
+	{0x066>>1,"16F77 rev%d\r\n",0x1F},			//00 0110 011x xxxx
+	{0x072>>1,"16F87 rev%d\r\n",0x1F},			//00 0111 001x xxxx
+	{0x076>>1,"16F88 rev%d\r\n",0x1F},			//00 0111 011x xxxx
+	{0x07A>>1,"16F627 rev%d\r\n",0x1F},			//00 0111 101x xxxx
+	{0x07C>>1,"16F628 rev%d\r\n",0x1F},			//00 0111 110x xxxx
+	{0x08E>>1,"16F872 rev%d\r\n",0x1F},			//00 1000 111x xxxx
+	{0x092>>1,"16F874 rev%d\r\n",0x1F},			//00 1001 001x xxxx
+	{0x096>>1,"16F873 rev%d\r\n",0x1F},			//00 1001 011x xxxx
+	{0x09A>>1,"16F877 rev%d\r\n",0x1F},			//00 1001 101x xxxx
+	{0x09E>>1,"16F876 rev%d\r\n",0x1F},			//00 1001 111x xxxx
+	{0x0BA>>1,"16F737 rev%d\r\n",0x1F},			//00 1011 101x xxxx
+	{0x0BE>>1,"16F747 rev%d\r\n",0x1F},			//00 1011 111x xxxx
+	{0x0D0>>1,"16F870 rev%d\r\n",0x1F},			//00 1101 000x xxxx
+	{0x0D2>>1,"16F871 rev%d\r\n",0x1F},			//00 1101 001x xxxx
+	{0x0DE>>1,"16F777 rev%d\r\n",0x1F},			//00 1101 111x xxxx
+	{0x0E0>>1,"16F876A rev%d\r\n",0xF},			//00 1110 0000 xxxx
+	{0x0E2>>1,"16F877A rev%d\r\n",0xF},			//00 1110 0010 xxxx
+	{0x0E4>>1,"16F873A rev%d\r\n",0xF},			//00 1110 0100 xxxx
+	{0x0E6>>1,"16F874A rev%d\r\n",0xF},			//00 1110 0110 xxxx
+	{0x0EA>>1,"16F767 rev%d\r\n",0x1F},			//00 1110 101x xxxx
+	{0x0F8>>1,"12F629 rev%d\r\n",0x1F},			//00 1111 100x xxxx
+	{0x0FA>>1,"12F635 rev%d\r\n",0x1F},			//00 1111 101x xxxx
+	{0x0FC>>1,"12F675 rev%d\r\n",0x1F},			//00 1111 110x xxxx
+	{0x104>>1,"16F627A rev%d\r\n",0x1F},		//01 0000 010x xxxx
+	{0x106>>1,"16F628A rev%d\r\n",0x1F},		//01 0000 011x xxxx
+	{0x108>>1,"16F684 rev%d\r\n",0x1F},			//01 0000 100x xxxx
+	{0x110>>1,"16F648A rev%d\r\n",0x1F},		//01 0001 000x xxxx
+	{0x10A>>1,"16F636-639 rev%d\r\n",0x1F},		//01 0000 101x xxxx
+	{0x10C>>1,"16F630 rev%d\r\n",0x1F},			//01 0000 110x xxxx
+	{0x10E>>1,"16F676 rev%d\r\n",0x1F},			//01 0000 111x xxxx
+	{0x114>>1,"16F716 rev%d\r\n",0x1F},			//01 0001 010x xxxx
+	{0x118>>1,"16F688 rev%d\r\n",0x1F},			//01 0001 100x xxxx
+	{0x120>>1,"16F785 rev%d\r\n",0x1F},			//01 0010 000x xxxx
+	{0x122>>1,"16HV785 rev%d\r\n",0x1F},		//01 0010 001x xxxx
+	{0x124>>1,"16F616 rev%d\r\n",0x1F},			//01 0010 010x xxxx
+	{0x126>>1,"16HV616 rev%d\r\n",0x1F},		//01 0010 011x xxxx
+	{0x132>>1,"16F687 rev%d\r\n",0x1F},			//01 0011 001x xxxx
+	{0x134>>1,"16F689 rev%d\r\n",0x1F},			//01 0011 010x xxxx
+	{0x138>>1,"16F917 rev%d\r\n",0xF},			//01 0011 1000 xxxx
+	{0x13A>>1,"16F916 rev%d\r\n",0xF},			//01 0011 1010 xxxx
+	{0x13C>>1,"16F914 rev%d\r\n",0xF},			//01 0011 1100 xxxx
+	{0x13E>>1,"16F913 rev%d\r\n",0xF},			//01 0011 1110 xxxx
+	{0x140>>1,"16F690 rev%d\r\n",0x1F},			//01 0100 000x xxxx
+	{0x142>>1,"16F631 rev%d\r\n",0x1F},			//01 0100 001x xxxx
+	{0x144>>1,"16F677 rev%d\r\n",0x1F},			//01 0100 010x xxxx
+	{0x146>>1,"16F946 rev%d\r\n",0xF},			//01 0100 0110 xxxx
+	{0x148>>1,"16F1847 rev%d\r\n",0x1F},		//01 0100 100x xxxx
+	{0x14A>>1,"16LF1847 rev%d\r\n",0x1F},		//01 0100 101x xxxx
+	{0x150>>1,"12F752 rev%d\r\n",0x1F},			//01 0101 000x xxxx
+	{0x152>>1,"12HV752 rev%d\r\n",0x1F},		//01 0101 001x xxxx
+	{0x158>>1,"16F1526 rev%d\r\n",0x1F},		//01 0101 100x xxxx
+	{0x15A>>1,"16F1527 rev%d\r\n",0x1F},		//01 0101 101x xxxx
+	{0x15C>>1,"16LF1526 rev%d\r\n",0x1F},		//01 0101 110x xxxx
+	{0x15E>>1,"16LF1527 rev%d\r\n",0x1F},		//01 0101 111x xxxx
+	{0x164>>1,"16F1513 rev%d\r\n",0x1F},		//01 0110 010x xxxx
+	{0x168>>1,"16F1516 rev%d\r\n",0x1F},		//01 0110 100x xxxx
+	{0x16A>>1,"16F1517 rev%d\r\n",0x1F},		//01 0110 101x xxxx
+	{0x16C>>1,"16F1518 rev%d\r\n",0x1F},		//01 0110 110x xxxx
+	{0x16E>>1,"16F1519 rev%d\r\n",0x1F},		//01 0110 111x xxxx
+	{0x170>>1,"16F1512 rev%d\r\n",0x1F},		//01 0111 000x xxxx
+	{0x172>>1,"16LF1512 rev%d\r\n",0x1F},		//01 0111 001x xxxx
+	{0x174>>1,"16LF1513 rev%d\r\n",0x1F},		//01 0111 010x xxxx
+	{0x178>>1,"16LF1516 rev%d\r\n",0x1F},		//01 0111 100x xxxx
+	{0x17A>>1,"16LF1517 rev%d\r\n",0x1F},		//01 0111 101x xxxx
+	{0x17C>>1,"16LF1518 rev%d\r\n",0x1F},		//01 0111 110x xxxx
+	{0x17E>>1,"16LF1519 rev%d\r\n",0x1F},		//01 0111 111x xxxx
+	{0x180>>1,"16F727 rev%d\r\n",0x1F},			//01 1000 000x xxxx
+	{0x182>>1,"16F726 rev%d\r\n",0x1F},			//01 1000 001x xxxx
+	{0x184>>1,"16F724 rev%d\r\n",0x1F},			//01 1000 010x xxxx
+	{0x186>>1,"16F723 rev%d\r\n",0x1F},			//01 1000 011x xxxx
+	{0x188>>1,"16F722 rev%d\r\n",0x1F},			//01 1000 100x xxxx
+	{0x190>>1,"16LF727 rev%d\r\n",0x1F},		//01 1001 000x xxxx
+	{0x192>>1,"16LF726 rev%d\r\n",0x1F},		//01 1001 001x xxxx
+	{0x194>>1,"16LF724 rev%d\r\n",0x1F},		//01 1001 010x xxxx
+	{0x196>>1,"16LF723 rev%d\r\n",0x1F},		//01 1001 011x xxxx
+	{0x198>>1,"16LF722 rev%d\r\n",0x1F},		//01 1001 100x xxxx
+	{0x1AC>>1,"16F707 rev%d\r\n",0x1F},			//01 1010 110x xxxx
+	{0x1AE>>1,"16LF707 rev%d\r\n",0x1F},		//01 1010 111x xxxx
+	{0x1B0>>1,"16F723A rev%d\r\n",0x1F},		//01 1011 000x xxxx
+	{0x1B2>>1,"16F722A rev%d\r\n",0x1F},		//01 1011 001x xxxx
+	{0x1B4>>1,"16LF723A rev%d\r\n",0x1F},		//01 1011 010x xxxx
+	{0x1B6>>1,"16LF722A rev%d\r\n",0x1F},		//01 1011 011x xxxx
+	{0x1B8>>1,"12F1840 rev%d\r\n",0x1F},		//01 1011 100x xxxx
+	{0x1BA>>1,"12LF1840 rev%d\r\n",0x1F},		//01 1011 101x xxxx
+	{0x1C0>>1,"16F720 rev%d\r\n",0x1F},			//01 1100 000x xxxx
+	{0x1C2>>1,"16F721 rev%d\r\n",0x1F},			//01 1100 001x xxxx
+	{0x1C4>>1,"16LF720 rev%d\r\n",0x1F},		//01 1100 010x xxxx
+	{0x1C6>>1,"16LF721 rev%d\r\n",0x1F},		//01 1100 011x xxxx
+	{0x200>>1,"16F882 rev%d\r\n",0x1F},			//10 0000 000x xxxx
+	{0x202>>1,"16F883 rev%d\r\n",0x1F},			//10 0000 001x xxxx
+	{0x204>>1,"16F884 rev%d\r\n",0x1F},			//10 0000 010x xxxx
+	{0x206>>1,"16F886 rev%d\r\n",0x1F},			//10 0000 011x xxxx
+	{0x208>>1,"16F887 rev%d\r\n",0x1F},			//10 0000 100x xxxx
+	{0x218>>1,"12F615 rev%d\r\n",0x1F},			//10 0001 100x xxxx
+	{0x21A>>1,"12HV615 rev%d\r\n",0x1F},		//10 0001 101x xxxx
+	{0x224>>1,"12F609 rev%d\r\n",0x1F},			//10 0010 010x xxxx
+	{0x226>>1,"16F610 rev%d\r\n",0x1F},			//10 0010 011x xxxx
+	{0x228>>1,"12HV609 rev%d\r\n",0x1F},		//10 0010 100x xxxx
+	{0x22A>>1,"16HV610 rev%d\r\n",0x1F},		//10 0010 101x xxxx
+	{0x232>>1,"16F1933 rev%d\r\n",0x1F},		//10 0011 001x xxxx
+	{0x234>>1,"16F1934 rev%d\r\n",0x1F},		//10 0011 010x xxxx
+	{0x236>>1,"16F1936 rev%d\r\n",0x1F},		//10 0011 011x xxxx
+	{0x238>>1,"16F1937 rev%d\r\n",0x1F},		//10 0011 100x xxxx
+	{0x23A>>1,"16F1938 rev%d\r\n",0x1F},		//10 0011 101x xxxx
+	{0x23C>>1,"16F1939 rev%d\r\n",0x1F},		//10 0011 110x xxxx
+	{0x242>>1,"16LF1933 rev%d\r\n",0x1F},		//10 0100 001x xxxx
+	{0x244>>1,"16LF1934 rev%d\r\n",0x1F},		//10 0100 010x xxxx
+	{0x246>>1,"16LF1936 rev%d\r\n",0x1F},		//10 0100 011x xxxx
+	{0x248>>1,"16LF1937 rev%d\r\n",0x1F},		//10 0100 100x xxxx
+	{0x24A>>1,"16LF1938 rev%d\r\n",0x1F},		//10 0100 101x xxxx
+	{0x24C>>1,"16LF1939 rev%d\r\n",0x1F},		//10 0100 110x xxxx
+	{0x250>>1,"16F1946 rev%d\r\n",0x1F},		//10 0101 000x xxxx
+	{0x252>>1,"16F1947 rev%d\r\n",0x1F},		//10 0101 001x xxxx
+	{0x258>>1,"16LF1946 rev%d\r\n",0x1F},		//10 0101 100x xxxx
+	{0x25A>>1,"16LF1947 rev%d\r\n",0x1F},		//10 0101 101x xxxx
+	{0x270>>1,"12F1822 rev%d\r\n",0x1F},		//10 0111 000x xxxx
+	{0x272>>1,"16F1823 rev%d\r\n",0x1F},		//10 0111 001x xxxx
+	{0x274>>1,"16F1824 rev%d\r\n",0x1F},		//10 0111 010x xxxx
+	{0x276>>1,"16F1825 rev%d\r\n",0x1F},		//10 0111 011x xxxx
+	{0x278>>1,"16F1826 rev%d\r\n",0x1F},		//10 0111 100x xxxx
+	{0x27A>>1,"16F1827 rev%d\r\n",0x1F},		//10 0111 101x xxxx
+	{0x280>>1,"12LF1822 rev%d\r\n",0x1F},		//10 1000 000x xxxx
+	{0x282>>1,"16LF1823 rev%d\r\n",0x1F},		//10 1000 001x xxxx
+	{0x284>>1,"16LF1824 rev%d\r\n",0x1F},		//10 1000 010x xxxx
+	{0x286>>1,"16LF1825 rev%d\r\n",0x1F},		//10 1000 011x xxxx
+	{0x288>>1,"16LF1826 rev%d\r\n",0x1F},		//10 1000 100x xxxx
+	{0x28A>>1,"16LF1827 rev%d\r\n",0x1F},		//10 1000 101x xxxx
+	{0x298>>1,"10F322 rev%d\r\n",0x1F},			//10 1001 100x xxxx
+	{0x29A>>1,"10F320 rev%d\r\n",0x1F},			//10 1001 101x xxxx
+	{0x29C>>1,"10LF322 rev%d\r\n",0x1F},		//10 1001 110x xxxx
+	{0x29E>>1,"10LF320 rev%d\r\n",0x1F},		//10 1001 111x xxxx
+	{0x2A0>>1,"16F1782 rev%d\r\n",0x1F},		//10 1010 000x xxxx
+	{0x2A2>>1,"16F1783 rev%d\r\n",0x1F},		//10 1010 001x xxxx
+	{0x2A4>>1,"16F1784 rev%d\r\n",0x1F},		//10 1010 010x xxxx
+	{0x2A6>>1,"16F1786 rev%d\r\n",0x1F},		//10 1010 011x xxxx
+	{0x2A8>>1,"16F1787 rev%d\r\n",0x1F},		//10 1010 100x xxxx
+	{0x2AA>>1,"16LF1782 rev%d\r\n",0x1F},		//10 1010 101x xxxx
+	{0x2AC>>1,"16LF1783 rev%d\r\n",0x1F},		//10 1010 110x xxxx
+	{0x2AE>>1,"16LF1784 rev%d\r\n",0x1F},		//10 1010 111x xxxx
+	{0x2B0>>1,"16LF1786 rev%d\r\n",0x1F},		//10 1011 000x xxxx
+	{0x2B2>>1,"16LF1787 rev%d\r\n",0x1F},		//10 1011 001x xxxx
+	{0x2C0>>1,"16LF1903 rev%d\r\n",0x1F},		//10 1100 000x xxxx
+	{0x2C2>>1,"16LF1902 rev%d\r\n",0x1F},		//10 1100 001x xxxx
+	{0x2C4>>1,"16LF1907 rev%d\r\n",0x1F},		//10 1100 010x xxxx
+	{0x2C6>>1,"16LF1906 rev%d\r\n",0x1F},		//10 1100 011x xxxx
+	{0x2C8>>1,"16LF1904 rev%d\r\n",0x1F},		//10 1100 100x xxxx
+	{0x2CC>>1,"12F1501 rev%d\r\n",0x1F},		//10 1100 110x xxxx
+	{0x2CE>>1,"16F1503 rev%d\r\n",0x1F},		//10 1100 111x xxxx
+	{0x2D0>>1,"16F1507 rev%d\r\n",0x1F},		//10 1101 000x xxxx
+	{0x2D2>>1,"16F1508 rev%d\r\n",0x1F},		//10 1101 001x xxxx
+	{0x2D4>>1,"16F1509 rev%d\r\n",0x1F},		//10 1101 010x xxxx
+	{0x2D8>>1,"12LF1501 rev%d\r\n",0x1F},		//10 1101 100x xxxx
+	{0x2DA>>1,"16LF1503 rev%d\r\n",0x1F},		//10 1101 101x xxxx
+	{0x2DC>>1,"16LF1507 rev%d\r\n",0x1F},		//10 1101 110x xxxx
+	{0x2DE>>1,"16LF1508 rev%d\r\n",0x1F},		//10 1101 111x xxxx
+	{0x2E0>>1,"16LF1509 rev%d\r\n",0x1F},		//10 1110 000x xxxx
+	{0x2F0>>1,"16LF1554 rev%d\r\n",0x1F},		//10 1111 000x xxxx
+	{0x2F2>>1,"16LF1559 rev%d\r\n",0x1F},		//10 1111 001x xxxx
+// New devices with DevID & DevRev in different locations:
+	{0x3000,"16F1574\r\n",0},
+	{0x3001,"16F1575\r\n",0},
+	{0x3002,"16F1578\r\n",0},
+	{0x3003,"16F1579\r\n",0},
+	{0x3004,"16LF1574\r\n",0},
+	{0x3005,"16LF1575\r\n",0},
+	{0x3006,"16LF1578\r\n",0},
+	{0x3007,"16LF1579\r\n",0},
+	{0x3020,"16F1454\r\n",0},
+	{0x3021,"16F1455\r\n",0},
+	{0x3023,"16F1459\r\n",0},
+	{0x3024,"16LF1454\r\n",0},
+	{0x3025,"16LF1455\r\n",0},
+	{0x3027,"16LF1459\r\n",0},
+	{0x302A,"16F1789\r\n",0},
+	{0x302B,"16F1788\r\n",0},
+	{0x302C,"16LF1789\r\n",0},
+	{0x302D,"16LF1788\r\n",0},
+	{0x3030,"16F753\r\n",0},
+	{0x3031,"16HV753\r\n",0},
+	{0x303A,"16F18324\r\n",0},
+	{0x303B,"16F18344\r\n",0},
+	{0x303C,"16LF18324\r\n",0},
+	{0x303D,"16LF18344\r\n",0},
+	{0x303E,"16F18325\r\n",0},
+	{0x303F,"16F18345\r\n",0},
+	{0x3040,"16LF18325\r\n",0},
+	{0x3041,"16LF18345\r\n",0},
+	{0x3042,"16F1708\r\n",0},
+	{0x3043,"16F1704\r\n",0},
+	{0x3044,"16LF1708\r\n",0},
+	{0x3045,"16LF1704\r\n",0},
+	{0x3048,"16F1716\r\n",0},
+	{0x3049,"16F1713\r\n",0},
+	{0x304A,"16LF1716\r\n",0},
+	{0x304B,"16LF1713\r\n",0},
+	{0x304C,"16F1613\r\n",0},
+	{0x304D,"16LF1613\r\n",0},
+	{0x3050,"12F1572\r\n",0},
+	{0x3051,"12F1571\r\n",0},
+	{0x3052,"12LF1572\r\n",0},
+	{0x3053,"12LF1571\r\n",0},
+	{0x3054,"16F1709\r\n",0},
+	{0x3055,"16F1705\r\n",0},
+	{0x3056,"16LF1709\r\n",0},
+	{0x3057,"16LF1705\r\n",0},
+	{0x3058,"12F1612\r\n",0},
+	{0x3059,"12LF1612\r\n",0},
+	{0x305A,"16F1719\r\n",0},
+	{0x305B,"16F1718\r\n",0},
+	{0x305C,"16F1717\r\n",0},
+	{0x305D,"16LF1719\r\n",0},
+	{0x305E,"16LF1718\r\n",0},
+	{0x305F,"16LF1717\r\n",0},
+	{0x3060,"16F1707\r\n",0},
+	{0x3061,"16F1703\r\n",0},
+	{0x3062,"16LF1707\r\n",0},
+	{0x3063,"16LF1703\r\n",0},
+	{0x3066,"16F18313\r\n",0},
+	{0x3067,"16F18323\r\n",0},
+	{0x3068,"16LF18313\r\n",0},
+	{0x3069,"16LF18323\r\n",0},
+	{0x306A,"16F18854\r\n",0},
+	{0x306B,"16LF18854\r\n",0},
+	{0x306C,"16F18855\r\n",0},
+	{0x306D,"16F18875\r\n",0},
+	{0x306E,"16LF18855\r\n",0},
+	{0x306F,"16LF18875\r\n",0},
+	{0x3070,"16F18856\r\n",0},
+	{0x3071,"16F18876\r\n",0},
+	{0x3072,"16LF18856\r\n",0},
+	{0x3073,"16LF18876\r\n",0},
+	{0x3074,"16F18857\r\n",0},
+	{0x3075,"16F18877\r\n",0},
+	{0x3076,"16LF18857\r\n",0},
+	{0x3077,"16LF18877\r\n",0},
+	{0x3078,"16F1614\r\n",0},
+	{0x3079,"16F1618\r\n",0},
+	{0x307A,"16LF1614\r\n",0},
+	{0x307B,"16LF1618\r\n",0},
+	{0x307C,"16F1615\r\n",0},
+	{0x307D,"16F1619\r\n",0},
+	{0x307E,"16LF1615\r\n",0},
+	{0x307F,"16LF1619\r\n",0},
+	{0x3080,"16F1764\r\n",0},
+	{0x3081,"16F1765\r\n",0},
+	{0x3082,"16LF1764\r\n",0},
+	{0x3083,"16LF1765\r\n",0},
+	{0x3084,"16F1768\r\n",0},
+	{0x3085,"16F1769\r\n",0},
+	{0x3086,"16LF1768\r\n",0},
+	{0x3087,"16LF1769\r\n",0},
+	{0x308A,"16F1773\r\n",0},
+	{0x308B,"16F1776\r\n",0},
+	{0x308C,"16LF1773\r\n",0},
+	{0x308D,"16LF1776\r\n",0},
+	{0x308E,"16F1777\r\n",0},
+	{0x308F,"16F1778\r\n",0},
+	{0x3090,"16F1779\r\n",0},
+	{0x3091,"16LF1777\r\n",0},
+	{0x3092,"16LF1778\r\n",0},
+	{0x3093,"16LF1779\r\n",0},
+	{0x3096,"16F19155\r\n",0},
+	{0x3097,"16LF19155\r\n",0},
+	{0x3098,"16F19156\r\n",0},
+	{0x3099,"16LF19156\r\n",0},
+	{0x309A,"16F19175\r\n",0},
+	{0x309B,"16LF19175\r\n",0},
+	{0x309C,"16F19176\r\n",0},
+	{0x309D,"16LF19176\r\n",0},
+	{0x309E,"16F19195\r\n",0},
+	{0x309F,"16LF19195\r\n",0},
+	{0x30A0,"16F19196\r\n",0},
+	{0x30A1,"16LF19196\r\n",0},
+	{0x30A2,"16F19197\r\n",0},
+	{0x30A3,"16LF19197\r\n",0},
+	{0x30A4,"16F18326\r\n",0},
+	{0x30A5,"16F18346\r\n",0},
+	{0x30A6,"16LF18326\r\n",0},
+	{0x30A7,"16LF18346\r\n",0},
+	{0x30AC,"16F15354\r\n",0},
+	{0x30AD,"16LF15354\r\n",0},
+	{0x30AE,"16F15355\r\n",0},
+	{0x30AF,"16LF15355\r\n",0},
+	{0x30B0,"16F15356\r\n",0},
+	{0x30B1,"16LF15356\r\n",0},
+	{0x30B2,"16F15375\r\n",0},
+	{0x30B3,"16LF15375\r\n",0},
+	{0x30B4,"16F15376\r\n",0},
+	{0x30B5,"16LF15376\r\n",0},
+	{0x30B6,"16F15385\r\n",0},
+	{0x30B7,"16LF15385\r\n",0},
+	{0x30B8,"16F15386\r\n",0},
+	{0x30B9,"16LF15386\r\n",0},
+	{0x30BE,"16F15313\r\n",0},
+	{0x30BF,"16LF15313\r\n",0},
+	{0x30BA,"16F19185\r\n",0},
+	{0x30BB,"16LF19185\r\n",0},
+	{0x30BC,"16F19186\r\n",0},
+	{0x30BD,"16LF19186\r\n",0},
+	{0x30C0,"16F15323\r\n",0},
+	{0x30C1,"16LF15323\r\n",0},
+	{0x30C2,"16F15324\r\n",0},
+	{0x30C3,"16LF15324\r\n",0},
+	{0x30C4,"16F15344\r\n",0},
+	{0x30C5,"16LF15344\r\n",0},
+	{0x30C6,"16F15325\r\n",0},
+	{0x30C7,"16LF15325\r\n",0},
+	{0x30C8,"16F15345\r\n",0},
+	{0x30C9,"16LF15345\r\n",0},
+	{0x30CA,"16F18424\r\n",0},
+	{0x30CB,"16LF18424\r\n",0},
+	{0x30CC,"16F18425\r\n",0},
+	{0x30CD,"16LF18425\r\n",0},
+	{0x30CE,"16F18444\r\n",0},
+	{0x30CF,"16LF18444\r\n",0},
+	{0x30D0,"16F18445\r\n",0},
+	{0x30D1,"16LF18445\r\n",0},
+	{0x30D2,"16F18426\r\n",0},
+	{0x30D3,"16LF18426\r\n",0},
+	{0x30D4,"16F18446\r\n",0},
+	{0x30D5,"16LF18446\r\n",0},
+	{0x30D7,"16F18455\r\n",0},
+	{0x30D8,"16LF18455\r\n",0},
+	{0x30D9,"16F18456\r\n",0},
+	{0x30DA,"16LF18456\r\n",0},
+	{0x30DB,"16F17114\r\n",0},
+	{0x30DC,"16F17124\r\n",0},
+	{0x30DD,"16F17144\r\n",0},
+	{0x30DE,"16F17125\r\n",0},
+	{0x30DF,"16F17145\r\n",0},
+	{0x30E0,"16F17126\r\n",0},
+	{0x30E1,"16F17146\r\n",0},
+	{0x30E2,"16F17115\r\n",0},
+	{0x30E3,"16F15213\r\n",0},
+	{0x30E4,"16F15223\r\n",0},
+	{0x30E5,"16F15243\r\n",0},
+	{0x30E6,"16F15214\r\n",0},
+	{0x30E7,"16F15224\r\n",0},
+	{0x30E8,"16F15244\r\n",0},
+	{0x30E9,"16F15225\r\n",0},
+	{0x30EA,"16F15245\r\n",0},
+	{0x30EB,"16F15256\r\n",0},
+	{0x30EC,"16F15276\r\n",0},
+	{0x30ED,"16F15275\r\n",0},
+	{0x30EE,"16F15274\r\n",0},
+	{0x30EF,"16F15255\r\n",0},
+	{0x30F0,"16F15254\r\n",0},
+	{0x30F1,"16F18013\r\n",0},
+	{0x30F2,"16F18014\r\n",0},
+	{0x30F3,"16F18023\r\n",0},
+	{0x30F4,"16F18024\r\n",0},
+	{0x30F5,"16F18015\r\n",0},
+	{0x30F6,"16F18025\r\n",0},
+	{0x30F7,"16F18044\r\n",0},
+	{0x30F8,"16F18045\r\n",0},
+	{0x30F9,"16F18026\r\n",0},
+	{0x30FA,"16F18046\r\n",0},
+	{0x30FB,"16F18054\r\n",0},
+	{0x30FC,"16F18055\r\n",0},
+	{0x30FD,"16F18074\r\n",0},
+	{0x30FE,"16F18075\r\n",0},
+	{0x30FF,"16F18056\r\n",0},
+	{0x3100,"16F18076\r\n",0},
+	{0x3107,"16F18114\r\n",0},
+	{0x3108,"16F18124\r\n",0},
+	{0x3109,"16F18144\r\n",0},
+	{0x310A,"16F18154\r\n",0},
+	{0x310B,"16F18174\r\n",0},
+	{0x310C,"16F18115\r\n",0},
+	{0x310D,"16F18125\r\n",0},
+	{0x310E,"16F18145\r\n",0},
+	{0x310F,"16F18155\r\n",0},
+	{0x3110,"16F18175\r\n",0},
+	{0x3111,"16F18126\r\n",0},
+	{0x3112,"16F18146\r\n",0},
+	{0x3113,"16F18156\r\n",0},
+	{0x3114,"16F18176\r\n",0},
+	{0x3101,"16F17154\r\n",0},
+	{0x3102,"16F17174\r\n",0},
+	{0x3103,"16F17155\r\n",0},
+	{0x3104,"16F17175\r\n",0},
+	{0x3105,"16F17156\r\n",0},
+	{0x3106,"16F17176\r\n",0},
+};
+
+void PIC16_ID(int id)
+{
+	char s[64];
+	int i;
+	for(i=0;i<sizeof(PIC16LIST)/sizeof(PIC16LIST[0]);i++){
+		if(PIC16LIST[i].revmask&&(id>>5)==PIC16LIST[i].id){		//id + rev in same location
+			sprintf(s,PIC16LIST[i].device,id&PIC16LIST[i].revmask);
+			PrintMessage(s);
+			return;
+		}
+		else if(!PIC16LIST[i].revmask&&id==PIC16LIST[i].id){		//id separate from rev
+			sprintf(s,PIC16LIST[i].device);
+			PrintMessage(s);
+			return;
+		}
+	}
+	sprintf(s,"%s",strings[S_nodev]); //"Unknown device\r\n");
+	PrintMessage(s);
+}
+
+void DisplayCODE16F(int size){
+// display 14 bit PIC CODE memory
+	char s[256]="",t[256]="";
+	char* aux=(char*)malloc((size/COL+1)*(16+COL*5));
+	aux[0]=0;
+	int valid=0,empty=1,i,j,lines=0;
+	for(i=0;i<size&&i<sizeW;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<sizeW&&i<size;j++){
+			sprintf(t,"%04X ",memCODE_W[j]);
+			strcat(s,t);
+			if((memCODE_W[j]&0x3fff)<0x3fff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s\r\n",i,s);
+			empty=0;
+			strcat(aux,t);
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=(sizeW<size?sizeW:size)-COL*2;
+				lines=490;
+			}
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+void DisplayEE16F(int size){
+// display 14 bit PIC EEPROM memory
+	int valid=0,empty=1,i,j;
+	char s[256]="",t[256]="",v[256]="";
+	char* aux=(char*)malloc((size/COL+1)*(16+COL*5));
+	aux[0]=0;
+#ifdef __GTK_H__
+	char *g;
+#endif
+	empty=1;
+	v[0]=0;
+	for(i=0x2100;i<0x2100+size&&i<sizeW;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<0x2100+size&&j<sizeW;j++){
+			sprintf(t,"%02X ",memCODE_W[j]&0xff);
+			strcat(s,t);
+			sprintf(t,"%c",isprint(memCODE_W[j]&0xFF)&&(memCODE_W[j]&0xFF)<0xFF?memCODE_W[j]&0xFF:'.');
+#ifdef __GTK_H__
+			g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+			if(g) strcat(v,g);
+			g_free(g);
+#else
+			strcat(v,t);
+#endif
+			if((memCODE_W[j]&0xFF)<0xff) valid=1;/**/
+		}
+		if(valid){
+			sprintf(t,"%04X: %s %s\r\n",i,s,v);
+			empty=0;
+			strcat(aux,t);
+		}
+		s[0]=0;
+		v[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+void Read16Fxxx(int dim,int dim2,int dim3,int vdd)
+// read 14 bit PIC
+// dim=program size 	dim2=eeprom size   dim3=config size
+// dim2<0 -> eeprom @ 0x2200
+// vdd=0 -> vpp before vdd
+// vdd=1 -> vdd (+50ms) before vpp
+// vdd=2 -> vdd before vpp
+// DevREV@0x2005
+// DevID@0x2006
+// Config@0x2007
+// Calib1/Config2@0x2008
+// Calib2/Calib1@0x2009
+// eeprom@0x2100
+{
+	int k=0,k2=0,z=0,i,j,ee2200=0;
+	char s[512],t[256],*aux;
+	if(dim2<0){
+		dim2=-dim2;
+		ee2200=1;
+	}
+	if(dim>0x2000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size exceeds limits\r\n"
+		return;
+	}
+	if(dim2>0x400||dim2<0){		//Max 1K
+		PrintMessage(strings[S_EELim]);	//"EEPROM size exceeds limits\r\n"
+		return;
+	}
+	if(dim3>0x100||dim3<0){
+		PrintMessage(strings[S_ConfigLim]);	//"Config area size exceeds limits\r\n"
+		return;
+	}
+	if(dim3<8)dim3=8;
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Read16Fxxx(%d,%d,%d,%d)\n",dim,dim2,dim3,vdd);
+	}
+	sizeW=0x2100+dim2;
+	if(memCODE_W) free(memCODE_W);
+	memCODE_W=(WORD*)malloc(sizeof(WORD)*sizeW);
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	if(vdd==0){						//VPP before VDD
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=NOP;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x5;			//VDD+VPP
+	}
+	else if(vdd==1){				//VDD before VPP with delay 50ms
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=1;				//VDD
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=25000>>8;
+		bufferU[j++]=25000&0xff;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=2000>>8;
+		bufferU[j++]=2000&0xff;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x5;			//VDD+VPP
+	}
+	else if(vdd==2){				//VDD before VPP without delay
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=1;				//VDD
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x5;			//VDD+VPP
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?55:5);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i++){
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==dim-1){		//2B cmd -> 4B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==READ_DATA_PROG){
+					memCODE_W[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],i*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr],dim,k);	//"Error reading code area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+	for(i=k;i<0x2000;i++) memCODE_W[i]=0x3fff;
+//****************** read config area ********************
+	PrintMessage(strings[S_Read_CONFIG_A]);		//read config ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]);		//read config ...
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	for(i=0x2000;i<0x2000+dim3;i++){		//Config
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==0x2000+dim3-1){		//2B cmd -> 4B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==READ_DATA_PROG){
+					memCODE_W[0x2000+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(i-0x2000+dim)*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=dim3){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigErr],dim3,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+	for(i=0x2000+k2;i<0x2000+dim3;i++) memCODE_W[i]=0x3fff;
+//****************** read eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_ReadEE]);		//Read EEPROM ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		PrintStatusSetup();
+		if(ee2200){		//eeprom a 0x2200
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=0xFF;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x100-dim3;
+		for(k2=0,i=0x2100;i<0x2100+dim2;i++){
+			bufferU[j++]=READ_DATA_DATA;
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF*2/3-3||i==0x2100+dim2-1){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(8);
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==READ_DATA_DATA){
+						memCODE_W[0x2100+k2++]=bufferI[z+1];
+						z++;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i-0x2100+dim)*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr. %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k2!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,k2);	//"Error reading EE area, ..."
+			for(i=0x2100+k2;i<0x2100+dim2;i++) memCODE_W[i]=0x3fff;
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=1;					//VDD
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();			//clear status report
+//****************** visualize ********************
+	for(i=0;i<4;i+=2){
+		PrintMessage4("ID%d: 0x%04X\tID%d: 0x%04X\r\n",i,memCODE_W[0x2000+i],i+1,memCODE_W[0x2000+i+1]);
+	}
+	PrintMessage1(strings[S_DevID],memCODE_W[0x2006]);	//"DevID: 0x%04X\r\n"
+	if(memCODE_W[0x2005]<0x3FFF) PrintMessage1(strings[S_DevREV],memCODE_W[0x2005]);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(memCODE_W[0x2006]);
+	PrintMessage1(strings[S_ConfigWord],memCODE_W[0x2007]);	//"Configuration word: 0x%04X\r\n"
+	if(dim3>8){
+		PrintMessage1(strings[S_Config2Cal1],memCODE_W[0x2008]);	//"Config2 or Cal1: 0x%04X\r\n"
+	}
+	if(dim3>9){
+		PrintMessage1(strings[S_Calib1_2],memCODE_W[0x2009]);	//"Calibration word 1 or 2: 0x%04X\r\n"
+	}
+	PrintMessage(strings[S_CodeMem2]);	//"\r\nCode memory\r\n"
+	DisplayCODE16F(dim);
+	s[0]=0;
+	int valid=0,empty=1;
+	if(dim3>8){
+		aux=(char*)malloc((dim3/COL+1)*(16+COL*5));
+		aux[0]=0;
+		empty=1;
+		PrintMessage(strings[S_ConfigResMem]);	//"\r\nConfig and reserved memory:\r\n"
+		for(i=0x2000;i<0x2000+dim3;i+=COL){
+			valid=0;
+			for(j=i;j<i+COL&&j<0x2000+dim3;j++){
+				sprintf(t,"%04X ",memCODE_W[j]);
+				strcat(s,t);
+				if(memCODE_W[j]<0x3fff) valid=1;
+			}
+			if(valid){
+				snprintf(t,sizeof(t),"%04X: %s\r\n",i,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}
+	if(dim2){
+		PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+		DisplayEE16F(dim2);
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Read16F1xxx(int dim,int dim2,int dim3,int options)
+// read 14 bit enhanced PIC
+// dim=program size (up to 0x8000)
+// dim2=eeprom size (up to 0x400)
+// dim3=config area size @0x8000
+// options:
+//		bit0=0 -> vpp before vdd
+//		bit0=1 -> vdd before vpp
+//		bit1=1 -> LVP programming
+//		bit2=1 -> Config3@0x8009
+//		bit3=1 -> Config4@0x800A
+//		bit4=1 -> PIC16F18xxx (calib words @0xE000 + new commands)
+// DevREV@0x8005     DevID@0x8006
+// Config1@0x8007    Config2@0x8008
+// Config3@0x8009    Config4@0x800A
+// Calib1@0x8009/A   Calib2@0x800A/B    Calib3@0x800B/C
+// eeprom@0x0 or 0xF000
+{
+	int k=0,k2=0,z=0,i,j;
+	int F18x=options&16;
+	if(F18x&&FWVersion<0xA00){		//only for 16F18xxx
+		PrintMessage1(strings[S_FWver2old],"0.10.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	char s[256],t[256],*aux;
+	if(dim>0x8000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size exceeds limits\r\n"
+		return;
+	}
+	if(dim2>0x400||dim2<0){		//Max 1K
+		PrintMessage(strings[S_EELim]);	//"EEPROM size exceeds limits\r\n"
+		return;
+	}
+	if(dim3>0x200||dim3<0){
+		PrintMessage(strings[S_ConfigLim]);	//"Config area size exceeds limits\r\n"
+		return;
+	}
+	if(dim3<11)dim3=11;		//at least config1-2 + calib1-2
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read16F1xxx(%d,%d,%d,%d)\n",dim,dim2,dim3,options);
+	}
+	if((options&2)==0){				//HV entry
+		if(!StartHVReg(8.5)){
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+		else hvreg=8.5;
+	}
+	else StartHVReg(-1);			//LVP mode, turn off HV
+	sizeW=0x8200;
+	if(F18x) sizeW=0xE004;
+	sizeEE=dim2;
+	if(memCODE_W) free(memCODE_W);
+	memCODE_W=(WORD*)malloc(sizeof(WORD)*sizeW);
+	for(i=0;i<sizeW;i++) memCODE_W[i]=0x3fff;
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(sizeEE);			//EEPROM
+	for(i=0;i<sizeEE;i++) memEE[i]=0xFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	if((options&2)==0){				//HV entry
+		if((options&1)==0){				//VPP before VDD
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x5;			//VDD+VPP
+	}
+		else{							//VDD before VPP without delay
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=1;				//VDD
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x5;			//VDD+VPP
+	}
+	}
+	else{			//Low voltage programming
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;			//0000 1010 0001 0010 1100 0010 1011 0010 = 0A12C2B2
+		bufferU[j++]=2;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x12;
+		bufferU[j++]=0xC2;
+		bufferU[j++]=0xB2;
+		bufferU[j++]=SET_CK_D;		//Clock pulse
+		bufferU[j++]=0x4;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i++){
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==dim-1){		//2B cmd -> 4B data
+			bufferU[j++]=FLUSH;				//remember: FLUSH generates a response even empty!
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==READ_DATA_PROG){
+					memCODE_W[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],i*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr],dim,k);	//"Error reading code area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read config area ********************
+	PrintMessage(strings[S_Read_CONFIG_A]);		//read config ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]);		//read config ...
+	bufferU[j++]=LOAD_CONF;			//counter at 0x8000
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0xFF;
+	for(i=0x8000;i<0x8000+dim3;i++){		//Config
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==0x8000+dim3-1){		//2B cmd -> 4B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==READ_DATA_PROG){
+					memCODE_W[0x8000+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(i-0x8000+dim)*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=dim3){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigErr],dim3,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//	for(i=0x8000+k2;i<0x8000+dim3;i++) memCODE_W[i]=0x3fff;
+//****************** read calibration area ********************
+	if(F18x){
+		k2=0;
+		PrintMessage(strings[S_Read_CONFIG_A]);		//read config ...
+		bufferU[j++]=LOAD_PC;			//counter at 0xE000
+		bufferU[j++]=0xE0;
+		bufferU[j++]=0x00;
+		for(i=0;i<4;i++) bufferU[j++]=READ_DATA_INC;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		for(z=0;z<DIMBUF-2;z++){
+			if(bufferI[z]==READ_DATA_INC){
+				memCODE_W[0xE000+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+				z+=2;
+			}
+		}
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"Calibration area @0xE000\n");
+		}
+		if(k2!=4){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigErr],dim3,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+//****************** read eeprom ********************
+	if(dim2&&!F18x){					//16F1xxx
+		PrintMessage(strings[S_ReadEE]);		//Read EEPROM ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x16;		//Reset address
+		for(i=k=0;i<dim2;i++){
+			bufferU[j++]=READ_DATA_DATA;
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF*2/3-3||i==dim2-1){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==READ_DATA_DATA){
+						memEE[k++]=bufferI[z+1];
+						z++;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],i*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(i!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,i);	//"Error reading EE area, ..."
+			for(;i<dim2;i++) memEE[i]=0xff;
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+	else if(dim2&&F18x){					//16F18xxx
+		PrintMessage(strings[S_ReadEE]);		//Read EEPROM ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		bufferU[j++]=LOAD_PC;				//counter at 0xF000
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x00;
+		for(i=k=0;i<dim2;i++){
+			bufferU[j++]=READ_DATA_INC;
+			if(j>DIMBUF/3-3||i==dim2-1){		//1B cmd -> 3B answer
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==READ_DATA_INC){
+						memEE[k++]=bufferI[z+2];	//LSB
+						z+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],i*100/(dim+dim2+dim3),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(i!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,i);	//"Error reading EE area, ..."
+			for(;i<dim2;i++) memEE[i]=0xff;
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+/***********************************/
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=1;					//VDD
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();			//clear status report
+//****************** visualize ********************
+	for(i=0;i<4;i+=2){
+		PrintMessage4("ID%d: 0x%04X\tID%d: 0x%04X\r\n",i,memCODE_W[0x8000+i],i+1,memCODE_W[0x8000+i+1]);
+	}
+	PrintMessage1(strings[S_DevID],memCODE_W[0x8006]);	//"DevID: 0x%04X\r\n"
+	if(memCODE_W[0x8005]<0x3FFF) PrintMessage1(strings[S_DevREV],memCODE_W[0x8005]);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(memCODE_W[0x8006]);
+	PrintMessage2(strings[S_ConfigWordX],1,memCODE_W[0x8007]);	//"Configuration word %d: 0x%04X\r\n"
+	PrintMessage2(strings[S_ConfigWordX],2,memCODE_W[0x8008]);	//"Configuration word %d: 0x%04X\r\n"
+	if((options&0xC)==0&&F18x==0){	//2 config + 2/3 calib words
+		PrintMessage2(strings[S_CalibWordX],1,memCODE_W[0x8009]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],2,memCODE_W[0x800A]);	//"Calibration word %d: 0x%04X\r\n"
+		if(memCODE_W[0x800B]<0x3FFF) PrintMessage2(strings[S_CalibWordX],3,memCODE_W[0x800B]);	//"Calibration word %d: 0x%04X\r\n"
+	}
+	else if((options&0xC)==4&&F18x==0){	//3 config + 3 calib words
+		PrintMessage2(strings[S_ConfigWordX],3,memCODE_W[0x8009]);	//"Configuration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],1,memCODE_W[0x800A]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],2,memCODE_W[0x800B]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],3,memCODE_W[0x800C]);	//"Calibration word %d: 0x%04X\r\n"
+	}
+	else if((options&0xC)==8){		//4 config
+		PrintMessage2(strings[S_ConfigWordX],3,memCODE_W[0x8009]);	//"Configuration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_ConfigWordX],4,memCODE_W[0x800A]);	//"Configuration word %d: 0x%04X\r\n"
+	}
+	if(F18x){			//4 calib words @0xE000
+		PrintMessage2(strings[S_CalibWordX],1,memCODE_W[0xE000]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],2,memCODE_W[0xE001]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],3,memCODE_W[0xE002]);	//"Calibration word %d: 0x%04X\r\n"
+		PrintMessage2(strings[S_CalibWordX],4,memCODE_W[0xE003]);	//"Calibration word %d: 0x%04X\r\n"
+	}
+	PrintMessage(strings[S_CodeMem2]);	//"\r\nCode memory:\r\n"
+	DisplayCODE16F(dim);
+	if(dim3>15){
+		int valid=0,empty=1;
+		s[0]=0;
+		aux=(char*)malloc(dim3/COL*(16+COL*5));
+		aux[0]=0;
+		empty=1;
+		PrintMessage(strings[S_ConfigResMem]);	//"\r\nConfig and reserved memory:\r\n"
+		for(i=0x8000;i<0x8000+dim3;i+=COL){
+			valid=0;
+			for(j=i;j<i+COL&&j<0x8000+dim3;j++){
+				sprintf(t,"%04X ",memCODE_W[j]);
+				strcat(s,t);
+				if(memCODE_W[j]<0x3fff) valid=1;
+			}
+			if(valid){
+				sprintf(t,"%04X: %s\r\n",i,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}
+	if(dim2) DisplayEE();	//visualize
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+#define LOAD_PC_ADDR 0x80
+#define BULK_ERASE_PROGRAM_MEM 0x18
+#define ROW_ERASE_PROGRAM_MEM 0xF0
+#define LOAD_NVM 0x00
+#define LOAD_NVM_INC 0x02
+#define READ_NVM 0xFC
+#define READ_NVM_INC 0xFE
+#define INC_ADDR8 0xF8
+#define BEGIN_INT_PROG 0xE0
+#define BEGIN_EXT_PROG 0xC0
+#define END_EXT_PROG 0x82
+
+void Read16F18xxx(int dim,int dim2,int dim3,int options)
+// read 14 bit enhanced PIC with new 8b commands
+// dim=program size (up to 0x8000)
+// dim2=if>0 use eeprom, size is automatic when reading DCI
+// dim3=not used
+// options:
+//		bit0=0 -> vpp before vdd
+//		bit0=1 -> vdd before vpp
+//		bit1=1 -> LVP programming
+//		bit4=1 -> do not use DIA&DCI
+// DevREV@0x8005     DevID@0x8006
+// Config1@0x8007    Config2@0x8008 ...
+// Device info area @0x8100
+// Device configuration info area @0x8200
+{
+	int k=0,k2=0,z=0,i,j;
+	int useDCI=(options&0x10)==0?1:0;
+	if(FWVersion<0xB00){		//only for 16F18xxx
+		PrintMessage1(strings[S_FWver2old],"0.11.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	char s[256],t[256],*aux;
+	if(dim>0x8000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size exceeds limits\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Read16F18xxx(%d,%d,%d,%d)\n",dim,dim2,dim3,options);
+	}
+	if((options&2)==0){				//HV entry
+		if(!StartHVReg(8.5)){
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+		else hvreg=8.5;
+	}
+	else StartHVReg(-1);			//LVP mode, turn off HV
+	sizeW=0x8220;
+	if(memCODE_W) free(memCODE_W);
+	memCODE_W=(WORD*)malloc(sizeof(WORD)*sizeW);
+	for(i=0;i<sizeW;i++) memCODE_W[i]=0x3fff;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	if((options&2)==0){				//HV entry
+		if((options&1)==0){				//VPP before VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=4;				//VPP
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+		else{							//VDD before VPP without delay
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=1;				//VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+	}
+	else{			//Low voltage programming
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;			//0000 1010 0001 0010 1100 0010 1011 0010 = 0A12C2B2
+		bufferU[j++]=2;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x12;
+		bufferU[j++]=0xC2;
+		bufferU[j++]=0xB2;
+		bufferU[j++]=SET_CK_D;		//Clock pulse
+		bufferU[j++]=0x4;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i++){
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==dim-1){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;				//remember: FLUSH generates a response (even empty)!
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memCODE_W[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],i*100/(dim+dim2+0x60),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr],dim,k);	//"Error reading code area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read config area ********************
+	PrintMessage(strings[S_Read_CONFIG_A]);		//read config ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]);		//read config ...
+	bufferU[j++]=ICSP8_LOAD;			//counter at 0x8000
+	bufferU[j++]=LOAD_PC_ADDR;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x00;
+	k2=0;
+	for(i=0x8000;i<0x8010;i++){		//Config
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==0x800F){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memCODE_W[0x8000+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(i-0x8000+dim)*100/(dim+dim2+0x60),i);	//"Read: %d%%, addr %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=0x10){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigErr],0x10,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read device info area ********************
+	if(useDCI){	//if not disabled
+		if(saveLog) fprintf(logfile,"Read device info area @0x8100\n");
+		bufferU[j++]=ICSP8_LOAD;			//counter at 0x8000
+		bufferU[j++]=LOAD_PC_ADDR;
+		bufferU[j++]=0x81;
+		bufferU[j++]=0x00;
+		k2=0;
+		for(i=0x8100;i<0x8120;i++){		//DIA
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==0x811F){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						memCODE_W[0x8100+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+						z+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i-0x8100+dim+0x20)*100/(dim+dim2+0x60),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		if(k2!=0x20){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigErr],0x20,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+		}
+	//****************** read calibration area (Device Configuration Information) ********************
+		if(saveLog) fprintf(logfile,"Read Device Configuration Information @0x8200\n");
+		bufferU[j++]=ICSP8_LOAD;			//counter at 0x8200
+		bufferU[j++]=LOAD_PC_ADDR;
+		bufferU[j++]=0x82;
+		bufferU[j++]=0x00;
+		k2=0;
+		for(i=0x8200;i<0x8220;i++){		//DCI
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==0x821F){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						memCODE_W[0x8200+k2++]=(bufferI[z+1]<<8)+bufferI[z+2];
+						z+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i-0x8200+dim+0x40)*100/(dim+dim2+0x60),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		if(k2!=0x20){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigErr],0x20,k2);	//"Error reading config area, requested %d words, read %d\r\n"
+		}
+	}
+//****************** read eeprom ********************
+	if(dim2){					//EEPROM
+		if(useDCI) dim2=memCODE_W[0x8203]; 	//EEPROM size from DCI
+		if(dim2>0x1000||dim2<0){		//Max 4K
+			PrintMessage(strings[S_EELim]);	//"EEPROM size exceeds limits\r\n"
+			return;
+		}
+		sizeEE=dim2;
+		if(memEE) free(memEE);
+		memEE=(unsigned char*)malloc(sizeEE);			//EEPROM
+		for(i=0;i<sizeEE;i++) memEE[i]=0xFF;
+		PrintMessage(strings[S_ReadEE]);		//Read EEPROM ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		bufferU[j++]=ICSP8_LOAD;			//counter at 0xF000
+		bufferU[j++]=LOAD_PC_ADDR;
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x00;
+		for(i=k=0;i<dim2;i++){
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==dim2-1){		//2B cmd -> 3B answer
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						memEE[k++]=bufferI[z+2];	//LSB
+						z+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],i*100+dim+0x60/(dim+dim2+0x60),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(i!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,i);	//"Error reading EE area, ..."
+			for(;i<dim2;i++) memEE[i]=0xff;
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+/***********************************/
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=1;					//VDD
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();			//clear status report
+//****************** visualize ********************
+	for(i=0;i<4;i+=2){
+		PrintMessage4("ID%d: 0x%04X\tID%d: 0x%04X\r\n",i,memCODE_W[0x8000+i],i+1,memCODE_W[0x8000+i+1]);
+	}
+	PrintMessage1(strings[S_DevID],memCODE_W[0x8006]);	//"DevID: 0x%04X\r\n"
+	if(memCODE_W[0x8005]<0x3FFF) PrintMessage1(strings[S_DevREV],memCODE_W[0x8005]);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(memCODE_W[0x8006]);
+	for(i=0;i<5;i++){
+		PrintMessage2(strings[S_ConfigWordX],i+1,memCODE_W[0x8007+i]);	//"Configuration word %d: 0x%04X\r\n"
+	}
+	if(useDCI){	//if not disabled
+		PrintMessage("Device Information Area @0x8100\r\n");
+		s[0]=0;
+		for(i=0;i<0x20;i+=COL){
+			sprintf(t,"%04X: ",0x8100+i);
+			strcat(s,t);
+			for(j=i;j<i+COL&&j<0x20;j++){
+				sprintf(t,"%04X ",memCODE_W[0x8100+j]);
+				strcat(s,t);
+			}
+			strcat(s,"\r\n");
+		}
+		PrintMessage(s);
+		PrintMessage("Device Configuration Information @0x8200\r\n");
+		s[0]=0;
+		for(i=0;i<0x20;i+=COL){
+			sprintf(t,"%04X: ",0x8200+i);
+			strcat(s,t);
+			for(j=i;j<i+COL&&j<0x20;j++){
+				sprintf(t,"%04X ",memCODE_W[0x8200+j]);
+				strcat(s,t);
+			}
+			strcat(s,"\r\n");
+		}
+		PrintMessage(s);
+		PrintMessage1("Erase row size: %d words\r\n",memCODE_W[0x8200]);
+		PrintMessage1("Write latches: %d\r\n",memCODE_W[0x8201]);
+		PrintMessage1("User rows: %d\r\n",memCODE_W[0x8202]);
+		PrintMessage1("->%d Flash words\r\n",memCODE_W[0x8200]*memCODE_W[0x8202]);
+		PrintMessage1("EE data memory size: %d\r\n",memCODE_W[0x8203]);
+		PrintMessage1("Pin count: %d\r\n",memCODE_W[0x8204]);
+		if(dim!=memCODE_W[0x8200]*memCODE_W[0x8202]) PrintMessage(strings[S_WarnFlashSize]);	//"Warning, flash size is different from the expected value"
+	}
+	PrintMessage(strings[S_CodeMem2]);	//"\r\nCode memory:\r\n"
+	DisplayCODE16F(dim);
+	if(dim2) DisplayEE();	//visualize
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write12F6xx(int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// vpp before vdd
+// DevID@0x2006
+// Config@0x2007
+// Calib1@0x2008 (save)
+// Calib2@0x2009 (save)
+// eeprom@0x2100
+// erase: BULK_ERASE_PROG (1001) +10ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 4ms
+// eeprom:	BULK_ERASE_DATA (1011) + 16ms
+//			LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 8ms
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff,calib1=0x3fff,calib2=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(load_calibword){
+		if(sizeW>0x2009) load_calibword=2;
+		else if(sizeW>0x2008) load_calibword=1;
+		else{
+			PrintMessage(strings[S_NoCalibW]);	//"Can't find calibration data\r\n"
+			load_calibword=0;
+		}
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write12F6xx(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib1
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib2
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	calib1=(bufferI[z+1]<<8)+bufferI[z+2];
+	if(calib1<0x3fff){
+		PrintMessage1(strings[S_CalibWord1],calib1);	//"Calib1: 0x%04X\r\n"
+	}
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	calib2=(bufferI[z+1]<<8)+bufferI[z+2];
+	if(calib2<0x3fff){
+		PrintMessage1(strings[S_CalibWord2],calib2);	//"Calib2: 0x%04X\r\n"
+	}
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=WAIT_T3;		//necessary when erasing fully written 16F62xA
+								//not mentioned in the prog spec!
+	if(programID||load_calibword||ICDenable){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		if(load_calibword){
+			bufferU[j++]=INC_ADDR_N;
+			if(load_calibword==2) bufferU[j++]=0x09;
+			else bufferU[j++]=0x08;
+		}
+	}
+	bufferU[j++]=LOAD_DATA_PROG;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	if(dim2){
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	}
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=4000>>8;
+	bufferU[j++]=4000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(50);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-12||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*5+2);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		int err_e=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=8000>>8;
+		bufferU[j++]=8000&0xff;
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=WAIT_T3;			// delay T3=8ms
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=1;
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x2100-0x2001;		//EEPROM area: counter at 0x2100
+		for(w=2,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=6ms min
+				bufferU[j++]=WAIT_T3;				//Tprogram 8ms
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-12||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*9+2);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err_e++;
+							if(max_err&&err+err_e>max_err){
+								PrintMessage1(strings[S_MaxErr],err+err_e);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err_e+=i-k;
+		err+=err_e;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],err_e);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=4000>>8;
+	bufferU[j++]=4000&0xff;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;		//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+	bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(load_calibword){
+		bufferU[j++]=LOAD_DATA_PROG;			//Calib word 1
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		bufferU[j++]=LOAD_DATA_PROG;			//Calib word 2
+		bufferU[j++]=memCODE_W[0x2009]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2009]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(load_calibword){
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2008]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_Calib1Err],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing Calib1: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		if(load_calibword==2){
+			for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+			if (memCODE_W[0x2009]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+				PrintMessage("\r\n");
+				PrintMessage2(strings[S_Calib2Err],memCODE_W[0x2009],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing Calib2: written %04X, read %04X\r\n"
+				err_c++;
+			}
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F8x (int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// vdd + 50ms + vdd&vpp
+// DevID@0x2006
+// Config@0x2007
+// eeprom@0x2100
+// erase if protected:
+// LOAD_CONF (0)(0x3FFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 10ms
+// + CUST_CMD (0001) + CUST_CMD (0111)
+// erase if not protected and DevID=16F84A:
+// LOAD_DATA_PROG (0010)(0x3FFF) + BULK_ERASE_PROG (1001) +10ms
+// LOAD_DATA_DATA (0011)(0xFF) + BULK_ERASE_DATA (1011) + BEGIN_PROG (1000) + 10ms
+// erase if not protected and DevID!=16F84A:
+// LOAD_DATA_PROG (0010)(0x3FFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 10ms + CUST_CMD (0001) + CUST_CMD (0111)
+// LOAD_DATA_DATA (0011)(0xFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 10ms + CUST_CMD (0001) + CUST_CMD (0111)
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 20ms or 8ms(16F84A)
+// write eeprom: LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 20ms or 8ms(16F84A)
+// verify during write
+{
+	int err=0;
+	WORD devID,config;
+	int k=0,z=0,i,j,w,r;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F8x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=25000>>8;
+	bufferU[j++]=25000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;			//50ms
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(140);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_ConfigWord],config);	//"Config word: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	if(config<0x3FF0){
+		PrintMessage(strings[S_ProtErase]);	//"Override write protection\r\n"
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0x3F;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x07;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+	}
+	else if(devID>>5==0x2B){			//16F84A
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=0x3f;				//MSB
+		bufferU[j++]=0xff;				//LSB
+		bufferU[j++]=BULK_ERASE_PROG;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		if(dim2){
+			bufferU[j++]=LOAD_DATA_DATA;
+			bufferU[j++]=0xff;				//LSB
+			bufferU[j++]=BULK_ERASE_DATA;
+			bufferU[j++]=BEGIN_PROG;
+			bufferU[j++]=WAIT_T3;
+		}
+	}
+	else{								//altri
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=0x3f;				//MSB
+		bufferU[j++]=0xff;				//LSB
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		if(dim2){
+			bufferU[j++]=LOAD_DATA_DATA;	//EEPROM:  spec error?
+			bufferU[j++]=0xff;				//LSB
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x01;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x07;
+			bufferU[j++]=BEGIN_PROG;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x01;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x07;
+		}
+	}
+	if(!programID){					//back to program memory
+		bufferU[j++]=NOP;				//exit program mode
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x0;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+		bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+		bufferU[j++]=EN_VPP_VCC;		//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=WAIT_T3;			//50ms
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+		bufferU[j++]=0x5;
+	}
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	r=(devID>>5==0x2B)?8000:20000;
+	bufferU[j++]=r>>8;
+	bufferU[j++]=r&0xff;
+	bufferU[j++]=FLUSH;
+	r/=1000;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(!programID?140:60);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*r+4);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;
+		bufferU[j++]=INC_ADDR_N;	//EEPROM: counter at 0x2100
+		bufferU[j++]=1;
+		for(w=0,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG;			//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*r+5);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],i-k);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;			//internally timed
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(programID?125:35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F62x (int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// vpp before vdd
+// DevID@0x2006
+// Config@0x2007
+// eeprom@0x2200
+// erase if protected:
+// LOAD_CONF (0000)(0) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 15ms + CUST_CMD (0001) + CUST_CMD (0111)
+// erase if not protected:
+// LOAD_DATA_PROG (0010)(0x3FFF) + BULK_ERASE_PROG (1001) +5ms
+// LOAD_DATA_DATA (0011)(0xFF) + BULK_ERASE_DATA (1011) + BEGIN_PROG (1000) + 5ms
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 8ms
+// write ID: LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 16ms
+// write CONFIG: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 8ms
+// eeprom: LOAD_DATA_DATA (0011) + BEGIN_PROG2 (11000) + 8ms
+// verify during write
+{
+	int err=0;
+	WORD devID,config;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F62x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay exit-enter prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(12);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_ConfigWord],config);	//"Config word: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=5000>>8;
+	bufferU[j++]=5000&0xff;
+	if(config<0x3C00){
+		PrintMessage(strings[S_ProtErase]);	//"Override write protection\r\n"
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0x3F;				//fake config	spec ERROR!!! is written data=0!!
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x07;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=BEGIN_PROG;		//Tera+Tprog=5+8 ms
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+	}
+	else{
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=0x3f;				//MSB
+		bufferU[j++]=0xff;				//LSB
+		bufferU[j++]=BULK_ERASE_PROG;
+		bufferU[j++]=BEGIN_PROG;		//Tera=5ms
+		bufferU[j++]=WAIT_T3;
+		if(dim2){
+			bufferU[j++]=LOAD_DATA_DATA;
+			bufferU[j++]=0xff;				//LSB
+			bufferU[j++]=BULK_ERASE_DATA;
+			bufferU[j++]=BEGIN_PROG;		//Tera=5ms
+			bufferU[j++]=WAIT_T3;
+		}
+	}
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=8000>>8;
+	bufferU[j++]=8000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(60);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//program only, internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram=8ms
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*9+2);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;		//20FF
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0xFF;		//21FE
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x2;		//EEPROM: counter at 0x2200
+		for(w=0,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG2;			//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram=8ms
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*14+1);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],i-k);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//erase + prog internally timed, T=8+5 ms
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG2;				//prog only, internally timed, T=8 ms
+	bufferU[j++]=WAIT_T3;					//Tprogram 8ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(programID?125:35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d\n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write12F62x(int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// vpp before vdd
+// save OSCCAL @ dim-1
+// CONFIG@0x2007 includes 2  calibration bits
+// DevID@0x2006
+// eeprom@0x2100
+// erase: BULK_ERASE_PROG (1001) +10ms
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 3ms
+// eeprom: BULK_ERASE_DATA (1011) + 9ms
+// LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 6ms
+// verify during write
+{
+	int err=0;
+	WORD devID,config,osccal;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write12F62x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	for(i=0;i<dim-0xff;i+=0xff){
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0xff;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=dim-1-i;
+	bufferU[j++]=READ_DATA_PROG;	// OSCCAL
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	osccal=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+1];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	if(programID){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+	}
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms after exiting program mode
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=3000>>8;
+	bufferU[j++]=3000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(40);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	if(!load_osccal) memCODE_W[dim-1]=osccal;	//backup osccal
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*6.5+j*0.1);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	err+=i-k;
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=6000>>8;
+		bufferU[j++]=6000&0xff;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;
+		bufferU[j++]=INC_ADDR_N;	//EEPROM: counter at 0x2100
+		bufferU[j++]=1;
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=WAIT_T3;			// delay=12ms
+		bufferU[j++]=WAIT_T3;
+		for(w=3,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=6ms
+				bufferU[j++]=WAIT_T3;				//Tprogram 6ms
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*7+2);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],i-k);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	if(!load_calibword)	memCODE_W[0x2007]=(memCODE_W[0x2007]&0xfff)+(config&0x3000);
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms
+	bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F87x (int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// dim2<0 -> eeprom @ 0x2200
+// vdd + (50ms?) + vdd&vpp
+// DevID@0x2006
+// Config@0x2007
+// eeprom@0x2100
+// erase if protected:
+// LOAD_CONF (0000)(0x3FFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 8ms
+// + CUST_CMD (0001) + CUST_CMD (0111)
+// erase if not protected:
+// LOAD_DATA_PROG (0010)(0x3FFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 8ms + CUST_CMD (0001) + CUST_CMD (0111)
+// LOAD_DATA_DATA (0011)(0xFF) + CUST_CMD (0001) + CUST_CMD (0111)
+// + BEGIN_PROG (1000) + 8ms + CUST_CMD (0001) + CUST_CMD (0111)
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 4ms
+// write eeprom: LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 8ms
+// verify during write
+{
+	int err=0;
+	WORD devID,config;
+	int k=0,z=0,i,j,w,ee2200=0;
+	if(dim2<0){
+		dim2=-dim2;
+		ee2200=1;
+	}
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F87x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(60);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_ConfigWord],config);	//"Config word: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=8000>>8;
+	bufferU[j++]=8000&0xff;
+	if((config&0x3130)!=0x3130){
+		PrintMessage(strings[S_ProtErase]);	//"override write protection\r\n"
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0x3F;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=0x07;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=NOP;				//exit program mode
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x0;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+		bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+		bufferU[j++]=EN_VPP_VCC;		//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+		bufferU[j++]=0x5;
+	}
+	else{
+		if(ICDenable||programID){			//erase 0x2000-2004 also
+			bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+			bufferU[j++]=0x3F;				//fake config
+			bufferU[j++]=0xFF;				//fake config
+		}
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=0x3f;				//MSB
+		bufferU[j++]=0xff;				//LSB
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x07;
+		if(dim2){
+			bufferU[j++]=LOAD_DATA_DATA;	//EEPROM:  spec error?
+			bufferU[j++]=0xff;				//LSB
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x01;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x07;
+			bufferU[j++]=BEGIN_PROG;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x01;
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x07;
+		}
+		if(ICDenable||programID){			//back to addr 0
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x1;
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x0;
+			bufferU[j++]=SET_CK_D;
+			bufferU[j++]=0x0;
+			bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+			bufferU[j++]=EN_VPP_VCC;		//VDD
+			bufferU[j++]=0x1;
+			bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+			bufferU[j++]=0x5;
+		}
+	}
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=4000>>8;
+	bufferU[j++]=4000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(60);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*5+2);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		int err_e=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=1;					//EEPROM: counter at 0x2100
+		if(ee2200){		//eeprom at 0x2200
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=0xFF;
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=1;
+		}
+		for(w=0,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG2;			//internally timed ?????
+				bufferU[j++]=WAIT_T3;				//Tprogram         ?????
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*8+5);
+				w=0;
+				for(z=0;z<DIMBUF;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err_e++;
+							if(max_err&&err+err_e>max_err){
+								PrintMessage1(strings[S_MaxErr],err+err_e);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err_e+=i-k;
+		err+=err_e;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],err_e);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=8000>>8;
+	bufferU[j++]=8000&0xff;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;		//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG2;			//internally timed
+		bufferU[j++]=WAIT_T3;				//Tprogram
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG2;			//internally timed
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(programID?125:35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F87xA (int dim,int dim2,int seq)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// seq=0: vdd + (50ms) + vdd&vpp
+// seq=1: vdd + (50us) + vdd&vpp
+// DevID@0x2006
+// Config@0x2007
+// write CONFIG2@0x2008 if different from 3FFF
+// eeprom@0x2100
+// erase:
+// CHIP ERASE (11111) + 15ms
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 1.2ms + END_PROGX (10111)
+// write eeprom: LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 12ms
+// verify during write
+{
+	int err=0;
+	WORD devID,config;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F87xA(%d,%d,%d)\n",dim,dim2,seq);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	bufferU[0]=0;
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=25000>>8;
+	bufferU[j++]=25000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(seq==0){
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(seq==0?90:40);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_ConfigWord],config);	//"Config word: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=15000>>8;
+	bufferU[j++]=15000&0xff;
+	if(ICDenable||programID){			//erase 0x2000-2004 also
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0x3F;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+	}
+	bufferU[j++]=CUST_CMD;
+	bufferU[j++]=0x1F;					// CHIP_ERASE (11111)
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=1200>>8;
+	bufferU[j++]=1200&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(60);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x17;					//END_PROGX (10111)
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-11||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*1.5+(6-w)*0.2+2);
+			w=0;
+			for(z=0;z<DIMBUF-6;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+4]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+5]<<8)+bufferI[z+6]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+5]<<8)+bufferI[z+6]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=7;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		int err_e=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=12000>>8;
+		bufferU[j++]=12000&0xff;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;
+		bufferU[j++]=INC_ADDR_N;		//EEPROM: counter at 0x2100
+		bufferU[j++]=1;
+		for(w=0,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG;			//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram 8ms
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*12.5+5);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err_e++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err_e+=i-k;
+		err+=err_e;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],err_e);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=12000>>8;
+	bufferU[j++]=12000&0xff;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;		//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed
+		bufferU[j++]=WAIT_T3;				//Tprogram
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;				//internally timed
+	bufferU[j++]=WAIT_T3;					//Tprogram
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(sizeW>0x2008&&memCODE_W[0x2008]!=0x3fff){
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word2 0x2008
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;				//internally timed
+		bufferU[j++]=WAIT_T3;					//Tprogram
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	i=28;
+	if(programID) i+=50;
+	if(ICDenable) i+=13;
+	PacketIO(i);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(sizeW>0x2008&&memCODE_W[0x2008]!=0x3fff){
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F81x (int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// seq=0: vdd + (50ms) + vdd&vpp
+// seq=1: vdd + (50us) + vdd&vpp
+// DevID@0x2006
+// Config@0x2007
+// write CONFIG2@0x2008 if different from 3FFF
+// erase if protected: CHIP ERASE (11111) + 8ms
+// erase if not protected:
+// BULK_ERASE_PROG (1001) + BEGIN_PROG (1001) + 2ms + END_PROGX (10111)
+// BULK_ERASE_DATA (1011) + BEGIN_PROG (1001) + 2ms + END_PROGX (10111)
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 1.5ms + END_PROGX (10111)
+// write eeprom: LOAD_DATA_DATA (0011) + BEGIN_PROG2 (11000) + 1.5ms + END_PROGX (10111)
+// verify during write
+{
+	int err=0;
+	WORD devID,config;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F81x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=25000>>8;
+	bufferU[j++]=25000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Config
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(40);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	config=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_ConfigWord],config);	//"Config word: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	if(programID||ICDenable){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0x3F;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+	}
+	if((config&0x2100)!=0x2100){
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x1F;					// CHIP_ERASE (11111)
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+	}
+	else{
+		bufferU[j++]=BULK_ERASE_PROG;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x17;					//END_PROGX (10111)
+	}
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x17;					//END_PROGX (10111)
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-11||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*2.5+3);
+			w=0;
+			for(z=0;z<DIMBUF-6;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+4]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+5]<<8)+bufferI[z+6]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+5]<<8)+bufferI[z+6]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=7;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		int err_e=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=0x0;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+		bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+		bufferU[j++]=EN_VPP_VCC;		//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=LOAD_DATA_DATA;
+		bufferU[j++]=0x01;
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=BEGIN_PROG;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x17;					//END_PROGX (10111)
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		for(w=0,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG2;			//externally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram
+				bufferU[j++]=CUST_CMD;
+				bufferU[j++]=0x17;					//END_PROGX (10111)
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-10||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*2.5+5);
+				w=0;
+				for(z=0;z<DIMBUF-5;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+4]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+5]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+5]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err_e++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=6;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err_e+=i-k;
+		err+=err_e;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],err_e);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram
+			bufferU[j++]=CUST_CMD;
+			bufferU[j++]=0x17;					//END_PROGX (10111)
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;		//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG2;				//externally timed
+		bufferU[j++]=WAIT_T3;					//Tprogram
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x17;						//END_PROGX (10111)
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG2;				//externally timed
+	bufferU[j++]=WAIT_T3;					//Tprogram
+	bufferU[j++]=CUST_CMD;
+	bufferU[j++]=0x17;						//END_PROGX (10111)
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(sizeW>0x2008&&memCODE_W[0x2008]!=0x3fff){
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word2 0x2008
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG2;				//externally timed
+		bufferU[j++]=WAIT_T3;					//Tprogram
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x17;						//END_PROGX (10111)
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=7;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=7;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(sizeW>0x2008&&memCODE_W[0x2008]!=0x3fff){
+		for(z+=7;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write12F61x(int dim, int d, int d2)
+// write 14 bit PIC
+// dim=program size
+// d not used
+// vpp before vdd
+// DevREV@0x2005
+// DevID@0x2006
+// Config@0x2007
+// Calib1@0x2008 (save)
+// Calib2@0x2009
+// erase: BULK_ERASE_PROG (1001) +10ms
+// write: LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 4ms + END_PROG (1010)
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff,devREV=0x3fff,calib1=0x3fff,calib2=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(load_calibword){
+		if(sizeW>0x2008) load_calibword=1;
+		else{
+			PrintMessage(strings[S_NoCalibW]);	//"Can't find calibration data\r\n"
+			load_calibword=0;
+		}
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write12F61x(%d)\n",dim);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x05;
+	bufferU[j++]=READ_DATA_PROG;	//DevREV
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib1
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib2
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devREV=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	if(devREV<0x3FFF) PrintMessage1(strings[S_DevREV],devREV);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	calib1=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	calib2=(bufferI[z+1]<<8)+bufferI[z+2];
+	if(calib1<0x3fff) PrintMessage1(strings[S_CalibWord1],calib1);	//"Calib1: 0x%04X\r\n"
+	if(calib2<0x3fff) PrintMessage1(strings[S_CalibWord2],calib2);	//"Calib2: 0x%04X\r\n"
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	if(programID||load_calibword){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		if(load_calibword){
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=0x08;
+		}
+	}
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms after exiting program mode
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=4000>>8;
+	bufferU[j++]=4000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(40);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+			bufferU[j++]=END_PROG;
+			bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-12||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*5+2.5);
+			w=0;
+			for(z=0;z<DIMBUF-7;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+5]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+6]<<8)+bufferI[z+7]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=8;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+			bufferU[j++]=END_PROG;
+			bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG2;			//externally timed, T=3ms min
+	bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+	bufferU[j++]=END_PROG;
+	bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(load_calibword){
+		bufferU[j++]=LOAD_DATA_PROG;			//Calib word 1
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG2;			//externally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 4ms
+		bufferU[j++]=END_PROG;
+		bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=8;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(load_calibword){
+		for(z+=8;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2008]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_Calib1Err],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing Calib1: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F88x(int dim,int dim2)
+// write 14 bit PIC
+// dim=program size 	dim2=eeprom size
+// vpp before vdd
+// DevID@0x2006
+// Config@0x2007
+// Config2@0x2008
+// Calib1@0x2009 (salva)
+// eeprom@0x2100
+// erase: BULK_ERASE_PROG (1001) +6ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 3ms
+// eeprom:	BULK_ERASE_DATA (1011) + 6ms
+//			LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 6ms
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff,calib1=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2009){
+		PrintMessage(strings[S_NoConfigW4]);	//"Can't find CONFIG (0x2008)\r\nEnd\r\n"
+		return;
+	}
+	if(load_calibword){
+		if(sizeW>0x200A) load_calibword=1;
+		else{
+			PrintMessage(strings[S_NoCalibW]);	//"Can't find calibration data\r\n"
+			load_calibword=0;
+		}
+	}
+	if(dim2){
+		if(sizeW<0x2100){
+			dim2=0;
+			PrintMessage(strings[S_NoEEMem]);	//"Can't find EEPROM data\r\n"
+		}
+		else if(dim2>sizeW-0x2100) dim2=sizeW-0x2100;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F88x(%d,%d)\n",dim,dim2);
+	}
+	for(i=0;i<0x200A&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib1
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=6000>>8;
+	bufferU[j++]=6000&0xff;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	calib1=(bufferI[z+1]<<8)+bufferI[z+2];
+	if(calib1<0x3fff){
+		PrintMessage1(strings[S_CalibWord1],calib1);	//"Calib1: 0x%04X\r\n"
+	}
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	if(programID||load_calibword||ICDenable){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		if(load_calibword){
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=9;
+		}
+	}
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=6ms
+	bufferU[j++]=EN_VPP_VCC;		//exit program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			// delay T3=6ms after exiting program mode
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x4;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=3000>>8;
+	bufferU[j++]=3000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(40);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-12||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*3+2);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=6000>>8;
+		bufferU[j++]=6000&0xff;
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=WAIT_T3;			// delay T3=6ms
+		bufferU[j++]=INC_ADDR_N;		//use only INC_ADDR_N so verification does not look at it
+		bufferU[j++]=0xFF;
+		bufferU[j++]=INC_ADDR_N;		//EEPROM: counter at 0x2100
+		bufferU[j++]=1;
+		for(w=2,i=k=0x2100;i<0x2100+dim2;i++){
+			if(memCODE_W[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memCODE_W[i]&0xff;
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=6ms min
+				bufferU[j++]=WAIT_T3;				//Tprogram 6ms
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-12||i==0x2100+dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i-0x2100+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*6.5+2);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memCODE_W[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memCODE_W[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							err++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=0x2200;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d \n"
+				}
+			}
+		}
+		err+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],i-k);	//"completed, %d errors\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=3000>>8;
+	bufferU[j++]=3000&0xff;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;			//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;				//internally timed, T=3ms min
+	bufferU[j++]=WAIT_T3;					//Tprogram 3ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word2 0x2008
+	bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;				//internally timed, T=3ms min
+	bufferU[j++]=WAIT_T3;					//Tprogram 3ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(load_calibword){
+		bufferU[j++]=LOAD_DATA_PROG;		//Calib word 1
+		bufferU[j++]=memCODE_W[0x2009]>>8;	//MSB
+		bufferU[j++]=memCODE_W[0x2009]&0xff;	//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(35);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"\r\n"
+		err_c++;
+	}
+	if(load_calibword){
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2009]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_Calib1Err],memCODE_W[0x2009],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing Calib1: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F7x(int dim,int vdd)
+// dim=program size
+// write 14 bit PIC
+// vdd=0  vdd +50ms before vpp
+// vdd=1  vdd before vpp
+// DevID@0x2006
+// Config@0x2007
+// Config2@0x2008
+// erase: BULK_ERASE_PROG (1001) +30ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 1ms + END_PROG2(1110)
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F7x(%d,%d)\n",dim,vdd);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?20:70);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	//enter program mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?50:100);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+	j=0;
+	//enter program mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=1000>>8;
+	bufferU[j++]=1000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?2:52);
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//externally timed, T=1ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 1ms min
+			bufferU[j++]=END_PROG2;
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-10||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*1.5+2);
+			w=0;
+			for(z=0;z<DIMBUF-6;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+4]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+5]<<8)+bufferI[z+6]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+5]<<8)+bufferI[z+6]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=7;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//externally timed, T=1ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+			bufferU[j++]=END_PROG2;
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;			//externally timed, T=1ms min
+	bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+	bufferU[j++]=END_PROG2;
+	bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(sizeW>0x2008&&memCODE_W[0x2008]<0x3fff){
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word 2 0x2008
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;			//externally timed, T=1ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+		bufferU[j++]=END_PROG2;
+		bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(sizeW>0x2008&&memCODE_W[0x2008]<0x3fff){
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F71x(int dim,int vdd)
+// write 14 bit PIC
+// dim=program size
+// vdd=0  vdd +50ms before vpp
+// vdd=1  vdd before vpp
+// DevID@0x2006
+// Config@0x2007
+// erase: BULK_ERASE_PROG (1001) +6ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG2 (11000) + 2ms + END_PROG2(1110)
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(sizeW<0x2007){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F71x(%d,%d)\n",dim,vdd);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?20:70);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	//enter program mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=NOP;
+	if(programID){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+	}
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=10ms
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T3;			//delay after exiting prog mode
+	//enter program mode
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	if(vdd==0){
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+		bufferU[j++]=WAIT_T3;			//delay between vdd and vpp
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(vdd?30:130);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed, T=1ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 1ms min
+			bufferU[j++]=END_PROG2;
+			bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-11||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*2.5+2);
+			w=0;
+			for(z=0;z<DIMBUF-7;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+5]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+6]<<8)+bufferI[z+7]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+6]<<8)+bufferI[z+7]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=8;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG2;			//externally timed, T=1ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+			bufferU[j++]=END_PROG2;
+			bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=3;
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=7;
+	}
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG2;			//externally timed, T=1ms min
+	bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+	bufferU[j++]=END_PROG2;
+	bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(sizeW>0x2008&&memCODE_W[0x2008]<0x3fff){
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word 2 0x2008
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG2;			//externally timed, T=1ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 1ms
+		bufferU[j++]=END_PROG2;
+		bufferU[j++]=WAIT_T2;				//Tdischarge 100us
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(15);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(sizeW>0x2008&&memCODE_W[0x2008]<0x3fff){
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F72x(int dim, int d, int d2)
+// write 14 bit PIC
+// dim=program size
+// d not used
+// vpp before vdd
+// DevID@0x2006
+// Config@0x2007
+// Config2@0x2008 (not used on LF devices)
+// erase: BULK_ERASE_PROG (1001) +6ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 2.5ms
+// verify during write
+{
+	int err=0;
+	WORD devID=0x3fff;
+	int k=0,z=0,i,j,w;
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(!StartHVReg(8.5)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	if(sizeW<0x2008){
+		PrintMessage(strings[S_NoConfigW3]);	//"Can't find CONFIG (0x2007)\r\nEnd\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write16F72x(%d)\n",dim);
+	}
+	for(i=0;i<0x2009&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x06;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=CUST_CMD;
+	bufferU[j++]=0x16;		//Reset address
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=6000>>8;
+	bufferU[j++]=6000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(3);
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	PIC16_ID(devID);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	j=0;
+	if(programID||ICDenable){
+		bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+		bufferU[j++]=0xFF;				//fake config
+		bufferU[j++]=0xFF;				//fake config
+	}
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// delay T3=6ms
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=CUST_CMD;
+	bufferU[j++]=0x16;		//Reset address
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2500>>8;
+	bufferU[j++]=2500&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(18);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	for(w=i=k=0,j=0;i<dim;i++){
+		if(memCODE_W[i]<0x3fff){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			w++;
+		}
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF-12||i==dim-1){
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, add. %03X"
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(w*2.5+2);
+			w=0;
+			for(z=0;z<DIMBUF-5;z++){
+				if(bufferI[z]==INC_ADDR&&memCODE_W[k]>=0x3fff) k++;
+				else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+					if (memCODE_W[k]!=(bufferI[z+4]<<8)+bufferI[z+5]){
+						PrintMessage("\r\n");
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+4]<<8)+bufferI[z+5]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+						if(max_err&&err>max_err){
+							PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+							PrintMessage(strings[S_IntW]);	//"Write interrupted"
+							i=dim;
+							z=DIMBUF;
+						}
+					}
+					k++;
+					z+=6;
+				}
+			}
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+			}
+		}
+	}
+	err+=i-k;
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write ID, CONFIG, CALIB ********************
+	PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+	int err_c=0;
+	int ICDgoto=0x2800+(ICDaddr&0x7FF);		//GOTO ICD routine (0x28xx)
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=6000>>8;
+	bufferU[j++]=6000&0xff;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x2000
+	bufferU[j++]=0xFF;				//fake config
+	bufferU[j++]=0xFF;				//fake config
+	if(programID){
+		for(i=0x2000;i<0x2004;i++){
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+			bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+	}
+	else{
+		bufferU[j++]=INC_ADDR_N;
+		bufferU[j++]=4;
+	}
+	if(ICDenable){		//write a GOTO ICD routine (0x28xx)
+		bufferU[j++]=LOAD_DATA_PROG;
+		bufferU[j++]=ICDgoto>>8;		//MSB
+		bufferU[j++]=ICDgoto&0xFF;			//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed, T=3ms min
+		bufferU[j++]=WAIT_T3;				//Tprogram 3ms
+		bufferU[j++]=READ_DATA_PROG;
+	}
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=3;
+	bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x2007
+	bufferU[j++]=memCODE_W[0x2007]>>8;		//MSB
+	bufferU[j++]=memCODE_W[0x2007]&0xff;		//LSB
+	bufferU[j++]=BEGIN_PROG;				//internally timed, T=5ms min
+	bufferU[j++]=WAIT_T3;					//Tprogram 3ms
+	bufferU[j++]=READ_DATA_PROG;
+	bufferU[j++]=INC_ADDR;
+	if(sizeW>0x2008){						//only if Config2 is present
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word 2 0x2008
+		bufferU[j++]=memCODE_W[0x2008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x2008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;				//internally timed, T=5ms min
+		bufferU[j++]=WAIT_T3;					//Tprogram 3ms
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=FLUSH;
+	}
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(45);
+	for(i=0,z=0;programID&&i<4;i++){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (memCODE_W[0x2000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage("\r\n");
+			PrintMessage3(strings[S_IDErr],i,memCODE_W[0x2000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	if(ICDenable){
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if (ICDgoto!=(bufferI[z+1]<<8)+bufferI[z+2]){
+			PrintMessage4(strings[S_ICDErr],0x2004,i,ICDgoto,(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ICD (0x%X): written %04X, read %04X\r\n"
+			err_c++;
+		}
+		z+=6;
+	}
+	for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	if(~memCODE_W[0x2007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+		err_c++;
+	}
+	if(sizeW>0x2008){						//only if Config2 is present
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x2008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x2008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+	}
+	err+=err_c;
+	PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+	if(saveLog){
+		fprintf(logfile,strings[S_Log9],err);	//"Area config. 	errors=%d \n"
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write16F1xxx(int dim,int dim2,int options)
+// write 14 bit enhanced PIC
+// dim=program size
+// dim2=eeprom size
+// options:
+//		bit0=0 -> vpp before vdd
+//		bit0=1 -> vdd before vpp
+//		bit1=1 -> LVP programming
+//		bit2=1 -> Config3@0x8009
+//		bit3=1 -> Config4@0x800A
+//		bit4=1 -> PIC16F18xxx (calib words @0xE000 + new commands)
+// DevREV@0x8005     DevID@0x8006
+// Config1@0x8007    Config2@0x8008
+// Config3@0x8009    Config4@0x800A
+// Calib1@0x8009/A   Calib2@0x800A/B    Calib3@0x800B/C
+// eeprom@0x0 or 0xF000
+// erase: BULK_ERASE_PROG (1001) +5ms
+// write:LOAD_DATA_PROG (0010) + BEGIN_PROG (1000) + 2.5ms (8 word algorithm)
+// config write time 5ms
+// eeprom:	BULK_ERASE_DATA (1011) + 5ms
+//			LOAD_DATA_DATA (0011) + BEGIN_PROG (1000) + 2.5ms
+// verify after write
+// write (16F18xxx): LOAD_DATA_INC (100010) + BEGIN_PROG (1000) + 2.5ms (32 word algorithm)
+{
+	int err=0;
+	WORD devID=0x3fff,devREV=0x3fff,calib1=0x3fff,calib2=0x3fff,calib3=0x3fff;
+	int k=0,k2=0,z=0,i,j,w;
+	int F18x=options&16;
+	if(F18x&&FWVersion<0xA00){		//only for 16F18xxx
+		PrintMessage1(strings[S_FWver2old],"0.10.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(sizeW<0x8009){
+		PrintMessage(strings[S_NoConfigW5]);	//"Can't find CONFIG (0x8007-0x8008)\r\n"
+		PrintMessage(strings[S_End]);
+		return;
+	}
+	if((options&4)&&sizeW<0x800A){		//Config3 defaults to 0x3FFF
+		sizeW=0x800A;
+		memCODE_W=(WORD*)realloc(memCODE_W,sizeof(WORD)*sizeW);
+		memCODE_W[0x8009]=0x3FFF;
+	}
+	if((options&8)&&sizeW<0x800B){		//Config4 defaults to 0x3FFF
+		sizeW=0x800B;
+		memCODE_W=(WORD*)realloc(memCODE_W,sizeof(WORD)*sizeW);
+		memCODE_W[0x800A]=0x3FFF;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write16F1xxx(%d,%d,%d)\n",dim,dim2,options);
+	}
+	if(dim2>sizeEE) dim2=sizeEE;
+	if((options&2)==0){				//HV entry
+			if(!StartHVReg(8.5)){
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+	}
+	else StartHVReg(-1);			//LVP mode, turn off HV
+	for(i=0;i<0x800C&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+//	bufferU[0]=0;
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	if((options&2)==0){				//HV entry
+		if((options&1)==0){				//VPP before VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=4;				//VPP
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+		else{							//VDD before VPP without delay
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=1;				//VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+	}
+	else{			//Low voltage programming
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;			//0000 1010 0001 0010 1100 0010 1011 0010 = 0A12C2B2
+		bufferU[j++]=2;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x12;
+		bufferU[j++]=0xC2;
+		bufferU[j++]=0xB2;
+		bufferU[j++]=SET_CK_D;		//Clock pulse
+		bufferU[j++]=0x4;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+	}
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=LOAD_CONF;			//counter at 0x8000
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0xFF;
+	bufferU[j++]=INC_ADDR_N;
+	bufferU[j++]=0x05;
+	bufferU[j++]=READ_DATA_PROG;	//DevREV
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//DevID
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=INC_ADDR;
+	if(options&4) bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib1
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib2
+	bufferU[j++]=INC_ADDR;
+	bufferU[j++]=READ_DATA_PROG;	//Calib3
+//	bufferU[j++]=CUST_CMD;
+//	bufferU[j++]=0x16;		//Reset address
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2500>>8;
+	bufferU[j++]=2500&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devREV=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	if(devREV<0x3FFF) PrintMessage1(strings[S_DevREV],devREV);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(devID);
+	if(memCODE_W[0x8006]<0x3FFF&&devID!=memCODE_W[0x8006]) PrintMessage(strings[S_DevMismatch]);	//"Warning: the device is different from what specified in source data"
+	if(!F18x){		//16F1xxx
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		calib1=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(calib1<0x3fff) PrintMessage2(strings[S_CalibWordX],1,calib1);	//"Calibration word %d: 0x%04X\r\n"
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		calib2=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(calib2<0x3fff) PrintMessage2(strings[S_CalibWordX],2,calib2);	//"Calibration word %d: 0x%04X\r\n"
+		for(z+=3;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		calib3=(bufferI[z+1]<<8)+bufferI[z+2];
+		if(calib3<0x3fff) PrintMessage2(strings[S_CalibWordX],3,calib3);	//"Calibration word %d: 0x%04X\r\n"
+	}
+	else{		//16F18xxx
+		WORD calib[4]={0x3FFF,0x3FFF,0x3FFF,0x3FFF};
+		bufferU[j++]=LOAD_PC;			//counter at 0xE000
+		bufferU[j++]=0xE0;
+		bufferU[j++]=0x00;
+		for(i=0;i<4;i++) bufferU[j++]=READ_DATA_INC;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"Calibration area @0xE000\n");
+		}
+		for(z=0,i=0;z<DIMBUF-2&&i<4;z++){
+			if(bufferI[z]==READ_DATA_INC){
+				calib[i++]=(bufferI[z+1]<<8)+bufferI[z+2];
+				z+=2;
+			}
+		}
+		if(i!=4){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigErr],4,i);	//"Error reading config area, requested %d words, read %d\r\n"
+		}
+		else{
+			for(i=0;i<4;i++) PrintMessage2(strings[S_CalibWordX],i+1,calib[i]);	//"Calibration word %d: 0x%04X\r\n"
+		}
+	}
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erasing ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartErase]);
+	int dly=8;
+	j=0;
+	if(programID){
+		bufferU[j++]=LOAD_CONF;			//PC @ 0x8000
+		bufferU[j++]=0xFF;
+		bufferU[j++]=0xFF;
+	}
+	else if(!F18x){
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x16;		//Reset address
+	}
+	else{	//18F18xxx
+		bufferU[j++]=LOAD_PC;	//counter at 0
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=BULK_ERASE_PROG;
+	bufferU[j++]=WAIT_T3;			// wait 5ms
+	bufferU[j++]=WAIT_T3;
+	if(F18x){		//18F18xxx: EEPROM@0xF000
+		bufferU[j++]=LOAD_PC;			//counter at 0xF000
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x00;
+		bufferU[j++]=BULK_ERASE_PROG;
+		bufferU[j++]=WAIT_T3;			// wait 5ms
+		bufferU[j++]=WAIT_T3;
+		dly+=6;
+	}
+	if(!F18x){
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x16;		//Reset address
+	}
+	else{	//18F18xxx
+		bufferU[j++]=LOAD_PC;	//counter at 0
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(dly);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
+	fflush(logfile);
+	int valid,inc;
+	for(;dim>0&&memCODE_W[dim]>=0x3fff;dim--); //skip empty space at end
+	if(!F18x){					//16F1xxx
+	if(dim%8) dim+=8-dim%8;		//grow to 8 word multiple
+	for(i=k=0,j=0;i<dim;i+=8){
+		valid=inc=0;
+		for(;i<dim&&!valid;){	//skip empty locations (8 words)
+			valid=0;
+			for(k=0;k<8;k++) if(memCODE_W[i+k]<0x3fff) valid=1;
+			if(!valid){
+				inc+=8;
+				i+=8;
+			}
+			if(inc&&(valid||inc==248)){	//increase address to skip empty words
+				bufferU[j++]=INC_ADDR_N;
+				bufferU[j++]=k=inc;
+				inc=0;
+			}
+			if(j>DIMBUF-4||(valid&&j>1)){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3+k/2);
+				j=0;
+			}
+		}
+		if(valid){
+			k=0;
+			bufferU[j++]=LOAD_DATA_PROG;
+			bufferU[j++]=memCODE_W[i+k]>>8;  		//MSB
+			bufferU[j++]=memCODE_W[i+k]&0xff;		//LSB
+			for(k=1;k<8;k++){
+				bufferU[j++]=INC_ADDR;
+				bufferU[j++]=LOAD_DATA_PROG;
+				bufferU[j++]=memCODE_W[i+k]>>8;  		//MSB
+				bufferU[j++]=memCODE_W[i+k]&0xff;		//LSB
+			}
+			bufferU[j++]=BEGIN_PROG;			//internally timed, T=2.5ms
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=INC_ADDR;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d 0=%d\n"
+				}
+				PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, addr. %03X"
+			}
+		}
+	}
+	else{					//16F18xxx 32 word algorithm
+		if(dim%32) dim+=32-dim%32;		//grow to 32 word multiple
+		for(i=k=0,j=0;i<dim;i+=32){
+			for(valid=0;i<dim&&!valid;i+=valid?0:32){	//skip empty locations (32 words)
+				valid=0;
+				for(k=0;k<32;k++) if(memCODE_W[i+k]<0x3fff) valid=1;
+			}
+			bufferU[j++]=LOAD_PC;	//update counter
+			bufferU[j++]=i>>8;
+			bufferU[j++]=i&0xFF;
+			for(k=0;k<32&&i<dim;k++){
+				bufferU[j++]=k<31?LOAD_DATA_INC:LOAD_DATA_PROG;
+				bufferU[j++]=memCODE_W[i+k]>>8;  		//MSB
+				bufferU[j++]=memCODE_W[i+k]&0xff;		//LSB
+				if(j>DIMBUF-4){
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					PacketIO(3);
+					j=0;
+				}
+			}
+			if(i<dim){
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=2.5ms
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d 0=%d\n"
+			}
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, addr. %03X"
+		}
+	}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verifying code ... "
+	PrintStatusSetup();
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_CodeV]);
+	j=0;
+	if(!F18x){
+	bufferU[j++]=CUST_CMD;
+	bufferU[j++]=0x16;		//Reset address
+	}
+	else{	//18F18xxx
+		bufferU[j++]=LOAD_PC;	//counter at 0
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(i=k=0;i<dim;i++){
+		if(j==0){				//skip empty locations (only after a write)
+			for(valid=0;i<dim&&!valid;){
+				for(k2=0;k2<255&&!valid;k2++) if(memCODE_W[i+k2]<0x3fff) valid=1;
+				if(k2>16){			//increase address to skip empty words, if enough are found
+					bufferU[j++]=INC_ADDR_N;
+					bufferU[j++]=k2;
+					i+=k2;
+					k+=k2;
+				}
+				if(j>DIMBUF-4||(valid&&j>1)){		//if buffer is full or last skip
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					PacketIO(3+j/2*0.1);
+					j=0;
+				}
+			}
+		}
+		if(memCODE_W[i]<0x3FFF) bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(j>DIMBUF*2/4-3||i==dim-1){		//2B cmd -> 4B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==INC_ADDR) k++;
+				else if(bufferI[z]==READ_DATA_PROG){
+					if(memCODE_W[k]<0x3FFF&&(memCODE_W[k]!=(bufferI[z+1]<<8)+bufferI[z+2])){
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+					}
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i);	//"Verify: %d%%, addr. %04X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+			}
+			if(err>=max_err) i=dim;
+		}
+	}
+	PrintStatusEnd();
+	if(k<dim){
+		PrintMessage2(strings[S_CodeVError3],dim,k);	//"Error verifying code area, requested %d words, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** write eeprom ********************
+	if(dim2&&err<max_err&&!F18x){
+		int errEE=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEAreaW]);
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=5000>>8;
+		bufferU[j++]=5000&0xff;
+		bufferU[j++]=BULK_ERASE_DATA;
+		bufferU[j++]=WAIT_T3;			// wait 5ms
+		bufferU[j++]=CUST_CMD;
+		bufferU[j++]=0x16;		//Reset address
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);
+		j=0;
+		for(w=i=k=0;i<dim2;i++){
+			if(memEE[i]<0xff){
+				bufferU[j++]=LOAD_DATA_DATA;
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=5ms max
+				bufferU[j++]=WAIT_T3;				//Tprogram
+				bufferU[j++]=READ_DATA_DATA;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-12||i==dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*5+2);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memEE[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_DATA&&bufferI[z+3]==READ_DATA_DATA){
+						if (memEE[k]!=bufferI[z+4]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memEE[k],bufferI[z+4]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							errEE++;
+							if(max_err&&err+errEE>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"write interrupted"
+								i=dim2;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d\n"
+				}
+			}
+		}
+		errEE+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+		err+=errEE;
+	}
+	else if(dim2&&err<max_err&&F18x){	//16F18xxx
+		int errEE=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEAreaW]);
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=5000>>8;
+		bufferU[j++]=5000&0xff;
+		bufferU[j++]=LOAD_PC;	//update counter
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);
+		j=0;
+		for(w=i=k=0;i<dim2;i++){
+			if(memEE[i]<0xff){
+				bufferU[j++]=LOAD_DATA_PROG;
+				bufferU[j++]=0;
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=BEGIN_PROG;			//internally timed, T=2.5ms max
+				bufferU[j++]=WAIT_T3;				//Tprogram
+				bufferU[j++]=READ_DATA_PROG;
+				w++;
+			}
+			bufferU[j++]=INC_ADDR;
+			if(j>DIMBUF-12||i==dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*5+2);
+				w=0;
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==INC_ADDR&&memEE[k]>=0xff) k++;
+					else if(bufferI[z]==LOAD_DATA_PROG&&bufferI[z+3]==READ_DATA_PROG){
+						if (memEE[k]!=bufferI[z+5]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memEE[k],bufferI[z+5]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							errEE++;
+							if(max_err&&err+errEE>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"write interrupted"
+								i=dim2;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=6;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d\n"
+				}
+			}
+		}
+		errEE+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+		err+=errEE;
+
+	}
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	if(max_err&&err<max_err){
+		PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
+		int err_c=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=5000>>8;
+		bufferU[j++]=5000&0xff;
+		bufferU[j++]=LOAD_CONF;			//PC @ 0x8000
+		bufferU[j++]=0xFF;
+		bufferU[j++]=0xFF;
+		if(programID){
+			for(i=0x8000;i<0x8004;i++){
+				bufferU[j++]=LOAD_DATA_PROG;
+				bufferU[j++]=memCODE_W[i]>>8;		//MSB
+				bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+				bufferU[j++]=BEGIN_PROG;			//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram 5ms
+				bufferU[j++]=READ_DATA_PROG;
+				bufferU[j++]=INC_ADDR;
+			}
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=3;
+		}
+		else{
+			bufferU[j++]=INC_ADDR_N;
+			bufferU[j++]=7;
+		}
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word 0x8007
+		bufferU[j++]=memCODE_W[0x8007]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x8007]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed
+		bufferU[j++]=WAIT_T3;				//Tprogram 5ms
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		bufferU[j++]=LOAD_DATA_PROG;			//Config word 2
+		bufferU[j++]=memCODE_W[0x8008]>>8;		//MSB
+		bufferU[j++]=memCODE_W[0x8008]&0xff;		//LSB
+		bufferU[j++]=BEGIN_PROG;			//internally timed
+		bufferU[j++]=WAIT_T3;				//Tprogram 5ms
+		bufferU[j++]=READ_DATA_PROG;
+		bufferU[j++]=INC_ADDR;
+		if(options&0xC){
+			bufferU[j++]=LOAD_DATA_PROG;			//Config word 3
+			bufferU[j++]=memCODE_W[0x8009]>>8;		//MSB
+			bufferU[j++]=memCODE_W[0x8009]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram 5ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		if(options&8){
+			bufferU[j++]=LOAD_DATA_PROG;			//Config word 4
+			bufferU[j++]=memCODE_W[0x800A]>>8;		//MSB
+			bufferU[j++]=memCODE_W[0x800A]&0xff;		//LSB
+			bufferU[j++]=BEGIN_PROG;			//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram 5ms
+			bufferU[j++]=READ_DATA_PROG;
+			bufferU[j++]=INC_ADDR;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=(programID?22:0)+(options&0xC?10:0);
+		PacketIO(18+j);
+		for(i=0,z=0;programID&&i<4;i++){
+			for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+				if (memCODE_W[0x8000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+				PrintMessage("\r\n");
+				PrintMessage3(strings[S_IDErr],i,memCODE_W[0x8000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+				err_c++;
+			}
+			z+=6;
+		}
+		for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x8007]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x8007],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+		if(~memCODE_W[0x8008]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x8008],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+			err_c++;
+		}
+		if(options&0xC){
+			for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+			if(~memCODE_W[0x8009]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+				PrintMessage("\r\n");
+				PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x8009],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+				err_c++;
+			}
+		}
+		if(options&8){
+			for(z+=6;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
+			if(~memCODE_W[0x800A]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+				PrintMessage("\r\n");
+				PrintMessage2(strings[S_ConfigWErr3],memCODE_W[0x800A],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing config area: written %04X, read %04X\r\n"
+				err_c++;
+			}
+		}
+		err+=err_c;
+		PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+		if(saveLog){
+			fprintf(logfile,strings[S_Log9],err);	//"Config area 	errors=%d \n"
+		}
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+
+
+void Write16F18xxx(int dim,int dim2,int options)
+// write 14 bit enhanced PIC
+// dim=program size (words)
+// dim2=eeprom size (bytes)
+// options:
+//		bit0=0 -> vpp before vdd
+//		bit0=1 -> vdd before vpp
+//		bit1=1 -> LVP programming
+//		bit4=1 -> do not use DIA&DCI
+// DevREV@0x8005     DevID@0x8006
+// Config@0x8007-800B
+// Device info area @0x8100
+// Device configuration info area @0x8200
+// erase: BULK_ERASE_PROGRAM_MEM (0x18) +14ms
+// EEPROM erase: idem
+// write flash: LOAD_NVM (0x0/2) + BEGIN_INT_PROG (0xE0) + 2.8ms (32 word algorithm)
+// EEPROM write: one word, 6ms
+// config write: one word, 10ms
+// verify after write
+{
+	int err=0;
+	WORD devID=0x3fff,devREV=0x3fff;
+	int k=0,k2=0,z=0,i,j,w;
+	int useDCI=(options&0x10)==0?1:0;
+	int rowN=32;		//32 word algorithm
+	if(FWVersion<0xB00){
+		PrintMessage1(strings[S_FWver2old],"0.11.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(sizeW<0x800C){
+		PrintMessage(strings[S_NoConfigW6]);	//"Can't find CONFIG (0x8007-0x800B)\r\n"
+		PrintMessage1(strings[S_End],0);
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"Log.txt"
+		fprintf(logfile,"Write16F18xxx(%d,%d,%d)\n",dim,dim2,options);
+	}
+	if(dim2>0) dim2=sizeEE;
+	if(dim2>0x1000) dim2=0x100;
+	if((options&2)==0){				//HV entry
+			if(!StartHVReg(8.5)){
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+	}
+	else StartHVReg(-1);			//LVP mode, turn off HV
+	for(i=0;i<0x800C&&i<sizeW;i++) memCODE_W[i]&=0x3FFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	if((options&2)==0){				//HV entry
+		if((options&1)==0){				//VPP before VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=4;				//VPP
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+		else{							//VDD before VPP without delay
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=1;				//VDD
+			bufferU[j++]=EN_VPP_VCC;
+			bufferU[j++]=0x5;			//VDD+VPP
+		}
+	}
+	else{			//Low voltage programming
+		bufferU[j++]=EN_VPP_VCC;
+		bufferU[j++]=4;				//VPP
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;			//0000 1010 0001 0010 1100 0010 1011 0010 = 0A12C2B2
+		bufferU[j++]=2;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x12;
+		bufferU[j++]=0xC2;
+		bufferU[j++]=0xB2;
+		bufferU[j++]=SET_CK_D;		//Clock pulse
+		bufferU[j++]=0x4;
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;
+	}
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=ICSP8_LOAD;
+	bufferU[j++]=LOAD_PC_ADDR;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x05;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;	//DevREV
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;	//DevID
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2800>>8;
+	bufferU[j++]=2800&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	for(z=0;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
+	devREV=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
+	devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage1(strings[S_DevID],devID);	//"DevID: 0x%04X\r\n"
+	if(devREV<0x3FFF) PrintMessage1(strings[S_DevREV],devREV);	//"DevREV: 0x%04X\r\n"
+	PIC16_ID(devID);
+	if(memCODE_W[0x8006]<0x3FFF&&devID!=memCODE_W[0x8006]) PrintMessage(strings[S_DevMismatch]);	//"Warning: the device is different from what specified in source data"
+//****************** DIA-DCI ********************
+	if(useDCI){	//if not disabled
+		if(saveLog) fprintf(logfile,"Device Information Area @0x8100\n");
+		WORD DIA[0x20];
+		bufferU[j++]=ICSP8_LOAD;			//counter at 0x8100
+		bufferU[j++]=LOAD_PC_ADDR;
+		bufferU[j++]=0x81;
+		bufferU[j++]=0x00;
+		k=0;
+		for(i=0;i<0x20;i++){		//DIA
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==0x1F){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						DIA[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+						z+=2;
+					}
+				}
+				j=0;
+			}
+		}
+		PrintMessage("Device Information Area @0x8100\r\n");
+		char s[256],t[256];
+		s[0]=0;
+		for(i=0;i<0x20;i+=COL){
+			sprintf(t,"%04X: ",0x8100+i);
+			strcat(s,t);
+			for(j=i;j<i+COL&&j<0x20;j++){
+				sprintf(t,"%04X ",DIA[j]);
+				strcat(s,t);
+			}
+			strcat(s,"\r\n");
+		}
+		PrintMessage(s);
+		if(saveLog) fprintf(logfile,"Device Configuration Information @0x8200\n");
+		WORD DCI[0x20];
+		j=0;
+		k=0;
+		bufferU[j++]=ICSP8_LOAD;
+		bufferU[j++]=LOAD_PC_ADDR;
+		bufferU[j++]=0x82;
+		bufferU[j++]=0x00;
+		for(i=0;i<0x20;i++){		//DCI
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==0x1F){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						DCI[k++]=(bufferI[z+1]<<8)+bufferI[z+2];
+						z+=2;
+					}
+				}
+				j=0;
+			}
+		}
+		PrintMessage("Device Configuration Information @0x8200\r\n");
+		s[0]=0;
+		for(i=0;i<0x20;i+=COL){
+			sprintf(t,"%04X: ",0x8200+i);
+			strcat(s,t);
+			for(j=i;j<i+COL&&j<0x20;j++){
+				sprintf(t,"%04X ",DCI[j]);
+				strcat(s,t);
+			}
+			strcat(s,"\r\n");
+		}
+		PrintMessage(s);
+		PrintMessage1("Erase row size: %d words\r\n",DCI[0]);
+		PrintMessage1("Write latches: %d\r\n",DCI[1]);
+		PrintMessage1("User rows: %d\r\n",DCI[2]);
+		PrintMessage1("->%d Flash words\r\n",DCI[0]*DCI[2]);
+		PrintMessage1("EE data memory size: %d\r\n",DCI[3]);
+		PrintMessage1("Pin count: %d\r\n",DCI[4]);
+		if(DCI[0]*DCI[2]!=dim) PrintMessage(strings[S_WarnFlashSize]);	//"Warning, flash size is different from the expected value"
+		if(dim2>DCI[3]) dim2=DCI[3];	//limit EE to the real one
+	}
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erasing ... "
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartErase]);
+	j=0;
+	bufferU[j++]=ICSP8_LOAD;
+	bufferU[j++]=LOAD_PC_ADDR;
+	if(programID){	//0x8000 to erase UserID
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x00;
+	}
+	else{
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	}
+	bufferU[j++]=ICSP8_SHORT;
+	bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
+	bufferU[j++]=WAIT_T3;			// wait ~14ms
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	//separate EEPROM erase (undocumented on 16F184xx devices)
+	bufferU[j++]=ICSP8_LOAD;
+	bufferU[j++]=LOAD_PC_ADDR;
+	bufferU[j++]=0xF0;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP8_SHORT;
+	bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
+	bufferU[j++]=WAIT_T3;			// wait ~14ms
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(30);
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	PrintStatusSetup();
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
+	fflush(logfile);
+	int valid,inc;
+	for(;dim>0&&memCODE_W[dim-1]>=0x3fff;dim--); //skip empty space at end
+	if(dim%rowN) dim+=rowN-dim%rowN;		//grow to 32 word multiple
+	for(i=k=0,j=0;i<dim;i+=rowN){
+		for(valid=0;i<dim&&!valid;i+=valid?0:rowN){	//skip empty locations (32 words)
+			valid=0;
+			for(k=0;k<rowN;k++) if(memCODE_W[i+k]<0x3fff) valid=1;
+		}
+		bufferU[j++]=ICSP8_LOAD;
+		bufferU[j++]=LOAD_PC_ADDR;	//update counter
+		bufferU[j++]=i>>8;
+		bufferU[j++]=i&0xFF;
+		for(k=0;k<rowN&&i<dim;k++){	//load all latches
+			bufferU[j++]=ICSP8_LOAD;
+			bufferU[j++]=k<(rowN-1)?LOAD_NVM_INC:LOAD_NVM;
+			bufferU[j++]=memCODE_W[i+k]>>8;  		//MSB
+			bufferU[j++]=memCODE_W[i+k]&0xff;		//LSB
+			if(j>DIMBUF-5){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+				j=0;
+			}
+		}
+		if(i<dim){
+			bufferU[j++]=ICSP8_SHORT;
+			bufferU[j++]=BEGIN_INT_PROG;			//internally timed, T=2.8ms
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d 0=%d\n"
+			}
+			PrintStatus(strings[S_CodeWriting],i*100/dim,i);	//"Writing: %d%%, addr. %03X"
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verifying code ... "
+	PrintStatusSetup();
+	if(saveLog)	fprintf(logfile,"%s\n",strings[S_CodeV]);
+	j=0;
+	bufferU[j++]=ICSP8_LOAD;
+	bufferU[j++]=LOAD_PC_ADDR;	//update counter
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(i=k=0;i<dim;i++){
+		if(j==0){				//skip empty locations (only at the beginning of a packet)
+			for(k2=i;k2<dim&&memCODE_W[k2]>=0x3fff;k2++);
+			if(k2>i+10){			//at least 10 skipped
+				i=k2;
+				k=i;
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=LOAD_PC_ADDR;	//update counter
+				bufferU[j++]=(i>>8)&0xFF;
+				bufferU[j++]=i&0xFF;
+			}
+		}
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==dim-1){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					if(memCODE_W[k]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+						PrintMessage3(strings[S_CodeWError2],k,memCODE_W[k],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+						err++;
+					}
+					z+=2;
+					k++;
+				}
+			}
+			PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i);	//"Verify: %d%%, addr. %04X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+			}
+			if(err>=max_err) i=dim;
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** write eeprom ********************
+	else if(dim2&&err<max_err){
+		int errEE=0;
+		PrintMessage(strings[S_EEAreaW]);	//"Writing EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_EEAreaW]);
+		j=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=5600>>8;		//5.6ms in datasheet?
+		bufferU[j++]=5600&0xff;
+		bufferU[j++]=ICSP8_LOAD;
+		bufferU[j++]=LOAD_PC_ADDR;	//load address
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x00;
+		for(w=i=k=0;i<dim2;i++){
+			if(memEE[i]<0xff){
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=LOAD_NVM;
+				bufferU[j++]=0;  		//MSB
+				bufferU[j++]=memEE[i]&0xff;		//LSB
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=BEGIN_INT_PROG;		//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram XXms
+				bufferU[j++]=ICSP8_READ;
+				bufferU[j++]=READ_NVM_INC;
+				w++;
+			}
+			else{
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=INC_ADDR8;
+			}
+			if(j>DIMBUF-10||i==dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(w*6+2);
+				j=0;
+				w=0;
+				for(z=0;z<DIMBUF-5;z++){
+					if(bufferI[z]==ICSP8_SHORT&&memEE[k]>=0xff) k++;
+					else if(bufferI[z]==ICSP8_LOAD&&bufferI[z+3]==ICSP8_READ){
+						if(memEE[k]!=bufferI[z+5]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError3],k,memEE[k],bufferI[z+5]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+							errEE++;
+							if(max_err&&err+errEE>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"write interrupted"
+								i=dim2;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=5;
+					}
+				}
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d\n"
+				}
+			}
+		}
+		errEE+=i-k;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+		if(max_err&&err+errEE>max_err){
+			PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+		}
+		err+=errEE;
+	}
+//****************** write ID, CONFIG, CALIB ********************
+	if(max_err&&err<max_err){
+		char t[256];
+		PrintMessage(strings[S_ConfigAreaW]);	//"Writing CONFIG area ... "
+		PrintMessage("\r\n");
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
+		int err_c=0;
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=10000>>8;		//5.6ms in datasheet, but requires more in practice
+		bufferU[j++]=10000&0xff;
+		if(programID){
+			bufferU[j++]=ICSP8_LOAD;
+			bufferU[j++]=LOAD_PC_ADDR;	//load address
+			bufferU[j++]=0x80;
+			bufferU[j++]=0x00;
+			for(i=0x8000;i<0x8004;i++){
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=LOAD_NVM;
+				bufferU[j++]=memCODE_W[i]>>8;		//MSB
+				bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=BEGIN_INT_PROG;		//internally timed
+				bufferU[j++]=WAIT_T3;				//Tprogram 10ms
+				bufferU[j++]=ICSP8_READ;
+				bufferU[j++]=READ_NVM_INC;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(45);
+			for(i=0,z=0;i<4;i++){
+				for(;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
+				if (memCODE_W[0x8000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+					PrintMessage3(strings[S_IDErr],i,memCODE_W[0x8000+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing ID%d: written %04X, read %04X\r\n"
+					err_c++;
+				}
+				z+=6;
+			}
+			j=0;
+		}
+		bufferU[j++]=ICSP8_LOAD;
+		bufferU[j++]=LOAD_PC_ADDR;	//load address
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x07;
+		for(i=0x8007;i<0x800C;i++){		//5 config words
+			bufferU[j++]=ICSP8_LOAD;
+			bufferU[j++]=LOAD_NVM;
+			bufferU[j++]=memCODE_W[i]>>8;		//MSB
+			bufferU[j++]=memCODE_W[i]&0xff;		//LSB
+			bufferU[j++]=ICSP8_SHORT;
+			bufferU[j++]=BEGIN_INT_PROG;		//internally timed
+			bufferU[j++]=WAIT_T3;				//Tprogram 10ms
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(55);
+		for(i=0,z=0;i<5;i++){
+			for(;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
+			if (~memCODE_W[0x8007+i]&((bufferI[z+1]<<8)+bufferI[z+2])){	//error if written 0 and read 1 (~W&R)
+				
+				sprintf(t,"config%d",i+1);
+				PrintMessage3(strings[S_WErr2],t,memCODE_W[0x8007+i],(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing %s: written %04X, read %04X"
+				err_c++;
+			}
+			z+=6;
+		}
+		err+=err_c;
+		PrintMessage1(strings[S_ComplErr],err_c);	//"completed, %d errors\r\n"
+		if(saveLog){
+			fprintf(logfile,strings[S_Log9],err_c);	//"Config area 	errors=%d \n"
+		}
+	}
+//****************** exit ********************
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=NOP;				//exit program mode
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
diff --git a/progP16.h b/progP16.h
new file mode 100644
index 0000000..53a4b49
--- /dev/null
+++ b/progP16.h
@@ -0,0 +1,20 @@
+void Read16Fxxx(int dim,int dim2,int dim3,int vdd);
+void Write12F6xx(int dim,int dim2);
+void Write12F61x(int dim,int d,int d2);
+void Write12F62x(int dim,int dim2);
+void Write16F7x(int dim,int vdd);
+void Write16F71x(int dim,int vdd);
+void Write16F72x(int dim,int d,int d2);
+void Write16F62x (int dim,int dim2);
+void Write16F8x(int dim,int dim2);
+void Write16F81x(int dim,int dim2);
+void Write16F87x(int dim,int dim2);
+void Write16F87xA(int dim,int dim2,int seq);
+void Write16F88x(int dim,int dim2);
+void Read16F1xxx(int dim,int dim2,int dim3,int options);
+void Write16F1xxx(int dim,int dim2,int options);
+void Read16F18xxx(int dim,int dim2,int dim3,int options);
+void Write16F18xxx(int dim,int dim2,int options);
+void DisplayCODE16F(int size);
+void DisplayEE16F(int size);
+
diff --git a/progP18.c b/progP18.c
new file mode 100644
index 0000000..922e8bf
--- /dev/null
+++ b/progP18.c
@@ -0,0 +1,2662 @@
+/**
+ * \file progP18F.c - algorithms to program the PIC18 family of microcontrollers
+ * Copyright (C) 2009-2022 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+//This cannot be executed conditionally on MSVC
+//#include "stdafx.h"
+
+#include "common.h"
+
+struct ID18{
+	int id;
+	char *device;
+	int revmask;
+} PIC18LIST[]={
+	{0x0400,"18F252/2539 rev%d\r\n",0x1F},
+	{0x0420,"18F452/4539 rev%d\r\n",0x1F},
+	{0x0480,"18F242/2439 rev%d\r\n",0x1F},
+	{0x04A0,"18F442/4439 rev%d\r\n",0x1F},
+	{0x0500,"18F2320 rev%d\r\n",0x1F},
+	{0x0520,"18F4320 rev%d\r\n",0x1F},
+	{0x0580,"18F2220 rev%d\r\n",0x1F},
+	{0x05A0,"18F4220 rev%d\r\n",0x1F},
+	{0x0600,"18F8720 rev%d\r\n",0x1F},
+	{0x0620,"18F6720 rev%d\r\n",0x1F},
+	{0x0640,"18F8620 rev%d\r\n",0x1F},
+	{0x0660,"18F6620 rev%d\r\n",0x1F},
+	{0x07C0,"18F1320 rev%d\r\n",0x1F},
+	{0x07E0,"18F1220 rev%d\r\n",0x1F},
+	{0x0800,"18F248 rev%d\r\n",0x1F},
+	{0x0820,"18F448 rev%d\r\n",0x1F},
+	{0x0840,"18F258 rev%d\r\n",0x1F},
+	{0x0860,"18F458 rev%d\r\n",0x1F},
+	{0x0880,"18F4431 rev%d\r\n",0x1F},
+	{0x08A0,"18F4331 rev%d\r\n",0x1F},
+	{0x08C0,"18F2431 rev%d\r\n",0x1F},
+	{0x08E0,"18F2331 rev%d\r\n",0x1F},
+	{0x0B20,"18F6520 rev%d\r\n",0x1F},
+	{0x0B00,"18F8520 rev%d\r\n",0x1F},
+	{0x0C00,"18F4620 rev%d\r\n",0x1F},
+	{0x0C20,"18F4610 rev%d\r\n",0x1F},
+	{0x0C40,"18F4525 rev%d\r\n",0x1F},
+	{0x0C60,"18F4515 rev%d\r\n",0x1F},
+	{0x0C80,"18F2620 rev%d\r\n",0x1F},
+	{0x0CA0,"18F2610 rev%d\r\n",0x1F},
+	{0x0CC0,"18F2525 rev%d\r\n",0x1F},
+	{0x0CE0,"18F2515 rev%d\r\n",0x1F},
+	{0x0E80,"18F4680 rev%d\r\n",0x1F},
+	{0x0EA0,"18F4585 rev%d\r\n",0x1F},
+	{0x0EC0,"18F2680 rev%d\r\n",0x1F},
+	{0x0EE0,"18F2585 rev%d\r\n",0x1F},
+	{0x1081,"18F4523 rev%d\r\n",0x0F},
+	{0x1080,"18F4520 rev%d\r\n",0x0F},
+	{0x10A0,"18F4510 rev%d\r\n",0x1F},
+	{0x10C1,"18F4423 rev%d\r\n",0x0F},
+	{0x10C0,"18F4420 rev%d\r\n",0x0F},
+	{0x10E0,"18F4410 rev%d\r\n",0x1F},
+	{0x1100,"18F2523 rev%d\r\n",0x0F},
+	{0x1100,"18F2520 rev%d\r\n",0x0F},
+	{0x1120,"18F2510 rev%d\r\n",0x1F},
+	{0x1140,"18F2423 rev%d\r\n",0x0F},
+	{0x1140,"18F2420 rev%d\r\n",0x0F},
+	{0x1160,"18F2410 rev%d\r\n",0x1F},
+	{0x1200,"18F4550 rev%d\r\n",0x1F},
+	{0x1220,"18F4455 rev%d\r\n",0x1F},
+	{0x1240,"18F2550 rev%d\r\n",0x1F},
+	{0x1260,"18F2455 rev%d\r\n",0x1F},
+	{0x1340,"18F6527 rev%d\r\n",0x1F},
+	{0x1360,"18F8527 rev%d\r\n",0x1F},
+	{0x1380,"18F6622 rev%d\r\n",0x1F},
+	{0x13A0,"18F8622 rev%d\r\n",0x1F},
+	{0x13C0,"18F6627 rev%d\r\n",0x1F},
+	{0x13E0,"18F8627 rev%d\r\n",0x1F},
+	{0x1400,"18F6722 rev%d\r\n",0x1F},
+	{0x1420,"18F8722 rev%d\r\n",0x1F},
+	{0x1520,"18F65J10 rev%d\r\n",0x1F},
+	{0x1540,"18F65J15 rev%d\r\n",0x1F},
+	{0x1560,"18F66J10 rev%d\r\n",0x1F},
+	{0x1580,"18F66J15 rev%d\r\n",0x1F},
+	{0x15A0,"18F67J10 rev%d\r\n",0x1F},
+	{0x15E0,"18F85J10 rev%d\r\n",0x1F},
+	{0x1700,"18F85J15 rev%d\r\n",0x1F},
+	{0x1720,"18F86J10 rev%d\r\n",0x1F},
+	{0x1740,"18F86J15 rev%d\r\n",0x1F},
+	{0x1760,"18F87J10 rev%d\r\n",0x1F},
+	{0x1800,"18F66J60 rev%d\r\n",0x1F},
+	{0x1820,"18F86J60 rev%d\r\n",0x1F},
+	{0x1840,"18F96J60 rev%d\r\n",0x1F},
+	{0x1A80,"18F4580 rev%d\r\n",0x1F},
+	{0x1AA0,"18F4480 rev%d\r\n",0x1F},
+	{0x1AC0,"18F2580 rev%d\r\n",0x1F},
+	{0x1AE0,"18F2480 rev%d\r\n",0x1F},
+	{0x1C00,"18F25J10 rev%d\r\n",0x1F},
+	{0x1C20,"18F45J10 rev%d\r\n",0x1F},
+	{0x1C40,"18LF25J10 rev%d\r\n",0x1F},
+	{0x1C60,"18LF45J10 rev%d\r\n",0x1F},
+	{0x1D00,"18F24J10 rev%d\r\n",0x1F},
+	{0x1D20,"18F44J10 rev%d\r\n",0x1F},
+	{0x1D40,"18LF24J10 rev%d\r\n",0x1F},
+	{0x1D60,"18LF44J10 rev%d\r\n",0x1F},
+	{0x1E00,"18F1230 rev%d\r\n",0x1F},
+	{0x1E20,"18F1330 rev%d\r\n",0x1F},
+	{0x1F00,"18F66J65 rev%d\r\n",0x1F},
+	{0x1F20,"18F67J60 rev%d\r\n",0x1F},
+	{0x1F40,"18F86J65 rev%d\r\n",0x1F},
+	{0x1F60,"18F87J60 rev%d\r\n",0x1F},
+	{0x1F80,"18F96J65 rev%d\r\n",0x1F},
+	{0x1FA0,"18F97J60 rev%d\r\n",0x1F},
+	{0x1FE0,"18F1330-ICD rev%d\r\n",0x1F},
+	{0x2000,"18F46K20 rev%d\r\n",0x1F},
+	{0x2020,"18F26K20 rev%d\r\n",0x1F},
+	{0x2040,"18F45K20 rev%d\r\n",0x1F},
+	{0x2060,"18F25K20 rev%d\r\n",0x1F},
+	{0x2080,"18F44K20 rev%d\r\n",0x1F},
+	{0x20A0,"18F24K20 rev%d\r\n",0x1F},
+	{0x20C0,"18F43K20 rev%d\r\n",0x1F},
+	{0x20E0,"18F23K20 rev%d\r\n",0x1F},
+	{0x2100,"18F4321 rev%d\r\n",0x1F},
+	{0x2120,"18F2321 rev%d\r\n",0x1F},
+	{0x2140,"18F4221 rev%d\r\n",0x1F},
+	{0x2160,"18F2221 rev%d\r\n",0x1F},
+	{0x2400,"18F4450 rev%d\r\n",0x1F},
+	{0x2420,"18F2450 rev%d\r\n",0x1F},
+	{0x2700,"18F2682 rev%d\r\n",0x1F},
+	{0x2720,"18F2685 rev%d\r\n",0x1F},
+	{0x2740,"18F4682 rev%d\r\n",0x1F},
+	{0x2760,"18F4685 rev%d\r\n",0x1F},
+	{0x2A00,"18F4553 rev%d\r\n",0x1F},
+	{0x2A20,"18F4458 rev%d\r\n",0x1F},
+	{0x2A40,"18F2553 rev%d\r\n",0x1F},
+	{0x2A60,"18F2458 rev%d\r\n",0x1F},
+	{0x3800,"18F63J90 rev%d\r\n",0x1F},
+	{0x3820,"18F64J90 rev%d\r\n",0x1F},
+	{0x3860,"18F65J90 rev%d\r\n",0x1F},
+	{0x3880,"18F83J90 rev%d\r\n",0x1F},
+	{0x38A0,"18F84J90 rev%d\r\n",0x1F},
+	{0x38E0,"18F85J90 rev%d\r\n",0x1F},
+	{0x3900,"18F63J11 rev%d\r\n",0x1F},
+	{0x3920,"18F64J11 rev%d\r\n",0x1F},
+	{0x3960,"18F65J11 rev%d\r\n",0x1F},
+	{0x3980,"18F83J11 rev%d\r\n",0x1F},
+	{0x39A0,"18F84J11 rev%d\r\n",0x1F},
+	{0x39E0,"18F85J11 rev%d\r\n",0x1F},
+	{0x4100,"18F65J50 rev%d\r\n",0x1F},
+	{0x4140,"18F66J50 rev%d\r\n",0x1F},
+	{0x4160,"18F66J55 rev%d\r\n",0x1F},
+	{0x4180,"18F67J50 rev%d\r\n",0x1F},
+	{0x41A0,"18F85J50 rev%d\r\n",0x1F},
+	{0x41E0,"18F86J50 rev%d\r\n",0x1F},
+	{0x4200,"18F86J55 rev%d\r\n",0x1F},
+	{0x4220,"18F87J50 rev%d\r\n",0x1F},
+	{0x4440,"18F66J11 rev%d\r\n",0x1F},
+	{0x4460,"18F66J16 rev%d\r\n",0x1F},
+	{0x4480,"18F67J11 rev%d\r\n",0x1F},
+	{0x44E0,"18F86J11 rev%d\r\n",0x1F},
+	{0x4500,"18F86J16 rev%d\r\n",0x1F},
+	{0x4520,"18F87J11 rev%d\r\n",0x1F},
+	{0x4700,"18LF13K50 rev%d\r\n",0x1F},
+	{0x4720,"18LF14K50 rev%d\r\n",0x1F},
+	{0x4740,"18F13K50 rev%d\r\n",0x1F},
+	{0x4760,"18F14K50 rev%d\r\n",0x1F},
+	{0x49C0,"18F6628 rev%d\r\n",0x1F},
+	{0x49E0,"18F8628 rev%d\r\n",0x1F},
+	{0x4A00,"18F6723 rev%d\r\n",0x1F},
+	{0x4A20,"18F8723 rev%d\r\n",0x1F},
+	{0x4C00,"18F24J50 rev%d\r\n",0x1F},
+	{0x4C20,"18F25J50 rev%d\r\n",0x1F},
+	{0x4C40,"18F26J50 rev%d\r\n",0x1F},
+	{0x4C60,"18F44J50 rev%d\r\n",0x1F},
+	{0x4C80,"18F45J50 rev%d\r\n",0x1F},
+	{0x4D80,"18F24J11 rev%d\r\n",0x1F},
+	{0x4DA0,"18F25J11 rev%d\r\n",0x1F},
+	{0x4DC0,"18F26J11 rev%d\r\n",0x1F},
+	{0x4DE0,"18F44J11 rev%d\r\n",0x1F},
+	{0x4E00,"18F45J11 rev%d\r\n",0x1F},
+	{0x4E20,"18F46J11 rev%d\r\n",0x1F},
+	{0x4E60,"18LF25J11 rev%d\r\n",0x1F},
+	{0x4E80,"18LF26J11 rev%d\r\n",0x1F},
+	{0x4EA0,"18LF44J11 rev%d\r\n",0x1F},
+	{0x4EC0,"18LF45J11 rev%d\r\n",0x1F},
+	{0x4EE0,"18LF46J11 rev%d\r\n",0x1F},
+	{0x4F20,"18F14K22 rev%d\r\n",0x1F},
+	{0x4F40,"18F13K22 rev%d\r\n",0x1F},
+	{0x4F60,"18LF14K22 rev%d\r\n",0x1F},
+	{0x4F80,"18LF13K22 rev%d\r\n",0x1F},
+	{0x5000,"18F66J90 rev%d\r\n",0x1F},
+	{0x5020,"18F67J90 rev%d\r\n",0x1F},
+	{0x5040,"18F66J93/86J72 rev%d\r\n",0x1F},
+	{0x5060,"18F67J93/87J72 rev%d\r\n",0x1F},
+	{0x5080,"18F86J90 rev%d\r\n",0x1F},
+	{0x50A0,"18F87J90 rev%d\r\n",0x1F},
+	{0x50C0,"18F86J93 rev%d\r\n",0x1F},
+	{0x50E0,"18F87J93 rev%d\r\n",0x1F},
+	{0x5400,"18F46K22 rev%d\r\n",0x1F},
+	{0x5420,"18LF46K22 rev%d\r\n",0x1F},
+	{0x5440,"18F26K22 rev%d\r\n",0x1F},
+	{0x5460,"18LF26K22 rev%d\r\n",0x1F},
+	{0x5500,"18F45K22 rev%d\r\n",0x1F},
+	{0x5520,"18LF45K22 rev%d\r\n",0x1F},
+	{0x5540,"18F25K22 rev%d\r\n",0x1F},
+	{0x5560,"18LF25K22 rev%d\r\n",0x1F},
+	{0x5600,"18F44K22 rev%d\r\n",0x1F},
+	{0x5620,"18LF44K22 rev%d\r\n",0x1F},
+	{0x5640,"18F24K22 rev%d\r\n",0x1F},
+	{0x5660,"18LF24K22 rev%d\r\n",0x1F},
+	{0x5700,"18F43K22 rev%d\r\n",0x1F},
+	{0x5720,"18LF43K22 rev%d\r\n",0x1F},
+	{0x5740,"18F23K22 rev%d\r\n",0x1F},
+	{0x5760,"18LF23K22 rev%d\r\n",0x1F},
+	{0x5820,"18F26J53 rev%d\r\n",0x1F},
+	{0x5860,"18F27J53 rev%d\r\n",0x1F},
+	{0x58A0,"18F46J53 rev%d\r\n",0x1F},
+	{0x58E0,"18F47J53 rev%d\r\n",0x1F},
+	{0x5920,"18F26J13 rev%d\r\n",0x1F},
+	{0x5960,"18F27J13 rev%d\r\n",0x1F},
+	{0x59A0,"18F46J13 rev%d\r\n",0x1F},
+	{0x59E0,"18F47J13 rev%d\r\n",0x1F},
+	{0x5A20,"18LF26J53 rev%d\r\n",0x1F},
+	{0x5A60,"18LF27J53 rev%d\r\n",0x1F},
+	{0x5AA0,"18LF46J53 rev%d\r\n",0x1F},
+	{0x5AE0,"18LF47J53 rev%d\r\n",0x1F},
+	{0x5B20,"18LF26J13 rev%d\r\n",0x1F},
+	{0x5B60,"18LF27J13 rev%d\r\n",0x1F},
+	{0x5BA0,"18LF46J13 rev%d\r\n",0x1F},
+	{0x5BE0,"18LF47J13 rev%d\r\n",0x1F},
+	{0x5C00,"18F45K50 rev%d\r\n",0x1F},
+	{0x5C20,"18F25K50 rev%d\r\n",0x1F},
+	{0x5C60,"18F24K50 rev%d\r\n",0x1F},
+	{0x5C80,"18LF45K50 rev%d\r\n",0x1F},
+	{0x5CA0,"18LF25K50 rev%d\r\n",0x1F},
+	{0x5CE0,"18LF24K50 rev%d\r\n",0x1F},
+	{0x5D00,"18F46K50 rev%d\r\n",0x1F},
+	{0x5D20,"18F26K50 rev%d\r\n",0x1F},
+	{0x5D40,"18LF46K50 rev%d\r\n",0x1F},
+	{0x5D60,"18LF26K50 rev%d\r\n",0x1F},
+	{0x60E0,"18F66K80 rev%d\r\n",0x1F},
+	{0x6100,"18F46K80 rev%d\r\n",0x1F},
+	{0x6120,"18F26K80 rev%d\r\n",0x1F},
+	{0x6140,"18F65K80 rev%d\r\n",0x1F},
+	{0x6160,"18F45K80 rev%d\r\n",0x1F},
+	{0x6180,"18F25K80 rev%d\r\n",0x1F},
+	{0x61C0,"18LF66K80 rev%d\r\n",0x1F},
+	{0x61E0,"18LF46K80 rev%d\r\n",0x1F},
+	{0x6200,"18LF26K80 rev%d\r\n",0x1F},
+	{0x6220,"18LF65K80 rev%d\r\n",0x1F},
+	{0x6240,"18LF45K80 rev%d\r\n",0x1F},
+	{0x6260,"18LF25K80 rev%d\r\n",0x1F},
+	{0x6B80,"18F57K42 rev%c%d\r\n",0xFFFF},
+	{0x6BA0,"18F56K42 rev%c%d\r\n",0xFFFF},
+	{0x6BC0,"18F55K42 rev%c%d\r\n",0xFFFF},
+	{0x6BE0,"18F47K42 rev%c%d\r\n",0xFFFF},
+	{0x6C00,"18F46K42 rev%c%d\r\n",0xFFFF},
+	{0x6C20,"18F45K42 rev%c%d\r\n",0xFFFF},
+	{0x6C40,"18F27K42 rev%c%d\r\n",0xFFFF},
+	{0x6C60,"18F26K42 rev%c%d\r\n",0xFFFF},
+	{0x6CC0,"18LF57K42 rev%c%d\r\n",0xFFFF},
+	{0x6CE0,"18LF56K42 rev%c%d\r\n",0xFFFF},
+	{0x6D00,"18LF55K42 rev%c%d\r\n",0xFFFF},
+	{0x6D20,"18LF47K42 rev%c%d\r\n",0xFFFF},
+	{0x6D40,"18LF46K42 rev%c%d\r\n",0xFFFF},
+	{0x6D60,"18LF45K42 rev%c%d\r\n",0xFFFF},
+	{0x6D80,"18LF27K42 rev%c%d\r\n",0xFFFF},
+	{0x6DA0,"18LF26K42 rev%c%d\r\n",0xFFFF},
+	{0x6EC0,"18F26K83 rev%c%d\r\n",0xFFFF},
+	{0x6EE0,"18F25K83 rev%c%d\r\n",0xFFFF},
+	{0x6F00,"18LF26K83 rev%c%d\r\n",0xFFFF},
+	{0x6F20,"18LF25K83 rev%c%d\r\n",0xFFFF},
+	{0x73C0,"18F25Q43 rev%c%d\r\n",0xFFFF},
+	{0x73E0,"18F45Q43 rev%c%d\r\n",0xFFFF},
+	{0x7400,"18F55Q43 rev%c%d\r\n",0xFFFF},
+	{0x7420,"18F26Q43 rev%c%d\r\n",0xFFFF},
+	{0x7440,"18F46Q43 rev%c%d\r\n",0xFFFF},
+	{0x7460,"18F56Q43 rev%c%d\r\n",0xFFFF},
+	{0x7480,"18F27Q43 rev%c%d\r\n",0xFFFF},
+	{0x74A0,"18F47Q43 rev%c%d\r\n",0xFFFF},
+	{0x74C0,"18F57Q43 rev%c%d\r\n",0xFFFF},
+	{0x74E0,"18F15Q41 rev%c%d\r\n",0xFFFF},
+	{0x7500,"18F05Q41 rev%c%d\r\n",0xFFFF},
+	{0x7520,"18F14Q41 rev%c%d\r\n",0xFFFF},
+	{0x7540,"18F04Q41 rev%c%d\r\n",0xFFFF},
+	{0x7560,"18F16Q41 rev%c%d\r\n",0xFFFF},
+	{0x7580,"18F06Q41 rev%c%d\r\n",0xFFFF},
+	{0x75A0,"18F16Q40 rev%c%d\r\n",0xFFFF},
+	{0x75C0,"18F06Q40 rev%c%d\r\n",0xFFFF},
+	{0x75E0,"18F15Q40 rev%c%d\r\n",0xFFFF},
+	{0x7600,"18F05Q40 rev%c%d\r\n",0xFFFF},
+	{0x7620,"18F14Q40 rev%c%d\r\n",0xFFFF},
+	{0x7640,"18F04Q40 rev%c%d\r\n",0xFFFF},
+	{0x7660,"18F24Q71 rev%c%d\r\n",0xFFFF},
+	{0x76A0,"18F25Q71 rev%c%d\r\n",0xFFFF},
+	{0x76E0,"18F26Q71 rev%c%d\r\n",0xFFFF},
+	{0x7720,"18F46Q71 rev%c%d\r\n",0xFFFF},
+	{0x7760,"18F56Q71 rev%c%d\r\n",0xFFFF},
+	{0x77A0,"18F44Q71 rev%c%d\r\n",0xFFFF},
+	{0x77E0,"18F45Q71 rev%c%d\r\n",0xFFFF},
+	{0x7820,"18F54Q71 rev%c%d\r\n",0xFFFF},
+	{0x7860,"18F55Q71 rev%c%d\r\n",0xFFFF},
+	{0x9900,"18F26Q84 rev%c%d\r\n",0xFFFF},
+	{0x9901,"18F46Q84 rev%c%d\r\n",0xFFFF},
+	{0x9902,"18F56Q84 rev%c%d\r\n",0xFFFF},
+	{0x9903,"18F27Q84 rev%c%d\r\n",0xFFFF},
+	{0x9904,"18F47Q84 rev%c%d\r\n",0xFFFF},
+	{0x9905,"18F57Q84 rev%c%d\r\n",0xFFFF},
+	{0x9906,"18F26Q83 rev%c%d\r\n",0xFFFF},
+	{0x9907,"18F46Q83 rev%c%d\r\n",0xFFFF},
+	{0x9908,"18F56Q83 rev%c%d\r\n",0xFFFF},
+	{0x9909,"18F27Q83 rev%c%d\r\n",0xFFFF},
+	{0x990A,"18F47Q83 rev%c%d\r\n",0xFFFF},
+	{0x990B,"18F57Q83 rev%c%d\r\n",0xFFFF},
+};
+
+void PIC18_ID(int id)
+{
+	char s[128];
+	int i;
+	for(i=0;i<sizeof(PIC18LIST)/sizeof(PIC18LIST[0]);i++){
+		if(PIC18LIST[i].revmask!=0xFFFF&&PIC18LIST[i].id==(id&~PIC18LIST[i].revmask)){
+			sprintf(s,PIC18LIST[i].device,id&PIC18LIST[i].revmask);
+			PrintMessage(s);
+			return;
+		}
+		else if(PIC18LIST[i].revmask==0xFFFF&&PIC18LIST[i].id==(id&0xFFFF)){
+			int MJrev=(id>>22)&0x3F;
+			int MNrev=(id>>16)&0x3F;
+			sprintf(s,PIC18LIST[i].device,MJrev+'A',MNrev);
+			PrintMessage(s);
+			return;
+		}
+	}
+	sprintf(s,"%s",strings[S_nodev]); //"Unknown device\r\n");
+	PrintMessage(s);
+}
+
+void DisplayCODE18F(int dim){
+// display  PIC18F CODE memory
+	char s[256]="",t[256]="";
+	char* aux=(char*)malloc((dim/COL+1)*(16+COL*6));
+	aux[0]=0;
+	int valid=0,empty=1,i,j,lines=0;
+	for(i=0;i<dim&&i<size;i+=COL*2){
+		valid=0;
+		for(j=i;j<i+COL*2&&j<dim;j++){
+			sprintf(t,"%02X ",memCODE[j]);
+			strcat(s,t);
+			if(memCODE[j]<0xff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s\r\n",i,s);
+			strcat(aux,t);
+			empty=0;
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=(dim<size?dim:size)-COL*4;
+				lines=490;
+			}
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+void Read18Fx(int dim,int dim2,int options)
+// read 16 bit PIC 18Fxxxx
+// dim=program size (bytes) 	dim2=eeprom size (bytes)
+// options:
+//	bit [3:0]
+//   0 = vdd before vpp (12V)
+//   1 = vdd before vpp (9V)
+//   2 = low voltage entry with 32 bit key
+//   3 = vdd before vpp (9V) with 32 bit key
+//	bit [7:4]
+//     0 = normal control registers address
+//     1 = new control registers address (18FxxK80)
+{
+	int k=0,k2=0,z=0,i,j;
+	int entry=options&0xF;
+	int newAddr=(options>>4)&0xF;
+	if(dim>0x1FFFFF||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(entry>0&&!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	double vpp=-1;
+	if(entry==0) vpp=12;
+	else if(entry==1||entry==3) vpp=8.5;
+	if(!StartHVReg(vpp)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Read18F(%d,%d,%d)    (0x%X,0x%X,0x%X)\n",dim,dim2,options,dim,dim2,options);
+	}
+	size=dim;
+	sizeEE=dim2;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(size);		//CODE
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(sizeEE);			//EEPROM
+	for(j=0;j<8;j++) memID[j]=0xFF;
+	for(j=0;j<14;j++) memCONFIG[j]=0xFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=NOP;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	if(entry==2){					//LV entry with key
+		bufferU[j++]=EN_VPP_VCC;		//VDD
+		bufferU[j++]=0x1;
+	}
+	if(entry==2||entry==3){			//entry with key
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x4D;
+		bufferU[j++]=0x43;
+		bufferU[j++]=0x48;
+		bufferU[j++]=0x50;
+		bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=WAIT_T3;
+	}
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//3F
+	bufferU[j++]=0x3F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRU
+	bufferU[j++]=0xF8;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//FF
+	bufferU[j++]=0xFF;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRH
+	bufferU[j++]=0xF7;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//FE
+	bufferU[j++]=0xFE;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRL
+	bufferU[j++]=0xF6;
+	bufferU[j++]=TBLR_INC_N;		//DevID1-2	0x3FFFFE-F
+	bufferU[j++]=2;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRU
+	bufferU[j++]=0xF8;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRH
+	bufferU[j++]=0xF7;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRL
+	bufferU[j++]=0xF6;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(entry==2?11:4);
+	for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF;z++);
+	if(z<DIMBUF-3){
+		PrintMessage2(strings[S_DevID2],bufferI[z+3],bufferI[z+2]);	//"DevID: 0x%02X%02X\r\n"
+		PIC18_ID(bufferI[z+2]+(bufferI[z+3]<<8));
+	}
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//code read ...
+	PrintStatusSetup();
+	if(saveLog)	fprintf(logfile,"Read code\n");
+	for(i=0,j=0;i<dim;i+=DIMBUF-4){
+		bufferU[j++]=TBLR_INC_N;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF;z++);
+		for(j=z+2;(j<z+2+bufferI[z+1])&&j<DIMBUF;j++) memCODE[k++]=bufferI[j];
+		PrintStatus(strings[S_CodeReading2],i*100/(dim+dim2),i);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read config area ********************
+	if(saveLog)	fprintf(logfile,"Read config\n");
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//TBLPTRU	ID 0x200000
+	bufferU[j++]=0x20;			//TBLPTRU	ID 0x200000
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//TBLPTRU
+	bufferU[j++]=0xF8;			//TBLPTRU
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRH
+	bufferU[j++]=0xF7;			//TBLPTRH
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRL
+	bufferU[j++]=0xF6;			//TBLPTRL
+	bufferU[j++]=TBLR_INC_N;
+	bufferU[j++]=8;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//TBLPTRU	CONFIG 0x300000
+	bufferU[j++]=0x30;			//TBLPTRU	CONFIG 0x300000
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//TBLPTRU
+	bufferU[j++]=0xF8;			//TBLPTRU
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRH
+	bufferU[j++]=0xF7;			//TBLPTRH
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRL
+	bufferU[j++]=0xF6;			//TBLPTRL
+	bufferU[j++]=TBLR_INC_N;
+	bufferU[j++]=14;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(8);
+	for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF-28;z++);
+	if(z<DIMBUF-28){
+		for(i=0;i<8;i++) memID[k2++]=bufferI[z+i+2];
+		for(;i<14+8;i++) memCONFIG[-8+k2++]=bufferI[z+i+8];
+	}
+	j=0;
+	if(saveLog){
+		fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+	}
+	if(k2!=22){
+		PrintMessage2(strings[S_ReadConfigErr],22,k2);	//"Error reading config area, requested %d bytes, read %d\r\n"
+	}
+//****************** read eeprom ********************
+	if(dim2){
+		PrintMessage(strings[S_ReadEE]);		//read eeprom ...
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"Read EEPROM\n");
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x9E;				//EEPGD=0
+		bufferU[j++]=newAddr==0?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x9C;				//CFGS=0
+		bufferU[j++]=newAddr==0?0xA6:0x7F;
+		for(k2=0,i=0;i<dim2;i++){
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;			//MOVLW
+			bufferU[j++]=i&0xFF;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;					//MOVWF
+			bufferU[j++]=newAddr==0?0xA9:0x74;	//ADDR
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;		//MOVLW
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;					//MOVWF
+			bufferU[j++]=newAddr==0?0xAA:0x75;	//ADDRH
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x80;			//RD=1
+			bufferU[j++]=newAddr==0?0xA6:0x7F;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x50;			//MOVF EEDATA,w
+			bufferU[j++]=newAddr==0?0xA8:0x73;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//MOVWF TABLAT
+			bufferU[j++]=0xF5;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x00;			//NOP
+			bufferU[j++]=0x00;
+			bufferU[j++]=SHIFT_TABLAT;
+			if(j>DIMBUF-26||i==dim2-1){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(10);
+				for(z=0;z<DIMBUF-1;z++){
+					if(bufferI[z]==SHIFT_TABLAT){
+						memEE[k2++]=bufferI[z+1];
+						z+=8;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i+dim)*100/(dim+dim2),i);	//"Read: %d%%, addr. %03X"
+				if(RWstop) i=dim2;
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k2!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,k2);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+	PrintMessage("\r\n");
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=1;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	for(i=0;i<8;i+=2){
+		PrintMessage4(strings[S_ChipID2],i,memID[i],i+1,memID[i+1]);	//"ID%d: 0x%02X   ID%d: 0x%02X\r\n"
+	}
+	for(i=0;i<7;i++){
+		PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]);	//"CONFIG%dH: 0x%02X\t"
+		PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]);	//"CONFIG%dL: 0x%02X\r\n"
+	}
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+	DisplayCODE18F(dim);
+	if(dim2){
+		DisplayEE();	//visualize
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Write18Fx(int dim,int dim2,int wbuf,int eraseW1,int eraseW2,int options)
+// write 16 bit PIC 18Fxxxx
+// dim=program size  (bytes)	dim2=eeprom size (bytes)	wbuf=write buffer size {<=64}
+// eraseW1=erase word @3C0005	(not used if >= 0x10000)
+// eraseW2=erase word @3C0004	(not used if >= 0x10000)
+// options:
+//	bit [3:0]
+//     0 = vdd before vpp (12V)
+//     1 = vdd before vpp (9V)
+//     2 = low voltage entry with 32 bit key
+//     3 = vdd before vpp (9V) with 32 bit key
+//	bit [7:4]
+//     0 = normal eeprom write algoritm
+//     1 = with unlock sequence 55 AA
+//	bit [11:8]
+//     0 = 15ms erase delay, 1ms code write time, 5ms EE write, 5ms config write
+//     1 = 550ms erase delay, 1.2ms code write time, no config or EEPROM
+//     2 = 550ms erase delay, 3.4ms code write time, no config or EEPROM
+//     3 = separate block erase with 5ms delay, 1ms code write, 5ms EE write, 5ms config write
+//         + new control registers address (18FxxK80)
+{
+	int k=0,k2,z=0,i,j;
+	int err=0;
+	int EEalgo=(options>>4)&0xF,entry=options&0xF,optWrite=(options>>8)&0xF;
+	if(dim>0x1FFFFF||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(wbuf>64){
+		PrintMessage(strings[S_WbufLim]);	//"Write buffer size out of limits\r\n"
+		return;
+	}
+	if(entry>0&&!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	double vpp=-1;
+	if(entry==0) vpp=12;
+	else if(entry==1||entry==3) vpp=8.5;
+	if(!StartHVReg(vpp)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write18F(%d,%d,%d,%d)    (0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,wbuf,options,dim,dim2,wbuf,options);
+	}
+	if(dim>size) dim=size;
+	if(dim%wbuf){			//grow to an integer number of rows
+		dim+=wbuf-dim%wbuf;
+		j=size;
+		if(j<dim){
+			size=dim;
+			memCODE=(unsigned char*)realloc(memCODE,size);
+			for(;j<dim;j++) memCODE[j]=0xFF;
+		}
+	}
+	if(dim2>sizeEE) dim2=sizeEE;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Empty data area\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=1;						//T1=1u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	if(entry==2){					//LV entry with key
+		bufferU[j++]=EN_VPP_VCC;		//VDD
+		bufferU[j++]=0x1;
+	}
+	if(entry==2||entry==3){			//entry with key
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=WAIT_T3;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x4D;
+		bufferU[j++]=0x43;
+		bufferU[j++]=0x48;
+		bufferU[j++]=0x50;
+		bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=WAIT_T3;
+	}
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//3F
+	bufferU[j++]=0x3F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRU
+	bufferU[j++]=0xF8;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//FF
+	bufferU[j++]=0xFF;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRH
+	bufferU[j++]=0xF7;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x0E;			//FE
+	bufferU[j++]=0xFE;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6E;			//-> TBLPTRL
+	bufferU[j++]=0xF6;
+	bufferU[j++]=TBLR_INC_N;		//DevID1-2	0x3FFFFE-F
+	bufferU[j++]=2;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=5100>>8;
+	bufferU[j++]=5100&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(entry==2?10:3);
+	for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF;z++);
+	if(z<DIMBUF-3){
+		PrintMessage2(strings[S_DevID2],bufferI[z+3],bufferI[z+2]);	//"DevID: 0x%02X%02X\r\n"
+		PIC18_ID(bufferI[z+2]+(bufferI[z+3]<<8));
+	}
+	j=0;
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(optWrite!=3){	//chip erase
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//3C
+		bufferU[j++]=0x3C;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//-> TBLPTRU
+		bufferU[j++]=0xF8;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//TBLPTRH=0
+		bufferU[j++]=0xF7;
+		if(eraseW1<0x10000){
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;			//05
+			bufferU[j++]=0x05;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//-> TBLPTRL
+			bufferU[j++]=0xF6;
+			bufferU[j++]=TABLE_WRITE;		// eraseW1@3C0005
+			bufferU[j++]=(eraseW1>>8)&0xFF; 	//0x3F;
+			bufferU[j++]=eraseW1&0xFF; 		//0x3F;
+		}
+		if(eraseW2<0x10000){
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;			//04
+			bufferU[j++]=0x04;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//-> TBLPTRL
+			bufferU[j++]=0xF6;
+			bufferU[j++]=TABLE_WRITE;		// eraseW2@3C0004
+			bufferU[j++]=(eraseW2>>8)&0xFF; 	//0x8F;
+			bufferU[j++]=eraseW2&0xFF; 		//0x8F;
+		}
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(16);	
+		if(optWrite!=0)	msDelay(550);//bulk erase delay
+		j=0;
+	}
+	else{	//separate block erase
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 3C
+		bufferU[j++]=0x3C;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+		bufferU[j++]=0xF8;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRH
+		bufferU[j++]=0xF7;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x04 @ 0x3C0004
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x01 @ 0x3C0005
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x01;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE BLOCK0\n");
+		}
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x04 @ 0x3C0004
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x02 @ 0x3C0005
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x02;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE BLOCK1\n");
+		}
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x04 @ 0x3C0004
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x04 @ 0x3C0005
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE BLOCK2\n");
+		}
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x04 @ 0x3C0004
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x08 @ 0x3C0005
+		bufferU[j++]=0x08;
+		bufferU[j++]=0x08;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE BLOCK3\n");
+		}
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x05 @ 0x3C0004
+		bufferU[j++]=0x05;
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x00 @ 0x3C0005
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE BOOT BLOCK\n");
+		}
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 4
+		bufferU[j++]=0x04;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x02 @ 0x3C0004
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x02;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 5
+		bufferU[j++]=0x05;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x00 @ 0x3C0005
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//MOVLW 6
+		bufferU[j++]=0x06;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+		bufferU[j++]=0xF6;
+		bufferU[j++]=TABLE_WRITE;	//0x80 @ 0x3C0006
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x80;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=CORE_INS;		//NOP
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(7);	//block erase delay
+		j=0;
+		if(saveLog){
+			fprintf(logfile,"ERASE CONFIG\n");
+		}
+		if(programID){
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x8E;			//EEPGD=1
+			bufferU[j++]=0x7F;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x9C;			//CFGS=0
+			bufferU[j++]=0x7F;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x84;			//WREN=1
+			bufferU[j++]=0x7F;
+			bufferU[j++]=CORE_INS;		//ID 0x200000
+			bufferU[j++]=0x0E;			//MOVLW
+			bufferU[j++]=0x20;			//
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+			bufferU[j++]=0xF8;			//
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6A;			//CLRF TBLPTRH
+			bufferU[j++]=0xF7;			//CLRF TBLPTRH
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6A;			//CLRF TBLPTRL
+			bufferU[j++]=0xF6;			//CLRF TBLPTRL
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x88;			//FREE=1
+			bufferU[j++]=0x7F;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x82;			//WR=1
+			bufferU[j++]=0x7F;
+			bufferU[j++]=CORE_INS;		//NOP
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x00;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(7);	//row erase delay
+			j=0;
+			if(saveLog){
+				fprintf(logfile,"ERASE ID\n");
+			}
+		}
+	}
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** prepare write ********************
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x8E;			//EEPGD=1
+	bufferU[j++]=optWrite!=3?0xA6:0x7F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x9C;			//CFCGS=0
+	bufferU[j++]=optWrite!=3?0xA6:0x7F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x84;			//WREN=1
+	bufferU[j++]=optWrite!=3?0xA6:0x7F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRU
+	bufferU[j++]=0xF8;			//TBLPTRU
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRH
+	bufferU[j++]=0xF7;			//TBLPTRH
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//TBLPTRL
+	bufferU[j++]=0xF6;			//TBLPTRL
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	j=0;
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"code write ... "
+	PrintStatusSetup();
+	int ww;
+	double wdly=1.0;
+	if(optWrite==1) wdly=1.2;
+	if(optWrite==2) wdly=3.4;
+	if(saveLog){
+		fprintf(logfile,"WRITE CODE\ndim=%d(0x%X)\n",dim,dim);	//
+	}
+	int valid,i0;
+	j=0;
+	for(i=k=0;i<dim;){		//write xx instruction words
+		if(k==0){				//skip row if empty
+			i0=i;
+			for(valid=0;!valid&&i<dim;i+=valid?0:wbuf){
+				for(k2=0;k2<wbuf&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+			}
+			if(i>=dim) break;
+			if(i>i0){				//some rows were skipped; update current address
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x0E;
+				bufferU[j++]=(i>>16)&0xFF;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+				bufferU[j++]=0xF8;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x0E;
+				bufferU[j++]=(i>>8)&0xFF;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;			//MOVWF TBLPTRH
+				bufferU[j++]=0xF7;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x0E;
+				bufferU[j++]=i&0xFF;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+				bufferU[j++]=0xF6;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+			}
+		}
+		if(DIMBUF-4-j<wbuf-2-k)	ww=(DIMBUF-4-j)/2;	//split data for a total of wbuf-2
+		else ww=(wbuf-2-k)/2;
+		bufferU[j++]=TBLW_INC_N;
+		bufferU[j++]=ww;
+		for(z=0;z<ww;z++){
+			bufferU[j++]=memCODE[i+1];
+			bufferU[j++]=memCODE[i];
+			i+=2;
+		}
+		k+=ww*2;
+		if(k==wbuf-2){	//Write row
+			if(j>DIMBUF-8){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+				j=0;
+			}
+			bufferU[j++]=TBLW_PROG_INC;
+			bufferU[j++]=memCODE[i+1];
+			bufferU[j++]=memCODE[i];
+			if(optWrite==1){	//1.2ms
+				bufferU[j++]=1200>>8;
+				bufferU[j++]=1200&0xFF;
+			}
+			else if(optWrite==2){	//3.4ms
+				bufferU[j++]=3400>>8;
+				bufferU[j++]=3400&0xFF;
+			}
+			else{				//1ms
+				bufferU[j++]=1000>>8;
+				bufferU[j++]=1000&0xFF;
+			}
+			i+=2;
+			k=0;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(k==0?wdly:2);
+		j=0;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim+dim2),i/2);	//"Write: %d%%,addr. %04X"
+		if(RWstop) i=dim;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d, k=%d 0=%d\n"
+		}
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write ID ********************
+	if(programID&&(optWrite==0||optWrite==3)){
+		PrintMessage(strings[S_IDW]);	//"Write ID ... "
+		if(saveLog)	fprintf(logfile,"Write ID\n");
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x8E;			//EEPGD=1
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x9C;			//CFCGS=0
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//TBLPTRU	ID 0x200000
+		bufferU[j++]=0x20;			//TBLPTRU	ID 0x200000
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//TBLPTRU
+		bufferU[j++]=0xF8;			//TBLPTRU
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRH
+		bufferU[j++]=0xF7;			//CLRF TBLPTRH
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRL
+		bufferU[j++]=0xF6;			//CLRF TBLPTRL
+		bufferU[j++]=TBLW_INC_N;
+		bufferU[j++]=3;
+		for(i=0;i<3;i++){
+			bufferU[j++]=memID[i*2+1];
+			bufferU[j++]=memID[i*2];
+		}
+		bufferU[j++]=TBLW_PROG;
+		bufferU[j++]=memID[i*2+1];
+		bufferU[j++]=memID[i*2];
+		bufferU[j++]=1000>>8;		//only one write so no need to specify different delay
+		bufferU[j++]=1000&0xFF;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d 0=%d\n"
+		}
+		PrintMessage(strings[S_Compl]);	//"completed\r\n"
+	}
+//****************** write and verify EEPROM ********************
+	if(dim2&&(optWrite==0||optWrite==3)){
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"Write EEPROM\n");
+		int errEE=0;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x9E;			//EEPGD=0
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x9C;			//CFGS=0
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x84;			//WREN=1
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		for(i=0;i<dim2&&err<=max_err;i++){
+			if(memEE[i]!=0xFF){
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x0E;			//MOVLW
+				bufferU[j++]=i&0xFF;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;					//MOVWF
+				bufferU[j++]=optWrite!=3?0xA9:0x74;	//ADDR
+				if(EEalgo==0){
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x0E;		//MOVLW
+					bufferU[j++]=(i>>8)&0xFF;
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x6E;					//MOVWF
+					bufferU[j++]=optWrite!=3?0xAA:0x75;	//ADDRH
+				}
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x0E;			//MOVLW
+				bufferU[j++]=memEE[i];
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;					//MOVWF
+				bufferU[j++]=optWrite!=3?0xA8:0x73;	//EEDATA
+				if(EEalgo==1){				//memory unlock
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x0E;		//MOVLW
+					bufferU[j++]=0x55;
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x6E;		//MOVWF
+					bufferU[j++]=0xA7;			//EECON2
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x0E;		//MOVLW
+					bufferU[j++]=0xAA;
+					bufferU[j++]=CORE_INS;
+					bufferU[j++]=0x6E;		//MOVWF
+					bufferU[j++]=0xA7;			//EECON2
+				}
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x82;
+				bufferU[j++]=optWrite!=3?0xA6:0x7F;	//WR=1
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x00;			//NOP
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x00;			//NOP
+				bufferU[j++]=WAIT_T3;		//write delay
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x80;			//RD=1
+				bufferU[j++]=optWrite!=3?0xA6:0x7F;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x50;			//MOVF EEDATA,w
+				bufferU[j++]=optWrite!=3?0xA8:0x73;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x6E;			//MOVWF TABLAT
+				bufferU[j++]=0xF5;
+				bufferU[j++]=CORE_INS;
+				bufferU[j++]=0x00;			//NOP
+				bufferU[j++]=0x00;
+				bufferU[j++]=SHIFT_TABLAT;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(8);
+				PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i);	//"Writing: %d%%, addr. %03X"
+				if(RWstop) i=dim2;
+				j=0;
+				for(z=DIMBUF-1;z&&!(bufferI[z]==SHIFT_TABLAT&&bufferI[z-1]==CORE_INS);z--);
+				if(z&&memEE[i]!=bufferI[z+1]) errEE++;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed: %d errors \r\n"
+		err+=errEE;
+	}
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verify code ... "
+	PrintStatusSetup();
+	if(saveLog)fprintf(logfile,"VERIFY CODE\n");
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x8E;			//EEPGD=1
+	bufferU[j++]=optWrite!=3?0xA6:0x7F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x9C;			//CFCGS=0
+	bufferU[j++]=optWrite!=3?0xA6:0x7F;
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRU
+	bufferU[j++]=0xF8;			//CLRF TBLPTRU
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRH
+	bufferU[j++]=0xF7;			//CLRF TBLPTRH
+	bufferU[j++]=CORE_INS;
+	bufferU[j++]=0x6A;			//CLRF TBLPTRL
+	bufferU[j++]=0xF6;			//CLRF TBLPTRL
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	if(saveLog){
+		fprintf(logfile,"\n\n");
+	}
+	for(i=0,j=0,k=0;i<dim;i+=DIMBUF-4){
+		i0=i;
+		for(valid=0;!valid&&i<dim;i+=valid?0:DIMBUF-4){		//skip verification if 0xFF
+			for(k2=0;k2<DIMBUF-4&&!valid&&i+k2<dim;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+		}
+		if(i>=dim) break;
+		if(i>i0){				//some data was skipped; update current address
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;
+			bufferU[j++]=(i>>16)&0xFF;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+			bufferU[j++]=0xF8;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;
+			bufferU[j++]=(i>>8)&0xFF;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//MOVWF TBLPTRH
+			bufferU[j++]=0xF7;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x0E;
+			bufferU[j++]=i&0xFF;
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x6E;			//MOVWF TBLPTRL
+			bufferU[j++]=0xF6;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+		}
+		bufferU[j++]=TBLR_INC_N;
+		bufferU[j++]=i<dim-(DIMBUF-4)?DIMBUF-4:dim-i;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		if(bufferI[1]==TBLR_INC_N){
+			for(z=0;z<bufferI[2]&&z<DIMBUF;z++){
+				if(memCODE[i+z]!=bufferI[z+3]){
+					PrintMessage4(strings[S_CodeVError],i+z,i+z,memCODE[i+z],bufferI[z+3]);	//"Error writing address %4X: written %02X, read %02X\r\n"
+					err++;
+				}
+				//k++;
+			}
+		}
+		PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i);	//"Verifica: %d%%, ind. %04X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	if(i<dim){
+		PrintMessage2(strings[S_CodeVError2],dim,i);	//"Error verifying code area, requested %d bytes, read %d\r\n"
+	}
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** verify ID ********************
+	if(programID&&err<max_err&&optWrite==0){
+		PrintMessage(strings[S_IDV]);	//"Verify ID ... "
+		int errID=0;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//TBLPTRU	ID 0x200000
+		bufferU[j++]=0x20;			//TBLPTRU	ID 0x200000
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//TBLPTRU
+		bufferU[j++]=0xF8;			//TBLPTRU
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRH
+		bufferU[j++]=0xF7;			//CLRF TBLPTRH
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRL
+		bufferU[j++]=0xF6;			//CLRF TBLPTRL
+		bufferU[j++]=TBLR_INC_N;
+		bufferU[j++]=8;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF;z++);
+		for(i=0;i<8;i++) if(memID[i]!=0xFF&&memID[i]!=bufferI[z+i+2]) errID++;
+		PrintMessage1(strings[S_ComplErr],errID);	//"completed: %d errors\r\n"
+		err+=errID;
+		if(err>=max_err){
+			PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+		}
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,0,0,err);	//"i=%d, k=%d, errors=%d\n"
+		}
+	}
+//****************** write CONFIG ********************
+	if(err<max_err&&(optWrite==0||optWrite==3)){
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"Write CONFIG\n");
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x8E;			//EEPGD=1
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x8C;			//CFCGS=1
+		bufferU[j++]=optWrite!=3?0xA6:0x7F;
+		bufferU[j++]=CORE_INS;		//CONFIG 0x300000
+		bufferU[j++]=0x0E;			//MOVLW
+		bufferU[j++]=0x30;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+		bufferU[j++]=0xF8;			//MOVWF TBLPTRU
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRH
+		bufferU[j++]=0xF7;			//CLRF TBLPTRH
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRL
+		bufferU[j++]=0xF6;			//CLRF TBLPTRL
+		for(i=0;i<14;i++){
+			if(memCONFIG[i]<0xFF){
+				bufferU[j++]=TBLW_PROG;
+				bufferU[j++]=0;
+				bufferU[j++]=memCONFIG[i];
+				bufferU[j++]=5000>>8;
+				bufferU[j++]=5000&0xFF;
+			}
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x2A;			//INCF
+			bufferU[j++]=0xF6;			//TBLPTRL
+			i++;
+			if(memCONFIG[i]<0xFF){
+				bufferU[j++]=TBLW_PROG;
+				bufferU[j++]=memCONFIG[i];
+				bufferU[j++]=0;
+				bufferU[j++]=5000>>8;
+				bufferU[j++]=5000&0xFF;
+			}
+			bufferU[j++]=CORE_INS;
+			bufferU[j++]=0x2A;			//INCF
+			bufferU[j++]=0xF6;			//TBLPTRL
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(12);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d\n"
+			}
+		}
+		PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify CONFIG ********************
+		PrintMessage(strings[S_ConfigV]);	//"Verify CONFIG ... "
+		int errC=0;
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x0E;			//TBLPTRU	CONFIG 0x300000
+		bufferU[j++]=0x30;			//
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6E;			//MOVWF TBLPTRU
+		bufferU[j++]=0xF8;			//MOVWF TBLPTRU
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRH
+		bufferU[j++]=0xF7;			//CLRF TBLPTRH
+		bufferU[j++]=CORE_INS;
+		bufferU[j++]=0x6A;			//CLRF TBLPTRL
+		bufferU[j++]=0xF6;			//CLRF TBLPTRL
+		bufferU[j++]=TBLR_INC_N;
+		bufferU[j++]=14;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		for(z=0;bufferI[z]!=TBLR_INC_N&&z<DIMBUF-16;z++);
+		if(z<DIMBUF-16){
+			for(i=0;i<14;i++) if(~memCONFIG[i]&bufferI[z+i+2]) errC++;	//error if written 0 and read 1 (~W&R)
+		}
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed: %d errors\r\n"
+		err+=errC;
+		if(err>=max_err){
+			PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+		}
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i,i,0,0,err);	//"i=%d, k=%d, errors=%d\n"
+		}
+	}
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=1;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+#define LOAD_PC_ADDR 0x80
+#define BULK_ERASE 0x18
+#define ROW_ERASE_PROGRAM_MEM 0xF0
+#define LOAD_NVM 0x00
+#define LOAD_NVM_INC 0x02
+#define READ_NVM 0xFC
+#define READ_NVM_INC 0xFE
+#define INC_ADDR8 0xF8
+#define BEGIN_INT_PROG 0xE0
+#define BEGIN_EXT_PROG 0xC0
+#define PROGRAM_DATA 0xC0
+#define PROGRAM_DATA_INC 0xE0
+#define END_EXT_PROG 0x82
+
+void Read18FKx(int dim,int dim2,int options)
+// read 16 bit PIC 18FxxKx3 with new 8b commands
+// dim=program size (bytes)
+// dim2=if>0 use eeprom, size is automatic when reading DCI
+// options:
+//	bit [3:0]
+//   	0 = vpp before vdd (8.5V)
+//	bit [7:4] 	memory layout
+//		code	config	EE			DCI			DIA			model
+//		 0		5		0x310000	0x3FFF00	0x3F0000	K42 K83
+//		 1		10		0x380000	0x3C0000	0x2C0000	Q40-43
+//		 2		35		0x380000	0x3C0000	0x2C0000	Q83-84
+{
+	int k=0,k2=0,z=0,i,j;
+	int devID=0,devREV=0;
+	int MemAddr;
+	int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0;
+	int type=(options>>4)&0xF;
+	if(type==0){		//K42 K83
+		EEaddr=0x310000;
+		DCIaddr=0x3FFF00;
+		DIAaddr=0x3F0000;
+		DIAlen=0x40;
+		UIDlen=0x10;
+		CONFIGlen=5;
+	}
+	else if(type==1){		//Q43
+		EEaddr=0x380000;
+		DCIaddr=0x3C0000;
+		DIAaddr=0x2C0000;
+		DIAlen=0x100;
+		UIDlen=0x40;
+		CONFIGlen=10;
+	}
+	else if(type==2){		//Q83-84
+		EEaddr=0x380000;
+		DCIaddr=0x3C0000;
+		DIAaddr=0x2C0000;
+		DIAlen=0x100;
+		UIDlen=0x40;
+		CONFIGlen=35;
+	}
+	else PrintMessage("unexpected parameter");
+	if(dim>0x1FFFFF||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	double vpp=8.5;
+	if(!StartHVReg(vpp)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Read18FKx(%d,%d,%d)    (0x%X,0x%X,0x%X)\n",dim,dim2,options,dim,dim2,options);
+	}
+	size=dim;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(size);		//CODE
+	unsigned char* memDIA=(unsigned char*)malloc(DIAlen);		//DIA
+	for(j=0;j<64;j++) memID[j]=0xFF;
+	for(j=0;j<14;j++) memCONFIG[j]=0xFF;
+	for(j=0;j<DIAlen;j++) memDIA[j]=0xFF;
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=2;						//T1=2u
+	bufferU[j++]=100;					//T2=100u
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=WAIT_T3;
+	MemAddr=0x3FFFFc<<1;		//devREV
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	MemAddr=DCIaddr<<1;		//DCI
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x0;
+	bufferU[j++]=0x0;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(4);
+	for(z=0;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		devREV=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	PrintMessage1("DevID: 0x%04X\r\n",devID);
+	PrintMessage1("RevID: 0x%04X\r\n",devREV);
+	PIC18_ID(devID+(devREV<<16));
+	PrintMessage("Device Configuration Information:\r\n");
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("Write latches per row: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+		sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-3){
+		PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//read code ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]);		//read code ...
+	PrintStatusSetup();
+	for(i=0,j=0;i<dim;i+=2){		//2 bytes per read
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==dim-2){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;				//remember: FLUSH generates a response (even empty)!
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memCODE[k++]=bufferI[z+2];	//Low byte
+					memCODE[k++]=bufferI[z+1];	//High byte
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(i+sizeEE+10+UIDlen+DIAlen)*100/(dim+sizeEE+10+UIDlen+DIAlen),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read config area ********************
+	PrintMessage(strings[S_Read_CONFIG_A]);		//read config ...
+	if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]);		//read config ...
+	MemAddr=0x300000<<1;		//config area
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	k2=0;
+	for(i=0;i<CONFIGlen;i++){		//Config
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==CONFIGlen-1){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memCONFIG[k2++]=bufferI[z+2];	//LSB
+					if(type==0) memCONFIG[k2++]=bufferI[z+1];	//MSB
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(dim+sizeEE+i+UIDlen+DIAlen)*100/(dim+sizeEE+CONFIGlen+UIDlen+DIAlen),i);	//"Read: %d%%, addr %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=10){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadConfigErr],10,k2);	//"Error reading config area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read user ID ********************
+	if(saveLog) fprintf(logfile,"Read user ID\n");
+	MemAddr=0x200000<<1;		//user ID
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	k2=0;
+	for(i=0;i<UIDlen;i+=2){
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==UIDlen-2){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memID[k2++]=bufferI[z+2];	//Low byte
+					memID[k2++]=bufferI[z+1];	//High byte
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(dim+sizeEE+10+i+DIAlen)*100/(dim+sizeEE+10+UIDlen+DIAlen),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=UIDlen){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadConfigErr],UIDlen,k2);	//"Error reading config area, requested %d bytes, read %d\r\n"
+	}
+//****************** read device info area (DIA) ********************
+	if(saveLog) fprintf(logfile,"Read device info area\n");
+	MemAddr=DIAaddr<<1;		//DIA
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	k2=0;
+	for(i=0;i<DIAlen;i+=2){		//DIA
+		bufferU[j++]=ICSP8_READ;
+		bufferU[j++]=READ_NVM_INC;
+		if((j+1)/2*3+3>DIMBUF||i==DIAlen-2){		//2B cmd -> 3B data
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			for(z=0;z<DIMBUF-2;z++){
+				if(bufferI[z]==ICSP8_READ){
+					memDIA[k2++]=bufferI[z+2];
+					memDIA[k2++]=bufferI[z+1];
+					z+=2;
+				}
+			}
+			PrintStatus(strings[S_CodeReading],(dim+sizeEE+10+UIDlen+i)*100/(dim+sizeEE+10+UIDlen+DIAlen),i);	//"Read: %d%%, addr. %03X"
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+	}
+	if(k2!=DIAlen){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadConfigErr],DIAlen,k2);	//"Error reading config area, requested %d bytes, read %d\r\n"
+	}
+	//****************** read eeprom ********************
+	if(dim2){					//EEPROM
+		if(sizeEE>0x1000||sizeEE<0){		//Max 4K
+			PrintMessage(strings[S_EELim]);	//"EEPROM size exceeds limits\r\n"
+			return;
+		}
+		if(memEE) free(memEE);
+		memEE=(unsigned char*)malloc(sizeEE);			//EEPROM
+		for(i=0;i<sizeEE;i++) memEE[i]=0xFF;
+		PrintMessage(strings[S_ReadEE]);		//Read EEPROM ...
+		if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]);		//Read EEPROM ...
+		MemAddr=EEaddr<<1;		//EE base address
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		for(i=k=0;i<sizeEE;i++){
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==sizeEE-1){		//2B cmd -> 3B answer
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(5);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						memEE[k++]=bufferI[z+2];	//LSB
+						z+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(dim+i+10+UIDlen+DIAlen)*100/(dim+sizeEE+10+UIDlen+DIAlen),i);	//"Read: %d%%, addr %03X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k!=sizeEE){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],sizeEE,k);	//"Error reading EE area, ..."
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+//****************** exit ********************
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=1;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	PrintMessage(strings[S_ConfigMem]);	//"CONFIG"
+	for(i=0;i<UIDlen;i+=2){
+		if(memID[i]<0xFF||memID[i+1]<0xFF) PrintMessage4(strings[S_ChipID2],i,memID[i],i+1,memID[i+1]);	//"ID%d: 0x%02X   ID%d: 0x%02X\r\n"
+	}
+	if(type==0){	//K42 K83 etc.
+		for(i=0;i<5;i++){
+			PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]);	//"CONFIG%dH: 0x%02X\t"
+			PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]);	//"CONFIG%dL: 0x%02X\r\n"
+		}
+	}
+	else if(type==1){	//Q43 etc.
+		for(i=0;i<10;i++)	PrintMessage2("CONFIG%d: 0x%02X\r\n",i+1,memCONFIG[i]);
+	}
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+	DisplayCODE18F(dim);
+	if(dim2){
+		DisplayEE();	//visualize
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
+// write 16 bit PIC 18FxxKx3 with new 8b commands
+// dim=program size (bytes) 	dim2=eeprom size (bytes)
+// options:
+//	bit [3:0]
+//   	0 = vpp before vdd (8.5V)
+//	bit [7:4] 	memory layout
+//		code	config	EE			DCI			DIA			model	program cycle	delays ms (E,W,EE)
+//		 0		5		0x310000	0x3FFF00	0x3F0000	K42 K83	multiple-word	25.5 2.8 5.6
+//		 1		10		0x380000	0x3C0000	0x2C0000	Q40-43  one-word 		11 0.075 11
+//		 2		35		0x380000	0x3C0000	0x2C0000	Q83-84	one-word 		11 0.075 11
+{
+	int k=0,k2,z=0,i,j,x=0,w=0;
+	int err=0;
+	int devID=0,devREV=0;
+	int MemAddr,rowN=0;
+	int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0;
+	int type=(options>>4)&0xF;
+	if(type==0){		//K42 K83
+		EEaddr=0x310000;
+		DCIaddr=0x3FFF00;
+		DIAaddr=0x3F0000;
+		DIAlen=0x40;
+		UIDlen=0x10;
+		CONFIGlen=5;
+	}
+	else if(type==1){		//Q43
+		EEaddr=0x380000;
+		DCIaddr=0x3C0000;
+		DIAaddr=0x2C0000;
+		DIAlen=0x100;
+		UIDlen=0x40;
+		CONFIGlen=10;
+	}
+	else if(type==2){		//Q83-84
+		EEaddr=0x380000;
+		DCIaddr=0x3C0000;
+		DIAaddr=0x2C0000;
+		DIAlen=0x100;
+		UIDlen=0x40;
+		CONFIGlen=35;
+	}
+	else PrintMessage("unexpected parameter");
+	if(dim>0x1FFFFF||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x800||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	double vpp=8.5;
+	if(!StartHVReg(vpp)){
+		PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();	//"log.txt"
+		fprintf(logfile,"Write18FKx(%d,%d,%d)    (0x%X,0x%X,0x%X)\n",dim,dim2,options,dim,dim2,options);
+	}
+	if(dim>size) dim=size;
+	if(dim2>sizeEE) dim2=sizeEE;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Empty data area\r\n"
+		return;
+	}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T1T2;
+	bufferU[j++]=2;						//T1=2u
+	bufferU[j++]=35;					//T2 adjusted to obtain ~80us when needed
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=11000>>8;
+	bufferU[j++]=11000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//VPP
+	bufferU[j++]=0x4;
+	bufferU[j++]=EN_VPP_VCC;		//VDD+VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=WAIT_T3;
+	MemAddr=0x3FFFFc<<1;		//devREV
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	MemAddr=DCIaddr<<1;		//DCI
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=MemAddr>>16;
+	bufferU[j++]=(MemAddr>>8)&0xFF;
+	bufferU[j++]=MemAddr&0xFF;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=ICSP8_READ;
+	bufferU[j++]=READ_NVM_INC;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x0;
+	bufferU[j++]=0x0;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(14);
+	for(z=0;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		devREV=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		devID=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	PrintMessage1("DevID: 0x%04X\r\n",devID);
+	PrintMessage1("RevID: 0x%04X\r\n",devREV);
+	PIC18_ID(devID+(devREV<<16));
+	PrintMessage("Device Configuration Information:\r\n");
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		rowN=(bufferI[z+1]<<8)+bufferI[z+2];
+		PrintMessage1("Write latches per row: %d\r\n",rowN);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+		sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
+	}
+	for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+	if(z<DIMBUF-3){
+		PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+	}
+	j=0;
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(type==0){		//K42 K83
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=25500>>8;
+		bufferU[j++]=25500&0xff;
+		MemAddr=0x300000<<1;	//address to erase Flash+User+Config
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		bufferU[j++]=ICSP8_SHORT;
+		bufferU[j++]=BULK_ERASE;
+		bufferU[j++]=WAIT_T3;	//TERAB
+		MemAddr=0x310000<<1;	//address to erase EEPROM
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		bufferU[j++]=ICSP8_SHORT;
+		bufferU[j++]=BULK_ERASE;
+		bufferU[j++]=WAIT_T3;	//TERAB
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=2800>>8;
+		bufferU[j++]=2800&0xff;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(52);
+	}
+	else if(type==1){	//Q43
+		bufferU[j++]=ICSP8_LOAD;
+		bufferU[j++]=BULK_ERASE;
+		bufferU[j++]=0;
+		bufferU[j++]=0xF;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1);
+		msDelay(12);		//bulk erase delay
+	}
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"code write ... "
+	PrintStatusSetup();
+	if(saveLog){
+		fprintf(logfile,"WRITE CODE\ndim=%d(0x%X)\n",dim,dim);	//
+	}
+	if(type==1){	//Q43
+		j=0;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x0;
+		bufferU[j++]=0x0;
+		bufferU[j++]=0x0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(i=k=0;i<dim;i+=2){
+			if(memCODE[i]<0xFF||memCODE[i+1]<0xFF){
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=PROGRAM_DATA;
+				bufferU[j++]=memCODE[i+1];	//High byte
+				bufferU[j++]=memCODE[i];	//Low byte
+				bufferU[j++]=WAIT_T2;		//Tprogram 75us
+				bufferU[j++]=ICSP8_READ;
+				bufferU[j++]=READ_NVM_INC;
+			}
+			else{
+				for(x=0;i+x<dim&&memCODE[i+x]==0xFF&&memCODE[i+x+1]==0xFF;x+=2);
+				if(x>9){	//set new address
+					i+=x;
+					MemAddr=i<<1;
+					bufferU[j++]=TX16;
+					bufferU[j++]=2;
+					bufferU[j++]=0x80;
+					bufferU[j++]=MemAddr>>16;
+					bufferU[j++]=(MemAddr>>8)&0xFF;
+					bufferU[j++]=MemAddr&0xFF;
+					i-=2;
+				}
+				else{
+					bufferU[j++]=ICSP8_SHORT;
+					bufferU[j++]=INC_ADDR8;
+				}
+			}
+			if(j>DIMBUF-8||i==dim-2){
+				PrintStatus(strings[S_CodeWriting],i*100/(dim+dim2),i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==ICSP8_SHORT&&memCODE[k]==0xff&&memCODE[k+1]==0xff) k+=2;
+					else if(bufferI[z]==TX16){		//need to find the next valid address
+						for(;k<dim&&memCODE[k]==0xFF&&memCODE[k+1]==0xFF;k+=2);
+					}
+					else if(bufferI[z]==ICSP8_LOAD&&bufferI[z+2]==ICSP8_READ){
+						if(memCODE[k]!=bufferI[z+4]||memCODE[k+1]!=bufferI[z+3]){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError2],k,(memCODE[k+1]<<8)+memCODE[k],(bufferI[z+3]<<8)+bufferI[z+4]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+							err++;
+							if(max_err&&err>max_err){
+								PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								i=dim;
+								z=DIMBUF;
+							}
+						}
+						k+=2;
+						z+=4;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d,\n"
+				}
+			}
+		}
+		err+=i-k;
+	}
+	else if(type==0){		//K42 K83
+		int valid;
+		for(;dim>0&&memCODE[dim-1]==0xff&&memCODE[dim-2]==0xff;dim-=2); //skip empty space at end
+		if(dim%rowN) dim+=rowN-dim%rowN;		//grow to N byte multiple
+		if(dim>size){
+			memCODE=(unsigned char*)realloc(memCODE,dim);
+			for(;size<dim;size++) memCODE[size]=0xFF;
+		}
+		for(i=k=0,j=0;i<dim;i+=rowN){
+			for(valid=0;i<dim&&!valid;i+=valid?0:rowN){	//skip empty locations (N words)
+				valid=0;
+				for(k=0;k<rowN;k++){	//check row
+					if(memCODE[i+k]<0xff){
+						valid=1;
+						k=rowN;
+					}
+				}
+			}
+			MemAddr=i<<1;
+			bufferU[j++]=TX16;	//load new address
+			bufferU[j++]=2;
+			bufferU[j++]=0x80;
+			bufferU[j++]=MemAddr>>16;
+			bufferU[j++]=(MemAddr>>8)&0xFF;
+			bufferU[j++]=MemAddr&0xFF;
+			for(k=0;k<rowN;k+=2){	//load all latches
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=k<(rowN-2)?LOAD_NVM_INC:LOAD_NVM;
+				bufferU[j++]=memCODE[i+k+1];	//High byte
+				bufferU[j++]=memCODE[i+k];	//Low byte
+				if(j>DIMBUF-5){
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					PacketIO(2);
+					j=0;
+				}
+			}
+			if(i<dim){
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=BEGIN_INT_PROG;			//internally timed, T=2.8ms
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(6);
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d, k=%d 0=%d\n"
+				}
+				PrintStatus(strings[S_CodeWriting],i*100/(dim*2+dim2),i);	//"Writing: %d%%, addr. %03X"
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage(strings[S_Compl]);	//"completed\r\n"
+		//****************** verify code ********************
+		PrintMessage(strings[S_CodeV]);	//"Verifying code ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"%s\n",strings[S_CodeV]);
+		j=0;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x0;
+		bufferU[j++]=0x0;
+		bufferU[j++]=0x0;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(i=k=0;i<dim;i+=2){
+			if(j==0){				//skip empty locations (only at the beginning of a packet)
+				for(x=0;i+x<dim&&memCODE[i+x]==0xFF&&memCODE[i+x+1]==0xFF;x+=2);
+				if(x>9){	//set new address
+					i+=x;
+					k=i;
+					MemAddr=i<<1;
+					bufferU[j++]=TX16;
+					bufferU[j++]=2;
+					bufferU[j++]=0x80;
+					bufferU[j++]=MemAddr>>16;
+					bufferU[j++]=(MemAddr>>8)&0xFF;
+					bufferU[j++]=MemAddr&0xFF;
+				}
+			}
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if((j+1)/2*3+3>DIMBUF||i==dim-2){		//2B cmd -> 3B data
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==ICSP8_READ){
+						if(memCODE[k]!=bufferI[z+2]||memCODE[k+1]!=bufferI[z+1]){
+							PrintMessage3(strings[S_CodeWError2],k,memCODE[k]+(memCODE[k+1]<<8),(bufferI[z+1]<<8)+bufferI[z+2]);	//"Error writing address %3X: written %04X, read %04X\r\n"
+							err++;
+						}
+						z+=2;
+						k+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeV2],(i+dim)/(dim*2+dim2)*100,i);	//"Verify: %d%%, addr. %04X"
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,err);	//"i=%d, k=%d, errors=%d\n"
+				}
+				if(err>=max_err){
+					PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+					i=dim;
+				}	
+			}
+		}
+		bufferU[j++]=SET_PARAMETER;
+		bufferU[j++]=SET_T3;
+		bufferU[j++]=5600>>8;
+		bufferU[j++]=5600&0xff;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(1);
+		j=0;
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed, %d errors\r\n"
+//****************** write and verify EEPROM ********************
+	if(dim2){
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"WRITE EEPROM\ndim2=%d(0x%X)\n",dim2,dim2);
+		int errEE=0;
+		j=0;
+		MemAddr=EEaddr<<1;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		for(i=k=0;i<dim2;i++){
+			if(memEE[i]<0xFF){
+				if(type==1){	//Q43
+					bufferU[j++]=ICSP8_LOAD;
+					bufferU[j++]=PROGRAM_DATA;
+					bufferU[j++]=0;
+					bufferU[j++]=memEE[i];
+				}
+				else if(type==0){		//K42 K83
+					bufferU[j++]=ICSP8_LOAD;
+					bufferU[j++]=LOAD_NVM;
+					bufferU[j++]=0;	//High byte
+					bufferU[j++]=memEE[i];	//Low byte
+					bufferU[j++]=ICSP8_SHORT;
+					bufferU[j++]=BEGIN_INT_PROG;			//internally timed
+				}
+				bufferU[j++]=WAIT_T3;				//Tprogram 11ms or 5.6ms
+				bufferU[j++]=ICSP8_READ;
+				bufferU[j++]=READ_NVM_INC;
+				w++;
+			}
+			else{
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=INC_ADDR8;
+			}
+			if(j>DIMBUF-8||i==dim2-1){
+				PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i+EEaddr);	//"Writing: %d%%, addr. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				w*=type==1?11:5.6;	//total write time
+				PacketIO(w+10);
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==ICSP8_SHORT&&memEE[k]==0xff) k++;
+					else if(bufferI[z]==ICSP8_LOAD){
+						w=type==1?bufferI[z+4]:bufferI[z+5];
+						if(memEE[k]!=w){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError2],k,memEE[k],w);	//"Error writing address %3X: written %04X, read %04X\r\n"
+							errEE++;
+							if(max_err&&err+errEE>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errEE);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=dim2;
+								z=DIMBUF;
+							}
+						}
+						k++;
+						z+=type==1?4:5;
+					}
+				}
+				j=0;
+				w=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errEE);	//"i=%d, k=%d, errors=%d,\n"
+				}
+			}
+		}
+		errEE+=i-k;
+		err+=errEE;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errEE);	//"completed, %d errors\r\n"
+	}
+//****************** write and verify ID ********************
+	#define IDaddr 0x200000
+	if(programID){
+		PrintMessage(strings[S_IDW]);	//"Write ID ... "
+		if(saveLog)	fprintf(logfile,"Write ID\n");
+		int errID=0;
+		j=0;
+		MemAddr=IDaddr<<1;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		for(i=k=0;i<UIDlen;i+=2){
+			if(memID[i]<0xFF||memID[i+1]<0xFF){
+				if(type==1){	//Q43
+					bufferU[j++]=ICSP8_LOAD;
+					bufferU[j++]=PROGRAM_DATA;
+					bufferU[j++]=memID[i+1];
+					bufferU[j++]=memID[i];
+				}
+				else if(type==0){		//K42 K83
+					bufferU[j++]=ICSP8_LOAD;
+					bufferU[j++]=LOAD_NVM;
+					bufferU[j++]=memID[i+1];
+					bufferU[j++]=memID[i];
+					bufferU[j++]=ICSP8_SHORT;
+					bufferU[j++]=BEGIN_INT_PROG;			//internally timed
+				}
+				bufferU[j++]=WAIT_T3;				//Tprogram 11ms or 5.6ms
+				bufferU[j++]=ICSP8_READ;
+				bufferU[j++]=READ_NVM_INC;
+			}
+			else{
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=INC_ADDR8;
+			}
+			if(j>DIMBUF-8||i==UIDlen-2){
+				PrintStatus(strings[S_CodeWriting],99,IDaddr+i);	//"Writing: %d%%, add. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(80);
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==ICSP8_SHORT&&memID[k]==0xff&&memID[k+1]==0xff) k+=2;
+					else if(bufferI[z]==ICSP8_LOAD){
+						if(type==1) w=(bufferI[z+3]<<8)+bufferI[z+4];
+						else if(type==0) w=(bufferI[z+4]<<8)+bufferI[z+5];
+						x=(memID[k+1]<<8)+memID[k];
+						if(x!=w){
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError2],k,x,w);	//"Error writing address %3X: written %04X, read %04X\r\n"
+							errID++;
+							if(max_err&&err+errID>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errID);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=UIDlen;
+								z=DIMBUF;
+							}
+						}
+						k+=2;
+						z+=type==1?4:5;
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errID);	//"i=%d, k=%d, errors=%d,\n"
+				}
+			}
+		}
+		errID+=i-k;
+		err+=errID;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errID);	//"completed, %d errors\r\n"
+	}
+//****************** write and verify CONFIG ********************
+	#define CONFIGaddr 0x300000
+	if(err<max_err){
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"Write CONFIG\n");
+		int errC=0;
+		j=0;
+		MemAddr=CONFIGaddr<<1;
+		bufferU[j++]=TX16;
+		bufferU[j++]=2;
+		bufferU[j++]=0x80;
+		bufferU[j++]=MemAddr>>16;
+		bufferU[j++]=(MemAddr>>8)&0xFF;
+		bufferU[j++]=MemAddr&0xFF;
+		for(i=k=0;i<CONFIGlen;i++){
+			if(type==1){	//Q43
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=PROGRAM_DATA;
+				bufferU[j++]=0;
+				bufferU[j++]=memCONFIG[i];
+			}
+			else if(type==0){		//K42 K83
+				bufferU[j++]=ICSP8_LOAD;
+				bufferU[j++]=LOAD_NVM;
+				bufferU[j++]=memCONFIG[i*2+1];	//High byte
+				bufferU[j++]=memCONFIG[i*2];	//Low byte
+				bufferU[j++]=ICSP8_SHORT;
+				bufferU[j++]=BEGIN_INT_PROG;			//internally timed
+			}
+			bufferU[j++]=WAIT_T3;				//Tprogram 11ms or 5.6ms
+			bufferU[j++]=ICSP8_READ;
+			bufferU[j++]=READ_NVM_INC;
+			if(j>DIMBUF-8||i==CONFIGlen-1){
+				PrintStatus(strings[S_CodeWriting],99,i+CONFIGaddr);	//"Writing: %d%%, addr. %03X"
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(80);
+				for(z=0;z<DIMBUF-4;z++){
+					if(bufferI[z]==ICSP8_LOAD){
+						if(type==1){	//Q43 single byte
+							w=bufferI[z+4];
+							x=memCONFIG[k];
+						}
+						else if(type==0){	//K42 K83 2 bytes
+							w=(bufferI[z+4]<<8)+bufferI[z+5];
+							x=(memCONFIG[k+1]<<8)+memCONFIG[k];
+						}
+						if(~x&w){	//error if written 0 and read 1 (~Written&Read)
+							PrintMessage("\r\n");
+							PrintMessage3(strings[S_CodeWError2],k+CONFIGaddr,x,w);	//"Error writing address %3X: written %04X, read %04X\r\n"
+							errC++;
+							if(max_err&&err+errC>max_err){
+								PrintMessage1(strings[S_MaxErr],err+errC);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+								PrintMessage(strings[S_IntW]);	//"Write interrupted"
+								i=dim2;
+								z=DIMBUF;
+							}
+						}
+						if(type==1){	//Q43 single byte
+							k++;
+							z+=4;
+						}
+						else if(type==0){	//K42 K83 2 bytes
+							k+=2;
+							z+=5;
+						}
+					}
+				}
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log8],i,i,k,k,errC);	//"i=%d, k=%d, errors=%d,\n"
+				}
+			}
+		}
+		errC+=10-k;
+		err+=errC;
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed, %d errors\r\n"
+	}
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=1;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(1);
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+
diff --git a/progP18.h b/progP18.h
new file mode 100644
index 0000000..c937bfe
--- /dev/null
+++ b/progP18.h
@@ -0,0 +1,6 @@
+void Read18Fx(int dim,int dim2,int options);
+void Read18FKx(int dim,int dim2,int options);
+void Write18Fx(int dim,int dim2,int wbuf,int eraseW1,int eraseW2,int options);
+void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3);
+void DisplayCODE18F(int dim);
+
diff --git a/progP24.c b/progP24.c
new file mode 100644
index 0000000..435b931
--- /dev/null
+++ b/progP24.c
@@ -0,0 +1,3917 @@
+/**
+ * \file progP24F.c - algorithms to program the PIC24 family of microcontrollers
+ * Copyright (C) 2009-2021 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+/*
+                ICSP  Code(KWord) EE(B) Config     Code_er Row Row_wr EE_er EE_wr Conf_wr wr_seq
+24F0xKAxxx      HV|LV  1.375-5.5   512  00-10(8b)   4064   32  4004   4050  4004   4004    NO
+24FJxxGA0xx     LV     5.5-44      NO   Code-2(16b) 404F   64  4001   -     -      4003    NO
+24FJxxGA1x/GB0x LV     11-22       NO   Code-4(16b) 404F   64  4001   -     -      4003    NO
+xDA/GB2/GA3/GC   "     22-87                   "            "                 "
+(new TABLPAG)
+24FJxxGB1x      LV     22-87       NO   Code-3(16b) 404F   64  4001   -     -      4003    NO
+24HJ-33FJ       LV      2-88       NO  00-12/16(8b) 404F   64  4001   -     -      4000    NO
+24E-33E         LV     11-88       NO   Code-20(8b) 400F    2  4001   -     -      4001   55-AA
+(new TABLPAG, new algorithm)
+30Fxx10-16      HV2     4-48      0-4K  00-0C(16b)  407F   32  4001   seq.  4004   4008   55-AA
+30F2020-23      LV5V    2-4        NO   00-0E(16b)  407F   32  4001   -     -      4008   55-AA
+
+*/
+
+#include "common.h"
+
+void CheckData(int a,int b,int addr,int *err)
+{
+	if(a!=b){
+#ifdef _MSC_VER
+		CString str;
+#endif
+		PrintMessage(strings[S_NL]);
+		PrintMessage4(strings[S_CodeVError],addr,addr,a,b);	//"Error writing address %4X: written %02X, read %02X\r\n"
+		(*err)++;
+	}
+}
+
+struct ID24{
+	int id;
+	char *device;
+} PIC24LIST[]={
+	{0x0040,"30F2010"},
+	{0x0041,"24HJ64GP206"},
+	{0x0047,"24HJ64GP210"},
+	{0x0049,"24HJ64GP506"},
+	{0x004B,"24HJ64GP510"},
+	{0x005D,"24HJ128GP206"},
+	{0x005F,"24HJ128GP210"},
+	{0x0061,"24HJ128GP506"},
+	{0x0063,"24HJ128GP510"},
+	{0x0065,"24HJ128GP306"},
+	{0x0067,"24HJ128GP310"},
+	{0x0071,"24HJ256GP206"},
+	{0x0073,"24HJ256GP210"},
+	{0x007B,"24HJ256GP610"},
+	{0x0080,"30F5011"},
+	{0x0081,"30F5013"},
+	{0x0089,"33FJ64MC506"},
+	{0x008A,"33FJ64MC508"},
+	{0x008B,"33FJ64MC510"},
+	{0x0091,"33FJ64MC706"},
+	{0x0097,"33FJ64MC710"},
+	{0x00A1,"33FJ128MC506"},
+	{0x00A3,"33FJ128MC510"},
+	{0x00A9,"33FJ128MC706"},
+	{0x00AE,"33FJ128MC708"},
+	{0x00AF,"33FJ128MC710"},
+	{0x00B7,"33FJ256MC510"},
+	{0x00BF,"33FJ256MC710"},
+	{0x00C1,"30F3012/33FJ64GP206"},
+	{0x00C3,"30F3013"},
+	{0x00CD,"33FJ64GP306"},
+	{0x00CF,"33FJ64GP310"},
+	{0x00D5,"33FJ64GP706"},
+	{0x00D6,"33FJ64GP708"},
+	{0x00D7,"33FJ64GP710"},
+	{0x00D9,"33FJ128GP206"},
+	{0x00E5,"33FJ128GP306"},
+	{0x00E7,"33FJ128GP310"},
+	{0x00ED,"33FJ128GP706"},
+	{0x00EE,"33FJ128GP708"},
+	{0x00EF,"33FJ128GP710"},
+	{0x00F5,"33FJ256GP506"},
+	{0x00F7,"33FJ256GP510"},
+	{0x00FF,"33FJ256GP710"},
+	{0x0100,"30F4012"},
+	{0x0101,"30F4011"},
+	{0x0141,"30F4013"},
+	{0x0160,"30F3014"},
+	{0x0188,"30F6010"},
+	{0x0192,"30F6011"},
+	{0x0193,"30F6012"},
+	{0x0197,"30F6013"},
+	{0x0198,"30F6014"},
+	{0x01C0,"30F3010"},
+	{0x01C1,"30F3011"},
+	{0x0200,"30F5015"},
+	{0x0201,"30F5016"},
+	{0x0240,"30F2011"},
+	{0x0241,"30F2012"},
+	{0x0280,"30F6015"},
+	{0x0281,"30F6010A"},
+	{0x02C0,"30F6011A"},
+	{0x02C1,"30F6013A"},
+	{0x02C2,"30F6012A"},
+	{0x02C3,"30F6014A"},
+	{0x0400,"30F2020"},
+	{0x0403,"30F2023"},
+	{0x0404,"30F1010"},
+	{0x0405,"24FJ64GA006"},
+	{0x0406,"24FJ96GA006"},
+	{0x0407,"24FJ128GA006"},
+	{0x0408,"24FJ64GA008"},
+	{0x0409,"24FJ96GA008"},
+	{0x040A,"24FJ128GA008"},
+	{0x040B,"24FJ64GA010"},
+	{0x040C,"24FJ96GA010"},
+	{0x040D,"24FJ128GA010"},
+	{0x0444,"24FJ16GA002"},
+	{0x0445,"24FJ32GA002"},
+	{0x0446,"24FJ48GA002"},
+	{0x0447,"24FJ64GA002"},
+	{0x044C,"24FJ16GA004"},
+	{0x044D,"24FJ32GA004"},
+	{0x044E,"24FJ48GA004"},
+	{0x044F,"24FJ64GA004"},
+	{0x0601,"33FJ32MC302"},
+	{0x0603,"33FJ32MC304"},
+	{0x0605,"33FJ32GP302"},
+	{0x0607,"33FJ32GP304"},
+	{0x0611,"33FJ64MC202"},
+	{0x0613,"33FJ64MC204"},
+	{0x0615,"33FJ64GP202"},
+	{0x0617,"33FJ64GP204"},
+	{0x0619,"33FJ64MC802"},
+	{0x061B,"33FJ64MC804"},
+	{0x061D,"33FJ64GP802"},
+	{0x061F,"33FJ64GP804"},
+	{0x0621,"33FJ128MC202"},
+	{0x0623,"33FJ128MC204"},
+	{0x0625,"33FJ128GP202"},
+	{0x0627,"33FJ128GP204"},
+	{0x0629,"33FJ128MC802"},
+	{0x062B,"33FJ128MC804"},
+	{0x062D,"33FJ128GP802"},
+	{0x062F,"33FJ128GP804"},
+	{0x0645,"24HJ32GP302"},
+	{0x0647,"24HJ32GP304"},
+	{0x0655,"24HJ64GP202"},
+	{0x0657,"24HJ64GP204"},
+	{0x0665,"24HJ128GP202"},
+	{0x0667,"24HJ128GP204"},
+	{0x0675,"24HJ64GP502"},
+	{0x0677,"24HJ64GP504"},
+	{0x067D,"24HJ128GP502"},
+	{0x067F,"24HJ128GP504"},
+	{0x0771,"24HJ256GP206A"},
+	{0x0773,"24HJ256GP210A"},
+	{0x077B,"24HJ256GP610A"},
+	{0x07B7,"33FJ256MC510A"},
+	{0x07BF,"33FJ256MC710A"},
+	{0x07F5,"33FJ256GP506A"},
+	{0x07F7,"33FJ256GP510A"},
+	{0x07FF,"33FJ256GP710A"},
+	{0x0800,"33FJ12MC201"},
+	{0x0801,"33FJ12MC202"},
+	{0x0802,"33FJ12GP201"},
+	{0x0803,"33FJ12GP202"},
+	{0x080A,"24HJ12GP201"},
+	{0x080B,"24HJ12GP202"},
+	{0x0C00,"33FJ06GS101"},
+	{0x0C01,"33FJ06GS102"},
+	{0x0C02,"33FJ06GS202"},
+	{0x0C03,"33FJ16GS502"},
+	{0x0C04,"33FJ16GS402"},
+	{0x0C05,"33FJ16GS504"},
+	{0x0C06,"33FJ16GS404"},
+	{0x0D00,"24F04KA201"},
+	{0x0D01,"24F16KA101"},
+	{0x0D02,"24F04KA200"},
+	{0x0D03,"24F16KA102"},
+	{0x0D08,"24F08KA101"},
+	{0x0D0A,"24F08KA102"},
+	{0x0F03,"33FJ16MC304"},
+	{0x0F07,"33FJ16GP304"},
+	{0x0F09,"33FJ32MC202"},
+	{0x0F0B,"33FJ32MC204"},
+	{0x0F0D,"33FJ32GP202"},
+	{0x0F0F,"33FJ32GP204"},
+	{0x0F17,"24HJ16GP304"},
+	{0x0F1D,"24HJ32GP202"},
+	{0x0F1F,"24HJ32GP204"},
+	{0x1001,"24FJ64GB106"},
+	{0x1003,"24FJ64GB108"},
+	{0x1007,"24FJ64GB110"},
+	{0x1008,"24FJ128GA106"},
+	{0x1009,"24FJ128GB106"},
+	{0x100A,"24FJ128GA100"},
+	{0x100B,"24FJ128GB108"},
+	{0x100E,"24FJ128GA110"},
+	{0x100F,"24FJ128GB110"},
+	{0x1010,"24FJ192GA106"},
+	{0x1011,"24FJ192GB106"},
+	{0x1012,"24FJ192GA108"},
+	{0x1013,"24FJ192GB108"},
+	{0x1016,"24FJ192GA110"},
+	{0x1017,"24FJ192GB110"},
+	{0x1018,"24FJ256GA106"},
+	{0x1019,"24FJ256GB106"},
+	{0x101A,"24FJ256GA108"},
+	{0x101B,"24FJ256GB108"},
+	{0x101E,"24FJ256GA110"},
+	{0x101F,"24FJ256GB110"},
+	{0x1780,"33EP512MC204"},
+	{0x1781,"33EP512MC202"},
+	{0x1783,"33EP512MC206"},
+	{0x1784,"33EP512MC504"},
+	{0x1785,"33EP512MC502"},
+	{0x1787,"33EP512MC506"},
+	{0x178F,"33EP512GP506"},
+	{0x1790,"24EP512MC204"},
+	{0x1791,"24EP512MC202"},
+	{0x1793,"24EP512MC206"},
+	{0x1798,"24EP512GP204"},
+	{0x1799,"24EP512GP202"},
+	{0x179B,"24EP512GP206"},
+	{0x178C,"33EP512GP504"},
+	{0x178D,"33EP512GP502"},
+	{0x1C00,"33EP32MC204"},
+	{0x1C01,"33EP32MC202"},
+	{0x1C02,"33EP32MC203"},
+	{0x1C04,"33EP32MC504"},
+	{0x1C05,"33EP32MC502"},
+	{0x1C06,"33EP32MC503"},
+	{0x1C0C,"33EP32GP504"},
+	{0x1C0D,"33EP32GP502"},
+	{0x1C0E,"33EP32GP503"},
+	{0x1C10,"24EP32MC204"},
+	{0x1C11,"24EP32MC202"},
+	{0x1C12,"24EP32MC203"},
+	{0x1C18,"24EP32GP204"},
+	{0x1C19,"24EP32GP202"},
+	{0x1C1A,"24EP32GP203"},
+	{0x1D20,"33EP64MC204"},
+	{0x1D21,"33EP64MC202"},
+	{0x1D22,"33EP64MC203"},
+	{0x1D23,"33EP64MC206"},
+	{0x1D24,"33EP64MC504"},
+	{0x1D25,"33EP64MC502"},
+	{0x1D26,"33EP64MC503"},
+	{0x1D27,"33EP64MC506"},
+	{0x1D2C,"33EP64GP504"},
+	{0x1D2D,"33EP64GP502"},
+	{0x1D2E,"33EP64GP503"},
+	{0x1D2F,"33EP64GP506"},
+	{0x1D30,"24EP64MC204"},
+	{0x1D31,"24EP64MC202"},
+	{0x1D32,"24EP64MC203"},
+	{0x1D33,"24EP64MC206"},
+	{0x1D38,"24EP64GP204"},
+	{0x1D39,"24EP64GP202"},
+	{0x1D3A,"24EP64GP203"},
+	{0x1D3B,"24EP64GP206"},
+ 	{0x1E40,"33EP128MC204"},
+ 	{0x1E41,"33EP128MC202"},
+ 	{0x1E43,"33EP128MC206"},
+ 	{0x1E44,"33EP128MC504"},
+ 	{0x1E45,"33EP128MC502"},
+ 	{0x1E47,"33EP128MC506"},
+ 	{0x1E4C,"33EP128GP504"},
+ 	{0x1E4D,"33EP128GP502"},
+ 	{0x1E4F,"33EP128GP506"},
+ 	{0x1E50,"24EP128MC204"},
+ 	{0x1E51,"24EP128MC202"},
+ 	{0x1E53,"24EP128MC206"},
+ 	{0x1E58,"24EP128GP204"},
+ 	{0x1E59,"24EP128GP202"},
+ 	{0x1E5B,"24EP128GP206"},
+ 	{0x1F60,"33EP256MC204"},
+ 	{0x1F61,"33EP256MC202"},
+ 	{0x1F63,"33EP256MC206"},
+ 	{0x1F64,"33EP256MC504"},
+ 	{0x1F65,"33EP256MC502"},
+ 	{0x1F67,"33EP256MC506"},
+ 	{0x1F6C,"33EP256GP504"},
+ 	{0x1F6D,"33EP256GP502"},
+ 	{0x1F6F,"33EP256GP506"},
+ 	{0x1F70,"24EP256MC204"},
+ 	{0x1F71,"24EP256MC202"},
+ 	{0x1F73,"24EP256MC206"},
+ 	{0x1F78,"24EP256GP204"},
+ 	{0x1F79,"24EP256GP202"},
+ 	{0x1F7B,"24EP256GP206"},
+	{0x4000,"33FJ32GS406"},
+	{0x4001,"33FJ64GS406"},
+	{0x4002,"33FJ32GS606"},
+	{0x4003,"33FJ64GS606"},
+	{0x4004,"33FJ32GS608"},
+	{0x4005,"33FJ64GS608"},
+	{0x4008,"33FJ32GS610"},
+	{0x4009,"33FJ64GS610"},
+	{0x4100,"24FJ128GB206"},
+	{0x4102,"24FJ128GB210"},
+	{0x4104,"24FJ256GB206"},
+	{0x4106,"24FJ256GB210"},
+	{0x4108,"24FJ128DA206"},
+	{0x4109,"24FJ128DA106"},
+	{0x410A,"24FJ128DA210"},
+	{0x410B,"24FJ128DA110"},
+	{0x410C,"24FJ256DA206"},
+	{0x410D,"24FJ256DA106"},
+	{0x410E,"24FJ256DA210"},
+	{0x410F,"24FJ256DA110"},
+	{0x4202,"24FJ32GA102"},
+	{0x4203,"24FJ32GB002"},
+	{0x4206,"24FJ64GA102"},
+	{0x4207,"24FJ64GB002"},
+	{0x420A,"24FJ32GA104"},
+	{0x420B,"24FJ32GB004"},
+	{0x420E,"24FJ64GA104"},
+	{0x420F,"24FJ64GB004"},
+	{0x46C0,"24FJ64GA306"},
+	{0x46C2,"24FJ128GA306"},
+	{0x46C4,"24FJ64GA308"},
+	{0x46C6,"24FJ128GA308"},
+	{0x46C8,"24FJ64GA310"},
+	{0x46CA,"24FJ128GA310"},
+	{0x4884,"24FJ64GC010"},
+	{0x4885,"24FJ128GC010"},
+	{0x4888,"24FJ64GC006"},
+	{0x4889,"24FJ128GC006"},
+	{0x488A,"24FJ64GC008"},
+	{0x488B,"24FJ128GC008"},
+};
+
+void PIC24_ID(int id)
+{
+	char s[64];
+	int i;
+	for(i=0;i<sizeof(PIC24LIST)/sizeof(PIC24LIST[0]);i++){
+		if(id==PIC24LIST[i].id){
+			strcpy(s,PIC24LIST[i].device);
+			strcat(s,"\r\n");
+			PrintMessage(s);
+			return;
+		}
+	}
+	PrintMessage(strings[S_nodev]); //"Unknown device\r\n");
+}
+
+void DisplayCODE24F(int dim){
+// display 16 bit PIC CODE memory
+	char s[256]="",t[256]="";
+	char* aux=(char*)malloc((dim/COL+1)*2*(16+COL*9));
+	aux[0]=0;
+	int valid=0,empty=1,i,j,d,lines=0;
+	for(i=0;i<dim&&i<size;i+=COL*2){
+		valid=0;
+		for(j=i;j<i+COL*2&&j<dim;j+=4){
+			d=(memCODE[j+3]<<24)+(memCODE[j+2]<<16)+(memCODE[j+1]<<8)+memCODE[j];
+			sprintf(t,"%08X ",d);
+			strcat(s,t);
+			if(d!=0xffffffff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%06X: %s\r\n",i/2,s);
+			empty=0;
+			strcat(aux,t);
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=(dim<size?dim:size)-COL*4;
+				lines=490;
+			}
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+void DisplayEE24F(){
+// display EE memory with address offset by 0x7FF000
+	char s[256],t[256],v[256],*aux;
+	int valid=0,empty=1;
+	int i,j;
+#ifdef __GTK_H__
+	char *g	;
+#endif
+	s[0]=0;
+	v[0]=0;
+	aux=(char*)malloc(0x1000/COL*(16+COL*5));
+	aux[0]=0;
+	for(i=0;i<0x1000&&i<sizeEE;i+=COL){
+		valid=0;
+		for(j=i;j<i+COL&&j<0x1000&&i<sizeEE;j+=2){
+			sprintf(t,"%02X %02X ",memEE[j],memEE[j+1]);
+			strcat(s,t);
+			sprintf(t,"%c",isprint(memEE[j])&&(memEE[j]<0xFF)?memEE[j]:'.');
+#ifdef __GTK_H__
+			g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+			if(g) strcat(v,g);
+			g_free(g);
+#else
+			strcat(v,t);
+#endif
+			if(memEE[j]<0xff) valid=1;
+			sprintf(t,"%c",isprint(memEE[j+1])&&(memEE[j+1]<0xFF)?memEE[j+1]:'.');
+#ifdef __GTK_H__
+			g=g_locale_to_utf8(t,-1,NULL,NULL,NULL);
+			if(g) strcat(v,g);
+			g_free(g);
+#else
+			strcat(v,t);
+#endif
+			if(memEE[j+1]<0xff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%04X: %s %s\r\n",i+0xF000,s,v);		//back to the device address
+			strcat(aux,t);
+			empty=0;
+		}
+		s[0]=0;
+		v[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+void Read24Fx(int dim,int dim2,int options,int appIDaddr,int executiveArea){
+// read 16 bit PIC 24Fxxxx
+// deviceID @ 0xFF0000
+// dim=program size (16 bit words)
+// dim2=eeprom size (in bytes, area starts at 0x800000-size)
+// options:
+//	bit [3:0]
+//     0 = low voltage ICSP entry
+//     1 = High voltage ICSP entry (6V)
+//     2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
+//     3 = low voltage ICSP entry (5V power supply)
+//	bit [7:4]
+//	   0 = config area in the last 2 program words
+//	   1 = config area in the last 3 program words
+//	   2 = config area in the last 4 program words
+//	   3 = 0xF80000 to 0xF80010 except 02 (24F)
+//     4 = 0xF80000 to 0xF80016 (24H-33F)
+//     5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
+//     6 = 0xF80000 to 0xF8000E (30FSMPS)
+//	bit [8]
+//	   0 = standard TABLPAG address
+//	   1 = new TABLPAG address
+// appIDaddr = application ID word lower address (high is 0x80)
+// executiveArea = size of executive area (16 bit words, starting at 0x800000)
+	int k=0,k2=0,z=0,i,j;
+	int entry=options&0xF;
+	int config=(options>>4)&0xF;
+	int EEbaseAddr=0x1000-dim2;
+	int newTABLPAG=options&0x100?1:0;
+	if(FWVersion<0x700){
+		PrintMessage1(strings[S_FWver2old],"0.7.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(entry<2&&!CheckV33Regulator()){		//except 30Fxx which is on 5V
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Read24Fx(%d,%d,%d,%d,%d)    (0x%X,0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,options,appIDaddr,executiveArea,dim,dim2,options,appIDaddr,executiveArea);
+	}
+	dim*=2;		//from words to bytes
+	if(dim>0x80000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x4000||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	unsigned char *memExec=0;
+	executiveArea*=2;
+	if(executiveArea) memExec=(unsigned char *)malloc(executiveArea);
+	for(i=0;i<executiveArea;i++) memExec[i]=0xFF;
+	size=dim;
+	sizeEE=0x1000;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(size);		//CODE
+	if(memEE) free(memEE);
+	memEE=(unsigned char*)malloc(0x1000);		//EEPROM
+	memset(memCODE,0xFF,dim);
+	memset(memEE,0xFF,0x1000);
+	if(config>2){					//only if separate config area
+		sizeCONFIG=48;
+		for(i=0;i<48;i++) memCONFIG[i]=0xFF;
+	}
+	if((entry==1)||(entry==2)){			//High voltage programming: 3.3V + 1.5V + R drop + margin
+		if(!StartHVReg(entry==2?12:6)){	//12V only for 30Fxx !!!
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+	}
+	else StartHVReg(-1);		//LVP: current limited to (5-0.7-3.6)/10k = 50uA
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	if((entry==0)||(entry==3)){		//LVP: pulse on MCLR
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+	}
+	else PrintMessage(strings[S_HVICSP]); //"High Voltage ICSP\r\n"
+	bufferU[j++]=WAIT_T3;	//>10ms before key (GA3xx-GC0xx)
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x4D;
+	bufferU[j++]=0x43;
+	bufferU[j++]=0x48;
+	bufferU[j++]=0x51;
+	bufferU[j++]=WAIT_T3;			//min 1ms
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=30000>>8;
+	bufferU[j++]=30000&0xff;
+	bufferU[j++]=WAIT_T3;			//min 25ms
+	if(entry==2){					//30Fx entry
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=ICSP_NOP;
+	}
+	else{
+		//Additional 5 clock cycles upon entering program mode
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+	}
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(55);
+	j=0;
+	//Read DeviceID @0xFF0000, DevRev @0xFF0002
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xF0;				//0xFF
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;				//0x0000
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	int w0=0,w1=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w1=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x44;				//append 1 NOP
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20+((appIDaddr>>12)&0xF);	//MOV XXXX,W6
+	bufferU[j++]=(appIDaddr>>4)&0xFF;
+	bufferU[j++]=((appIDaddr<<4)&0xF0)+6;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20;				//MOV 0,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//code read ...
+	PrintStatusSetup();
+//Read 6 24 bit words packed in 9 16 bit words
+//memory address advances by 24 bytes because of alignment
+	int High=0;
+	for(i=0;i<dim;i+=24){
+		if((i>>17)!=High){	//advance page
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(i>>21)&0xFF;
+			bufferU[j++]=(i>>13)&0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=SIX;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+			High=i>>17;
+		}
+		bufferU[j++]=SIX_LONG;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		if(i<dim-16){		//skip last read (dim is never multiple of 6)
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+		}
+		if(i<dim-8){		//skip last read (dim is never multiple of 6)
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+		}
+
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M0
+			memCODE[k]=bufferI[z+2];	//L0
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H0
+			memCODE[k+6]=bufferI[z+1];	//H1
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M1
+			memCODE[k+4]=bufferI[z+2];	//L1
+			k+=8;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M2
+			memCODE[k+0]=bufferI[z+2];	//L2
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H2
+			memCODE[k+6]=bufferI[z+1];	//H3
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M3
+			memCODE[k+4]=bufferI[z+2];	//L3
+			k+=8;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M4
+			memCODE[k+0]=bufferI[z+2];	//L4
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H4
+			memCODE[k+6]=bufferI[z+1];	//H5
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M5
+			memCODE[k+4]=bufferI[z+2];	//L5
+			k+=8;
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/dim,i/2);	//"Read: %d%%, addr. %05X"
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read config area ********************
+	if(config>2){					//config area @ 0xF80000
+		if(saveLog)	fprintf(logfile,"\nCONFIG:\n");
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		//save 0xF800000 to 0xF80010
+		for(i=0,z=0;i<9;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			memCONFIG[i*4]=bufferI[z+2];	//Low byte
+			memCONFIG[i*4+1]=bufferI[z+1];	//High byte
+			z+=3;
+		}
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		//save 0xF800012 to 0xF80016
+		for(i=9,z=0;i<12;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			memCONFIG[i*4]=bufferI[z+2];	//Low byte
+			memCONFIG[i*4+1]=bufferI[z+1];	//High byte
+			z+=3;
+		}
+		PrintStatusClear();
+	}
+//****************** read eeprom ********************
+	if(dim2){
+		if(saveLog)	fprintf(logfile,"\nEEPROM:\n");
+		PrintMessage(strings[S_ReadEE]);		//read eeprom ...
+		PrintStatusSetup();
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=0x45;				//append 1 NOP
+		bufferU[j++]=0x20;				//MOV #0x7F,W0
+		bufferU[j++]=0x07;
+		bufferU[j++]=0xF0;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x2F;		//MOV #<ADDR[15:0]>,W6   (base address)
+		bufferU[j++]=(EEbaseAddr>>4)&0xFF;
+		bufferU[j++]=(EEbaseAddr&0xF0)+6;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		for(k2=0,i=0;i<dim2;i+=2){
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			if(j>DIMBUF-6||i==dim2-2){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+				j=0;
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==REGOUT){
+						memEE[EEbaseAddr+k2++]=bufferI[z+2];
+						memEE[EEbaseAddr+k2++]=bufferI[z+1];
+						z+=3;
+						//k2+=2;		//skip high word
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i+dim)*100/(dim+dim2),i);	//"Read: %d%%, addr. %03X"
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		if(k2!=dim2){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadEEErr],dim2,k2);	//"Error reading EEPROM area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+//****************** read executive area ********************
+	if(executiveArea){
+		j=0;
+		PrintMessage(strings[S_Read_EXE_A]);		//read executive area ...
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"\nExecutive area:\n");
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=0x45;				//append 1 NOP
+		bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x08;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(i=0,k=0;i<executiveArea;i+=16){
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;
+			bufferU[j++]=0x04;				//GOTO 0x200
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+1]=bufferI[z+1];	//M0
+				memExec[k]=bufferI[z+2];	//L0
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+2]=bufferI[z+2];	//H0
+				memExec[k+6]=bufferI[z+1];	//H1
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+5]=bufferI[z+1];	//M1
+				memExec[k+4]=bufferI[z+2];	//L1
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+9]=bufferI[z+1];	//M2
+				memExec[k+8]=bufferI[z+2];	//L2
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+10]=bufferI[z+2];	//H2
+				memExec[k+14]=bufferI[z+1];	//H3
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+13]=bufferI[z+1];	//M3
+				memExec[k+12]=bufferI[z+2];	//L3
+			}
+			k+=16;
+			PrintStatus(strings[S_CodeReading2],i*100/executiveArea,0x800000+i/2);	//"Read: %d%%, addr. %05X"
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+		PrintStatusEnd();
+		if(k!=executiveArea){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadCodeErr2],executiveArea,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+	PrintMessage("\r\n");
+//****************** exit ********************
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	if(config>2){					//only if separate config area
+		PrintMessage(strings[S_ConfigMem]);				//"\r\nConfig Memory:\r\n"
+		if(config==3||config==4||config==6){
+			PrintMessage1("0xF80000: FBS = 0x%02X\r\n",memCONFIG[0]);
+			if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80002: FSS = 0x%02X\r\n",memCONFIG[4]);
+			}
+			PrintMessage1("0xF80004: FGS = 0x%02X\r\n",memCONFIG[8]);
+			PrintMessage1("0xF80006: FOSCSEL = 0x%02X\r\n",memCONFIG[12]);
+			PrintMessage1("0xF80008: FOSC = 0x%02X\r\n",memCONFIG[16]);
+			PrintMessage1("0xF8000A: FWDT = 0x%02X\r\n",memCONFIG[20]);
+			PrintMessage1("0xF8000C: FPOR = 0x%02X\r\n",memCONFIG[24]);
+			PrintMessage1("0xF8000E: FICD = 0x%02X\r\n",memCONFIG[28]);
+			if(config==3){			//0xF80000-10 except 02
+				PrintMessage1("0xF80010: FDS = 0x%02X\r\n",memCONFIG[32]);
+			}
+			else if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80010: UID0 = 0x%02X\r\n",memCONFIG[32]);
+				PrintMessage1("0xF80012: UID1 = 0x%02X\r\n",memCONFIG[36]);
+				PrintMessage1("0xF80014: UID2 = 0x%02X\r\n",memCONFIG[40]);
+				PrintMessage1("0xF80016: UID3 = 0x%02X\r\n",memCONFIG[44]);
+			}
+		}
+		else if(config==5){			//0xF80000-0C (16 bit)
+			PrintMessage2("0xF80000: FOSC = 0x%02X%02X\r\n",memCONFIG[1],memCONFIG[0]);
+			PrintMessage2("0xF80002: FWDT = 0x%02X%02X\r\n",memCONFIG[5],memCONFIG[4]);
+			PrintMessage2("0xF80004: FBORPOR = 0x%02X%02X\r\n",memCONFIG[9],memCONFIG[8]);
+			PrintMessage2("0xF80006: FBS = 0x%02X%02X\r\n",memCONFIG[13],memCONFIG[12]);
+			PrintMessage2("0xF80008: FSS = 0x%02X%02X\r\n",memCONFIG[17],memCONFIG[16]);
+			PrintMessage2("0xF8000A: FGS = 0x%02X%02X\r\n",memCONFIG[21],memCONFIG[20]);
+			PrintMessage2("0xF8000C: FICD = 0x%02X%02X\r\n",memCONFIG[25],memCONFIG[24]);
+		}
+	}
+	else{
+			//last 2 program words
+			PrintMessage2("CONFIG1: 0x%04X\r\nCONFIG2: 0x%04X\r\n",(memCODE[dim-3]<<8)+memCODE[dim-4]\
+				,(memCODE[dim-7]<<8)+memCODE[dim-8]);
+			if(config==1){			//last 3 program words
+				PrintMessage1("CONFIG3: 0x%04X\r\n",(memCODE[dim-11]<<8)+memCODE[dim-12]);
+			}
+			if(config==2){			//last 4 program words
+				PrintMessage1("CONFIG4: 0x%04X\r\n",(memCODE[dim-15]<<8)+memCODE[dim-16]);
+			}
+		}
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+	DisplayCODE24F(dim);
+	if(dim2){
+		PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+		DisplayEE24F();
+	}
+	if(executiveArea){
+		char s[256],t[256];
+		int d,valid,empty=1;
+		char* aux=(char*)malloc((dim/COL+1)*2*(16+COL*9));
+		aux[0]=0;
+		s[0]=0;
+		empty=1;
+		PrintMessage(strings[S_ExeMem]);	//"\r\nExecutive memory:\r\n"
+		for(i=0;i<executiveArea;i+=COL*2){
+			valid=0;
+			for(j=i;j<i+COL*2&&j<executiveArea;j+=4){
+				d=(memExec[j+3]<<24)+(memExec[j+2]<<16)+(memExec[j+1]<<8)+memExec[j];
+				sprintf(t,"%08X ",d);
+				strcat(s,t);
+				if(d!=0xffffffff) valid=1;
+			}
+			if(valid){
+				sprintf(t,"%06X: %s\r\n",i/2,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+void Read24Ex(int dim,int dim2,int options,int appIDaddr,int executiveArea){
+// read 16 bit PIC 24Exxxx
+// deviceID @ 0xFF0000
+// dim=program size (16 bit words)
+// dim2=dummy parameter
+// options: not used
+// appIDaddr = application ID word lower address (high is 0x80)
+// executiveArea = size of executive area (16 bit words, starting at 0x800000)
+	int k=0,z=0,i,j;
+	unsigned char UID[16];
+	for(i=0;i<16;i++) UID[i]=0xFF;
+	if(FWVersion<0x900){
+		PrintMessage1(strings[S_FWver2old],"0.9.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Read24Ex(%d,%d,%d,%d,%d)    (0x%X,0x%X,0x%X,0x%X,0x%X)\n",dim,dim2,options,appIDaddr,executiveArea,dim,dim2,options,appIDaddr,executiveArea);
+	}
+	dim*=2;		//from words to bytes
+	if(dim>0x100000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	unsigned char *memExec=0;
+	executiveArea*=2;
+	if(executiveArea) memExec=(unsigned char *)malloc(executiveArea);
+	for(i=0;i<executiveArea;i++) memExec[i]=0xFF;
+	size=dim;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(size);		//CODE
+	memset(memCODE,0xFF,dim);
+	StartHVReg(-1);		//LVP: current limited to (5-0.7-3.6)/10k = 50uA
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x4D;
+	bufferU[j++]=0x43;
+	bufferU[j++]=0x48;
+	bufferU[j++]=0x51;
+	bufferU[j++]=WAIT_T3;			//min 1ms
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=55000>>8;
+	bufferU[j++]=55000&0xff;
+	bufferU[j++]=WAIT_T3;			//min 50ms
+	//Additional 5 clock cycles upon entering program mode
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(65);
+	j=0;
+	//Read DeviceID @0xFF0000, DevRev @0xFF0002
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xF0;				//0xFF
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;				//0x0000
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	int w0=0,w1=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w1=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20+((appIDaddr>>12)&0xF);	//MOV XXXX,W6
+	bufferU[j++]=(appIDaddr>>4)&0xFF;
+	bufferU[j++]=((appIDaddr<<4)&0xF0)+6;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20;				//MOV 0,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//code read ...
+	PrintStatusSetup();
+//Read 6 24 bit words packed in 9 16 bit words
+//memory address advances by 24 bytes because of alignment
+	int High=0;
+	for(i=0;i<dim;i+=24){
+		if((i>>17)!=High){	//advance page
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(i>>21)&0xFF;
+			bufferU[j++]=(i>>13)&0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+			bufferU[j++]=SIX_LONG;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+			High=i>>17;
+		}
+		bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		if(i<dim-16){		//skip last read (dim is never multiple of 6)
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+		}
+		if(i<dim-8){		//skip last read (dim is never multiple of 6)
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+		}
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(4);
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M0
+			memCODE[k]=bufferI[z+2];	//L0
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H0
+			memCODE[k+6]=bufferI[z+1];	//H1
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M1
+			memCODE[k+4]=bufferI[z+2];	//L1
+			k+=8;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M2
+			memCODE[k+0]=bufferI[z+2];	//L2
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H2
+			memCODE[k+6]=bufferI[z+1];	//H3
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M3
+			memCODE[k+4]=bufferI[z+2];	//L3
+			k+=8;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M4
+			memCODE[k+0]=bufferI[z+2];	//L4
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H4
+			memCODE[k+6]=bufferI[z+1];	//H5
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+5]=bufferI[z+1];	//M5
+			memCODE[k+4]=bufferI[z+2];	//L5
+			k+=8;
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/dim,i/2);	//"Read: %d%%, addr. %05X"
+		if(RWstop) i=dim;
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);
+//****************** read executive area ********************
+	if(executiveArea){
+		j=0;
+		PrintMessage(strings[S_Read_EXE_A]);		//read executive area ...
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"\nExecutive area:\n");
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=0x45;				//append 1 NOP
+		bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x08;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0xF8;
+		bufferU[j++]=0x87;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		for(i=0,k=0;i<executiveArea;i+=16){
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0x96;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0xD3;
+			bufferU[j++]=0xD6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			bufferU[j++]=SIX_LONG;
+			bufferU[j++]=0x04;				//GOTO 0x200
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+1]=bufferI[z+1];	//M0
+				memExec[k]=bufferI[z+2];	//L0
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+2]=bufferI[z+2];	//H0
+				memExec[k+6]=bufferI[z+1];	//H1
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+5]=bufferI[z+1];	//M1
+				memExec[k+4]=bufferI[z+2];	//L1
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+9]=bufferI[z+1];	//M2
+				memExec[k+8]=bufferI[z+2];	//L2
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+10]=bufferI[z+2];	//H2
+				memExec[k+14]=bufferI[z+1];	//H3
+			}
+			for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			if(z<DIMBUF-2){
+				memExec[k+13]=bufferI[z+1];	//M3
+				memExec[k+12]=bufferI[z+2];	//L3
+			}
+			k+=16;
+			PrintStatus(strings[S_CodeReading2],i*100/executiveArea,0x800000+i/2);	//"Read: %d%%, addr. %05X"
+			if(RWstop) i=dim;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+		PrintStatusEnd();
+		if(k!=executiveArea){
+			PrintMessage("\r\n");
+			PrintMessage2(strings[S_ReadCodeErr2],executiveArea,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+		}
+		else PrintMessage(strings[S_Compl]);
+	}
+	PrintMessage("\r\n");
+//****************** read user ID ********************
+	j=0;
+	if(saveLog)	fprintf(logfile,"\nUser ID:\n");
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x45;				//append 1 NOP
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0xFF;
+	bufferU[j++]=0x86;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=0x04;				//GOTO 0x200
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0xDB;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0xD3;
+	bufferU[j++]=0xD6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0xDB;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0xD3;
+	bufferU[j++]=0xD6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;
+	bufferU[j++]=0x04;				//GOTO 0x200
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(3);
+	j=0;
+	k=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+1]=bufferI[z+1];	//M0
+		UID[k]=bufferI[z+2];	//L0
+	}
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+2]=bufferI[z+2];	//H0
+		UID[k+6]=bufferI[z+1];	//H1
+	}
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+5]=bufferI[z+1];	//M1
+		UID[k+4]=bufferI[z+2];	//L1
+	}
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+9]=bufferI[z+1];	//M2
+		UID[k+8]=bufferI[z+2];	//L2
+	}
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+10]=bufferI[z+2];	//H2
+		UID[k+14]=bufferI[z+1];	//H3
+	}
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2){
+		UID[k+13]=bufferI[z+1];	//M3
+		UID[k+12]=bufferI[z+2];	//L3
+	}
+	PrintMessage("\r\n");
+//****************** exit ********************
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+	for(i=0;i<10;i++) PrintMessage3("CONFIG%d(0x%05X): 0x%02X\r\n",i,(dim-40+i*4)/2,memCODE[dim-40+i*4]);
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+	DisplayCODE24F(dim);
+	if(executiveArea){
+		char s[256],t[256];
+		int d,valid,empty=1;
+		char* aux=(char*)malloc((executiveArea/COL+1)*2*(16+COL*9));
+		aux[0]=0;
+		s[0]=0;
+		empty=1;
+		PrintMessage(strings[S_ExeMem]);	//"\r\nExecutive memory:\r\n"
+		for(i=0;i<executiveArea;i+=COL*2){
+			valid=0;
+			for(j=i;j<i+COL*2&&j<executiveArea;j+=4){
+				d=(memExec[j+3]<<24)+(memExec[j+2]<<16)+(memExec[j+1]<<8)+memExec[j];
+				sprintf(t,"%08X ",d);
+				strcat(s,t);
+				if(d!=0xffffffff) valid=1;
+			}
+			if(valid){
+				sprintf(t,"%06X: %s\r\n",i/2,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}
+	for(i=0;i<4;i++){
+		if(UID[i*4]!=0xFF||UID[i*4+1]!=0xFF) PrintMessage2("UserID%d=%04X",i,(UID[i*4]<<8)+UID[i*4+1]);
+	}
+	sprintf(str,strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+}
+
+
+void Write24Fx(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait){
+// write 16 bit PIC 24Fxxxx
+// deviceID @ 0xFF0000
+// dim=program size (16 bit words)
+// dim2=eeprom size (in bytes, area starts at 0x800000-size)
+// options:
+//	bit [3:0]
+//     0 = low voltage ICSP entry
+//     1 = High voltage ICSP entry (6V)
+//     2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
+//     3 = low voltage ICSP entry (5V power supply)
+//	bit [7:4]
+//	   0 = config area in the last 2 program words
+//	   1 = config area in the last 3 program words
+//	   2 = config area in the last 4 program words
+//	   3 = 0xF80000 to 0xF80010 except 02 (24F)
+//     4 = 0xF80000 to 0xF80016 (24H-33F)
+//     5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
+//     6 = 0xF80000 to 0xF8000E (30FSMPS)
+//	bit [11:8]
+//	   0 = code erase word is 0x4064, row write is 0x4004
+//	   1 = code erase word is 0x404F, row write is 0x4001
+//	   2 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (2 ms)
+//	   3 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (200 ms)
+//	bit [15:12]
+//	   0 = eeprom erase word is 0x4050, write word is 0x4004
+//	   1 = eeprom erased with bulk erase, write word is 0x4004
+//	   2 = eeprom erased with special sequence, write word is 0x4004
+//	bit [19:16]
+//	   0 = config write is 0x4000
+//	   1 = config write is 0x4003
+//	   2 = config write is 0x4004
+//	   3 = config write is 0x4008
+//	bit [20]
+//	   0 = standard TABLPAG address
+//	   1 = new TABLPAG address
+// appIDaddr = application ID word lower address (high is 0x80)
+// rowSize = row size in instruction words (a row is written altogether)
+// wait = write delay in ms
+	int k=0,k2=0,z=0,i,j;
+	int entry=options&0xF;
+	int config=(options>>4)&0xF;
+	int EEbaseAddr=0x1000-dim2;
+	int newTABLPAG=options&0x100000?1:0;
+	int err=0;
+	if(FWVersion<0x700){
+		PrintMessage1(strings[S_FWver2old],"0.7.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(entry<2&&!CheckV33Regulator()){		//except 30Fxx which is on 5V
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Write24Fx(%d,%d,%d,%d,%d,%.1f)    (0x%X,0x%X,0x%X,0x%X,0x%X,%.3f)\n"
+			,dim,dim2,options,appIDaddr,rowSize,wait,dim,dim2,options,appIDaddr,rowSize,wait);
+	}
+	dim*=2;		//from words to bytes
+	if(dim>0x80000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x1000||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	j=size;
+	if(j%(rowSize*4)){			//grow to an integer number of rows
+		size=(j/(rowSize*4)+1)*rowSize*4;
+		memCODE=(unsigned char*)realloc(memCODE,size);
+		for(;j<size;j++) memCODE[j]=0xFF;
+	}
+	if(dim>size) dim=size;
+	if(sizeEE<0x1000) dim2=0;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Empty code area\r\n"
+		return;
+	}
+	if((entry==1)||(entry==2)){			//High voltage programming: 3.3V + 1.5V + R drop + margin
+		if(!StartHVReg(entry==2?12:6)){	//12V only for 30Fxx !!!
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+	}
+	else StartHVReg(-1);		//LVP: current limited to (5-0.7-3.6)/10k = 50uA
+	if(config>2){					//only if separate config area
+		PrintMessage(strings[S_ConfigMem]);				//"\r\nConfig Memory:\r\n"
+		if(config==3||config==4||config==6){
+			PrintMessage1("0xF80000: FBS = 0x%02X\r\n",memCONFIG[0]);
+			if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80002: FSS = 0x%02X\r\n",memCONFIG[4]);
+			}
+			PrintMessage1("0xF80004: FGS = 0x%02X\r\n",memCONFIG[8]);
+			PrintMessage1("0xF80006: FOSCSEL = 0x%02X\r\n",memCONFIG[12]);
+			PrintMessage1("0xF80008: FOSC = 0x%02X\r\n",memCONFIG[16]);
+			PrintMessage1("0xF8000A: FWDT = 0x%02X\r\n",memCONFIG[20]);
+			PrintMessage1("0xF8000C: FPOR = 0x%02X\r\n",memCONFIG[24]);
+			PrintMessage1("0xF8000E: FICD = 0x%02X\r\n",memCONFIG[28]);
+			if(config==3){			//0xF80000-10 except 02
+				PrintMessage1("0xF80010: FDS = 0x%02X\r\n",memCONFIG[32]);
+			}
+			else if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80010: UID0 = 0x%02X\r\n",memCONFIG[32]);
+				PrintMessage1("0xF80012: UID1 = 0x%02X\r\n",memCONFIG[36]);
+				PrintMessage1("0xF80014: UID2 = 0x%02X\r\n",memCONFIG[40]);
+				PrintMessage1("0xF80016: UID3 = 0x%02X\r\n",memCONFIG[44]);
+			}
+		}
+		else if(config==5){			//0xF80000-0C (16 bit)
+			PrintMessage2("0xF80000: FOSC = 0x%02X%02X\r\n",memCONFIG[1],memCONFIG[0]);
+			PrintMessage2("0xF80002: FWDT = 0x%02X%02X\r\n",memCONFIG[5],memCONFIG[4]);
+			PrintMessage2("0xF80004: FBORPOR = 0x%02X%02X\r\n",memCONFIG[9],memCONFIG[8]);
+			PrintMessage2("0xF80006: FBS = 0x%02X%02X\r\n",memCONFIG[13],memCONFIG[12]);
+			PrintMessage2("0xF80008: FSS = 0x%02X%02X\r\n",memCONFIG[17],memCONFIG[16]);
+			PrintMessage2("0xF8000A: FGS = 0x%02X%02X\r\n",memCONFIG[21],memCONFIG[20]);
+			PrintMessage2("0xF8000C: FICD = 0x%02X%02X\r\n",memCONFIG[25],memCONFIG[24]);
+		}
+	}
+	else{
+			//last 2 program words
+			PrintMessage2("CONFIG1: 0x%04X\r\nCONFIG2: 0x%04X\r\n",(memCODE[dim-3]<<8)+memCODE[dim-4]\
+				,(memCODE[dim-7]<<8)+memCODE[dim-8]);
+			if(config==1){			//last 3 program words
+				PrintMessage1("CONFIG3: 0x%04X\r\n",(memCODE[dim-11]<<8)+memCODE[dim-12]);
+			}
+			if(config==2){			//last 4 program words
+				PrintMessage1("CONFIG4: 0x%04X\r\n",(memCODE[dim-15]<<8)+memCODE[dim-16]);
+			}
+		}
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	if((entry==0)||(entry==3)){		//LVP: pulse on MCLR
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+	}
+	else PrintMessage(strings[S_HVICSP]); //"High Voltage ICSP\r\n"
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x4D;
+	bufferU[j++]=0x43;
+	bufferU[j++]=0x48;
+	bufferU[j++]=0x51;
+	bufferU[j++]=WAIT_T3;			//min 1ms
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=30000>>8;
+	bufferU[j++]=30000&0xff;
+	bufferU[j++]=WAIT_T3;			//min 25ms
+	if(entry==2){					//30Fx entry
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=ICSP_NOP;
+	}
+	else{
+		//Additional 5 clock cycles upon entering program mode
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+	}
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(37);
+	j=0;
+	//Read DeviceID @0xFF0000, DevRev @0xFF0002
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xF0;				//0xFF
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;				//0x0000
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	int w0=0,w1=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w1=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x44;				//append 1 NOP
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20+((appIDaddr>>12)&0xF);	//MOV XXXX,W6
+	bufferU[j++]=(appIDaddr>>4)&0xFF;
+	bufferU[j++]=((appIDaddr<<4)&0xF0)+6;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(saveLog)	fprintf(logfile,"\nERASE:\n");
+	int erase=(options&0xF00)>>8;
+	//bulk erase command
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x24;				//MOV XXXX,W10
+	if(erase==0){			//0x4064
+		bufferU[j++]=0x06;
+		bufferU[j++]=0x4A;
+	}
+	else if(erase==1){		//0x404F
+		bufferU[j++]=0x04;
+		bufferU[j++]=0xFA;
+	}
+	else if(erase>=2){		//0x407F
+		bufferU[j++]=0x07;
+		bufferU[j++]=0xFA;
+	}
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x0A;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG;			//TBLWTL W0,[W0] (dummy write)
+	bufferU[j++]=0xBB;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	if(erase>=2){				//30Fx, unlock and external timing
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV 0x55,W8
+		bufferU[j++]=0x05;
+		bufferU[j++]=0x58;
+		bufferU[j++]=0x88;				//MOV W8,NVMKEY
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0x20;				//MOV 0xAA,W8
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0x88;				//MOV W8,NVMKEY
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x38;
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=WAIT_T3;
+		if(erase==3){				//200 ms timing
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(20);
+			msDelay(200);
+			j=0;
+		}
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+		bufferU[j++]=0xA9;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+	}
+	else{		//internal timing
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=SIX;				//MOV NVMCON,W2
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x02;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W2,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x3C;
+	bufferU[j++]=0x22;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=REGOUT;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(7);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	w0=bufferI[z+1]&0x80;
+	//Wait for erase completion (max 1s)
+	bufferU[j++]=SIX;				//MOV NVMCON,W2
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x02;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W2,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x3C;
+	bufferU[j++]=0x22;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	for(i=0;erase<2&&i<100&&w0;i++){
+		PacketIO(5);
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		w0=bufferI[z+1]&0x80;
+		msDelay(10);
+	}
+	if(saveLog)	fprintf(logfile,"\nErase time: %dms\n",i*12);
+//****************** prepare write ********************
+	msDelay(10);
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=5;
+	bufferU[j++]=0x24;				//MOV XXXX,W10
+	bufferU[j++]=0x00;
+	bufferU[j++]=erase>0?0x1A:0x4A;	//0x4001/0x4004
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x0A;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x04;				//GOTO 0x200
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	if(saveLog)	fprintf(logfile,"\nWRITE CODE:\n");
+	PrintStatusSetup();
+//	instruction words are stored in code memory array as follows:
+//	L0 M0 H0 FF L1 M1 H1 FF
+	int valid,High=0;
+		for(i=0,k=0;i<dim;i+=4*4){		//write 4 instruction words
+			if(k==0){				//skip row if empty
+				for(valid=0;!valid&&i<dim;i+=valid?0:rowSize*4){
+					for(k2=0;k2<rowSize*4&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+				}
+				if(i>=dim) break;
+			}
+			if((i>>17)!=High){	//advance page
+				bufferU[j++]=SIX;				//MOV XXXX,W0
+				bufferU[j++]=0x20;
+				bufferU[j++]=(i>>21)&0xFF;
+				bufferU[j++]=(i>>13)&0xF0;
+				bufferU[j++]=SIX;				//MOV W0,TABLPAG
+				bufferU[j++]=0x88;
+				if(newTABLPAG){
+					bufferU[j++]=0x02;
+					bufferU[j++]=0xA0;
+				}
+				else{
+					bufferU[j++]=0x01;
+					bufferU[j++]=0x90;
+				}
+				bufferU[j++]=SIX;				//GOTO 0x200
+				bufferU[j++]=0x04;
+				bufferU[j++]=0x02;
+				bufferU[j++]=0x00;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(2);
+				j=0;
+				High=i>>17;
+			}
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=8;
+			bufferU[j++]=0x20+((i>>13)&0xF);						//MOV i/2,W7
+			bufferU[j++]=(i>>5)&0xFF;
+			bufferU[j++]=((i<<3)&0xF0)+7;
+			bufferU[j++]=0x20+((memCODE[i+1]>>4)&0xF);				//MOV LSW0,W0
+			bufferU[j++]=((memCODE[i+1]<<4)&0xF0)+((memCODE[i]>>4)&0xF);
+			bufferU[j++]=(memCODE[i]<<4)&0xF0;
+			bufferU[j++]=0x20+((memCODE[i+6]>>4)&0xF);				//MOV MSB1:MSB0,W1
+			bufferU[j++]=((memCODE[i+6]<<4)&0xF0)+((memCODE[i+2]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+2]<<4)&0xF0)+1;
+			bufferU[j++]=0x20+((memCODE[i+5]>>4)&0xF);				//MOV LSW1,W2
+			bufferU[j++]=((memCODE[i+5]<<4)&0xF0)+((memCODE[i+4]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+4]<<4)&0xF0)+2;
+			bufferU[j++]=0x20+((memCODE[i+9]>>4)&0xF);				//MOV LSW2,W3
+			bufferU[j++]=((memCODE[i+9]<<4)&0xF0)+((memCODE[i+8]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+8]<<4)&0xF0)+3;
+			bufferU[j++]=0x20+((memCODE[i+14]>>4)&0xF);				//MOV MSB3:MSB2,W4
+			bufferU[j++]=((memCODE[i+14]<<4)&0xF0)+((memCODE[i+10]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+10]<<4)&0xF0)+4;
+			bufferU[j++]=0x20+((memCODE[i+13]>>4)&0xF);				//MOV LSW3,W5
+			bufferU[j++]=((memCODE[i+13]<<4)&0xF0)+((memCODE[i+12]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+12]<<4)&0xF0)+5;
+			bufferU[j++]=0xEB;				//CLR W6
+			bufferU[j++]=0x03;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=0x88;				//Append 2 NOP
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7]
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[W7++]
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[++W7]
+			bufferU[j++]=0xEB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7++]
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7]
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[W7++]
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[++W7]
+			bufferU[j++]=0xEB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7++]
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0xB6;
+			k++;
+			if(k==rowSize/4){	//Write row
+				if(erase>1){				//30Fx, unlock and external timing
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					PacketIO(3);
+					j=0;
+					if(saveLog){
+						fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d, k=%d 0=%d\n"
+					}
+					bufferU[j++]=SIX_N;
+					bufferU[j++]=6;
+					bufferU[j++]=0x24;				//MOV XXXX,W10
+					bufferU[j++]=0x00;
+					bufferU[j++]=erase>0?0x1A:0x4A;	//0x4001/0x4004
+					bufferU[j++]=0x88;				//MOV W10,NVMCON
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0x20;				//MOV 0x55,W8
+					bufferU[j++]=0x05;
+					bufferU[j++]=0x58;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=0x20;				//MOV 0xAA,W8
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+					bufferU[j++]=0xA9;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=SIX_LONG;				//GOTO 0x200
+					bufferU[j++]=0x04;
+					bufferU[j++]=0x02;
+					bufferU[j++]=0x00;
+				}
+				else{		//internal timing
+				bufferU[j++]=SIX_LONG;				//GOTO 0x200
+				bufferU[j++]=0x04;
+				bufferU[j++]=0x02;
+				bufferU[j++]=0x00;
+				bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+				}
+				k=0;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			PrintStatus(strings[S_CodeWriting2],i*100/(dim+dim2),i/2);	//"Write: %d%%,addr. %04X"
+			if(RWstop) i=dim;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i/2,i/2,k,k);	//"i=%d, k=%d 0=%d\n"
+			}
+		}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verify code ... "
+	if(saveLog)	fprintf(logfile,"\nVERIFY CODE:\n");
+	PrintStatusSetup();
+//Read 4 24 bit words packed in 6 16 bit words
+//memory address advances by 16 bytes because of alignment
+	High=0xE0000000;
+	int r0=0,r1=0,r2=0,r3=0,w3,w2;
+	for(i=0;i<dim;i+=16){
+		//skip row if empty
+		for(valid=0;!valid&&i<dim;i+=valid?0:16){
+			for(k2=0;k2<16&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+		}
+		if(i>=dim) break;
+		if((i>>17)!=High){	//advance page
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(i>>21)&0xFF;
+			bufferU[j++]=(i>>13)&0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=SIX;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+			High=i>>17;
+		}
+		bufferU[j++]=SIX;				//MOV i/2,W6
+		bufferU[j++]=0x20+((i>>13)&0xF);
+		bufferU[j++]=(i>>5)&0xFF;
+		bufferU[j++]=((i<<3)&0xF0)+6;
+		bufferU[j++]=SIX;				//MOV #VISI,W7
+		bufferU[j++]=0x20;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i/2);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0+=bufferI[z+2]<<16;
+			r1=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r1+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2+=bufferI[z+2]<<16;
+			r3=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r3+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		w0=(memCODE[i+2]<<16)+(memCODE[i+1]<<8)+memCODE[i];
+		w1=(memCODE[i+6]<<16)+(memCODE[i+5]<<8)+memCODE[i+4];
+		w2=(memCODE[i+10]<<16)+(memCODE[i+9]<<8)+memCODE[i+8];
+		w3=(memCODE[i+14]<<16)+(memCODE[i+13]<<8)+memCODE[i+12];
+		CheckData(w0,r0,i/2,&err);
+		CheckData(w1,r1,i/2+2,&err);
+		CheckData(w2,r2,i/2+4,&err);
+		CheckData(w3,r3,i/2+6,&err);
+		PrintStatus(strings[S_CodeV2],i*100/dim,i/2);	//"Verify: %d%%, addr. %05X"
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i/2,i/2,k,k,err);	//"i=%d, k=%d, errori=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** erase, write and verify EEPROM ********************
+	if(dim2&&err<max_err){
+		//EEPROM @ 0x7F(EEbaseAddr)
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"\nWRITE EEPROM:\n");
+		int eewrite=(options&0xf000)>>12;
+		if(eewrite==0){		//24FxxKAxx
+			bufferU[j++]=SIX;				//MOV 0x4050,W10
+			bufferU[j++]=0x24;
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//MOV W10,NVMCON
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//MOV 0x7F,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=0x07;
+			bufferU[j++]=0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=SIX;				//MOV EEbaseAddr,W0
+			bufferU[j++]=0x2F;
+			bufferU[j++]=EEbaseAddr>>4;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX;				//TBLWTL W0,[W0]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x08;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;/**/
+			//Erase EEPROM
+			bufferU[j++]=SIX;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=SIX;				//MOV 0x4004,W10
+			bufferU[j++]=0x24;
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x4A;
+			bufferU[j++]=SIX;				//MOV W10,NVMCON
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(9);
+			j=0;
+		}
+		else if(eewrite==2){		//separate erase
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4046,W10
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4056,W10
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(6);
+			j=0;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4066,W10
+			bufferU[j++]=0x06;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(4);
+			j=0;
+		}
+		else if(eewrite==1){		//30Fxx
+			bufferU[j++]=SIX;				//MOV 0x7F,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=0x07;
+			bufferU[j++]=0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(1);
+			j=0;
+		}
+		//Write EEPROM
+		for(k2=0,i=0x1000-dim2;i<0x1000;i+=2){	//write 1 word (2 bytes)
+			if(memEE[i]<0xFF||memEE[i+1]<0xFF){
+			bufferU[j++]=SIX;				//MOV i,W7
+				bufferU[j++]=0x2F;
+				bufferU[j++]=i>>4;
+				bufferU[j++]=((i<<4)&0xF0)+7;
+				bufferU[j++]=SIX;				//MOV XXXX,W0
+				bufferU[j++]=0x20+((memEE[i+1]>>4)&0xF);
+				bufferU[j++]=((memEE[i+1]<<4)&0xF0)+((memEE[i]>>4)&0xF);
+				bufferU[j++]=(memEE[i]<<4)&0xF0;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+				bufferU[j++]=0xBB;
+				bufferU[j++]=0x1B;
+				bufferU[j++]=0x80;
+				if(eewrite==0){		//24FxxKAxx
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+				}
+				else if(eewrite==1){		//30Fxxxx
+					bufferU[j++]=SIX_N;
+					bufferU[j++]=6;
+					bufferU[j++]=0x24;				//MOV 0x4004,W10
+					bufferU[j++]=0x00;
+					bufferU[j++]=0x4A;
+					bufferU[j++]=0x88;				//MOV W10,NVMCON
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0x20;				//MOV 0x55,W8
+					bufferU[j++]=0x05;
+					bufferU[j++]=0x58;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=0x20;				//MOV 0xAA,W8
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+					bufferU[j++]=0xA9;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+				}
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(wait+2);
+				j=0;
+				PrintStatus(strings[S_CodeWriting],(i-0x1000+dim2)*100/(dim2),i);	//"Scrittura: %d%%, ind. %03X"
+				if(RWstop) i=dim;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d, k=%d 0=%d\n"
+				}
+			}
+		}
+		//Verify EEPROM
+		if(saveLog)	fprintf(logfile,"\nVERIFY EEPROM:\n");
+		bufferU[j++]=SIX;				//MOV 0xFE00,W6
+		bufferU[j++]=0x2F;
+		bufferU[j++]=EEbaseAddr>>4;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;				//MOV #VISI,W7
+		bufferU[j++]=0x20;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=SIX;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		int errE=0;
+		for(i=k2=EEbaseAddr;i<EEbaseAddr+dim2;i+=2){
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			if(j>DIMBUF-7||i==dim2-4){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				PacketIO(3);
+				for(z=0;z<DIMBUF-2;z++){
+					if(bufferI[z]==REGOUT){
+						CheckData(memEE[k2],bufferI[z+2],i,&errE);
+						CheckData(memEE[k2+1],bufferI[z+1],i+1,&errE);
+						z+=3;
+						k2+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i-EEbaseAddr)*100/(dim2),i);	//"Read: %d%%, addr. %03X"
+				if(RWstop) i=EEbaseAddr+dim2;
+				j=0;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				}
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errE);	//"completed: %d errors \r\n"
+		err+=errE;
+		PrintStatusClear();
+	}
+//****************** write CONFIG ********************
+	int written, read;
+	j=0;
+	if(config>2&&config<5&&err<max_err){	//config area @ 0xF80000
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"\nWRITE CONFIG:\n");
+		int confword=(options&0xF0000)>>16;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=6;
+		bufferU[j++]=0x20;				//MOV 0xF8,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x24;				//MOV 0x400x,W10
+		bufferU[j++]=0x00;
+		if(confword==0)bufferU[j++]=0x0A;		//0x4000
+		else if(confword==1)bufferU[j++]=0x3A;	//0x4003
+		else if(confword==2)bufferU[j++]=0x4A;	//0x4004
+		else if(confword==3)bufferU[j++]=0x8A;	//0x4008
+		bufferU[j++]=0x88;				//MOV W10,NVMCON
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		for(i=0;i<12;i++){
+			//Write CONFIG
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(memCONFIG[i*4]>>4)&0xF;
+			bufferU[j++]=(memCONFIG[i*4]<<4)&0xF0;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0x80;
+			if(memCONFIG[i*4]<0xFF){			//write if not empty
+				bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=ICSP_NOP;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(5);
+			msDelay(27);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+		//Verify write
+		int errC=0;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		for(i=0,z=0;i<9;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4];
+			read=bufferI[z+2];								//Low byte
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);
+			z+=3;
+		}
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		for(z=0;i<12;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4];
+			read=bufferI[z+2];								//Low byte
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);
+			z+=3;
+		}
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed: %d errors \r\n"
+		PrintStatusClear();
+		err+=errC;
+	}
+	else if(config>=5&&err<max_err){	//16 bit config area (30Fxxxx)
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"\nWRITE CONFIG:\n");
+		int Nconf=config==5?7:8;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV 0xF8,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		for(i=0;i<Nconf;i++){
+			//Erase CONFIG
+			bufferU[j++]=SIX;				//MOV 0xFFFF,W0
+			bufferU[j++]=0x2F;
+			bufferU[j++]=0xFF;
+			bufferU[j++]=0xF0;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+		bufferU[j++]=0xBB;
+		bufferU[j++]=0x1B;
+		bufferU[j++]=0x80;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 0x400x,W10
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x8A;				//0x4008
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		for(i=0;i<Nconf;i++){
+			int value=memCONFIG[i*4]+(memCONFIG[i*4+1]<<8);
+			//Write CONFIG
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20+(value>>12);
+			bufferU[j++]=(value>>4);
+			bufferU[j++]=(value<<4);
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0x80;
+			if(value<0xFFFF){			//write if not empty
+				bufferU[j++]=SIX_N;
+				bufferU[j++]=6;
+				bufferU[j++]=0x24;				//MOV 0x400x,W10
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x8A;				//0x4008
+				bufferU[j++]=0x88;				//MOV W10,NVMCON
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x0A;
+				bufferU[j++]=0x20;				//MOV 0x55,W8
+				bufferU[j++]=0x05;
+				bufferU[j++]=0x58;
+				bufferU[j++]=0x88;				//MOV W8,NVMKEY
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x38;
+				bufferU[j++]=0x20;				//MOV 0xAA,W8
+				bufferU[j++]=0x0A;
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0x88;				//MOV W8,NVMKEY
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x38;
+				bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+				bufferU[j++]=0xA9;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(3);
+			j=0;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			}
+		}
+		//Verify write
+		int errC=0;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(3);
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+		}
+		for(i=0,z=0;i<7;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4+1]+(memCONFIG[i*4]<<8);
+			read=bufferI[z+1]+(bufferI[z+2]<<8);
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);	//16 bit
+			z+=3;
+		}
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed: %d errors \r\n"
+		PrintStatusClear();
+		err+=errC;
+	}
+//****************** exit ********************
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
+
+void Write24Ex(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait){
+// write 16 bit PIC 24Exxxx
+// deviceID @ 0xFF0000
+// dim = program size (16 bit words)
+// dim2 = dummy parameter
+// options = dummy parameter
+// appIDaddr = dummy parameter
+// rowSize = dummy parameter
+// wait = dummy parameter
+	int k=0,k2=0,z=0,i,j;
+	int err=0;
+	if(FWVersion<0x900){
+		PrintMessage1(strings[S_FWver2old],"0.9.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Write24Ex(%d,%d,%d,%d,%d,%.1f)    (0x%X,0x%X,0x%X,0x%X,0x%X,%.3f)\n"
+			,dim,dim2,options,appIDaddr,rowSize,wait,dim,dim2,options,appIDaddr,rowSize,wait);
+	}
+	dim*=2;		//from words to bytes
+	if(dim>0x100000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim>size) for(i=size;i<dim;i++) memCODE[i]=0xFF;	//fill with 0xFF to avoid unintended writing
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Empty code area\r\n"
+		return;
+	}
+	StartHVReg(-1);		//LVP: current limited to (5-0.7-3.6)/10k = 50uA
+	//last 10 program words
+	for(i=0;i<10;i++) PrintMessage3("CONFIG%d(0x%05X): 0x%02X\r\n",i,(dim-40+i*4)/2,memCODE[dim-40+i*4]);
+	unsigned int start=GetTickCount();
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=EN_VPP_VCC;	//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x4D;
+	bufferU[j++]=0x43;
+	bufferU[j++]=0x48;
+	bufferU[j++]=0x51;
+	bufferU[j++]=WAIT_T3;			//min 1ms
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=55000>>8;
+	bufferU[j++]=55000&0xff;
+	bufferU[j++]=WAIT_T3;			//min 50ms
+	//Additional 5 clock cycles upon entering program mode
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x4;				//CK=1
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;				//CK=0
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(65);
+	j=0;
+	//Read DeviceID @0xFF0000, DevRev @0xFF0002
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xF0;				//0xFF
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;				//0x0000
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	int w0=0,w1=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w1=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x44;				//append 1 NOP
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xA0;
+	bufferU[j++]=0x20+((appIDaddr>>12)&0xF);	//MOV XXXX,W6
+	bufferU[j++]=(appIDaddr>>4)&0xFF;
+	bufferU[j++]=((appIDaddr<<4)&0xF0)+6;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0xF8;
+	bufferU[j++]=0x87;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(saveLog)	fprintf(logfile,"\nERASE:\n");
+	//bulk erase command
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=2;
+	bufferU[j++]=0x24;				//MOV 400D,W10
+	bufferU[j++]=0x00;
+	bufferU[j++]=0xDA;
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x4A;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV NVMCON,W0
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W0,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x7C;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV 0x55,W1
+	bufferU[j++]=0x05;
+	bufferU[j++]=0x51;
+	bufferU[j++]=0x88;				//MOV W1,NVMKEY
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x71;
+	bufferU[j++]=0x20;				//MOV 0xAA,W1
+	bufferU[j++]=0x0A;
+	bufferU[j++]=0xA1;
+	bufferU[j++]=0x88;				//MOV W8,NVMKEY
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x71;
+	bufferU[j++]=SIX_LONG5;				//BSET NVMCON,#WR
+	bufferU[j++]=0xA8;
+	bufferU[j++]=0xE7;
+	bufferU[j++]=0x29;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV NVMCON,W0
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W0,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x7C;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(4);
+	j=0;
+	for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	w0=bufferI[z+1]&0x80;
+	w0=1;
+	//Wait for erase completion (max 500m)
+	bufferU[j++]=SIX;				//MOV NVMCON,W0
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W0,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x7C;
+	bufferU[j++]=0x40;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	for(i=0;i<50&&w0;i++){
+		PacketIO(5);
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		w0=bufferI[z+1]&0x80;
+		msDelay(10);
+	}
+	if(saveLog)	fprintf(logfile,"ERASE TIME: %d ms\n",i*10);
+	msDelay(70);/*erase time seems always too low*/
+//****************** prepare write ********************
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;
+	bufferU[j++]=0x04;				//GOTO 0x200
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV 0xFA,W12
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xAC;
+	bufferU[j++]=0x88;				//MOV W12,TABLPAG
+	bufferU[j++]=0x02;
+	bufferU[j++]=0xAC;
+	bufferU[j++]=0x24;				//MOV XXXX,W10
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x1A;				//0x4001
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x39;
+	bufferU[j++]=0x4A;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	if(saveLog)	fprintf(logfile,"\nWRITE CODE:\n");
+	PrintStatusSetup();
+	int valid,High=0;
+//	instruction words are stored in code memory array as follows:
+//	L0 M0 H0 FF L1 M1 H1 FF ...
+//	use 2 write latches @ 0xFA0000
+	for(i=0,k=0;i<dim;i+=2*4){		//write 2 instruction words
+		//skip row if empty
+		for(valid=0;!valid&&i<dim;i+=valid?0:2*4){
+			for(k2=0;k2<2*4&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+		}
+		if(i>=dim) break;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=5;
+		bufferU[j++]=0xEB;				//CLR W6
+		bufferU[j++]=0x03;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0xEB;				//CLR W7
+		bufferU[j++]=0x03;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x20+((memCODE[i+1]>>4)&0xF);				//MOV LSW0,W0
+		bufferU[j++]=((memCODE[i+1]<<4)&0xF0)+((memCODE[i]>>4)&0xF);
+		bufferU[j++]=(memCODE[i]<<4)&0xF0;
+		bufferU[j++]=0x20+((memCODE[i+6]>>4)&0xF);				//MOV MSB1:MSB0,W1
+		bufferU[j++]=((memCODE[i+6]<<4)&0xF0)+((memCODE[i+2]>>4)&0xF);
+		bufferU[j++]=((memCODE[i+2]<<4)&0xF0)+1;
+		bufferU[j++]=0x20+((memCODE[i+5]>>4)&0xF);				//MOV LSW1,W2
+		bufferU[j++]=((memCODE[i+5]<<4)&0xF0)+((memCODE[i+4]>>4)&0xF);
+		bufferU[j++]=((memCODE[i+4]<<4)&0xF0)+2;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=0x84;				//Append 2 NOP
+		bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7]
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[W7++]
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[++W7]
+		bufferU[j++]=0xEB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7++]
+		bufferU[j++]=0x1B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=8;
+		bufferU[j++]=0x20+((i>>13)&0xF);		//MOV i/2,W3
+		bufferU[j++]=(i>>5)&0xFF;
+		bufferU[j++]=((i<<3)&0xF0)+3;
+		bufferU[j++]=0x20;						//MOV i/2/64K,W4
+		bufferU[j++]=(i>>21)&0xFF;
+		bufferU[j++]=((i>>13)&0xF0)+4;
+		bufferU[j++]=0x88;				//MOV W3,NVMADR
+		bufferU[j++]=0x39;
+		bufferU[j++]=0x53;
+		bufferU[j++]=0x88;				//MOV W4,NVMADRU
+		bufferU[j++]=0x39;
+		bufferU[j++]=0x64;
+		bufferU[j++]=0x20;				//MOV 0x55,W1
+		bufferU[j++]=0x05;
+		bufferU[j++]=0x51;
+		bufferU[j++]=0x88;				//MOV W1,NVMKEY
+		bufferU[j++]=0x39;
+		bufferU[j++]=0x71;
+		bufferU[j++]=0x20;				//MOV 0xAA,W1
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0xA1;
+		bufferU[j++]=0x88;				//MOV W1,NVMKEY
+		bufferU[j++]=0x39;
+		bufferU[j++]=0x71;
+		bufferU[j++]=SIX_LONG5;			//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x29;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(2);
+		j=0;
+		PrintStatus(strings[S_CodeWriting2],i*100/(dim+dim2),i/2);	//"Write: %d%%,addr. %04X"
+		if(RWstop) i=dim;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i/2,i/2,k,k);	//"i=%d, k=%d 0=%d\n"
+		}
+		//GOTO 0x200 is necessary to correctly write (???)
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX;				//MOV NVMCON,W2
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x39;
+		bufferU[j++]=0x42;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX;				//MOV W2,VISI
+		bufferU[j++]=0x88;
+		bufferU[j++]=0x7C;
+		bufferU[j++]=0x42;
+		bufferU[j++]=REGOUT;/**/
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		j=0;
+		PacketIO(2);
+	}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verify code ... "
+	if(saveLog)	fprintf(logfile,"\nVERIFY CODE:\n");
+	PrintStatusSetup();
+//Read 4 24 bit words packed in 6 16 bit words
+//memory address advances by 16 bytes because of alignment
+	High=0xE0000000;
+	int r0=0,r1=0,r2=0,r3=0,w3,w2;
+	for(i=0;i<dim;i+=16){
+		//skip row if empty
+		for(valid=0;!valid&&i<dim;i+=valid?0:16){
+			for(k2=0;k2<16&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+		}
+		if(i>=dim) break;
+		if((i>>17)!=High){	//advance page
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(i>>21)&0xFF;
+			bufferU[j++]=(i>>13)&0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+			bufferU[j++]=SIX_LONG;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			PacketIO(2);
+			j=0;
+			High=i>>17;
+		}
+		bufferU[j++]=SIX;				//MOV i/2,W6
+		bufferU[j++]=0x20+((i>>13)&0xF);
+		bufferU[j++]=(i>>5)&0xFF;
+		bufferU[j++]=((i<<3)&0xF0)+6;
+		bufferU[j++]=SIX;				//MOV #VISI,W7
+		bufferU[j++]=0x20;
+		bufferU[j++]=0xF8;
+		bufferU[j++]=0x87;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG5;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG5;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(4);
+		PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i/2);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		for(z=0;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0+=bufferI[z+2]<<16;
+			r1=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r1+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2+=bufferI[z+2]<<16;
+			r3=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r3+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		w0=(memCODE[i+2]<<16)+(memCODE[i+1]<<8)+memCODE[i];
+		w1=(memCODE[i+6]<<16)+(memCODE[i+5]<<8)+memCODE[i+4];
+		w2=(memCODE[i+10]<<16)+(memCODE[i+9]<<8)+memCODE[i+8];
+		w3=(memCODE[i+14]<<16)+(memCODE[i+13]<<8)+memCODE[i+12];
+		CheckData(w0,r0,i/2,&err);
+		CheckData(w1,r1,i/2+2,&err);
+		CheckData(w2,r2,i/2+4,&err);
+		CheckData(w3,r3,i/2+6,&err);
+		PrintStatus(strings[S_CodeV2],i*100/dim,i/2);	//"Verify: %d%%, addr. %05X"
+		j=0;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i/2,i/2,k,k,err);	//"i=%d, k=%d, errori=%d\n"
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** exit ********************
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(2);
+	j=0;
+	unsigned int stop=GetTickCount();
+	sprintf(str,strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	PrintMessage(str);
+	if(saveLog){
+		fprintf(logfile,str);
+		CloseLogFile();
+	}
+	PrintStatusClear();			//clear status report
+}
diff --git a/progP24.h b/progP24.h
new file mode 100644
index 0000000..1db78f7
--- /dev/null
+++ b/progP24.h
@@ -0,0 +1,7 @@
+void Read24Fx(int dim,int dim2,int options,int appIDaddr,int executiveArea);
+void Write24Fx(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait);
+void DisplayCODE24F(int dim);
+void DisplayEE24F();
+void Read24Ex(int dim,int dim2,int options,int appIDaddr,int executiveArea);
+void Write24Ex(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait);
+
diff --git a/progP32.c b/progP32.c
new file mode 100644
index 0000000..9416eed
--- /dev/null
+++ b/progP32.c
@@ -0,0 +1,2454 @@
+/**
+ * \file progP32.c - algorithms to program the PIC32 family of microcontrollers
+ * Copyright (C) 2019 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+
+#include "common.h"
+
+/*#ifdef _MSC_VER
+void COpenProgDlg::CheckData(int a,int b,int addr,int *err)
+#else
+void CheckData(int a,int b,int addr,int *err)
+#endif
+{
+	if(a!=b){
+#ifdef _MSC_VER
+		CString str;
+#endif
+		PrintMessage(strings[S_NL]);
+		PrintMessage4(strings[S_CodeVError],addr,addr,a,b);	//"Error writing address %4X: written %02X, read %02X\r\n"
+		(*err)++;
+	}
+}
+*/
+struct ID32{
+	int id;
+	char *device;
+} PIC32LIST[]={
+		{0x0938053,"PIC32MX360F512L"},
+		{0x0934053,"PIC32MX360F256L"},
+		{0x092D053,"PIC32MX340F128L"},
+		{0x092A053,"PIC32MX320F128L"},
+		{0x0916053,"PIC32MX340F512H"},
+		{0x0912053,"PIC32MX340F256H"},
+		{0x090D053,"PIC32MX340F128H"},
+		{0x090A053,"PIC32MX320F128H"},
+		{0x0906053,"PIC32MX320F064H"},
+		{0x0902053,"PIC32MX320F032H"},
+		{0x0978053,"PIC32MX460F512L"},
+		{0x0974053,"PIC32MX460F256L"},
+		{0x096D053,"PIC32MX440F128L"},
+		{0x0952053,"PIC32MX440F256H"},
+		{0x0956053,"PIC32MX440F512H"},
+		{0x094D053,"PIC32MX440F128H"},
+		{0x0942053,"PIC32MX420F032H"},
+		{0x04317053,"PIC32MX575F256H"},
+		{0x0430B053,"PIC32MX675F256H"},
+		{0x04303053,"PIC32MX775F256H"},
+		{0x04309053,"PIC32MX575F512H"},
+		{0x0430C053,"PIC32MX675F512H"},
+		{0x04325053,"PIC32MX695F512H"},
+		{0x0430D053,"PIC32MX775F512H"},
+		{0x0430E053,"PIC32MX795F512H"},
+		{0x04333053,"PIC32MX575F256L"},
+		{0x04305053,"PIC32MX675F256L"},
+		{0x04312053,"PIC32MX775F256L"},
+		{0x0430F053,"PIC32MX575F512L"},
+		{0x04311053,"PIC32MX675F512L"},
+		{0x04341053,"PIC32MX695F512L"},
+		{0x04307053,"PIC32MX775F512L"},
+		{0x04307053,"PIC32MX795F512L"},
+		{0x04400053,"PIC32MX534F064H"},
+		{0x04401053,"PIC32MX564F064H"},
+		{0x04403053,"PIC32MX564F128H"},
+		{0x04405053,"PIC32MX664F064H"},
+		{0x04407053,"PIC32MX664F128H"},
+		{0x0440B053,"PIC32MX764F128H"},
+		{0x0440C053,"PIC32MX534F064L"},
+		{0x0440D053,"PIC32MX564F064L"},
+		{0x0440F053,"PIC32MX564F128L"},
+		{0x04411053,"PIC32MX664F064L"},
+		{0x04413053,"PIC32MX664F128L"},
+		{0x04417053,"PIC32MX764F128L"},
+		{0x04A07053,"PIC32MX110F016B"},
+		{0x04A09053,"PIC32MX110F016C"},
+		{0x04A0B053,"PIC32MX110F016D"},
+		{0x04A01053,"PIC32MX210F016B"},
+		{0x04A03053,"PIC32MX210F016C"},
+		{0x04A05053,"PIC32MX210F016D"},
+		{0x04A06053,"PIC32MX120F032B"},
+		{0x04A08053,"PIC32MX120F032C"},
+		{0x04A0A053,"PIC32MX120F032D"},
+		{0x04A00053,"PIC32MX220F032B"},
+		{0x04A02053,"PIC32MX220F032C"},
+		{0x04A04053,"PIC32MX220F032D"},
+		{0x04D07053,"PIC32MX130F064B"},
+		{0x04D09053,"PIC32MX130F064C"},
+		{0x04D0B053,"PIC32MX130F064D"},
+		{0x04D01053,"PIC32MX230F064B"},
+		{0x04D03053,"PIC32MX230F064C"},
+		{0x04D05053,"PIC32MX230F064D"},
+		{0x04D06053,"PIC32MX150F128B"},
+		{0x04D08053,"PIC32MX150F128C"},
+		{0x04D0A053,"PIC32MX150F128D"},
+		{0x04D00053,"PIC32MX250F128B"},
+		{0x04D02053,"PIC32MX250F128C"},
+		{0x04D04053,"PIC32MX250F128D"},
+		{0x06610053,"PIC32MX170F256B"},
+		{0x0661A053,"PIC32MX170F256D"},
+		{0x06600053,"PIC32MX270F256B"},
+		{0x0660A053,"PIC32MX270F256D"},
+		{0x0660C053,"PIC32MX270F256DB"},
+		{0x06703053,"PIC32MX130F256B"},
+		{0x06705053,"PIC32MX130F256D"},
+		{0x06700053,"PIC32MX230F256B"},
+		{0x06702053,"PIC32MX230F256D"},
+		{0x05600053,"PIC32MX330F064H"},
+		{0x05601053,"PIC32MX330F064L"},
+		{0x05704053,"PIC32MX350F256H"},
+		{0x05705053,"PIC32MX350F256L"},
+		{0x05602053,"PIC32MX430F064H"},
+		{0x05603053,"PIC32MX430F064L"},
+		{0x05706053,"PIC32MX450F256H"},
+		{0x05707053,"PIC32MX450F256L"},
+		{0x0570C053,"PIC32MX350F128H"},
+		{0x0570D053,"PIC32MX350F128L"},
+		{0x0570E053,"PIC32MX450F128H"},
+		{0x0570F053,"PIC32MX450F128L"},
+		{0x05808053,"PIC32MX370F512H"},
+		{0x05809053,"PIC32MX370F512L"},
+		{0x0580A053,"PIC32MX470F512H"},
+		{0x0580B053,"PIC32MX470F512L"},
+		{0x05710053,"PIC32MX450F256HB"},
+		{0x05811053,"PIC32MX470F512LB"},
+		{0x05103053,"PIC32MZ1024ECG064"},
+		{0x05108053,"PIC32MZ1024ECH064"},
+		{0x05130053,"PIC32MZ1024ECM064"},
+		{0x05104053,"PIC32MZ2048ECG064"},
+		{0x05109053,"PIC32MZ2048ECH064"},
+		{0x05131053,"PIC32MZ2048ECM064"},
+		{0x0510D053,"PIC32MZ1024ECG100"},
+		{0x05112053,"PIC32MZ1024ECH100"},
+		{0x0513A053,"PIC32MZ1024ECM100"},
+		{0x0510E053,"PIC32MZ2048ECG100"},
+		{0x05113053,"PIC32MZ2048ECH100"},
+		{0x0513B053,"PIC32MZ2048ECM100"},
+		{0x05117053,"PIC32MZ1024ECG124"},
+		{0x0511C053,"PIC32MZ1024ECH124"},
+		{0x05144053,"PIC32MZ1024ECM124"},
+		{0x05118053,"PIC32MZ2048ECG124"},
+		{0x0511D053,"PIC32MZ2048ECH124"},
+		{0x05145053,"PIC32MZ2048ECM124"},
+		{0x05121053,"PIC32MZ1024ECG144"},
+		{0x05126053,"PIC32MZ1024ECH144"},
+		{0x0514E053,"PIC32MZ1024ECM144"},
+		{0x05122053,"PIC32MZ2048ECG144"},
+		{0x05127053,"PIC32MZ2048ECH144"},
+		{0x0514F053,"PIC32MZ2048ECM144"},
+		{0x06A10053,"PIC32MX150F256H"},
+		{0x06A11053,"PIC32MX150F256L"},
+		{0x06A30053,"PIC32MX170F512H"},
+		{0x06A31053,"PIC32MX170F512L"},
+		{0x06A12053,"PIC32MX250F256H"},
+		{0x06A13053,"PIC32MX250F256L"},
+		{0x06A32053,"PIC32MX270F512H"},
+		{0x06A33053,"PIC32MX270F512L"},
+		{0x06A14053,"PIC32MX550F256H"},
+		{0x06A15053,"PIC32MX550F256L"},
+		{0x06A34053,"PIC32MX570F512H"},
+		{0x06A35053,"PIC32MX570F512L"},
+		{0x06A50053,"PIC32MX120F064H"},
+		{0x06A00053,"PIC32MX130F128H"},
+		{0x06A01053,"PIC32MX130F128L"},
+		{0x06A02053,"PIC32MX230F128H"},
+		{0x06A03053,"PIC32MX230F128L"},
+		{0x06A04053,"PIC32MX530F128H"},
+		{0x06A05053,"PIC32MX530F128L"},
+		{0x07201053,"PIC32MZ0512EFE064"},
+		{0x07206053,"PIC32MZ0512EFF064"},
+		{0x0722E053,"PIC32MZ0512EFK064"},
+		{0x07202053,"PIC32MZ1024EFE064"},
+		{0x07207053,"PIC32MZ1024EFF064"},
+		{0x0722F053,"PIC32MZ1024EFK064"},
+		{0x07203053,"PIC32MZ1024EFG064"},
+		{0x07208053,"PIC32MZ1024EFH064"},
+		{0x07230053,"PIC32MZ1024EFM064"},
+		{0x07204053,"PIC32MZ2048EFG064"},
+		{0x07209053,"PIC32MZ2048EFH064"},
+		{0x07231053,"PIC32MZ2048EFM064"},
+		{0x0720B053,"PIC32MZ0512EFE100"},
+		{0x07210053,"PIC32MZ0512EFF100"},
+		{0x07238053,"PIC32MZ0512EFK100"},
+		{0x0720C053,"PIC32MZ1024EFE100"},
+		{0x07211053,"PIC32MZ1024EFF100"},
+		{0x07239053,"PIC32MZ1024EFK100"},
+		{0x0720D053,"PIC32MZ1024EFG100"},
+		{0x07212053,"PIC32MZ1024EFH100"},
+		{0x0723A053,"PIC32MZ1024EFM100"},
+		{0x0720E053,"PIC32MZ2048EFG100"},
+		{0x07213053,"PIC32MZ2048EFH100"},
+		{0x0723B053,"PIC32MZ2048EFM100"},
+		{0x07215053,"PIC32MZ0512EFE124"},
+		{0x0721A053,"PIC32MZ0512EFF124"},
+		{0x07242053,"PIC32MZ0512EFK124"},
+		{0x07216053,"PIC32MZ1024EFE124"},
+		{0x0721B053,"PIC32MZ1024EFF124"},
+		{0x07243053,"PIC32MZ1024EFK124"},
+		{0x07217053,"PIC32MZ1024EFG124"},
+		{0x0721C053,"PIC32MZ1024EFH124"},
+		{0x07244053,"PIC32MZ1024EFM124"},
+		{0x07218053,"PIC32MZ2048EFG124"},
+		{0x0721D053,"PIC32MZ2048EFH124"},
+		{0x07245053,"PIC32MZ2048EFM124"},
+		{0x0721F053,"PIC32MZ0512EFE144"},
+		{0x07224053,"PIC32MZ0512EFF144"},
+		{0x0724C053,"PIC32MZ0512EFK144"},
+		{0x07220053,"PIC32MZ1024EFE144"},
+		{0x07225053,"PIC32MZ1024EFF144"},
+		{0x0724D053,"PIC32MZ1024EFK144"},
+		{0x07221053,"PIC32MZ1024EFG144"},
+		{0x07226053,"PIC32MZ1024EFH144"},
+		{0x0724E053,"PIC32MZ1024EFM144"},
+		{0x07222053,"PIC32MZ2048EFG144"},
+		{0x07227053,"PIC32MZ2048EFH144"},
+		{0x0724F053,"PIC32MZ2048EFM144"},
+		{0x05F0C053,"PIC32MZ1025DAA169"},
+		{0x05F0D053,"PIC32MZ1025DAB169"},
+		{0x05F0F053,"PIC32MZ1064DAA169"},
+		{0x05F10053,"PIC32MZ1064DAB169"},
+		{0x05F15053,"PIC32MZ2025DAA169"},
+		{0x05F16053,"PIC32MZ2025DAB169"},
+		{0x05F18053,"PIC32MZ2064DAA169"},
+		{0x05F19053,"PIC32MZ2064DAB169"},
+		{0x05F42053,"PIC32MZ1025DAG169"},
+		{0x05F43053,"PIC32MZ1025DAH169"},
+		{0x05F45053,"PIC32MZ1064DAG169"},
+		{0x05F46053,"PIC32MZ1064DAH169"},
+		{0x05F4B053,"PIC32MZ2025DAG169"},
+		{0x05F4C053,"PIC32MZ2025DAH169"},
+		{0x05F4E053,"PIC32MZ2064DAG169"},
+		{0x05F4F053,"PIC32MZ2064DAH169"},
+		{0x05F78053,"PIC32MZ1025DAA176"},
+		{0x05F79053,"PIC32MZ1025DAB176"},
+		{0x05F7B053,"PIC32MZ1064DAA176"},
+		{0x05F7C053,"PIC32MZ1064DAB176"},
+		{0x05F81053,"PIC32MZ2025DAA176"},
+		{0x05F82053,"PIC32MZ2025DAB176"},
+		{0x05F84053,"PIC32MZ2064DAA176"},
+		{0x05F85053,"PIC32MZ2064DAB176"},
+		{0x05FAE053,"PIC32MZ1025DAG176"},
+		{0x05FAF053,"PIC32MZ1025DAH176"},
+		{0x05FB1053,"PIC32MZ1064DAG176"},
+		{0x05FB2053,"PIC32MZ1064DAH176"},
+		{0x05FB7053,"PIC32MZ2025DAG176"},
+		{0x05FB8053,"PIC32MZ2025DAH176"},
+		{0x05FBA053,"PIC32MZ2064DAG176"},
+		{0x05FBB053,"PIC32MZ2064DAH176"},
+		{0x05F5D053,"PIC32MZ1025DAA288"},
+		{0x05F5E053,"PIC32MZ1025DAB288"},
+		{0x05F60053,"PIC32MZ1064DAA288"},
+		{0x05F61053,"PIC32MZ1064DAB288"},
+		{0x05F66053,"PIC32MZ2025DAA288"},
+		{0x05F67053,"PIC32MZ2025DAB288"},
+		{0x05F69053,"PIC32MZ2064DAA288"},
+		{0x05F6A053,"PIC32MZ2064DAB288"},
+		{0x07800053,"PIC32MX154F128B"},
+		{0x07804053,"PIC32MX154F128D"},
+		{0x07808053,"PIC32MX155F128B"},
+		{0x0780C053,"PIC32MX155F128D"},
+		{0x07801053,"PIC32MX174F256B"},
+		{0x07805053,"PIC32MX174F256D"},
+		{0x07809053,"PIC32MX175F256B"},
+		{0x0780D053,"PIC32MX175F256D"},
+		{0x07802053,"PIC32MX254F128B"},
+		{0x07806053,"PIC32MX254F128D"},
+		{0x0780A053,"PIC32MX255F128B"},
+		{0x0780E053,"PIC32MX255F128D"},
+		{0x07803053,"PIC32MX274F256B"},
+		{0x07807053,"PIC32MX274F256D"},
+		{0x0780B053,"PIC32MX275F256B"},
+		{0x0780F053,"PIC32MX275F256D"},
+		{0x06211053,"PIC32MK0512GPD064"},
+		{0x0620E053,"PIC32MK1024GPD064"},
+		{0x06210053,"PIC32MK0512GPD100"},
+		{0x0620D053,"PIC32MK1024GPD100"},
+		{0x0620B053,"PIC32MK0512GPE064"},
+		{0x06208053,"PIC32MK1024GPE064"},
+		{0x0620A053,"PIC32MK0512GPE100"},
+		{0x06207053,"PIC32MK1024GPE100"},
+		{0x06205053,"PIC32MK0512MCF064"},
+		{0x06202053,"PIC32MK1024MCF064"},
+		{0x06201053,"PIC32MK0512MCF100"},
+		{0x06201053,"PIC32MK1024MCF100"},
+};
+
+void PIC32_ID(int id)
+{
+	char s[64];
+	int i;
+	for(i=0;i<sizeof(PIC32LIST)/sizeof(PIC32LIST[0]);i++){
+		if((id&0x0FFFFFFF)==PIC32LIST[i].id){
+			strcpy(s,PIC32LIST[i].device);
+			strcat(s,"\r\n");
+			PrintMessage(s);
+			return;
+		}
+	}
+	PrintMessage(strings[S_nodev]); //"Unknown device\r\n");
+}
+
+/*#ifdef _MSC_VER
+void COpenProgDlg::DisplayCODE24F(int dim){
+#else
+void DisplayCODE24F(int dim){
+#endif
+// display 16 bit PIC CODE memory
+	char s[256]="",t[256]="";
+	char* aux=(char*)malloc((dim/COL+1)*2*(16+COL*9));
+	aux[0]=0;
+	int valid=0,empty=1,i,j,d,lines=0;
+	for(i=0;i<dim&&i<size;i+=COL*2){
+		valid=0;
+		for(j=i;j<i+COL*2&&j<dim;j+=4){
+			d=(memCODE[j+3]<<24)+(memCODE[j+2]<<16)+(memCODE[j+1]<<8)+memCODE[j];
+			sprintf(t,"%08X ",d);
+			strcat(s,t);
+			if(d!=0xffffffff) valid=1;
+		}
+		if(valid){
+			sprintf(t,"%06X: %s\r\n",i/2,s);
+			empty=0;
+			strcat(aux,t);
+			lines++;
+			if(lines>500){	//limit number of lines printed
+				strcat(aux,"(...)\r\n");
+				i=(dim<size?dim:size)-COL*4;
+				lines=490;
+			}
+		}
+		s[0]=0;
+	}
+	if(empty) PrintMessage(strings[S_Empty]);	//empty
+	else PrintMessage(aux);
+	free(aux);
+}
+
+*/
+/*
+TDI=RB7   ->
+TCK=RB6   ->
+TDO=RB5   <-
+TMS=RB4   ->
+MCLR=RB3  ->
+*/
+//MCHP TAP INSTRUCTIONS (sent via JTAGSendCommand)
+#define MTAP_COMMAND 0x07 	//TDI and TDO connected to MCHP Command Shift register
+#define MTAP_SW_MTAP 0x04 	//Switch TAP controller to MCHP TAP controller
+#define MTAP_SW_ETAP 0x05 	//Switch TAP controller to EJTAG TAP controller
+#define MTAP_IDCODE 0x01 	//Select Chip Identification Data register
+//MTAP_COMMAND DR COMMANDS (sent via xferData)
+#define MCHP_STATUS 0x00 	//NOP and return Status.
+#define MCHP_ASSERT_RST 0xD1 	//Requests the reset controller to assert device Reset.
+#define MCHP_DE_ASSERT_RST 0xD0 //Removes the request for device Reset, which causes the reset controller
+								//to deassert device Reset if there is no other source requesting Reset (i.e., MCLR).
+#define MCHP_ERASE 0xFC 		//Cause the Flash controller to perform a Chip Erase.
+#define MCHP_FLASH_ENABLE 0xFE 	//Enables fetches and loads to the Flash (from the processor).
+#define MCHP_FLASH_DISABLE 0xFD //Disables fetches and loads to the Flash (from the processor).
+//EJTAG TAP INSTRUCTIONS
+#define ETAP_ADDRESS 0x08 	//Select Address register.
+#define ETAP_DATA 0x09 		//Select Data register.
+#define ETAP_CONTROL 0x0A 	//Select EJTAG Control register.
+#define ETAP_EJTAGBOOT 0x0C	//Set EjtagBrk, ProbEn and ProbTrap to ‘1’ as the reset value.
+#define ETAP_FASTDATA 0x0E 	//Selects the Data and Fastdata registers.
+
+void XferInstruction(int* j,int instruction){
+// fill buffer with XferInstruction (14 bytes)
+// if j<0 use separate counter and perform IO directly (also wait for CPU ready)
+	int i=0,z,w0=0;
+	int IO=0;
+	if((int)j==-1){
+		j=&i;
+		IO=1;
+	}
+	if(IO){
+//		bufferU[(*j)++]=JTAG_SEND_CMD;
+//		bufferU[(*j)++]=MTAP_SW_ETAP;
+//		bufferU[(*j)++]=JTAG_SET_MODE;
+//		bufferU[(*j)++]=0x3E;//0x1F;
+		bufferU[(*j)++]=JTAG_SEND_CMD;
+		bufferU[(*j)++]=ETAP_CONTROL;
+		bufferU[(*j)++]=FLUSH;
+		for(;(*j)<DIMBUF;(*j)++) bufferU[(*j)]=0x0;
+		PacketIO(5);
+		i=0;
+		bufferU[(*j)++]=JTAG_XFER_DATA;
+		bufferU[(*j)++]=0x00;
+		bufferU[(*j)++]=0x04;
+		bufferU[(*j)++]=0xC0;
+		bufferU[(*j)++]=0x00;
+		bufferU[(*j)++]=FLUSH;
+		for(;(*j)<DIMBUF;(*j)++) bufferU[(*j)]=0x0;
+		for(i=0;i<20;i++){	//Wait for CPU ready
+			PacketIO(5);
+			for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+			if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+			if(w0&0x40000) break;
+		}
+		if(i==20) PrintMessage1("i=20 ECR=0x%08X\r\n",w0);
+		i=0;
+	}
+	bufferU[(*j)++]=JTAG_SEND_CMD;
+	bufferU[(*j)++]=ETAP_DATA;
+	bufferU[(*j)++]=JTAG_XFER_DATA;
+	bufferU[(*j)++]=(instruction>>24)&0xFF;
+	bufferU[(*j)++]=(instruction>>16)&0xFF;
+	bufferU[(*j)++]=(instruction>>8)&0xFF;
+	bufferU[(*j)++]=instruction&0xFF;
+	bufferU[(*j)++]=JTAG_SEND_CMD;
+	bufferU[(*j)++]=ETAP_CONTROL;
+	bufferU[(*j)++]=JTAG_XFER_DATA;
+	bufferU[(*j)++]=0x00;
+	bufferU[(*j)++]=0x00;
+	bufferU[(*j)++]=0xC0;
+	bufferU[(*j)++]=0x00;
+	if(IO){
+		bufferU[(*j)++]=FLUSH;
+		for(;(*j)<DIMBUF;(*j)++) bufferU[(*j)]=0x0;
+		PacketIO(5);
+		i=0;
+	}
+}
+
+
+
+void Read32x(int dim,int options){
+// read 32 bit PIC32x
+// deviceID @ 0xFF0000
+// dim=program size (bytes)
+// options:
+//	bit [3:0]
+	int k=0,k2=0,z=0,i,j;
+	if(FWVersion<0xA00){
+		PrintMessage1(strings[S_FWver2old],"0.10.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(!CheckV33Regulator()){
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Read32x(%d,%d)    (0x%X,0x%X)\n",dim,options,dim,options);
+	}
+	//dim*=2;		//from words to bytes
+	if(dim>0x80000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	//unsigned char *memExec=0;
+	//executiveArea*=2;
+	//if(executiveArea) memExec=(unsigned char *)malloc(executiveArea);
+	//for(i=0;i<executiveArea;i++) memExec[i]=0xFF;
+	size=dim;
+	if(memCODE) free(memCODE);
+	memCODE=(unsigned char*)malloc(size);		//CODE
+	memset(memCODE,0xFF,dim);
+	StartHVReg(-1);		//disable HV
+	unsigned int start=GetTickCount();
+	int w0=0;
+	j=0;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=10000>>8;
+	bufferU[j++]=10000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=SET_PORT_DIR;
+	bufferU[j++]=0x27;	//RB7-6-4-3 output
+	bufferU[j++]=0xFF;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x08;	//MCLR=1
+	bufferU[j++]=0;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;	//MCLR=0
+	bufferU[j++]=0;
+	bufferU[j++]=JTAG_SET_MODE;
+	bufferU[j++]=0x3E;//0x1F;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_SW_MTAP;
+	bufferU[j++]=JTAG_SET_MODE;
+	bufferU[j++]=0x3E;//0x1F;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_COMMAND;
+	bufferU[j++]=JTAG_XFER_DATA;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=MCHP_STATUS;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(25);
+	j=0;
+	for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+//	PrintMessage1("w0: (0x%08X)\r\n",w0);
+	bufferU[j++]=JTAG_XFER_DATA;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=MCHP_STATUS;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	for(i=0;(w0&0xC)!=0x8&&i<20;i++){
+		PacketIO(5);
+		for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+//		PrintMessage1("w0: (0x%08X)\r\n",w0);
+	}
+	PrintMessage3("Device status: CFGRDY=%d FCBUSY=%d (0x%02X)\r\n",w0&0x8?1:0,w0&0x4?1:0,w0&0xFF);
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_IDCODE;
+	bufferU[j++]=JTAG_XFER_DATA;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	PacketIO(5);
+	j=0;
+	for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("IDCODE=0x%08X\r\n",w0);
+	PIC32_ID(w0);
+	//enable serial execution mode
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_SW_MTAP;
+	bufferU[j++]=JTAG_SET_MODE;
+	bufferU[j++]=0x3E;//0x1F;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_COMMAND;
+	bufferU[j++]=JTAG_XFER_DATA;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=0;
+	bufferU[j++]=MCHP_STATUS;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_SW_ETAP;
+	bufferU[j++]=JTAG_SET_MODE;
+	bufferU[j++]=0x3E;//0x1F;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=ETAP_EJTAGBOOT;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0x8;	//MCLR=1
+	bufferU[j++]=0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+//	msDelay(5);
+	/*
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	j=1;
+	for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** read code ********************
+	PrintMessage(strings[S_CodeReading1]);		//code read ...
+	PrintStatusSetup();
+//Read 6 24 bit words packed in 9 16 bit words
+//memory address advances by 24 bytes because of alignment
+	int High=0;
+	for(i=0;i<dim;i+=24){
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+1]=bufferI[z+1];	//M0
+			memCODE[k]=bufferI[z+2];	//L0
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			memCODE[k+2]=bufferI[z+2];	//H0
+			memCODE[k+6]=bufferI[z+1];	//H1
+		}
+		PrintStatus(strings[S_CodeReading2],i*100/dim,i/2);	//"Read: %d%%, addr. %05X"
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+	}
+	PrintStatusEnd();
+	if(k!=dim){
+		PrintMessage("\r\n");
+		PrintMessage2(strings[S_ReadCodeErr2],dim,k);	//"Error reading code area, requested %d bytes, read %d\r\n"
+	}
+	else PrintMessage(strings[S_Compl]);*/
+//****************** read config area ********************
+//0x1FC00BF0-0BFF
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=MTAP_SW_ETAP;
+	bufferU[j++]=JTAG_SET_MODE;
+	bufferU[j++]=0x3E;//0x1F;
+
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=ETAP_CONTROL;
+	bufferU[j++]=JTAG_XFER_DATA;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	j=0;
+	for(i=0;i<20;i++){	//Wait for CPU ready
+		PacketIO(5);
+		for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+		if(w0&0x40000) break;
+	}
+	//PrintMessage1("i=%d\r\n",i);
+	PrintMessage1("ECR=0x%08X\r\n",w0);
+	for(i=0xbFC00BF0;i<0xbFC00C10;i+=4){
+/*		XferInstruction(&j,0x3C13FF20);				//lui $s3, 0xFF20
+		XferInstruction(&j,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+		XferInstruction(&j,0x35080000+(i%0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+		XferInstruction(&j,0x8d090000);				//lw $t1, 0($t0)
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		XferInstruction(&j,0xae690000);				//sw $t1, 0($s3)
+		XferInstruction(&j,0);						//nop
+*/
+		XferInstruction(-1,0x3C13FF20);				//lui $s3, 0xFF20
+		XferInstruction(-1,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+		XferInstruction(-1,0x35080000+(i&0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+		XferInstruction(-1,0x8d090000);				//lw $t1, 0($t0)
+		XferInstruction(-1,0xae690000);				//sw $t1, 0($s3)
+		XferInstruction(-1,0);						//nop
+		j=0;
+		bufferU[j++]=JTAG_SEND_CMD;
+		bufferU[j++]=ETAP_FASTDATA;
+		bufferU[j++]=JTAG_XFER_F_DATA;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		w0=-10;
+		//for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		//for(z+=4;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+		if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+		PrintMessage2("[0x%08X]=0x%08X\r\n",i,w0);
+		//msDelay(5);
+	}
+	i=0xBF80F230;	//DEV ID
+	XferInstruction(-1,0x3C13FF20);				//lui $s3, 0xFF20
+	XferInstruction(-1,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+	XferInstruction(-1,0x35080000+(i&0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+	XferInstruction(-1,0x8d090000);				//lw $t1, 0($t0)
+	XferInstruction(-1,0xae690000);				//sw $t1, 0($s3)
+	XferInstruction(-1,0);						//nop
+	j=0;
+
+/*	XferInstruction(&j,0x3C13FF20);				//lui $s3, 0xFF20
+	XferInstruction(&j,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+	XferInstruction(&j,0x35080000+(i%0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+	XferInstruction(&j,0x8d090000);				//lw $t1, 0($t0)
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	XferInstruction(&j,0xae690000);				//sw $t1, 0($s3)
+	*/
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=ETAP_FASTDATA;
+	bufferU[j++]=JTAG_XFER_F_DATA;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	w0=-10;
+//	for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+//	for(z+=4;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+	PacketIO(5);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+	PacketIO(5);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+	PacketIO(5);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+	PacketIO(5);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+	XferInstruction(-1,0x3C13FF20);				//lui $s3, 0xFF20
+	XferInstruction(-1,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+	XferInstruction(-1,0x35080000+(i&0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+	XferInstruction(-1,0x8d090000);				//lw $t1, 0($t0)
+	XferInstruction(-1,0xae690000);				//sw $t1, 0($s3)
+	XferInstruction(-1,0);						//nop
+	j=0;
+	bufferU[j++]=JTAG_SEND_CMD;
+	bufferU[j++]=ETAP_FASTDATA;
+	bufferU[j++]=JTAG_XFER_F_DATA;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	PacketIO(5);
+	j=0;
+	w0=-10;
+//	for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+//	for(z+=4;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+	for(z=0;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+	if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+	PrintMessage1("DEVID=0x%08X\r\n",w0);
+// Boot block
+//	PrintMessage("BOOT BLOCK @0x1FC00000\r\n");
+	for(i=0x1FC00000;i<0x1FC00BF0&&0;i+=4){
+		XferInstruction(&j,0x3C13FF20);				//lui $s3, 0xFF20
+		XferInstruction(&j,0x3C080000+(i>>16));		//lui $t0,<FLASH_WORD_ADDR(31:16)>
+		XferInstruction(&j,0x35080000+(i%0xFFFF));	//ori $t0,<FLASH_WORD_ADDR(15:0)>
+		XferInstruction(&j,0x8d090000);				//lw $t1, 0($t0)
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		XferInstruction(&j,0xae690000);				//sw $t1, 0($s3)
+		bufferU[j++]=JTAG_SEND_CMD;
+		bufferU[j++]=ETAP_FASTDATA;
+		bufferU[j++]=JTAG_XFER_F_DATA;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		PacketIO(5);
+		j=0;
+		for(z=0;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		for(z+=4;bufferI[z]!=JTAG_XFER_DATA&&z<DIMBUF;z++);
+		for(z+=4;bufferI[z]!=JTAG_XFER_F_DATA&&z<DIMBUF;z++);
+		if(z<DIMBUF-4) w0=(bufferI[z+1]<<24)+(bufferI[z+2]<<16)+(bufferI[z+3]<<8)+bufferI[z+4];
+		PrintMessage2("[0x%08X]=0x%08X\r\n",i,w0);
+	}
+
+/*	if(config>2){					//config area @ 0xF80000
+		if(saveLog)	fprintf(logfile,"\nCONFIG:\n");
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+		//save 0xF800000 to 0xF80010
+		for(i=0,z=1;i<9;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			memCONFIG[i*4]=bufferI[z+2];	//Low byte
+			memCONFIG[i*4+1]=bufferI[z+1];	//High byte
+			z+=3;
+		}
+		writeP();
+		msDelay(3);
+		readP();
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+		//save 0xF800012 to 0xF80016
+		for(i=9,z=1;i<12;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			memCONFIG[i*4]=bufferI[z+2];	//Low byte
+			memCONFIG[i*4+1]=bufferI[z+1];	//High byte
+			z+=3;
+		}
+		PrintStatusClear();
+	}*/
+//****************** exit ********************
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EXT_PORT;
+	bufferU[j++]=0;	//MCLR=0
+	bufferU[j++]=0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(2);
+	readP();
+	if(saveLog)	WriteLogIO();
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+//****************** visualize ********************
+/*	if(config>2){					//only if separate config area
+		PrintMessage(strings[S_ConfigMem]);				//"\r\nConfig Memory:\r\n"
+		if(config==3||config==4||config==6){
+			PrintMessage1("0xF80000: FBS = 0x%02X\r\n",memCONFIG[0]);
+			if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80002: FSS = 0x%02X\r\n",memCONFIG[4]);
+			}
+			PrintMessage1("0xF80004: FGS = 0x%02X\r\n",memCONFIG[8]);
+			PrintMessage1("0xF80006: FOSCSEL = 0x%02X\r\n",memCONFIG[12]);
+			PrintMessage1("0xF80008: FOSC = 0x%02X\r\n",memCONFIG[16]);
+			PrintMessage1("0xF8000A: FWDT = 0x%02X\r\n",memCONFIG[20]);
+			PrintMessage1("0xF8000C: FPOR = 0x%02X\r\n",memCONFIG[24]);
+			PrintMessage1("0xF8000E: FICD = 0x%02X\r\n",memCONFIG[28]);
+			if(config==3){			//0xF80000-10 except 02
+				PrintMessage1("0xF80010: FDS = 0x%02X\r\n",memCONFIG[32]);
+			}
+			else if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80010: UID0 = 0x%02X\r\n",memCONFIG[32]);
+				PrintMessage1("0xF80012: UID1 = 0x%02X\r\n",memCONFIG[36]);
+				PrintMessage1("0xF80014: UID2 = 0x%02X\r\n",memCONFIG[40]);
+				PrintMessage1("0xF80016: UID3 = 0x%02X\r\n",memCONFIG[44]);
+			}
+		}
+		else if(config==5){			//0xF80000-0C (16 bit)
+			PrintMessage2("0xF80000: FOSC = 0x%02X%02X\r\n",memCONFIG[1],memCONFIG[0]);
+			PrintMessage2("0xF80002: FWDT = 0x%02X%02X\r\n",memCONFIG[5],memCONFIG[4]);
+			PrintMessage2("0xF80004: FBORPOR = 0x%02X%02X\r\n",memCONFIG[9],memCONFIG[8]);
+			PrintMessage2("0xF80006: FBS = 0x%02X%02X\r\n",memCONFIG[13],memCONFIG[12]);
+			PrintMessage2("0xF80008: FSS = 0x%02X%02X\r\n",memCONFIG[17],memCONFIG[16]);
+			PrintMessage2("0xF8000A: FGS = 0x%02X%02X\r\n",memCONFIG[21],memCONFIG[20]);
+			PrintMessage2("0xF8000C: FICD = 0x%02X%02X\r\n",memCONFIG[25],memCONFIG[24]);
+		}
+	}
+	else{
+			//last 2 program words
+			PrintMessage2("CONFIG1: 0x%04X\r\nCONFIG2: 0x%04X\r\n",(memCODE[dim-3]<<8)+memCODE[dim-4]\
+				,(memCODE[dim-7]<<8)+memCODE[dim-8]);
+			if(config==1){			//last 3 program words
+				PrintMessage1("CONFIG3: 0x%04X\r\n",(memCODE[dim-11]<<8)+memCODE[dim-12]);
+			}
+			if(config==2){			//last 4 program words
+				PrintMessage1("CONFIG4: 0x%04X\r\n",(memCODE[dim-15]<<8)+memCODE[dim-16]);
+			}
+		}
+	PrintMessage(strings[S_CodeMem]);	//"\r\nCode memory:\r\n"
+	DisplayCODE24F(dim);
+	if(dim2){
+		PrintMessage(strings[S_EEMem]);	//"\r\nEEPROM memory:\r\n"
+		DisplayEE24F();
+	}
+	if(executiveArea){
+		char s[256],t[256];
+		int d,valid,empty=1;
+		char* aux=(char*)malloc((dim/COL+1)*2*(16+COL*9));
+		aux[0]=0;
+		s[0]=0;
+		empty=1;
+		PrintMessage(strings[S_ExeMem]);	//"\r\nExecutive memory:\r\n"
+		for(i=0;i<executiveArea;i+=COL*2){
+			valid=0;
+			for(j=i;j<i+COL*2&&j<executiveArea;j+=4){
+				d=(memExec[j+3]<<24)+(memExec[j+2]<<16)+(memExec[j+1]<<8)+memExec[j];
+				sprintf(t,"%08X ",d);
+				strcat(s,t);
+				if(d!=0xffffffff) valid=1;
+			}
+			if(valid){
+				sprintf(t,"%06X: %s\r\n",i/2,s);
+				empty=0;
+				strcat(aux,t);
+			}
+			s[0]=0;
+		}
+		if(empty) PrintMessage(strings[S_Empty]);	//empty
+		else PrintMessage(aux);
+		free(aux);
+	}*/
+	PrintMessage1(strings[S_End],(stop-start)/1000.0);	//"\r\nEnd (%.2f s)\r\n"
+	if(saveLog) CloseLogFile();
+}
+
+/*
+#ifdef _MSC_VER
+void COpenProgDlg::Write24Fx(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait){
+#else
+void Write24Fx(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait){
+#endif
+// write 16 bit PIC 24Fxxxx
+// deviceID @ 0xFF0000
+// dim=program size (16 bit words)
+// dim2=eeprom size (in bytes, area starts at 0x800000-size)
+// options:
+//	bit [3:0]
+//     0 = low voltage ICSP entry
+//     1 = High voltage ICSP entry (6V)
+//     2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
+//     3 = low voltage ICSP entry (5V power supply)
+//	bit [7:4]
+//	   0 = config area in the last 2 program words
+//	   1 = config area in the last 3 program words
+//	   2 = config area in the last 4 program words
+//	   3 = 0xF80000 to 0xF80010 except 02 (24F)
+//     4 = 0xF80000 to 0xF80016 (24H-33F)
+//     5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
+//     6 = 0xF80000 to 0xF8000E (30FSMPS)
+//	bit [11:8]
+//	   0 = code erase word is 0x4064, row write is 0x4004
+//	   1 = code erase word is 0x404F, row write is 0x4001
+//	   2 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (2 ms)
+//	   3 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (200 ms)
+//	bit [15:12]
+//	   0 = eeprom erase word is 0x4050, write word is 0x4004
+//	   1 = eeprom erased with bulk erase, write word is 0x4004
+//	   2 = eeprom erased with special sequence, write word is 0x4004
+//	bit [19:16]
+//	   0 = config write is 0x4000
+//	   1 = config write is 0x4003
+//	   2 = config write is 0x4004
+//	   3 = config write is 0x4008
+//	bit [20]
+//	   0 = standard TABLPAG address
+//	   1 = new TABLPAG address
+// appIDaddr = application ID word lower address (high is 0x80)
+// rowSize = row size in instruction words (a row is written altogether)
+// wait = write delay in ms
+	int k=0,k2=0,z=0,i,j;
+	int entry=options&0xF;
+	int config=(options>>4)&0xF;
+	int EEbaseAddr=0x1000-dim2;
+	int newTABLPAG=options&0x100000?1:0;
+	int err=0;
+	if(FWVersion<0x700){
+		PrintMessage1(strings[S_FWver2old],"0.7.0");	//"This firmware is too old. Version %s is required\r\n"
+		return;
+	}
+	if(entry<2&&!CheckV33Regulator()){		//except 30Fxx which is on 5V
+		PrintMessage(strings[S_noV33reg]);	//Can't find 3.3V expansion board
+		return;
+	}
+	if(saveLog){
+		OpenLogFile();
+		fprintf(logfile,"Write24Fx(%d,%d,%d,%d,%d,%.1f)    (0x%X,0x%X,0x%X,0x%X,0x%X,%.3f)\n"
+			,dim,dim2,options,appIDaddr,rowSize,wait,dim,dim2,options,appIDaddr,rowSize,wait);
+	}
+	dim*=2;		//from words to bytes
+	if(dim>0x80000||dim<0){
+		PrintMessage(strings[S_CodeLim]);	//"Code size out of limits\r\n"
+		return;
+	}
+	if(dim2>0x1000||dim2<0){
+		PrintMessage(strings[S_EELim]);	//"EEPROM size out of limits\r\n"
+		return;
+	}
+	j=size;
+	if(j%(rowSize*4)){			//grow to an integer number of rows
+		size=(j/(rowSize*4)+1)*rowSize*4;
+		memCODE=(unsigned char*)realloc(memCODE,size);
+		for(;j<size;j++) memCODE[j]=0xFF;
+	}
+	if(dim>size) dim=size;
+	if(sizeEE<0x1000) dim2=0;
+	if(dim<1){
+		PrintMessage(strings[S_NoCode]);	//"Empty code area\r\n"
+		return;
+	}
+	if((entry==1)||(entry==2)){			//High voltage programming: 3.3V + 1.5V + R drop + margin
+		if(!StartHVReg(entry==2?12:6)){	//12V only for 30Fxx !!!
+			PrintMessage(strings[S_HVregErr]); //"HV regulator error\r\n"
+			return;
+		}
+	}
+	else StartHVReg(-1);		//LVP: current limited to (5-0.7-3.6)/10k = 50uA
+	if(config>2){					//only if separate config area
+		PrintMessage(strings[S_ConfigMem]);				//"\r\nConfig Memory:\r\n"
+		if(config==3||config==4||config==6){
+			PrintMessage1("0xF80000: FBS = 0x%02X\r\n",memCONFIG[0]);
+			if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80002: FSS = 0x%02X\r\n",memCONFIG[4]);
+			}
+			PrintMessage1("0xF80004: FGS = 0x%02X\r\n",memCONFIG[8]);
+			PrintMessage1("0xF80006: FOSCSEL = 0x%02X\r\n",memCONFIG[12]);
+			PrintMessage1("0xF80008: FOSC = 0x%02X\r\n",memCONFIG[16]);
+			PrintMessage1("0xF8000A: FWDT = 0x%02X\r\n",memCONFIG[20]);
+			PrintMessage1("0xF8000C: FPOR = 0x%02X\r\n",memCONFIG[24]);
+			PrintMessage1("0xF8000E: FICD = 0x%02X\r\n",memCONFIG[28]);
+			if(config==3){			//0xF80000-10 except 02
+				PrintMessage1("0xF80010: FDS = 0x%02X\r\n",memCONFIG[32]);
+			}
+			else if(config==4){			//0xF80000-16
+				PrintMessage1("0xF80010: UID0 = 0x%02X\r\n",memCONFIG[32]);
+				PrintMessage1("0xF80012: UID1 = 0x%02X\r\n",memCONFIG[36]);
+				PrintMessage1("0xF80014: UID2 = 0x%02X\r\n",memCONFIG[40]);
+				PrintMessage1("0xF80016: UID3 = 0x%02X\r\n",memCONFIG[44]);
+			}
+		}
+		else if(config==5){			//0xF80000-0C (16 bit)
+			PrintMessage2("0xF80000: FOSC = 0x%02X%02X\r\n",memCONFIG[1],memCONFIG[0]);
+			PrintMessage2("0xF80002: FWDT = 0x%02X%02X\r\n",memCONFIG[5],memCONFIG[4]);
+			PrintMessage2("0xF80004: FBORPOR = 0x%02X%02X\r\n",memCONFIG[9],memCONFIG[8]);
+			PrintMessage2("0xF80006: FBS = 0x%02X%02X\r\n",memCONFIG[13],memCONFIG[12]);
+			PrintMessage2("0xF80008: FSS = 0x%02X%02X\r\n",memCONFIG[17],memCONFIG[16]);
+			PrintMessage2("0xF8000A: FGS = 0x%02X%02X\r\n",memCONFIG[21],memCONFIG[20]);
+			PrintMessage2("0xF8000C: FICD = 0x%02X%02X\r\n",memCONFIG[25],memCONFIG[24]);
+		}
+	}
+	else{
+			//last 2 program words
+			PrintMessage2("CONFIG1: 0x%04X\r\nCONFIG2: 0x%04X\r\n",(memCODE[dim-3]<<8)+memCODE[dim-4]\
+				,(memCODE[dim-7]<<8)+memCODE[dim-8]);
+			if(config==1){			//last 3 program words
+				PrintMessage1("CONFIG3: 0x%04X\r\n",(memCODE[dim-11]<<8)+memCODE[dim-12]);
+			}
+			if(config==2){			//last 4 program words
+				PrintMessage1("CONFIG4: 0x%04X\r\n",(memCODE[dim-15]<<8)+memCODE[dim-16]);
+			}
+		}
+	unsigned int start=GetTickCount();
+	bufferU[0]=0;
+	j=1;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=EN_VPP_VCC;		//enter program mode
+	bufferU[j++]=0x0;
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=WAIT_T2;
+	bufferU[j++]=EN_VPP_VCC;		//VDD
+	bufferU[j++]=0x1;
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	if((entry==0)||(entry==3)){		//LVP: pulse on MCLR
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+	}
+	else PrintMessage(strings[S_HVICSP]); //"High Voltage ICSP\r\n"
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=TX16;
+	bufferU[j++]=2;
+	bufferU[j++]=0x4D;
+	bufferU[j++]=0x43;
+	bufferU[j++]=0x48;
+	bufferU[j++]=0x51;
+	bufferU[j++]=WAIT_T3;			//min 1ms
+	bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+	bufferU[j++]=0x5;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=30000>>8;
+	bufferU[j++]=30000&0xff;
+	bufferU[j++]=WAIT_T3;			//min 25ms
+	if(entry==2){					//30Fx entry
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=EN_VPP_VCC;	//VDD
+		bufferU[j++]=0x1;
+		bufferU[j++]=EN_VPP_VCC;		//VDD + VPP
+		bufferU[j++]=0x5;
+		bufferU[j++]=ICSP_NOP;
+	}
+	else{
+		//Additional 5 clock cycles upon entering program mode
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x4;				//CK=1
+		bufferU[j++]=SET_CK_D;
+		bufferU[j++]=0x0;				//CK=0
+	}
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(37);
+	readP();
+	if(saveLog)WriteLogIO();
+	j=1;
+	//Read DeviceID @0xFF0000, DevRev @0xFF0002
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x0F;
+	bufferU[j++]=0xF0;				//0xFF
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20;				//MOV XXXX,W6
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x06;				//0x0000
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0xB6;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(2);
+	readP();
+	if(saveLog)WriteLogIO();
+	j=1;
+	int w0=0,w1=0;
+	for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w1=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("DevID: 0x%04X\r\nDevRev: 0x%04X\r\n",w0,w1);
+	PIC24_ID(w0);
+	//Read ApplicationID @ appIDaddr
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=0x44;				//append 1 NOP
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x20+((appIDaddr>>12)&0xF);	//MOV XXXX,W6
+	bufferU[j++]=(appIDaddr>>4)&0xFF;
+	bufferU[j++]=((appIDaddr<<4)&0xF0)+6;
+	bufferU[j++]=0x20;				//MOV #VISI,W7
+	bufferU[j++]=0x78;
+	bufferU[j++]=0x47;
+	bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+	bufferU[j++]=0xBA;
+	bufferU[j++]=0x0B;
+	bufferU[j++]=0x96;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=SIX_LONG;				//GOTO 0x200
+	bufferU[j++]=0x04;
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=SET_PARAMETER;
+	bufferU[j++]=SET_T3;
+	bufferU[j++]=2000>>8;
+	bufferU[j++]=2000&0xff;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(2);
+	readP();
+	j=1;
+	if(saveLog)WriteLogIO();
+	for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	if(z<DIMBUF-2) w0=(bufferI[z+1]<<8)+bufferI[z+2];
+	PrintMessage2("ApplicationID @ 0x80%04X:  0x%04X\r\n",appIDaddr,w0);
+//****************** erase memory ********************
+	PrintMessage(strings[S_StartErase]);	//"Erase ... "
+	if(saveLog)	fprintf(logfile,"\nERASE:\n");
+	int erase=(options&0xF00)>>8;
+	//bulk erase command
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=4;
+	bufferU[j++]=0x24;				//MOV XXXX,W10
+	if(erase==0){			//0x4064
+		bufferU[j++]=0x06;
+		bufferU[j++]=0x4A;
+	}
+	else if(erase==1){		//0x404F
+		bufferU[j++]=0x04;
+		bufferU[j++]=0xFA;
+	}
+	else if(erase>=2){		//0x407F
+		bufferU[j++]=0x07;
+		bufferU[j++]=0xFA;
+	}
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x0A;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX_LONG;			//TBLWTL W0,[W0] (dummy write)
+	bufferU[j++]=0xBB;
+	bufferU[j++]=0x08;
+	bufferU[j++]=0x00;
+	if(erase>=2){				//30Fx, unlock and external timing
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV 0x55,W8
+		bufferU[j++]=0x05;
+		bufferU[j++]=0x58;
+		bufferU[j++]=0x88;				//MOV W8,NVMKEY
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x38;
+		bufferU[j++]=0x20;				//MOV 0xAA,W8
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0x88;				//MOV W8,NVMKEY
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x38;
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=WAIT_T3;
+		if(erase==3){				//200 ms timing
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(200);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+		}
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+		bufferU[j++]=0xA9;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+	}
+	else{		//internal timing
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=WAIT_T3;
+	bufferU[j++]=SIX;				//MOV NVMCON,W2
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x02;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W2,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x3C;
+	bufferU[j++]=0x22;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=REGOUT;
+	}
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(7);
+	readP();
+	j=1;
+	if(saveLog)WriteLogIO();
+	for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+	w0=bufferI[z+1]&0x80;
+	//Wait for erase completion (max 1s)
+	for(i=0;erase<2&&i<100&&w0;i++){
+	bufferU[j++]=SIX;				//MOV NVMCON,W2
+	bufferU[j++]=0x80;
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x02;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=SIX;				//MOV W2,VISI
+	bufferU[j++]=0x88;
+	bufferU[j++]=0x3C;
+	bufferU[j++]=0x22;
+	bufferU[j++]=REGOUT;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(10);
+		readP();
+		j=1;
+		if(saveLog)WriteLogIO();
+		for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		w0=bufferI[z+1]&0x80;
+	}
+//****************** prepare write ********************
+	bufferU[j++]=SIX_N;
+	bufferU[j++]=5;
+	bufferU[j++]=0x24;				//MOV XXXX,W10
+	bufferU[j++]=0x00;
+	bufferU[j++]=erase>0?0x1A:0x4A;	//0x4001/0x4004
+	bufferU[j++]=0x88;				//MOV W10,NVMCON
+	bufferU[j++]=0x3B;
+	bufferU[j++]=0x0A;
+	bufferU[j++]=0x20;				//MOV XXXX,W0
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x00;
+	bufferU[j++]=0x88;				//MOV W0,TABLPAG
+	if(newTABLPAG){
+		bufferU[j++]=0x02;
+		bufferU[j++]=0xA0;
+	}
+	else{
+		bufferU[j++]=0x01;
+		bufferU[j++]=0x90;
+	}
+	bufferU[j++]=0x04;				//GOTO 0x200
+	bufferU[j++]=0x02;
+	bufferU[j++]=0x00;
+	bufferU[j++]=ICSP_NOP;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(2);
+	readP();
+	j=1;
+	if(saveLog)WriteLogIO();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** write code ********************
+	PrintMessage(strings[S_StartCodeProg]);	//"Write code ... "
+	if(saveLog)	fprintf(logfile,"\nWRITE CODE:\n");
+	PrintStatusSetup();
+//	instruction words are stored in code memory array as follows:
+//	L0 M0 H0 FF L1 M1 H1 FF
+	int valid,High=0;
+		for(i=0,k=0;i<dim;i+=4*4){		//write 4 instruction words
+			if(k==0){				//skip row if empty
+				for(valid=0;!valid&&i<dim;i+=valid?0:rowSize*4){
+					for(k2=0;k2<rowSize*4&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+				}
+				if(i>=dim) break;
+			}
+			if((i>>17)!=High){	//advance page
+				bufferU[j++]=SIX;				//MOV XXXX,W0
+				bufferU[j++]=0x20;
+				bufferU[j++]=(i>>21)&0xFF;
+				bufferU[j++]=(i>>13)&0xF0;
+				bufferU[j++]=SIX;				//MOV W0,TABLPAG
+				bufferU[j++]=0x88;
+				if(newTABLPAG){
+					bufferU[j++]=0x02;
+					bufferU[j++]=0xA0;
+				}
+				else{
+					bufferU[j++]=0x01;
+					bufferU[j++]=0x90;
+				}
+				bufferU[j++]=SIX;				//GOTO 0x200
+				bufferU[j++]=0x04;
+				bufferU[j++]=0x02;
+				bufferU[j++]=0x00;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				writeP();
+				msDelay(2);
+				readP();
+				j=1;
+				if(saveLog)WriteLogIO();
+				High=i>>17;
+			}
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=8;
+			bufferU[j++]=0x20+((i>>13)&0xF);						//MOV i/2,W7
+			bufferU[j++]=(i>>5)&0xFF;
+			bufferU[j++]=((i<<3)&0xF0)+7;
+			bufferU[j++]=0x20+((memCODE[i+1]>>4)&0xF);				//MOV LSW0,W0
+			bufferU[j++]=((memCODE[i+1]<<4)&0xF0)+((memCODE[i]>>4)&0xF);
+			bufferU[j++]=(memCODE[i]<<4)&0xF0;
+			bufferU[j++]=0x20+((memCODE[i+6]>>4)&0xF);				//MOV MSB1:MSB0,W1
+			bufferU[j++]=((memCODE[i+6]<<4)&0xF0)+((memCODE[i+2]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+2]<<4)&0xF0)+1;
+			bufferU[j++]=0x20+((memCODE[i+5]>>4)&0xF);				//MOV LSW1,W2
+			bufferU[j++]=((memCODE[i+5]<<4)&0xF0)+((memCODE[i+4]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+4]<<4)&0xF0)+2;
+			bufferU[j++]=0x20+((memCODE[i+9]>>4)&0xF);				//MOV LSW2,W3
+			bufferU[j++]=((memCODE[i+9]<<4)&0xF0)+((memCODE[i+8]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+8]<<4)&0xF0)+3;
+			bufferU[j++]=0x20+((memCODE[i+14]>>4)&0xF);				//MOV MSB3:MSB2,W4
+			bufferU[j++]=((memCODE[i+14]<<4)&0xF0)+((memCODE[i+10]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+10]<<4)&0xF0)+4;
+			bufferU[j++]=0x20+((memCODE[i+13]>>4)&0xF);				//MOV LSW3,W5
+			bufferU[j++]=((memCODE[i+13]<<4)&0xF0)+((memCODE[i+12]>>4)&0xF);
+			bufferU[j++]=((memCODE[i+12]<<4)&0xF0)+5;
+			bufferU[j++]=0xEB;				//CLR W6
+			bufferU[j++]=0x03;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=0x88;				//Append 2 NOP
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7]
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[W7++]
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[++W7]
+			bufferU[j++]=0xEB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7++]
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7]
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[W7++]
+			bufferU[j++]=0xDB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTH.B [W6++],[++W7]
+			bufferU[j++]=0xEB;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=0xBB;				//TBLWTL [W6++],[W7++]
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0xB6;
+			k++;
+			if(k==rowSize/4){	//Write row
+				if(erase>1){				//30Fx, unlock and external timing
+					bufferU[j++]=FLUSH;
+					for(;j<DIMBUF;j++) bufferU[j]=0x0;
+					writeP();
+					msDelay(3);
+					readP();
+					j=1;
+					if(saveLog){
+						fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d, k=%d 0=%d\n"
+						WriteLogIO();
+					}
+					bufferU[j++]=SIX_N;
+					bufferU[j++]=6;
+					bufferU[j++]=0x24;				//MOV XXXX,W10
+					bufferU[j++]=0x00;
+					bufferU[j++]=erase>0?0x1A:0x4A;	//0x4001/0x4004
+					bufferU[j++]=0x88;				//MOV W10,NVMCON
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0x20;				//MOV 0x55,W8
+					bufferU[j++]=0x05;
+					bufferU[j++]=0x58;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=0x20;				//MOV 0xAA,W8
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+					bufferU[j++]=0xA9;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=SIX_LONG;				//GOTO 0x200
+					bufferU[j++]=0x04;
+					bufferU[j++]=0x02;
+					bufferU[j++]=0x00;
+				}
+				else{		//internal timing
+				bufferU[j++]=SIX_LONG;				//GOTO 0x200
+				bufferU[j++]=0x04;
+				bufferU[j++]=0x02;
+				bufferU[j++]=0x00;
+				bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+				}
+				k=0;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(3);
+			readP();
+			j=1;
+			PrintStatus(strings[S_CodeWriting2],i*100/(dim+dim2),i/2);	//"Write: %d%%,addr. %04X"
+			if(RWstop) i=dim;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i/2,i/2,k,k);	//"i=%d, k=%d 0=%d\n"
+				WriteLogIO();
+			}
+		}
+	PrintStatusEnd();
+	PrintMessage(strings[S_Compl]);	//"completed\r\n"
+//****************** verify code ********************
+	PrintMessage(strings[S_CodeV]);	//"Verify code ... "
+	if(saveLog)	fprintf(logfile,"\nVERIFY CODE:\n");
+	PrintStatusSetup();
+//Read 4 24 bit words packed in 6 16 bit words
+//memory address advances by 16 bytes because of alignment
+	High=0xE0000000;
+	int r0=0,r1=0,r2=0,r3=0,w3,w2;
+	for(i=0;i<dim;i+=16){
+		//skip row if empty
+		for(valid=0;!valid&&i<dim;i+=valid?0:16){
+			for(k2=0;k2<16&&!valid;k2++) if(memCODE[i+k2]<0xFF) valid=1;
+		}
+		if(i>=dim) break;
+		if((i>>17)!=High){	//advance page
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(i>>21)&0xFF;
+			bufferU[j++]=(i>>13)&0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=SIX;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(2);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+			High=i>>17;
+		}
+		bufferU[j++]=SIX;				//MOV i/2,W6
+		bufferU[j++]=0x20+((i>>13)&0xF);
+		bufferU[j++]=(i>>5)&0xFF;
+		bufferU[j++]=((i<<3)&0xF0)+6;
+		bufferU[j++]=SIX;				//MOV #VISI,W7
+		bufferU[j++]=0x20;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0x96;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [W6++],[W7++]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xDB;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=SIX_LONG;				//TBLRDH.B [++W6],[W7--]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0xD3;
+		bufferU[j++]=0xD6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		PrintStatus(strings[S_CodeV2],i*100/(dim+dim2),i/2);	//"Verify: %d%%, addr. %04X"
+		if(RWstop) i=dim;
+		for(z=1;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r0+=bufferI[z+2]<<16;
+			r1=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r1+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r2+=bufferI[z+2]<<16;
+			r3=bufferI[z+1]<<16;
+		}
+		for(z+=3;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+		if(z<DIMBUF-2){
+			r3+=(bufferI[z+1]<<8)+bufferI[z+2];
+		}
+		w0=(memCODE[i+2]<<16)+(memCODE[i+1]<<8)+memCODE[i];
+		w1=(memCODE[i+6]<<16)+(memCODE[i+5]<<8)+memCODE[i+4];
+		w2=(memCODE[i+10]<<16)+(memCODE[i+9]<<8)+memCODE[i+8];
+		w3=(memCODE[i+14]<<16)+(memCODE[i+13]<<8)+memCODE[i+12];
+		CheckData(w0,r0,i/2,&err);
+		CheckData(w1,r1,i/2+2,&err);
+		CheckData(w2,r2,i/2+4,&err);
+		CheckData(w3,r3,i/2+6,&err);
+		PrintStatus(strings[S_CodeV2],i*100/dim,i/2);	//"Verify: %d%%, addr. %05X"
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log8],i/2,i/2,k,k,err);	//"i=%d, k=%d, errori=%d\n"
+			WriteLogIO();
+		}
+		if(err>=max_err) break;
+	}
+	PrintStatusEnd();
+	PrintMessage1(strings[S_ComplErr],err);	//"completed: %d errors\r\n"
+	if(err>=max_err){
+		PrintMessage1(strings[S_MaxErr],err);	//"Exceeded maximum number of errors (%d), write interrupted\r\n"
+	}
+//****************** erase, write and verify EEPROM ********************
+	if(dim2&&err<max_err){
+		//EEPROM @ 0x7F(EEbaseAddr)
+		PrintMessage(strings[S_EEAreaW]);	//"Write EEPROM ... "
+		PrintStatusSetup();
+		if(saveLog)	fprintf(logfile,"\nWRITE EEPROM:\n");
+		int eewrite=(options&0xf000)>>12;
+		if(eewrite==0){		//24FxxKAxx
+			bufferU[j++]=SIX;				//MOV 0x4050,W10
+			bufferU[j++]=0x24;
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//MOV W10,NVMCON
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//MOV 0x7F,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=0x07;
+			bufferU[j++]=0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=SIX;				//MOV EEbaseAddr,W0
+			bufferU[j++]=0x2F;
+			bufferU[j++]=EEbaseAddr>>4;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX;				//TBLWTL W0,[W0]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x08;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;/**/
+	/*		//Erase EEPROM
+			bufferU[j++]=SIX;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=SIX;				//MOV 0x4004,W10
+			bufferU[j++]=0x24;
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x4A;
+			bufferU[j++]=SIX;				//MOV W10,NVMCON
+			bufferU[j++]=0x88;
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=SIX;				//GOTO 0x200
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x02;
+			bufferU[j++]=0x00;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(9);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+		}
+		else if(eewrite==2){		//separate erase
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4046,W10
+			bufferU[j++]=0x04;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4056,W10
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(6);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 4066,W10
+			bufferU[j++]=0x06;
+			bufferU[j++]=0x6A;
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(4);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+		}
+		else if(eewrite==1){		//30Fxx
+			bufferU[j++]=SIX;				//MOV 0x7F,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=0x07;
+			bufferU[j++]=0xF0;
+			bufferU[j++]=SIX;				//MOV W0,TABLPAG
+			bufferU[j++]=0x88;
+			if(newTABLPAG){
+				bufferU[j++]=0x02;
+				bufferU[j++]=0xA0;
+			}
+			else{
+				bufferU[j++]=0x01;
+				bufferU[j++]=0x90;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(1);
+			readP();
+			j=1;
+			if(saveLog)WriteLogIO();
+		}
+		//Write EEPROM
+		for(k2=0,i=0x1000-dim2;i<0x1000;i+=2){	//write 1 word (2 bytes)
+			if(memEE[i]<0xFF||memEE[i+1]<0xFF){
+			bufferU[j++]=SIX;				//MOV i,W7
+				bufferU[j++]=0x2F;
+				bufferU[j++]=i>>4;
+				bufferU[j++]=((i<<4)&0xF0)+7;
+				bufferU[j++]=SIX;				//MOV XXXX,W0
+				bufferU[j++]=0x20+((memEE[i+1]>>4)&0xF);
+				bufferU[j++]=((memEE[i+1]<<4)&0xF0)+((memEE[i]>>4)&0xF);
+				bufferU[j++]=(memEE[i]<<4)&0xF0;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+				bufferU[j++]=0xBB;
+				bufferU[j++]=0x1B;
+				bufferU[j++]=0x80;
+				if(eewrite==0){		//24FxxKAxx
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+				}
+				else if(eewrite==1){		//30Fxxxx
+					bufferU[j++]=SIX_N;
+					bufferU[j++]=6;
+					bufferU[j++]=0x24;				//MOV 0x4004,W10
+					bufferU[j++]=0x00;
+					bufferU[j++]=0x4A;
+					bufferU[j++]=0x88;				//MOV W10,NVMCON
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0x20;				//MOV 0x55,W8
+					bufferU[j++]=0x05;
+					bufferU[j++]=0x58;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=0x20;				//MOV 0xAA,W8
+					bufferU[j++]=0x0A;
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0x88;				//MOV W8,NVMKEY
+					bufferU[j++]=0x3B;
+					bufferU[j++]=0x38;
+					bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+					bufferU[j++]=0xA8;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+					bufferU[j++]=WAIT_T3;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=ICSP_NOP;
+					bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+					bufferU[j++]=0xA9;
+					bufferU[j++]=0xE7;
+					bufferU[j++]=0x61;
+				}
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				writeP();
+				msDelay(wait+2);		//write delay
+				readP();
+				j=1;
+				PrintStatus(strings[S_CodeWriting],(i-0x1000+dim2)*100/(dim2),i);	//"Scrittura: %d%%, ind. %03X"
+				if(RWstop) i=dim;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k,k);	//"i=%d, k=%d 0=%d\n"
+					WriteLogIO();
+				}
+			}
+		}
+		//Verify EEPROM
+		if(saveLog)	fprintf(logfile,"\nVERIFY EEPROM:\n");
+		bufferU[j++]=SIX;				//MOV 0xFE00,W6
+		bufferU[j++]=0x2F;
+		bufferU[j++]=EEbaseAddr>>4;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;				//MOV #VISI,W7
+		bufferU[j++]=0x20;
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=SIX;				//GOTO 0x200
+		bufferU[j++]=0x04;
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		int errE=0;
+		for(i=k2=EEbaseAddr;i<EEbaseAddr+dim2;i+=2){
+			bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+			bufferU[j++]=0xBA;
+			bufferU[j++]=0x0B;
+			bufferU[j++]=0xB6;
+			bufferU[j++]=REGOUT;
+			if(j>DIMBUF-7||i==dim2-4){
+				bufferU[j++]=FLUSH;
+				for(;j<DIMBUF;j++) bufferU[j]=0x0;
+				writeP();
+				msDelay(3);
+				readP();
+				for(z=1;z<DIMBUF-2;z++){
+					if(bufferI[z]==REGOUT){
+						CheckData(memEE[k2],bufferI[z+2],i,&errE);
+						CheckData(memEE[k2+1],bufferI[z+1],i+1,&errE);
+						z+=3;
+						k2+=2;
+					}
+				}
+				PrintStatus(strings[S_CodeReading],(i-EEbaseAddr)*100/(dim2),i);	//"Read: %d%%, addr. %03X"
+				if(RWstop) i=EEbaseAddr+dim2;
+				j=1;
+				if(saveLog){
+					fprintf(logfile,strings[S_Log7],i,i,k2,k2);	//"i=%d(0x%X), k=%d(0x%X)\n"
+					WriteLogIO();
+				}
+			}
+		}
+		PrintStatusEnd();
+		PrintMessage1(strings[S_ComplErr],errE);	//"completed: %d errors \r\n"
+		err+=errE;
+		PrintStatusClear();
+	}
+//****************** write CONFIG ********************
+	int written, read;
+	j=1;
+	if(config>2&&config<5&&err<max_err){	//config area @ 0xF80000
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"\nWRITE CONFIG:\n");
+		int confword=(options&0xF0000)>>16;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=6;
+		bufferU[j++]=0x20;				//MOV 0xF8,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x24;				//MOV 0x400x,W10
+		bufferU[j++]=0x00;
+		if(confword==0)bufferU[j++]=0x0A;		//0x4000
+		else if(confword==1)bufferU[j++]=0x3A;	//0x4003
+		else if(confword==2)bufferU[j++]=0x4A;	//0x4004
+		else if(confword==3)bufferU[j++]=0x8A;	//0x4008
+		bufferU[j++]=0x88;				//MOV W10,NVMCON
+		bufferU[j++]=0x3B;
+		bufferU[j++]=0x0A;
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		for(i=0;i<12;i++){
+			//Write CONFIG
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20;
+			bufferU[j++]=(memCONFIG[i*4]>>4)&0xF;
+			bufferU[j++]=(memCONFIG[i*4]<<4)&0xF0;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0x80;
+			//if(memCONFIG[i*4]<0xFF){			//write if not empty
+			bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=ICSP_NOP;
+			//}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(27);
+			readP();
+			j=1;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				WriteLogIO();
+			}
+		}
+		//Verify write
+		int errC=0;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+		for(i=0,z=1;i<9;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4];
+			read=bufferI[z+2];								//Low byte
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);
+			z+=3;
+		}
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+		for(z=1;i<12;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4];
+			read=bufferI[z+2];								//Low byte
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);
+			z+=3;
+		}
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed: %d errors \r\n"
+		PrintStatusClear();
+		err+=errC;
+	}
+	else if(config>=5&&err<max_err){	//16 bit config area (30Fxxxx)
+		PrintMessage(strings[S_ConfigW]);	//"Write CONFIG ..."
+		if(saveLog)	fprintf(logfile,"\nWRITE CONFIG:\n");
+		int Nconf=config==5?7:8;
+		bufferU[j++]=SIX_N;
+		bufferU[j++]=4;
+		bufferU[j++]=0x20;				//MOV 0xF8,W0
+		bufferU[j++]=0x0F;
+		bufferU[j++]=0x80;
+		bufferU[j++]=0x88;				//MOV W0,TABLPAG
+		if(newTABLPAG){
+			bufferU[j++]=0x02;
+			bufferU[j++]=0xA0;
+		}
+		else{
+			bufferU[j++]=0x01;
+			bufferU[j++]=0x90;
+		}
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		bufferU[j++]=0x04;				//GOTO 0x200
+		bufferU[j++]=0x02;
+		bufferU[j++]=0x00;
+		bufferU[j++]=ICSP_NOP;
+		for(i=0;i<Nconf;i++){
+			//Erase CONFIG
+			bufferU[j++]=SIX;				//MOV 0xFFFF,W0
+			bufferU[j++]=0x2F;
+			bufferU[j++]=0xFF;
+			bufferU[j++]=0xF0;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+		bufferU[j++]=0xBB;
+		bufferU[j++]=0x1B;
+		bufferU[j++]=0x80;
+			bufferU[j++]=SIX_N;
+			bufferU[j++]=6;
+			bufferU[j++]=0x24;				//MOV 0x400x,W10
+			bufferU[j++]=0x00;
+			bufferU[j++]=0x8A;				//0x4008
+			bufferU[j++]=0x88;				//MOV W10,NVMCON
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0x20;				//MOV 0x55,W8
+			bufferU[j++]=0x05;
+			bufferU[j++]=0x58;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+			bufferU[j++]=0x20;				//MOV 0xAA,W8
+			bufferU[j++]=0x0A;
+			bufferU[j++]=0xA8;
+			bufferU[j++]=0x88;				//MOV W8,NVMKEY
+			bufferU[j++]=0x3B;
+			bufferU[j++]=0x38;
+		bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+		bufferU[j++]=0xA8;
+		bufferU[j++]=0xE7;
+		bufferU[j++]=0x61;
+		bufferU[j++]=WAIT_T3;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+			bufferU[j++]=0xA9;
+			bufferU[j++]=0xE7;
+			bufferU[j++]=0x61;
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(3);
+			readP();
+			j=1;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				WriteLogIO();
+			}
+		}
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV 0,W7
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x07;
+		for(i=0;i<Nconf;i++){
+			int value=memCONFIG[i*4]+(memCONFIG[i*4+1]<<8);
+			//Write CONFIG
+			bufferU[j++]=SIX;				//MOV XXXX,W0
+			bufferU[j++]=0x20+(value>>12);
+			bufferU[j++]=(value>>4);
+			bufferU[j++]=(value<<4);
+			bufferU[j++]=ICSP_NOP;
+			bufferU[j++]=SIX_LONG;				//TBLWTL W0,[W7++]
+			bufferU[j++]=0xBB;
+			bufferU[j++]=0x1B;
+			bufferU[j++]=0x80;
+			if(value<0xFFFF){			//write if not empty
+				bufferU[j++]=SIX_N;
+				bufferU[j++]=6;
+				bufferU[j++]=0x24;				//MOV 0x400x,W10
+				bufferU[j++]=0x00;
+				bufferU[j++]=0x8A;				//0x4008
+				bufferU[j++]=0x88;				//MOV W10,NVMCON
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x0A;
+				bufferU[j++]=0x20;				//MOV 0x55,W8
+				bufferU[j++]=0x05;
+				bufferU[j++]=0x58;
+				bufferU[j++]=0x88;				//MOV W8,NVMKEY
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x38;
+				bufferU[j++]=0x20;				//MOV 0xAA,W8
+				bufferU[j++]=0x0A;
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0x88;				//MOV W8,NVMKEY
+				bufferU[j++]=0x3B;
+				bufferU[j++]=0x38;
+				bufferU[j++]=SIX_LONG;				//BSET NVMCON,#WR
+				bufferU[j++]=0xA8;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+				bufferU[j++]=WAIT_T3;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=ICSP_NOP;
+				bufferU[j++]=SIX_LONG;				//BCLR NVMCON,#WR
+				bufferU[j++]=0xA9;
+				bufferU[j++]=0xE7;
+				bufferU[j++]=0x61;
+			}
+			bufferU[j++]=FLUSH;
+			for(;j<DIMBUF;j++) bufferU[j]=0x0;
+			writeP();
+			msDelay(3);
+			readP();
+			j=1;
+			if(saveLog){
+				fprintf(logfile,strings[S_Log7],i,i,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+				WriteLogIO();
+			}
+		}
+		//Verify write
+		int errC=0;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV XXXX,W6
+		bufferU[j++]=0x00;
+		bufferU[j++]=0x06;
+		bufferU[j++]=SIX;
+		bufferU[j++]=0x20;				//MOV #VISI,W7
+		bufferU[j++]=0x78;
+		bufferU[j++]=0x47;
+		bufferU[j++]=ICSP_NOP;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=SIX_LONG;				//TBLRDL [W6++],[W7]
+		bufferU[j++]=0xBA;
+		bufferU[j++]=0x0B;
+		bufferU[j++]=0xB6;
+		bufferU[j++]=REGOUT;
+		bufferU[j++]=FLUSH;
+		for(;j<DIMBUF;j++) bufferU[j]=0x0;
+		writeP();
+		msDelay(3);
+		readP();
+		j=1;
+		if(saveLog){
+			fprintf(logfile,strings[S_Log7],0xF80000,0xF80000,0,0);	//"i=%d(0x%X), k=%d(0x%X)\n"
+			WriteLogIO();
+		}
+		for(i=0,z=1;i<7;i++){
+			for(;bufferI[z]!=REGOUT&&z<DIMBUF;z++);
+			written=memCONFIG[i*4+1]+(memCONFIG[i*4]<<8);
+			read=bufferI[z+1]+(bufferI[z+2]<<8);
+			if(~written&read)CheckData(written,read,0xF80000+i*2,&errC);	//16 bit
+			z+=3;
+		}
+		PrintMessage1(strings[S_ComplErr],errC);	//"completed: %d errors \r\n"
+		PrintStatusClear();
+		err+=errC;
+	}
+//****************** exit ********************
+	bufferU[j++]=SET_CK_D;
+	bufferU[j++]=0x0;
+	bufferU[j++]=EN_VPP_VCC;		//0
+	bufferU[j++]=0x0;
+	bufferU[j++]=FLUSH;
+	for(;j<DIMBUF;j++) bufferU[j]=0x0;
+	writeP();
+	msDelay(2);
+	readP();
+	if(saveLog)WriteLogIO();
+	j=1;
+	unsigned int stop=GetTickCount();
+	PrintStatusClear();
+	PrintMessage3(strings[S_EndErr],(stop-start)/1000.0,err,err!=1?strings[S_ErrPlur]:strings[S_ErrSing]);	//"\r\nEnd (%.2f s) %d %s\r\n\r\n"
+	if(saveLog) CloseLogFile();
+}
+*/
diff --git a/progP32.h b/progP32.h
new file mode 100644
index 0000000..4f8f327
--- /dev/null
+++ b/progP32.h
@@ -0,0 +1,4 @@
+void Read32x(int dim,int options);
+//void Write24Fx(int dim,int dim2,int options,int appIDaddr,int rowSize, double wait);
+//void DisplayCODE24F(int dim);
+
diff --git a/read.png b/read.png
new file mode 100644
index 0000000..c00de0e
--- /dev/null
+++ b/read.png
diff --git a/read_eeprom.sh b/read_eeprom.sh
new file mode 100644
index 0000000..3814155
--- /dev/null
+++ b/read_eeprom.sh
@@ -0,0 +1 @@
+./op -ee -d 2402 -s 24c02.hex
diff --git a/readme b/readme
new file mode 100644
index 0000000..9bc8887
--- /dev/null
+++ b/readme
@@ -0,0 +1,98 @@
+opgui: control program for open programmer, 
+an USB programmer for PIC and ATMEL micros, I2C/SPI/MicroWire memories, 
+and other I2C/SPI devices.
+Website: http://openprog.altervista.org
+These sources are given free of charge under the GNU General Public License version 2 
+
+Changelog (to use new features the corresponding firmware is required):
+V 0.12.1 february 2023: fixed crash when filtering with "*" while some devices were selected   
+
+V 0.12.0 october 2022: 	port to GTK3; device selected via tree;	added possibility to send manual commands;
+						added 16F15213-14-23-24-25-43-44-45-54-55-56-74-75-76, 
+						16F18013-14-15-23-24-25-26-44-45-46-54-55-56-74-75-76,
+						16F18114-15-24-25-26-44-45-46-54-55-56-74-75-76,
+						16F17114-15-24-25-26-44-45-46-54-55-56-74-75-76,
+						18F04-05-06-14-15-16Q40-41,
+						18F24-25-26-44-45-46-54-55-56Q71,
+						18F26-27-46-47-56-57Q83-84;
+						fixed write on 254005
+
+V 0.11.5 december 2021: fixed config word write on some 33FJXX devices
+
+V 0.11.4 july 2021:     fixed missing parentheses in progP18.c and progP16.c
+
+V 0.11.3 april 2021:    fixed EEPROM write on 16F184xx/188xx/191xx
+
+V 0.11.2 october 2020:  fixed 16F18xxx write with empty space at address 0;
+						added 18F25-26-27-45-46-47-55-56-57Q43, 
+						18F25-26-27-45-46-47-55-56-57K42, 18F25-26K83;
+						[linux] changed HW access path to /dev/hidraw
+
+V 0.11.1 february 2020: fixes: save file for 12F1XXX; 
+						timeout writing config for 16F18XXX; 
+						avoid reading DIA-DCI on 16F188XX;
+						EE verification of 0x22 on 18FXXX
+
+V 0.11.0 january 2019:  added 16F15313-23-24-25-44-45-54-55-56-75-76-85-86,
+						16F18424-25-26-44-45-46-54-55-56,
+						16F18854-55-56-57-75-76-77,
+						16F19155-56-75-76-85-86-95-96-97
+
+V 0.10.1 december 2018: added 16F1764-65-68-69-73-76-77-78-79;
+						removed MSVC6 function definitions
+
+V 0.10.0 june 2016:  	added 16F18313-23-24-25-26-44-45-46;
+						improved USB communication
+
+V 0.9.1 november 2014:	Fixed verification of ATTiny11-12;
+						fixed 24FJ128GA3xx-GB2xx-GCxx-DAxx;
+						added config force for PIC18, IO lines hardware test,
+						AVR auto speed communication, AVR write fuse at low frequency;
+						faster write verification for SPI FLASH memories;
+						added 10F320-22,12F529T39A,12F752,12F1612-13-14-15-18-19,
+						16F1512-13,16F1574-75-78-79,16F1703-04-05-07-08-09-13-16-17-18-19,
+						16F1788-89,16F570,16LF1554-59,
+						18F24K50-25K50-26K50-45K50-46K50,
+						18F25K80-26K80-45K80-46K80-65K80-66K80,
+						18F63J11-90,18F64J11-90,18F65J10-11-15-50-90,
+						18F66J10-11-15-16-50-55-90-93,18F67J10-11-50-90-93,
+						18F83J11-90,18F84J11-90,18F85J10-11-15-50-90,
+						18F86J10-11-15-16-50-55-90-93,18F87J10-11-50-72-90-93,
+						25X128,25Q40
+
+V 0.9.0 march 2014:		Write16F72x requires only config-word 1;
+						added HV serial programming for ATtiny11-12-13-24-25-44-45-84-85;
+						added 24FJ64GA3xx-GCxx,24FJ128GA3xx-GB2xx-GCxx-DAxx,24FJ256DAxx,24EPx,33EPx;
+						added 95xx SPI EEPROM,25X05 FLASH;
+						added 12F1571-72,16F527,16F753,16F1454-55-59;
+						some code rework & minor improvements
+
+V 0.8.1 june 2013:		added IO and Utility tabs;
+						start programming with S1; SPI/I2C speed selection; -command option;
+						multiple language support; force config word; skip LV check;
+						fixed EEPROM write when code protection is active (16F83-84,12F629,
+						12F675,16F627-28,16F630,16F676,16F870-1-2,16F873-74,16F876-77);
+						fixed read of files > 1MB;
+						modified prog mode entry for AVR;
+						fixed write of 93Sx6 with protection 
+
+V 0.8.0 june 2012:		added one-wire memories DS2430,DS2431,DS2433,DS28EC20, thermometer DS1820;
+						added UNIO memories 11010-20-40-80-160;
+						fixed algorithms for 24x1024/5 and 251024, 
+						added SPI FLASH 251005,252005,254005,258005,251605,25X10,25X20,25X40,25X80,
+						25X16,25X32,25X64;
+						added 16F1782-83-84-86-87,12C508-509
+
+V 0.7.10 january 2012:	added 12F617,12F1501,16F1503-07-08-09,16F720-21,16F72,16F707,
+						18F13K22,18F14K22,18F23K22,18F43K22,18F24K22,18F44K22,18F25K22,
+						18F45K22,18F26K22,18F46K22,18F8520,18F66J60,18F66J65,18F67J60,
+						18F86J60,18F86J65,18F87J60,18F96J60,18F96J65,18F97J60,
+						fixed read/write binary files, various corrections,
+						added support for in-circuit debugging
+						
+V 0.7.9	april 2011:		first public version, using the same version number as op
+
+To compile: make
+To install: make install
+Can be compiled under windows with MinGW/MSYS and GTK bundle
+
diff --git a/resources.xml b/resources.xml
new file mode 100644
index 0000000..3a37c27
--- /dev/null
+++ b/resources.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+	<gresource prefix="res">
+		<file preprocess="xml-stripblanks">opgui.glade</file>
+		<file>read.png</file>
+		<file>sys.png</file>
+		<file>write.png</file>
+		<file>style.css</file>
+	</gresource>
+</gresources>
diff --git a/strings.c b/strings.c
new file mode 100644
index 0000000..5899abe
--- /dev/null
+++ b/strings.c
@@ -0,0 +1,1070 @@
+// Strings.c v0.12.0
+
+#include "common.h"
+#define NL "\n"
+
+char *STR_ID[DIM];
+char *strings_it[DIM];
+char *strings_en[DIM];
+
+
+int strfind(const char* langid,const char* langfile){
+	FILE* f=fopen(langfile,"r");
+	char line[4096],*id,*string,*p;
+	char temp[32];
+	int i=0;
+//	printf("file %s f=%d\n",langfile, f); fflush(stdout);
+	if(f){
+		temp[0]=0;
+		for(;fgets(line,sizeof(line),f);){
+			if(sscanf(line,"[%[^]]",temp)&&!strncmp(langid,temp,sizeof(temp))){
+				strings=malloc(DIM*sizeof(char*));
+				for(i=0;i<DIM;i++) strings[i]=0;
+				for(;fgets(line,sizeof(line),f);){
+					if(strlen(line)>0&&line[0]=='[') break; //start of new table
+					id=strtok(line," \t");
+					string=strtok(0,"\n");
+					for(i=0;string&&i<DIM;i++){
+						if(!strcmp(id,STR_ID[i])){
+							for(;string&&string[0]&&string[0]=='\t';string++);
+							for(;(p=strstr(string,"\\n"));){
+								for(p[0]='\n';p[1];p++) p[1]=p[2];
+							}
+							for(;(p=strstr(string,"\\r"));){
+								for(p[0]='\r';p[1];p++) p[1]=p[2];
+							}
+							strings[i]=malloc(strlen(string)+1);
+							strcpy(strings[i],string);
+							i=DIM;
+						}
+					}
+				}
+				for(i=0;i<DIM;i++){
+					if(strings[i]==0){
+						strings[i]=malloc(strlen(strings_en[i])+1);
+						strcpy(strings[i],strings_en[i]);
+					}
+				}
+			}
+		}
+		fclose(f);
+	}
+	return i;	//i=0 if language table was not found
+}
+
+void GenerateLangFile(const char* langid,const char* langfile){
+	FILE* f=fopen(langfile,"a");
+	int i,j;
+	if(f){
+		fprintf(f,"\n\n[%s]\n",langid?langid:"x");
+		for(i=1;i<DIM;i++){
+			fprintf(f,"%s\t\t",STR_ID[i]);
+			for(j=0;strings_en[i][j];j++){
+				if(strings_en[i][j]=='\n') fprintf(f,"%s","\\n");
+				else if(strings_en[i][j]=='\r') fprintf(f,"%s","\\r");
+				else fprintf(f,"%c",strings_en[i][j]);
+			}
+			fprintf(f,"\n");
+		}
+		fclose(f);
+	}
+}
+
+void strinit()
+{
+	STR_ID[S_NL]=(char*) "S_NL";
+	STR_ID[S_noprog]=(char*) "S_noprog";
+	STR_ID[S_prog]="S_prog";
+	STR_ID[S_progDev]="S_progDev";
+	STR_ID[S_DevPermission]="S_DevPermission";
+	STR_ID[S_nodev_r]="S_nodev_r";
+	STR_ID[S_nodev_w]="S_nodev_w";
+	STR_ID[S_nodev]="S_nodev";
+	STR_ID[S_DevMismatch]="S_DevMismatch";
+	STR_ID[S_noV33reg]="S_noV33reg";
+	STR_ID[S_progver]="S_progver";
+	STR_ID[S_progid]="S_progid";
+	STR_ID[S_FWver2old]="S_FWver2old";
+	STR_ID[S_lowUsbV]="S_lowUsbV";
+	STR_ID[S_HiVPP]="S_HiVPP";
+	STR_ID[S_LowVPP]="S_LowVPP";
+	STR_ID[S_reg]="S_reg";
+	STR_ID[S_dev_det]="S_dev_det";
+	STR_ID[S_file]="S_file";
+	STR_ID[S_file2]="S_file2";
+	STR_ID[S_fileEEP]="S_fileEEP";
+	STR_ID[S_noDLL]="S_noDLL";
+	STR_ID[S_openEEfile]="S_openEEfile";
+	STR_ID[S_saveEEfile]="S_saveEEfile";
+	STR_ID[S_IhexShort]="S_IhexShort";
+	STR_ID[S_IhexChecksum]="S_IhexChecksum";
+	STR_ID[S_InvHandle]="S_InvHandle";
+	STR_ID[S_LogFile]="S_LogFile";
+	STR_ID[S_FileSaved]="S_FileSaved";
+	STR_ID[S_HVICSP]="S_HVICSP";
+	STR_ID[S_StartRead]="S_StartRead";
+	STR_ID[S_Read]="S_Read";
+	STR_ID[S_CodeReading]="S_CodeReading";
+	STR_ID[S_CodeReading1]="S_CodeReading1";
+	STR_ID[S_CodeReading2]="S_CodeReading2";
+	STR_ID[S_ReadEnd]="S_ReadEnd";
+	STR_ID[S_ReadID_CONFIG]="S_ReadID_CONFIG";
+	STR_ID[S_Read_CONFIG_A]="S_Read_CONFIG_A";
+	STR_ID[S_Read_EXE_A]="S_Read_EXE_A";
+	STR_ID[S_ReadEE]="S_ReadEE";
+	STR_ID[S_StartErase]="S_StartErase";
+	STR_ID[S_Writing]="S_Writing";
+	STR_ID[S_StartCodeProg]="S_StartCodeProg";
+	STR_ID[S_CodeWriting]="S_CodeWriting";
+	STR_ID[S_CodeWriting2]="S_CodeWriting2";
+	STR_ID[S_IDW]="S_IDW";
+	STR_ID[S_ConfigW]="S_ConfigW";
+	STR_ID[S_ConfigAreaW]="S_ConfigAreaW";
+	STR_ID[S_EEAreaW]="S_EEAreaW";
+	STR_ID[S_FuseAreaW]="S_FuseAreaW";
+	STR_ID[S_CodeV]="S_CodeV";
+	STR_ID[S_CodeV2]="S_CodeV2";
+	STR_ID[S_IDV]="S_IDV";
+	STR_ID[S_ConfigV]="S_ConfigV";
+	STR_ID[S_EEV]="S_EEV";
+	STR_ID[S_IntW]="S_IntW";
+	STR_ID[S_TotErr]="S_TotErr";
+	STR_ID[S_ComplErr]="S_ComplErr";
+	STR_ID[S_Compl]="S_Compl";
+	STR_ID[S_Ready]="S_Ready";
+	STR_ID[S_End]="S_End";
+	STR_ID[S_EndErr]="S_EndErr";
+	STR_ID[S_ProtErase]="S_ProtErase";
+	STR_ID[S_Inohex]="S_Inohex";
+	STR_ID[S_ReadErr]="S_ReadErr";
+	STR_ID[S_ReadCodeErr]="S_ReadCodeErr";
+	STR_ID[S_ReadCodeErr2]="S_ReadCodeErr2";
+	STR_ID[S_ReadEEErr]="S_ReadEEErr";
+	STR_ID[S_ConfigErr]="S_ConfigErr";
+	STR_ID[S_ReadConfigErr]="S_ReadConfigErr";
+	STR_ID[S_ErrOsccal]="S_ErrOsccal";
+	STR_ID[S_CodeWError]="S_CodeWError";
+	STR_ID[S_CodeWError2]="S_CodeWError2";
+	STR_ID[S_CodeWError3]="S_CodeWError3";
+	STR_ID[S_CodeWError4]="S_CodeWError4";
+	STR_ID[S_ConfigWErr]="S_ConfigWErr";
+	STR_ID[S_ConfigWErr2]="S_ConfigWErr2";
+	STR_ID[S_ConfigWErr3]="S_ConfigWErr3";
+	STR_ID[S_WErr1]="S_WErr1";
+	STR_ID[S_WErr2]="S_WErr2";
+	STR_ID[S_IDErr]="S_IDErr";
+	STR_ID[S_ICDErr]="S_ICDErr";
+	STR_ID[S_Calib1Err]="S_Calib1Err";
+	STR_ID[S_Calib2Err]="S_Calib2Err";
+	STR_ID[S_CodeVError]="S_CodeVError";
+	STR_ID[S_CodeVError2]="S_CodeVError2";
+	STR_ID[S_CodeVError3]="S_CodeVError3";
+	STR_ID[S_ErrSing]="S_ErrSing";
+	STR_ID[S_ErrPlur]="S_ErrPlur";
+	STR_ID[S_MaxErr]="S_MaxErr";
+	STR_ID[S_I2CInitErr]="S_I2CInitErr";
+	STR_ID[S_I2CAckErr]="S_I2CAckErr";
+	STR_ID[S_ComErr]="S_ComErr";
+	STR_ID[S_InsErr]="S_InsErr";
+	STR_ID[S_SyncErr]="S_SyncErr";
+	STR_ID[S_HVregErr]="S_HVregErr";
+	STR_ID[S_Log1]="S_Log1";
+	STR_ID[S_Log2]="S_Log2";
+	STR_ID[S_Log3]="S_Log3";
+	STR_ID[S_Log4]="S_Log4";
+	STR_ID[S_Log5]="S_Log5";
+	STR_ID[S_Log6]="S_Log6";
+	STR_ID[S_Log7]="S_Log7";
+	STR_ID[S_Log8]="S_Log8";
+	STR_ID[S_Log9]="S_Log9";
+	STR_ID[S_comTimeout]="S_comTimeout";
+	STR_ID[S_EraseTimeout]="S_EraseTimeout";
+	STR_ID[S_ConfigTimeout]="S_ConfigTimeout";
+	STR_ID[S_ConfigTimeout2]="S_ConfigTimeout2";
+	STR_ID[S_CodeTimeout]="S_CodeTimeout";
+	STR_ID[S_CodeTimeout2]="S_CodeTimeout2";
+	STR_ID[S_OsccalTimeout]="S_OsccalTimeout";
+	STR_ID[S_EETimeout]="S_EETimeout";
+	STR_ID[S_ConfigWTimeout]="S_ConfigWTimeout";
+	STR_ID[S_CodeWTimeout]="S_CodeWTimeout";
+	STR_ID[S_ConfigWTimeout2]="S_ConfigWTimeout2";
+	STR_ID[S_EEWTimeout]="S_EEWTimeout";
+	STR_ID[S_IDWTimeout]="S_IDWTimeout";
+	STR_ID[S_ConfigNWTimeout]="S_ConfigNWTimeout";
+	STR_ID[S_CodeVTimeout]="S_CodeVTimeout";
+	STR_ID[S_ConfigVTimeout]="S_ConfigVTimeout";
+	STR_ID[S_ProgModeTimeout]="S_ProgModeTimeout";
+	STR_ID[S_ProgModeXTimeout]="S_ProgModeXTimeout";
+	STR_ID[S_LogTimeout]="S_LogTimeout";
+	STR_ID[S_CodeMem]="S_CodeMem";
+	STR_ID[S_EEMem]="S_EEMem";
+	STR_ID[S_IDMem]="S_IDMem";
+	STR_ID[S_ConfigMem]="S_ConfigMem";
+	STR_ID[S_ConfigResMem]="S_ConfigResMem";
+	STR_ID[S_CodeMem2]="S_CodeMem2";
+	STR_ID[S_ExeMem]="S_ExeMem";
+	STR_ID[S_LPOsc]="S_LPOsc";
+	STR_ID[S_XTOsc]="S_XTOsc";
+	STR_ID[S_IntOsc]="S_IntOsc";
+	STR_ID[S_RCOsc]="S_RCOsc";
+	STR_ID[S_WDTON]="S_WDTON";
+	STR_ID[S_WDTOFF]="S_WDTOFF";
+	STR_ID[S_CPOFF]="S_CPOFF";
+	STR_ID[S_CPON]="S_CPON";
+	STR_ID[S_MCLRON]="S_MCLRON";
+	STR_ID[S_MCLROFF]="S_MCLROFF";
+	STR_ID[S_ChipID]="S_ChipID";
+	STR_ID[S_ChipID2]="S_ChipID2";
+	STR_ID[S_BKOsccal]="S_BKOsccal";
+	STR_ID[S_Osccal]="S_Osccal";
+	STR_ID[S_DevID]="S_DevID";
+	STR_ID[S_DevID2]="S_DevID2";
+	STR_ID[S_DevREV]="S_DevREV";
+	STR_ID[S_ConfigWord]="S_ConfigWord";
+	STR_ID[S_ConfigWord2]="S_ConfigWord2";
+	STR_ID[S_ConfigWordX]="S_ConfigWordX";
+	STR_ID[S_ConfigWordH]="S_ConfigWordH";
+	STR_ID[S_ConfigWordL]="S_ConfigWordL";
+	STR_ID[S_Config2Cal1]="S_Config2Cal1";
+	STR_ID[S_CalibWord1]="S_CalibWord1";
+	STR_ID[S_Calib1_2]="S_Calib1_2";
+	STR_ID[S_CalibWord2]="S_CalibWord2";
+	STR_ID[S_CalibWordX]="S_CalibWordX";
+	STR_ID[S_Protected]="S_Protected";
+	STR_ID[S_CodeLim]="S_CodeLim";
+	STR_ID[S_EELim]="S_EELim";
+	STR_ID[S_ConfigLim]="S_ConfigLim";
+	STR_ID[S_WbufLim]="S_WbufLim";
+	STR_ID[S_MaxRetry]="S_MaxRetry";
+	STR_ID[S_NoCode]="S_NoCode";
+	STR_ID[S_NoCode2]="S_NoCode2";
+	STR_ID[S_NoCalibW]="S_NoCalibW";
+	STR_ID[S_NoEEMem]="S_NoEEMem";
+	STR_ID[S_NoConfigW]="S_NoConfigW";
+	STR_ID[S_NoConfigW2]="S_NoConfigW2";
+	STR_ID[S_NoConfigW3]="S_NoConfigW3";
+	STR_ID[S_NoConfigW4]="S_NoConfigW4";
+	STR_ID[S_NoConfigW5]="S_NoConfigW5";
+	STR_ID[S_NoConfigW6]="S_NoConfigW6";
+	STR_ID[S_Empty]="S_Empty";
+	STR_ID[S_NextIns]="S_NextIns";
+	STR_ID[S_ForceConfigW]="S_ForceConfigW";
+	STR_ID[S_ForceConfigWx]="S_ForceConfigWx";
+	STR_ID[S_WarnFlashSize]="S_WarnFlashSize";
+	STR_ID[I_Fopen]="I_Fopen";
+	STR_ID[I_Fsave]="I_Fsave";
+	STR_ID[I_DevR]="I_DevR";
+	STR_ID[I_DevW]="I_DevW";
+	STR_ID[I_Info]="I_Info";
+	STR_ID[I_Data]="I_Data";
+	STR_ID[I_Opt]="I_Opt";
+	STR_ID[I_Dev]="I_Dev";
+	STR_ID[I_Type]="I_Type";
+	STR_ID[I_Speed]="I_Speed";
+	STR_ID[I_ReadRes]="I_ReadRes";
+	STR_ID[I_ID_BKo_W]="I_ID_BKo_W";
+	STR_ID[I_EE]="I_EE";
+	STR_ID[I_CalW]="I_CalW";
+	STR_ID[I_OSCW]="I_OSCW";
+	STR_ID[I_OSC]="I_OSC";
+	STR_ID[I_BKOSC]="I_BKOSC";
+	STR_ID[I_OSCF]="I_OSCF";
+	STR_ID[I_CONN]="I_CONN";
+	STR_ID[I_QUIT]="I_QUIT";
+	STR_ID[I_LOG]="I_LOG";
+	STR_ID[I_CK_V33]="I_CK_V33";
+	STR_ID[I_LANG]="I_LANG";
+	STR_ID[I_MAXERR]="I_MAXERR";
+	STR_ID[I_ADDR]="I_ADDR";
+	STR_ID[I_USBD]="I_USBD";
+	STR_ID[I_I2CDATAOUT]="I_I2CDATAOUT";
+	STR_ID[I_I2CDATATR]="I_I2CDATATR";
+	STR_ID[I_I2C_NB]="I_I2C_NB";
+	STR_ID[I_I2CMode]="I_I2CMode";
+	STR_ID[I_I2CSend]="I_I2CSend";
+	STR_ID[I_I2CReceive]="I_I2CReceive";
+	STR_ID[I_TestHW]="I_TestHW";
+	STR_ID[I_TestHWB]="I_TestHWB";
+	STR_ID[I_TestMSG]="I_TestMSG";
+	STR_ID[I_IO_Enable]="I_IO_Enable";
+	STR_ID[I_IO_Commands]="I_IO_Commands";
+	STR_ID[I_SPIMEM]="I_SPIMEM";
+	STR_ID[I_I2CMEM]="I_I2CMEM";
+	STR_ID[I_UWMEM]="I_UWMEM";
+	STR_ID[I_OWMEM]="I_OWMEM";
+	STR_ID[I_OWDEV]="I_OWDEV";
+	STR_ID[I_UNIOMEM]="I_UNIOMEM";
+	STR_ID[I_3V3REQUIRED]="I_3V3REQUIRED";
+	STR_ID[I_PIC_FORCECW]="I_PIC_FORCECW";
+	STR_ID[I_AT_FUSE]="I_AT_FUSE";
+	STR_ID[I_AT_FUSEH]="I_AT_FUSEH";
+	STR_ID[I_AT_FUSEX]="I_AT_FUSEX";
+	STR_ID[I_AT_LOCK]="I_AT_LOCK";
+	STR_ID[I_W_LANGFILE]="I_W_LANGFILE";
+	STR_ID[I_AT_FUSELF]="I_AT_FUSELF";
+	STR_ID[I_AT_COMM]="I_AT_COMM";
+	STR_ID[I_WAITS1]="I_WAITS1";
+	STR_ID[I_PRESSS1]="I_PRESSS1";
+	STR_ID[S_WaitS1W]="S_WaitS1W";
+	STR_ID[S_WaitS1R]="S_WaitS1R";
+	STR_ID[I_ICD_ENABLE]="I_ICD_ENABLE";
+	STR_ID[I_ICD_ADDRESS]="I_ICD_ADDRESS";
+	STR_ID[I_LOAD_COFF]="I_LOAD_COFF";
+	STR_ID[I_SHOW_PC]="I_SHOW_PC";
+	STR_ID[I_SHOW_STATUS]="I_SHOW_STATUS";
+	STR_ID[I_SHOW_BANK0]="I_SHOW_BANK0";
+	STR_ID[I_SHOW_BANK1]="I_SHOW_BANK1";
+	STR_ID[I_SHOW_BANK2]="I_SHOW_BANK2";
+	STR_ID[I_SHOW_BANK3]="I_SHOW_BANK3";
+	STR_ID[I_SHOW_EE]="I_SHOW_EE";
+	STR_ID[I_STOP]="I_STOP";
+	STR_ID[I_ICD_RUN]="I_ICD_RUN";
+	STR_ID[I_ICD_HALT]="I_ICD_HALT";
+	STR_ID[I_ICD_STEP]="I_ICD_STEP";
+	STR_ID[I_ICD_STEPOVER]="I_ICD_STEPOVER";
+	STR_ID[I_ICD_STOP]="I_ICD_STOP";
+	STR_ID[I_ICD_REFRESH]="I_ICD_REFRESH";
+	STR_ID[I_ICD_CMD]="I_ICD_CMD";
+	STR_ID[I_ICD_HELP]="I_ICD_HELP";
+	STR_ID[I_ICD_SOURCE]="I_ICD_SOURCE";
+	STR_ID[I_ICD_STATUS]="I_ICD_STATUS";
+	STR_ID[I_ICD_HELP_TXT]="I_ICD_HELP_TXT";
+	STR_ID[I_GUI_CMD_HELP]="I_GUI_CMD_HELP";
+	STR_ID[L_HELP]="L_HELP";
+	STR_ID[L_OPTERR]="L_OPTERR";
+	STR_ID[L_INFO1]="L_INFO1";
+	STR_ID[L_INFO2]="L_INFO2";
+	STR_ID[L_UNKNOWN]="L_UNKNOWN";
+	STR_ID[L_NAME]="L_NAME";
+	STR_ID[L_DEV_RO]="L_DEV_RO";
+	STR_ID[L_DEV_RW]="L_DEV_RW";
+
+	strings_it[S_NL]=NL;
+	strings_it[S_noprog]="Programmatore non rilevato" NL;
+	strings_it[S_prog]="Programmatore rilevato" NL;
+	strings_it[S_progDev]="Programmatore rilevato su %s" NL;
+	strings_it[S_DevPermission]="Impossibile aprire %s, assicurati di avere i diritti di lettura" NL;
+	strings_it[S_nodev_r]="Dispositivo non supportato in lettura" NL;
+	strings_it[S_nodev_w]="Dispositivo non supportato in scrittura" NL;
+	strings_it[S_nodev]="Dispositivo sconosciuto" NL;
+	strings_it[S_DevMismatch]="Attenzione: il dispositivo è diverso da quello specificato nei dati" NL;
+	strings_it[S_noV33reg]="Regolatore a 3,3V non rilevato" NL;
+	strings_it[S_progver]="Versione firmware %d.%d.%d" NL;
+	strings_it[S_progid]="ID Hardware: %d.%d.%d";
+	strings_it[S_FWver2old]="Questo firmware è troppo vecchio. E' richiesta la versione %s" NL;
+	strings_it[S_lowUsbV]="Tensione USB troppo bassa (VUSB<4.5V)" NL;
+	strings_it[S_HiVPP]="Attenzione: tensione regolatore troppo alta" NL NL;
+	strings_it[S_LowVPP]="Attenzione: tensione regolatore troppo bassa" NL NL;
+	strings_it[S_reg]="Regolatore avviato e funzionante dopo %dms VPP=%.1fV" NL NL;
+	strings_it[S_dev_det]="Dispositivo rilevato: vid=0x%04X pid=0x%04X" NL "Percorso: %s" NL;
+	strings_it[S_file]="File Hex8 (*.hex)|*.hex|Tutti i file (*.*)|*.*||";
+	strings_it[S_file2]="File Hex8 (*.hex)|*.hex|File binari (*.bin)|*.bin|Tutti i file (*.*)|*.*||";
+	strings_it[S_fileEEP]="File Hex8 (*.hex *.eep)|*.hex;*.eep|Tutti i file (*.*)|*.*||";
+	strings_it[S_noDLL]="Impossibile aprire hid.dll";
+	strings_it[S_openEEfile]="Apri file EEPROM";
+	strings_it[S_saveEEfile]="Salva file EEPROM";
+	strings_it[S_IhexShort]="Linea Ihex8 troppo corta:" NL "%s" NL;
+	strings_it[S_IhexChecksum]="Errore di checksum nella linea Ihex8:" NL "%s" NL;
+	strings_it[S_InvHandle]="Handle invalido" NL;
+	strings_it[S_LogFile]="Registro.txt";
+	strings_it[S_FileSaved]="Salvato %s" NL;
+						//
+	strings_it[S_HVICSP]="ICSP ad alta tensione" NL;
+	strings_it[S_StartRead]="Inizio lettura..." NL;
+	strings_it[S_Read]="Lettura ... ";
+	strings_it[S_CodeReading1]="Lettura codice ... ";
+	strings_it[S_CodeReading]="Lettura: %3d%%, ind. %03X";
+	strings_it[S_CodeReading2]="Lettura: %3d%%, ind. %05X";
+	strings_it[S_ReadEnd]="Lettura completata: %d word" NL;
+	strings_it[S_ReadID_CONFIG]="Lettura ID e CONFIG";
+	strings_it[S_Read_CONFIG_A]="Lettura area CONFIG ... ";
+	strings_it[S_Read_EXE_A]="Lettura area Executive ... ";
+	strings_it[S_ReadEE]="Lettura area EEPROM ... ";
+	strings_it[S_StartErase]="Cancellazione ... ";
+	strings_it[S_Writing]="Inizio scrittura..." NL;
+	strings_it[S_StartCodeProg]="Scrittura codice ... ";
+	strings_it[S_CodeWriting]="Scrittura: %3d%%, ind. %03X";
+	strings_it[S_CodeWriting2]="Scrittura: %3d%%, ind. %04X";
+	strings_it[S_IDW]="Scrittura ID ... ";
+	strings_it[S_ConfigW]="Scrittura CONFIG ... ";
+	strings_it[S_ConfigAreaW]="Scrittura area CONFIG ... ";
+	strings_it[S_EEAreaW]="Scrittura area EEPROM ... ";
+	strings_it[S_FuseAreaW]="Scrittura area FUSE ... ";
+	strings_it[S_CodeV]="Verifica codice ... ";
+	strings_it[S_CodeV2]="Verifica: %d%%, ind. %04X";
+	strings_it[S_IDV]="Verifica ID ... ";
+	strings_it[S_ConfigV]="Verifica CONFIG ... ";
+	strings_it[S_EEV]="Verifica EEPROM ... ";
+	strings_it[S_IntW]="Scrittura interrotta" NL;
+	strings_it[S_TotErr]="completata, %d errori totali" NL;
+	strings_it[S_ComplErr]="completata, %d errori" NL;
+	strings_it[S_Compl]="completata" NL;
+	strings_it[S_Ready]="pronto";
+	strings_it[S_End]= NL "Fine (%.2f s)" NL NL;
+	strings_it[S_EndErr]= NL "Fine (%.2f s) %d %s" NL NL;
+	strings_it[S_ProtErase]="Il dispositivo è protetto, sovrascrivo la protezione." NL;
+	strings_it[S_Inohex]="Errore: '%.4s' non sembra molto esadecimale, vero?" NL;
+	strings_it[S_ReadErr]="Errore in lettura: word richieste=%d, lette=%d" NL;
+	strings_it[S_ReadCodeErr]="Errore in lettura area programma, richieste %d word, lette %d" NL;
+	strings_it[S_ReadCodeErr2]="Errore in lettura area programma, richiesti %d byte, letti %d" NL;
+	strings_it[S_ReadEEErr]="Errore in lettura area EEPROM, richiesti %d byte, letti %d" NL;
+	strings_it[S_ConfigErr]="Errore in lettura area configurazione, richieste %d word, lette %d" NL;
+	strings_it[S_ReadConfigErr]="Errore in lettura area configurazione, richiesti %d byte, letti %d" NL;
+	strings_it[S_ErrOsccal]="Errore in lettura OSCCAL e BKOSCCAL";
+	strings_it[S_CodeWError]="Errore in scrittura all'indirizzo %3X: scritto %03X, letto %03X" NL;
+	strings_it[S_CodeWError2]="Errore in scrittura all'indirizzo %3X: scritto %04X, letto %04X" NL;
+	strings_it[S_CodeWError3]="Errore in scrittura all'indirizzo %4X: scritto %02X, letto %02X" NL;
+	strings_it[S_CodeWError4]="Errore in scrittura area programma, richiesti %d byte, scritti %d" NL;
+	strings_it[S_ConfigWErr]="Errore in scrittura config: scritto %03X, letto %03X" NL;
+	strings_it[S_ConfigWErr2]="Errore in scrittura CONFIG";
+	strings_it[S_ConfigWErr3]="Errore in scrittura config: scritto %04X, letto %04X" NL;
+	strings_it[S_WErr1]="Errore in scrittura %s: scritto %02X, letto %02X" NL;
+	strings_it[S_WErr2]="Errore in scrittura %s: scritto %04X, letto %04X" NL;
+	strings_it[S_IDErr]="Errore in scrittura ID%d: scritto %04X, letto %04X" NL;
+	strings_it[S_ICDErr]="Errore in scrittura ICD (0x%X): scritto %04X, letto %04X" NL;
+	strings_it[S_Calib1Err]="Errore in scrittura Calib1: scritto %04X, letto %04X" NL;
+	strings_it[S_Calib2Err]="Errore in scrittura Calib2: scritto %04X, letto %04X" NL;
+	strings_it[S_CodeVError]="Errore in verifica, indirizzo %04X (%d), scritto %02X, letto %02X" NL;
+	strings_it[S_CodeVError2]="Errore in verifica area programma, richiesti %d byte, letti %d" NL;
+	strings_it[S_CodeVError3]="Errore in verifica area programma, richieste %d word, lette %d" NL;
+	strings_it[S_ErrSing]="errore";
+	strings_it[S_ErrPlur]="errori";
+	strings_it[S_MaxErr]="Superato il massimo numero di errori (%d), scrittura interrotta" NL;
+	strings_it[S_I2CInitErr]="Errore di inizializzazione bus I2C" NL;
+	strings_it[S_I2CAckErr]="Errore di acknowledge I2C" NL;
+	strings_it[S_ComErr]="Errore di comunicazione" NL;
+	strings_it[S_InsErr]="Istruzione sconosciuta" NL;
+	strings_it[S_SyncErr]="Errore di sincronizzazione" NL;
+	strings_it[S_HVregErr]="Errore sul regolatore HV" NL;
+	strings_it[S_WarnFlashSize]="Attenzione, la dimensione della flash non corrisponde a quella del dispositivo scelto" NL;
+						//
+	strings_it[S_Log1]="i=%d(0x%X), k=%d(0x%X)  NumberOfBytesRead=%d" NL;
+	strings_it[S_Log2]="i=%d, k=%d, errori=%d, NumberOfBytesRead=%d" NL NL;
+	strings_it[S_Log3]="i=%d, k2=%d NumberOfBytesRead=%d" NL;
+	strings_it[S_Log4]="Area config. 	errori=%d   NumberOfBytesRead=%d" NL;
+	strings_it[S_Log5]="dim=%d(0x%X), dimx=%d(0x%X), dimx/wbuf=%d " NL NL;
+	strings_it[S_Log6]="i=%d(0x%X),  NumberOfBytesRead=%d" NL NL;
+	strings_it[S_Log7]="i=%d(0x%X), k=%d(0x%X)" NL;
+	strings_it[S_Log8]="i=%d(0x%X), k=%d(0x%X), errori=%d" NL;
+	strings_it[S_Log9]="Area config. 	errori=%d" NL;
+						//
+	strings_it[S_comTimeout]="Timeout comunicazione" NL;
+	strings_it[S_EraseTimeout]="Timeout in cancellazione" NL;
+	strings_it[S_ConfigTimeout]="Timeout in lettura config" NL;
+	strings_it[S_ConfigTimeout2]="Timeout in lettura area config" NL;
+	strings_it[S_CodeTimeout]="Timeout in lettura, indirizzo %02X (%d)" NL;
+	strings_it[S_CodeTimeout2]="Timeout in lettura, indirizzo %04X (%d)" NL;
+	strings_it[S_OsccalTimeout]="Timeout in lettura osccal" NL;
+	strings_it[S_EETimeout]="Timeout in lettura EEPROM, indirizzo %02X (%d)" NL;
+	strings_it[S_ConfigWTimeout]="Timeout in verifica config" NL;
+	strings_it[S_CodeWTimeout]="Timeout in scrittura, indirizzo %02X (%d)" NL;
+	strings_it[S_ConfigWTimeout2]="Timeout in scrittura area config" NL;
+	strings_it[S_EEWTimeout]="Timeout in scrittura EEPROM, indirizzo %03X (%d)" NL;
+	strings_it[S_IDWTimeout]="Timeout in scrittura ID" NL;
+	strings_it[S_ConfigNWTimeout]="Timeout in scrittura CONFIG%d" NL;
+	strings_it[S_CodeVTimeout]="Timeout in verifica, indirizzo %04X (%d)" NL;
+	strings_it[S_ConfigVTimeout]="Timeout in verifica area config" NL;
+	strings_it[S_ProgModeTimeout]="Timeout in entrata program mode" NL;
+	strings_it[S_ProgModeXTimeout]="Timeout in uscita programmazione" NL;
+	strings_it[S_LogTimeout]="Timeout" NL;
+						//
+	strings_it[S_CodeMem]= NL "memoria CODICE:" NL;
+	strings_it[S_EEMem]= NL "memoria EEPROM:" NL;
+	strings_it[S_IDMem]= NL "memoria ID:" NL;
+	strings_it[S_ConfigMem]= NL "memoria CONFIG:" NL;
+	strings_it[S_ConfigResMem]= NL "Memoria configurazione e riservata:" NL;
+	strings_it[S_CodeMem2]= NL "Memoria programma:" NL;
+	strings_it[S_ExeMem]= NL "memoria Executive:" NL;
+						//
+	strings_it[S_LPOsc]="LP oscillator" NL;
+	strings_it[S_XTOsc]="XT oscillator" NL;
+	strings_it[S_IntOsc]="Internal osc." NL;
+	strings_it[S_RCOsc]="RC oscillator" NL;
+	strings_it[S_WDTON]="WDT ON" NL;
+	strings_it[S_WDTOFF]="WDT OFF" NL;
+	strings_it[S_CPOFF]="Code protection OFF" NL;
+	strings_it[S_CPON]="Code protection ON" NL;
+	strings_it[S_MCLRON]="Master clear ON" NL;
+	strings_it[S_MCLROFF]="Master clear OFF" NL;
+	strings_it[S_ChipID]="ID%d: 0x%03X   ID%d: 0x%03X" NL;
+	strings_it[S_ChipID2]="ID%d: 0x%02X   ID%d: 0x%02X" NL;
+	strings_it[S_BKOsccal]="Backup OSCCAL: 0x%03X" NL;
+	strings_it[S_Osccal]="OSCCAL: 0x%03X" NL;
+	strings_it[S_DevID]="DevID: 0x%04X" NL;
+	strings_it[S_DevID2]="DevID: 0x%02X%02X" NL;
+	strings_it[S_DevREV]="DevREV: 0x%04X" NL;
+	strings_it[S_ConfigWord]="Configuration word: 0x%03X" NL;
+	strings_it[S_Config2Cal1]="Configuration word2 o calibration word 1: 0x%03X" NL;
+	strings_it[S_ConfigWord2]="Configuration word2: 0x%04X" NL;
+	strings_it[S_ConfigWordX]="Configuration word %d: 0x%04X" NL;
+	strings_it[S_ConfigWordH]="CONFIG%dH: 0x%02X\t";
+	strings_it[S_ConfigWordL]="CONFIG%dL: 0x%02X" NL;
+	strings_it[S_CalibWord1]="Calibration word1: 0x%04X" NL;
+	strings_it[S_Calib1_2]="Calibration word 1 or 2: 0x%04X" NL;
+	strings_it[S_CalibWord2]="Calibration word2: 0x%04X" NL;
+	strings_it[S_CalibWordX]="Calibration word %d: 0x%04X" NL;
+	strings_it[S_Protected]="Dispositivo protetto";
+						//
+	strings_it[S_CodeLim]="Dimensione programma oltre i limiti" NL;
+	strings_it[S_EELim]="Dimensione eeprom oltre i limiti" NL;
+	strings_it[S_ConfigLim]="Dimensione area config oltre i limiti" NL;
+	strings_it[S_WbufLim]="Dimensione buffer scrittura oltre i limiti" NL;
+	strings_it[S_MaxRetry]="Max tentativi di scrittura: %d" NL;
+						//
+	strings_it[S_NoCode]="Area dati vuota" NL;
+	strings_it[S_NoCode2]="Niente da scrivere" NL;
+	strings_it[S_NoCalibW]="Impossibile trovare i dati di calibrazione" NL;
+	strings_it[S_NoEEMem]="Impossibile trovare i dati EEPROM" NL;
+	strings_it[S_NoConfigW]="Impossibile leggere la config word" NL;
+	strings_it[S_NoConfigW2]="Impossibile trovare la locazione CONFIG (0xFFF)" NL;
+	strings_it[S_NoConfigW3]="Impossibile trovare la locazione CONFIG (0x2007)" NL "Fine" NL;
+	strings_it[S_NoConfigW4]="Impossibile trovare la locazione CONFIG (0x2008)" NL "Fine" NL;
+	strings_it[S_NoConfigW5]="Impossibile trovare la locazione CONFIG (0x8007-0x8008)" NL "Fine" NL;
+	strings_it[S_NoConfigW6]="Impossibile trovare la locazione CONFIG (0x8007-0x800B)" NL "Fine" NL;
+	strings_it[S_Empty]="(vuoto)" NL;
+	strings_it[S_NextIns]="Prossima istruzione";
+	strings_it[S_ForceConfigW]="Forzo config word" NL;
+	strings_it[S_ForceConfigWx]="Forzo config word%d [0x%04X]=0x%04X" NL;
+						//
+	strings_it[I_CANCEL]="A_nnulla";
+	strings_it[I_OPEN]="_Apri";
+	strings_it[I_SAVE]="_Salva";
+	strings_it[I_Fopen]="Apri file";
+	strings_it[I_Fsave]="Salva file";
+	strings_it[I_DevR]="Leggi dispositivo";
+	strings_it[I_DevW]="Scrivi dispositivo";
+	strings_it[I_Info]="Informazioni";
+	strings_it[I_Data]="Dati";
+	strings_it[I_Opt]="Opzioni";
+	strings_it[I_Dev]="Dispositivo";
+	strings_it[I_Type]="Filtra per tipo";
+	strings_it[I_Speed]="Velocità";
+	strings_it[I_ReadRes]="Leggi area riservata";
+	strings_it[I_ID_BKo_W]="Programma ID e BKosccal";
+	strings_it[I_EE]="Leggi e programma EEPROM";
+	strings_it[I_CalW]="Programma Calib1 e 2";
+	strings_it[I_OSCW]="Scrivi OSCCal";
+	strings_it[I_OSC]="OSCCal";
+	strings_it[I_BKOSC]="Backup OSCCal";
+	strings_it[I_OSCF]="Da File";
+	strings_it[I_CONN]="Riconnetti";
+	strings_it[I_QUIT]="Quit";
+	strings_it[I_LOG]="Registra eventi su file";
+	strings_it[I_CK_V33]="Salta controllo regolatore a 3,3V";
+	strings_it[I_LANG]="Lingua";
+	strings_it[I_MAXERR]="Max errori in scrittura";
+	strings_it[I_ADDR]="Indirizzo";
+	strings_it[I_USBD]="Ritardo minimo USB (ms)";
+	strings_it[I_I2CDATAOUT]="Dati da scrivere";
+	strings_it[I_I2CDATATR]="Dati trasferiti";
+	strings_it[I_I2C_NB]="Byte da scrivere/leggere";
+	strings_it[I_I2CMode]="Modalità";
+	strings_it[I_I2CSend]="Invia";
+	strings_it[I_I2CReceive]="Ricevi";
+	strings_it[I_TestHW]="Test hardware: rimuovere eventuali dispositivi dal programmatore";
+	strings_it[I_TestHWB]="Test hardware";
+	strings_it[I_TestMSG]="Verifica sul programmatore il valore delle seguenti tensioni:";
+	strings_it[I_IO_Enable]="Abilita IO";
+	strings_it[I_IO_Commands]="Comandi manuali";
+	strings_it[I_SPIMEM]="Memoria SPI";
+	strings_it[I_I2CMEM]="Memoria I2C";
+	strings_it[I_UWMEM]="Memoria Microwire";
+	strings_it[I_OWMEM]="Memoria OneWire";
+	strings_it[I_OWDEV]="Dispositivo OneWire";
+	strings_it[I_UNIOMEM]="Memoria UNI/O";
+	strings_it[I_3V3REQUIRED]="adattatore 3,3V";
+	strings_it[I_PIC_FORCECW]="Forza config word";
+	strings_it[I_AT_FUSE]="Scrivi Fuse Low";
+	strings_it[I_AT_FUSEH]="Scrivi Fuse High";
+	strings_it[I_AT_FUSEX]="Scrivi Extended Fuse";
+	strings_it[I_AT_LOCK]="Scrivi Lock";
+	strings_it[I_AT_FUSELF]="Scrivi Fuse Low @3kHz";
+	strings_it[I_AT_COMM]="Comunicazione @ %.0f kbps" NL;
+	strings_it[I_W_LANGFILE]="Scrivi file linguaggio";
+	strings_it[I_WAITS1]="Inizia a scrivere/leggere con S1";
+	strings_it[I_PRESSS1]="Premi S1 per iniziare" NL;
+	strings_it[S_WaitS1W]="Premi S1 per programmare, un tasto per uscire" NL;
+	strings_it[S_WaitS1R]="Premi S1 per leggere, un tasto per uscire" NL;
+	strings_it[I_ICD_ENABLE]="Abilita ICD";
+	strings_it[I_ICD_ADDRESS]="Indirizzo routine ICD";
+	strings_it[I_LOAD_COFF]="Carica file COFF ...";
+	strings_it[I_SHOW_PC]="Mostra Program Counter";
+	strings_it[I_SHOW_STATUS]="Mostra Status";
+	strings_it[I_SHOW_BANK0]="Mostra banco memoria 0";
+	strings_it[I_SHOW_BANK1]="Mostra banco memoria 1";
+	strings_it[I_SHOW_BANK2]="Mostra banco memoria 2";
+	strings_it[I_SHOW_BANK3]="Mostra banco memoria 3";
+	strings_it[I_SHOW_EE]="Mostra EEPROM";
+	strings_it[I_STOP]="Fermato" NL;
+	strings_it[I_ICD_RUN]="Vai/continua";
+	strings_it[I_ICD_HALT]="Ferma";
+	strings_it[I_ICD_STEP]="Passo";
+	strings_it[I_ICD_STEPOVER]="Passo sopra";
+	strings_it[I_ICD_STOP]="Arresta";
+	strings_it[I_ICD_REFRESH]="Rinfresca";
+	strings_it[I_ICD_CMD]="linea di comando";
+	strings_it[I_ICD_HELP]="Aiuto";
+	strings_it[I_ICD_SOURCE]="Sorgente";
+	strings_it[I_ICD_STATUS]="Status";
+	strings_it[I_ICD_HELP_TXT]=
+		"Guida ICD" NL NL
+		"Doppio click sul nome di una variabile per" NL
+		"aggiungerla alla lista di osservazione;" NL
+		"doppio click nuovamente per rimuoverla." NL
+		"Scorciatoie:" NL
+		" F1 guida" NL
+		" F5 ferma" NL
+		" F7 passo" NL
+		" F8 passo sopra" NL
+		" F9 vai" NL
+		"Guida comandi:" NL
+		" variabile=x         imposta variabile a x" NL
+		" [var ind.]=x        imposta a x la variabile all'indirizzo ind." NL
+		" help                guida comandi" NL
+		" break <ind>         imposta breakpoint all'indirizzo <ind>" NL
+		" freeze [on,off]     freeze periferiche" NL
+		" h[alt]              ferma esecuzione" NL
+		" list <ind>          mostra codice a partire da <ind>" NL
+		" p[rint] 0x<ind>     osserva variabile all'indirizzo <ind>" NL
+		" p[rint] <var>       osserva variabile <var>" NL
+		" p[rint] bank <b>    osserva i registri nel banco <b>" NL
+		" p[rint] p <ind>     osserva la memoria programma all'indirizzo <ind>" NL
+		" p[rint] ee <ind>    osserva la memoria eeprom all'indirizzo <ind>" NL
+		" p[rint] ee          osserva tutta la memoria eeprom" NL
+		" r[un]               vai" NL
+		" s[tep] [n]          passo singolo [n volte]" NL
+		" step over / ss [n]  passo sopra le chiamate [n volte]" NL
+		" version             leggi versione debugger" NL
+		" w[atch] variabile   aggiungi/rimuovi variabile alla lista di osservazione" NL
+		" w[atch] 0x<ind>     aggiungi/rimuovi variabile all'indirizzo <ind> alla lista di osservazione" NL;
+	strings_it[I_GUI_CMD_HELP]=
+		"Opzioni da linea di comando:" NL
+		" ?,h,help            guida comandi" NL
+		" command <messaggio> invia <messaggio> al programmatore ed esci." NL
+		"                     Il messaggio è composto da byte esadecimali separati da uno spazio," NL
+		"                     fino a un massimo di 64; quelli non specificati vengono posti a 0" NL
+		" lang <lingua>       carica <lingua>" NL
+		" langfile            scrivi tutte le stringhe su file" NL;
+	strings_it[L_HELP]=
+		"op [opzioni]" NL NL
+		"-BKosccal                   carica BKosccal da file" NL
+		"-calib                      carica calibration da file" NL
+		"-command <messaggio>        invia <messaggio> al programmatore ed esci." NL
+		"                            Il messaggio è composto da byte esadecimali separati da uno spazio," NL
+		"                            fino a un massimo di 64; quelli non specificati vengono posti a 0" NL
+		"-cwX <cw>                   forza config word X [1-7]" NL
+		"-d, device <disp.>          dispositivo" NL
+		"-ee                         usa eeprom" NL
+		"-err <max>                  imposta massimo errori in scrittura" NL
+		"-fuse <val>                 scrive il byte fuse low (solo Atmel)" NL
+		"-fuseh <val>                scrive il byte fuse high (solo Atmel)" NL
+		"-fusex <val>                scrive il byte extended fuse (solo Atmel)" NL
+		"-fuse3k <val>               scrive il byte fuse low a 3kHz (solo Atmel)" NL
+		"-h, help                    guida" NL
+		"-HWtest                     test hardware" NL
+		"-i, info                    informazioni programmatore" NL
+		"-icd <val>                  abilita ICD (goto indirizzo)" NL
+		"-i2c_r <N Ctr Ind>          leggi N byte dal bus I2C" NL
+		"-i2c_r2 <N Ctr Ind(2)>      leggi N byte dal bus I2C (indirizzi 16b)" NL
+		"-i2c_w <N Ctr Ind Dati>     scrivi N byte sul bus I2C" NL
+		"-i2c_w2 <N Ctr Ind(2) Dati> scrivi N byte sul bus I2C (indirizzi 16b)" NL
+		"-i2cspeed <s>               cambia velocità I2C: 0=100k,1=200k,2=500k,3=800k" NL
+		"-id                         usa ID" NL
+		"-l, log [=file]             salva registro" NL
+		"-lang <lingua>              carica <lingua>" NL
+		"-langfile                   scrivi tutte le stringhe su file" NL
+		"-lock <val>                 scrive il byte lock (solo Atmel)" NL
+		"-mode <mode>                SPI mode: 00,01,10,11" NL
+		"-nolvcheck                  salta controllo regolatore a 3,3V" NL
+		"-osccal                     carica osccal da file invece che dal valore salvato prima della cancellazione" NL
+		"-p, path <percorso>         percorso programmatore [/dev/usb/hiddev0]" NL
+		"-pid <pid>                  pid programmatore [0x100]" NL
+		"-r, reserved                leggi area riservata" NL
+		"-rep <n>                    dimensione report [64]" NL
+		"-s1, S1                     Programmazione multipla comandata da S1" NL
+		"-s, save <file>             salva su file Ihex" NL
+		"-se, saveEE <file>          salva EEPROM su file Ihex (solo ATxxxx)" NL
+		"-spi_r <N>                  leggi N byte dal bus SPI" NL
+		"-spi_w <N Dati>             scrivi N byte sul bus SPI" NL
+		"-spispeed <s>               cambia velocità SPI: 0=100k,1=200k,2=300k,3=500k" NL
+		"-support                    dispositivi supportati" NL
+		"-use_BKosccal               copia BKosccal su osccal" NL
+		"-v, version                 versione" NL
+		"-vid <vid>                  vid programmatore [0x4D8]" NL
+		"-w, write <file>            scrivi file Ihex" NL
+		"-we, writeEE <file>         scrivi EEPROM file Ihex (solo ATxxxx)" NL
+		"" NL
+		"es.  op -d 12F683 -s prova.hex" NL;
+	strings_it[L_OPTERR]="Errore nelle opzioni" NL;
+	strings_it[L_INFO1]="vid 0x%04hx pid 0x%04hx versione 0x%04hx ";
+	strings_it[L_INFO2]= NL "bus: %d devnum: %d ifnum: %d" NL;
+	strings_it[L_UNKNOWN]="sconosciuto";
+	strings_it[L_NAME]="Il dispositivo su %s si chiama %s" NL;
+	strings_it[L_DEV_RO]="Dispositivi supportati in sola lettura:";
+	strings_it[L_DEV_RW]="Dispositivi supportati in lettura e scrittura:";
+
+// ENGLISH strings
+	strings_en[S_NL]=NL;
+	strings_en[S_noprog]="Programmer not detected" NL;
+	strings_en[S_prog]="Programmer detected" NL;
+	strings_en[S_progDev]="Programmer detected on %s" NL;
+	strings_en[S_DevPermission]="Cannot open %s, make sure you have read permission on it" NL;
+	strings_en[S_nodev_r]="Device not supported for reading" NL;
+	strings_en[S_nodev_w]="Device not supported for writing" NL;
+	strings_en[S_nodev]="Unknown device" NL;
+	strings_en[S_DevMismatch]="Warning: the device is different from what specified in source data" NL;
+	strings_en[S_noV33reg]="3.3V Regulator not detected" NL;
+	strings_en[S_progver]="Firmware version %d.%d.%d" NL;
+	strings_en[S_progid]="Hardware ID: %d.%d.%d";
+	strings_en[S_FWver2old]="This firmware is too old. Version %s is required" NL;
+	strings_en[S_lowUsbV]="USB voltage too low (VUSB<4.5V)" NL;
+	strings_en[S_HiVPP]="Warning: regulator voltage too high" NL NL;
+	strings_en[S_LowVPP]="Warning: regulator voltage too low" NL NL;
+	strings_en[S_reg]="Regulator up and running after %dms VPP=%.1fV" NL NL;
+	strings_en[S_dev_det]="Device detected: vid=0x%04X pid=0x%04X" NL "Path: %s" NL;
+	strings_en[S_file]="Hex8 files (*.hex)|*.hex|All files (*.*)|*.*||";
+	strings_en[S_file2]="Hex8 files (*.hex)|*.hex|Binary files (*.bin)|*.bin|All files (*.*)|*.*||";
+	strings_en[S_fileEEP]="Hex8 files (*.hex *.eep)|*.hex;*.eep|All files (*.*)|*.*||";
+	strings_en[S_noDLL]="Error opening hid.dll";
+	strings_en[S_openEEfile]="Open EEPROM file";
+	strings_en[S_saveEEfile]="Save EEPROM file";
+						//
+	strings_en[S_IhexShort]="Intel hex8 line too short:" NL "%s" NL;
+	strings_en[S_IhexChecksum]="Intel hex8 checksum error in line:" NL "%s" NL;
+	strings_en[S_InvHandle]="Invalid handle" NL;
+	strings_en[S_LogFile]="Log.txt";
+	strings_en[S_FileSaved]="Saved file %s" NL;
+		//
+	strings_en[S_HVICSP]="High Voltage ICSP" NL;
+	strings_en[S_StartRead]="Reading ..." NL;
+	strings_en[S_Read]="Reading ... ";
+	strings_en[S_CodeReading1]="Reading code ... ";
+	strings_en[S_CodeReading]="Reading: %3d%%, add. %03X";
+	strings_en[S_CodeReading2]="Reading: %3d%%, add. %05X";
+	strings_en[S_ReadEnd]="Reading completed: %d words" NL;
+	strings_en[S_ReadID_CONFIG]="Reading ID and CONFIG";
+	strings_en[S_Read_CONFIG_A]="Reading CONFIG area ... ";
+	strings_en[S_Read_EXE_A]="Reading Executive area ... ";
+	strings_en[S_ReadEE]="Reading EEPROM ... ";
+	strings_en[S_StartErase]="Erasing ... ";
+	strings_en[S_Writing]="Writing ..." NL;
+	strings_en[S_StartCodeProg]="Writing code ... ";
+	strings_en[S_CodeWriting]="Writing: %3d%%, add. %03X";
+	strings_en[S_CodeWriting2]="Writing: %3d%%, add. %04X";
+	strings_en[S_IDW]="Writing ID ... ";
+	strings_en[S_ConfigW]="Writing CONFIG ... ";
+	strings_en[S_ConfigAreaW]="Writing CONFIG area ... ";
+	strings_en[S_EEAreaW]="Writing EEPROM ... ";
+	strings_en[S_FuseAreaW]="Writing FUSE area ... ";
+	strings_en[S_CodeV]="Verifying code ... ";
+	strings_en[S_CodeV2]="Verifying: %d%%, add. %04X";
+	strings_en[S_IDV]="Verifying ID ... ";
+	strings_en[S_ConfigV]="Verifying CONFIG ... ";
+	strings_en[S_EEV]="Verifying EEPROM ... ";
+	strings_en[S_IntW]="Write interrupted" NL;
+	strings_en[S_TotErr]="completed, %d total errors" NL;
+	strings_en[S_ComplErr]="completed, %d errors" NL;
+	strings_en[S_Compl]="completed" NL;
+	strings_en[S_Ready]="ready";
+	strings_en[S_End]= NL "End (%.2f s)" NL NL;
+	strings_en[S_EndErr]= NL "End (%.2f s) %d %s" NL NL;
+	strings_en[S_ProtErase]="Device protected, overriding protection." NL;
+		//
+	strings_en[S_Inohex]="Error: '%.4s' doesn't look very hexadecimal, right?" NL;
+	strings_en[S_ReadErr]="Read error: requested words=%d, read=%d" NL;
+	strings_en[S_ReadCodeErr]="Error reading code area, requested %d words, read %d" NL;
+	strings_en[S_ReadCodeErr2]="Error reading code area, requested %d bytes, read %d" NL;
+	strings_en[S_ReadEEErr]="Error reading EEPROM area, requested %d bytes, read %d" NL;
+	strings_en[S_ConfigErr]="Error reading configuration area, requested %d words, read %d" NL;
+	strings_en[S_ReadConfigErr]="Error reading configuration area, requested %d bytes, read %d" NL;
+	strings_en[S_ErrOsccal]="Error reading OSCCAL and BKOSCCAL";
+	strings_en[S_CodeWError]="Error writing address %3X: written %03X, read %03X" NL;
+	strings_en[S_CodeWError2]="Error writing address %3X: written %04X, read %04X" NL;
+	strings_en[S_CodeWError3]="Error writing address %4X: written %02X, read %02X" NL;
+	strings_en[S_CodeWError4]="Error writing code area, requested %d bytes, written %d" NL;
+	strings_en[S_ConfigWErr]="Error writing config area: written %03X, read %03X" NL;
+	strings_en[S_ConfigWErr2]="Error writing CONFIG";
+	strings_en[S_ConfigWErr3]="Error writing config area: written %04X, read %04X" NL;
+	strings_en[S_WErr1]="Error writing %s: written %02X, read %02X" NL;
+	strings_en[S_WErr2]="Error writing %s: written %04X, read %04X" NL;
+	strings_en[S_IDErr]="Error writing ID%d: written %04X, read %04X" NL;
+	strings_en[S_ICDErr]="Error writing ICD (0x%X): written %04X, read %04X" NL;
+	strings_en[S_Calib1Err]="Error writing Calib1: written %04X, read %04X" NL;
+	strings_en[S_Calib2Err]="Error writing Calib2: written %04X, read %04X" NL;
+	strings_en[S_CodeVError]="Error verifying address %04X (%d), written %02X, read %02X" NL;
+	strings_en[S_CodeVError2]="Error verifying code area, requested %d bytes, read %d" NL;
+	strings_en[S_CodeVError3]="Error verifying code area, requested %d words, read %d" NL;
+	strings_en[S_ErrSing]="error";
+	strings_en[S_ErrPlur]="errors";
+	strings_en[S_MaxErr]="Exceeded maximum number of errors (%d), write interrupted" NL;
+	strings_en[S_I2CInitErr]="Error initializing I2C bus" NL;
+	strings_en[S_I2CAckErr]="I2C acknowledge error" NL;
+	strings_en[S_ComErr]="Communication error" NL;
+	strings_en[S_InsErr]="Unknown instruction" NL;
+	strings_en[S_SyncErr]="Synchronization error" NL;
+	strings_en[S_HVregErr]="HV regulator error" NL;
+		//
+	strings_en[S_Log1]="i=%d(0x%X), k=%d(0x%X)  NumberOfBytesRead=%d" NL;
+	strings_en[S_Log2]="i=%d, k=%d, errors=%d, NumberOfBytesRead=%d" NL NL;
+	strings_en[S_Log3]="i=%d, k2=%d NumberOfBytesRead=%d" NL;
+	strings_en[S_Log4]="Config area. 	errors=%d   NumberOfBytesRead=%d" NL;
+	strings_en[S_Log5]="dim=%d(0x%X), dimx=%d(0x%X), dimx/wbuf=%d " NL NL;
+	strings_en[S_Log6]="i=%d(0x%X),  NumberOfBytesRead=%d" NL NL;
+	strings_en[S_Log7]="i=%d(0x%X), k=%d(0x%X)" NL;
+	strings_en[S_Log8]="i=%d(0x%X), k=%d(0x%X), errors=%d" NL;
+	strings_en[S_Log9]="Config area. 	errors=%d" NL;
+		//
+	strings_en[S_comTimeout]="Communication timeout" NL;
+	strings_en[S_EraseTimeout]="Timeout during erase" NL;
+	strings_en[S_ConfigTimeout]="Timeout reading CONFIG" NL;
+	strings_en[S_ConfigTimeout2]="Timeout reading config area" NL;
+	strings_en[S_CodeTimeout]="Timeout reading address %02X (%d)" NL;
+	strings_en[S_CodeTimeout2]="Timeout reading address %04X (%d)" NL;
+	strings_en[S_OsccalTimeout]="Timeout reading osccal" NL;
+	strings_en[S_EETimeout]="Timeout reading EEPROM, address %02X (%d)" NL;
+	strings_en[S_ConfigWTimeout]="Timeout verifying config" NL;
+	strings_en[S_CodeWTimeout]="Timeout writing address %02X (%d)" NL;
+	strings_en[S_ConfigWTimeout2]="Timeout writing config area" NL;
+	strings_en[S_EEWTimeout]="Timeout writing EEPROM, address %03X (%d)" NL;
+	strings_en[S_IDWTimeout]="Timeout writing ID" NL;
+	strings_en[S_ConfigNWTimeout]="Timeout writing CONFIG%d" NL;
+	strings_en[S_CodeVTimeout]="Timeout verifying address %04X (%d)" NL;
+	strings_en[S_ConfigVTimeout]="Timeout verifying config area" NL;
+	strings_en[S_ProgModeTimeout]="Timeout entering program mode" NL;
+	strings_en[S_ProgModeXTimeout]="Timeout exiting program mode" NL;
+	strings_en[S_LogTimeout]="Timeout" NL;
+		//
+	strings_en[S_CodeMem]= NL "Code memory:" NL;
+	strings_en[S_EEMem]= NL "EEPROM memory:" NL;
+	strings_en[S_IDMem]= NL "ID:" NL;
+	strings_en[S_ConfigMem]= NL "CONFIG:" NL;
+	strings_en[S_ConfigResMem]= NL "Configuration and reserved memory:" NL;
+	strings_en[S_CodeMem2]= NL "Code memory:" NL;
+	strings_en[S_ExeMem]= NL "Executive memory:" NL;
+		//
+	strings_en[S_LPOsc]="LP oscillator" NL;
+	strings_en[S_XTOsc]="XT oscillator" NL;
+	strings_en[S_IntOsc]="Internal osc." NL;
+	strings_en[S_RCOsc]="RC oscillator" NL;
+	strings_en[S_WDTON]="WDT ON" NL;
+	strings_en[S_WDTOFF]="WDT OFF" NL;
+	strings_en[S_CPOFF]="Code protection OFF" NL;
+	strings_en[S_CPON]="Code protection ON" NL;
+	strings_en[S_MCLRON]="Master clear ON" NL;
+	strings_en[S_MCLROFF]="Master clear OFF" NL;
+	strings_en[S_ChipID]="ID%d: 0x%03X   ID%d: 0x%03X" NL;
+	strings_en[S_ChipID2]="ID%d: 0x%02X   ID%d: 0x%02X" NL;
+	strings_en[S_BKOsccal]="Backup OSCCAL: 0x%03X" NL;
+	strings_en[S_Osccal]="OSCCAL: 0x%03X" NL;
+	strings_en[S_DevID]="DevID: 0x%04X" NL;
+	strings_en[S_DevID2]="DevID: 0x%02X%02X" NL;
+	strings_en[S_DevREV]="DevREV: 0x%04X" NL;
+	strings_en[S_ConfigWord]="Configuration word: 0x%03X" NL;
+	strings_en[S_Config2Cal1]="Configuration word2 or calibration word 1: 0x%03X" NL;
+	strings_en[S_ConfigWord2]="Configuration word2: 0x%04X" NL;
+	strings_en[S_ConfigWordX]="Configuration word %d: 0x%04X" NL;
+	strings_en[S_ConfigWordH]="CONFIG%dH: 0x%02X\t";
+	strings_en[S_ConfigWordL]="CONFIG%dL: 0x%02X" NL;
+	strings_en[S_CalibWord1]="Calibration word1: 0x%04X" NL;
+	strings_en[S_Calib1_2]="Calibration word 1 or 2: 0x%04X" NL;
+	strings_en[S_CalibWord2]="Calibration word2: 0x%04X" NL;
+	strings_en[S_CalibWordX]="Calibration word %d: 0x%04X" NL;
+	strings_en[S_Protected]="protected device";
+		//
+	strings_en[S_CodeLim]="Code size exceeds limits" NL;
+	strings_en[S_EELim]="Eeprom size exceeds limits" NL;
+	strings_en[S_ConfigLim]="Config area size exceeds limits" NL;
+	strings_en[S_WbufLim]="Write buffer size exceeds limits" NL;
+	strings_en[S_MaxRetry]="Max retries in writing: %d" NL;
+		//
+	strings_en[S_NoCode]="Data area is empty" NL;
+	strings_en[S_NoCode2]="Nothing to write" NL;
+	strings_en[S_NoCalibW]="Can't find calibration data" NL;
+	strings_en[S_NoEEMem]="Can't find EEPROM data" NL;
+	strings_en[S_NoConfigW]="Impossibile leggere la config word" NL;
+	strings_en[S_NoConfigW2]="Can't find CONFIG location (0xFFF)" NL;
+	strings_en[S_NoConfigW3]="Can't find CONFIG location (0x2007)" NL "End" NL;
+	strings_en[S_NoConfigW4]="Can't find CONFIG location (0x2008)" NL "End" NL;
+	strings_en[S_NoConfigW5]="Can't find CONFIG location (0x8007-0x8008)" NL "End" NL;
+	strings_en[S_NoConfigW6]="Can't find CONFIG location (0x8007-0x800B)" NL "End" NL;
+	strings_en[S_Empty]="(empty)" NL;
+	strings_en[S_NextIns]="Next instruction";
+	strings_en[S_ForceConfigW]="Forcing config words" NL;
+	strings_en[S_ForceConfigWx]="Forcing config word%d [0x%04X]=0x%04X" NL;
+	strings_en[S_WarnFlashSize]="Warning, flash size is different from the expected value" NL;
+		//
+	strings_en[I_CANCEL]="_Cancel";
+	strings_en[I_OPEN]="_Open";
+	strings_en[I_SAVE]="_Save";
+	strings_en[I_Fopen]="Open file";
+	strings_en[I_Fsave]="Save file";
+	strings_en[I_DevR]="Read device";
+	strings_en[I_DevW]="Write device";
+	strings_en[I_Info]="Info";
+	strings_en[I_Data]="Data";
+	strings_en[I_Opt]="Options";
+	strings_en[I_Dev]="Device";
+	strings_en[I_Type]="Filter by type";
+	strings_en[I_Speed]="Speed";
+	strings_en[I_ReadRes]="Read reserved area";
+	strings_en[I_ID_BKo_W]="Write ID and BKosccal";
+	strings_en[I_EE]="Read and write EEPROM";
+	strings_en[I_CalW]="Write Calib1 e 2";
+	strings_en[I_OSCW]="Write OSCCal";
+	strings_en[I_OSC]="OSCCal";
+	strings_en[I_BKOSC]="Backup OSCCal";
+	strings_en[I_OSCF]="From File";
+	strings_en[I_CONN]="Reconnect";
+	strings_en[I_QUIT]="Quit";
+	strings_en[I_LOG]="Log activity";
+	strings_en[I_CK_V33]="Skip 3.3V regulator check";
+	strings_en[I_LANG]="Language";
+	strings_en[I_MAXERR]="Max errors during write";
+	strings_en[I_ADDR]="Address";
+	strings_en[I_USBD]="Min USB delay (ms)";
+	strings_en[I_I2CDATAOUT]="Data to send";
+	strings_en[I_I2CDATATR]="Data transferred";
+	strings_en[I_I2C_NB]="Bytes to read/write";
+	strings_en[I_I2CMode]="Mode";
+	strings_en[I_I2CSend]="Send";
+	strings_en[I_I2CReceive]="Receive";
+	strings_en[I_TestHW]="Hardware test: remove any device from programmer";
+	strings_en[I_TestHWB]="Hardware test";
+	strings_en[I_TestMSG]="Verify on the programmer the value of the following voltages:";
+	strings_en[I_IO_Enable]="Enable IO";
+	strings_en[I_IO_Commands]="Manual commands";
+	strings_en[I_SPIMEM]="SPI Memory";
+	strings_en[I_I2CMEM]="I2C Memory";
+	strings_en[I_UWMEM]="Microwire Memory";
+	strings_en[I_OWMEM]="OneWire Memory";
+	strings_en[I_OWDEV]="OneWire Device";
+	strings_en[I_UNIOMEM]="UNI/O Memory";
+	strings_en[I_3V3REQUIRED]="3.3V adapter";
+	strings_en[I_PIC_FORCECW]="Force config word";
+	strings_en[I_AT_FUSE]="Write Fuse Low";
+	strings_en[I_AT_FUSEH]="Write Fuse High";
+	strings_en[I_AT_FUSEX]="Write Extended Fuse";
+	strings_en[I_AT_LOCK]="Write Lock";
+	strings_en[I_AT_FUSELF]="Write Fuse Low @3kHz";
+	strings_en[I_AT_COMM]="Communicating @ %.0f kbps" NL;
+	strings_en[I_W_LANGFILE]="Write language file";
+	strings_en[I_WAITS1]="Wait for S1 before read/write";
+	strings_en[I_PRESSS1]="Press S1 to start" NL;
+	strings_en[S_WaitS1W]="Press S1 to program, any key to exit";
+	strings_en[S_WaitS1R]="Press S1 to read, any key to exit";
+	strings_en[I_ICD_ENABLE]="Enable ICD";
+	strings_en[I_ICD_ADDRESS]="ICD routine address";
+	strings_en[I_LOAD_COFF]="Load COFF file ...";
+	strings_en[I_SHOW_PC]="Show Program Counter";
+	strings_en[I_SHOW_STATUS]="Show status registers";
+	strings_en[I_SHOW_BANK0]="Show memory bank 0";
+	strings_en[I_SHOW_BANK1]="Show memory bank 1";
+	strings_en[I_SHOW_BANK2]="Show memory bank 2";
+	strings_en[I_SHOW_BANK3]="Show memory bank 3";
+	strings_en[I_SHOW_EE]="show EEPROM";
+	strings_en[I_STOP]="Stopped" NL;
+	strings_en[I_ICD_RUN]="Run/Continue";
+	strings_en[I_ICD_HALT]="Halt";
+	strings_en[I_ICD_STEP]="Step";
+	strings_en[I_ICD_STEPOVER]="Step over";
+	strings_en[I_ICD_STOP]="Stop";
+	strings_en[I_ICD_REFRESH]="Refresh";
+	strings_en[I_ICD_CMD]="Command line";
+	strings_en[I_ICD_HELP]="Help";
+	strings_en[I_ICD_SOURCE]="Source";
+	strings_en[I_ICD_STATUS]="Status";
+	strings_en[I_ICD_HELP_TXT]=
+		"ICD help" NL NL
+		"Double click variable name to add to watch list;" NL
+		"double click again to remove it." NL
+		"Key shortcuts:" NL
+		" F1 help" NL
+		" F5 halt" NL
+		" F7 step" NL
+		" F8 step over" NL
+		" F9 run" NL
+		"Command-line help:" NL
+		" variable=x          set variable to x" NL
+		" [var addr]=x        set variable at addr to x" NL
+		" help                command help" NL
+		" break <addr>        set breakpoint at address <addr>" NL
+		" freeze [on,off]     freeze peripherals" NL
+		" h[alt]              halt execution" NL
+		" list <addr>         show code starting from <addr>" NL
+		" p[rint] 0x<addr>    print variable at address <addr>" NL
+		" p[rint] <var>       print variable <var>" NL
+		" p[rint] bank <b>    print registers in bank <b>" NL
+		" p[rint] p <addr>    print program memory at address <addr>" NL
+		" p[rint] ee <addr>   print eeprom memory at address <addr>" NL
+		" p[rint] ee          print all eeprom memory" NL
+		" r[un]               run" NL
+		" s[tep] [n]          single step [n times]" NL
+		" step over / ss [n]  step over calls [n times]" NL
+		" version             read debugger version" NL
+		" w[atch] variable    add/remove watch for variable" NL
+		" w[atch] 0x<addr>    add/remove watch at address <addr>" NL;
+	strings_en[I_GUI_CMD_HELP]=
+		"Command line options:" NL
+		" ?,h,help            this help" NL
+		" command <message>   send <message> to the programmer and exit." NL
+		"                     The message is composed of up to 64 hexadecimal bytes separated by a space;" NL
+		"                     those not specified are 0" NL
+		" lang <language>     load <language> strings" NL
+		" langfile            write all strings to file" NL;
+	strings_en[L_HELP]="op [options]" NL
+		"-BKosccal                   load BKosccal from file" NL
+		"-calib                      load calibration from file" NL
+		"-command <message>          send <message> to the programmer and exit." NL
+		"                            The message is composed of up to 64 hexadecimal bytes separated by a space;" NL
+		"                            those not specified are 0" NL
+		"-cwX <cw>                   force config word X [1-7]" NL
+		"-d, device <dev.>           device" NL
+		"-ee                         use eeprom" NL
+		"-err <max>                  max errors during writing" NL
+		"-fuse <val>                 write fuse low byte (Atmel only)" NL
+		"-fuseh <val>                write fuse high byte (Atmel only)" NL
+		"-fusex <val>                write extended fuse byte (Atmel only)" NL
+		"-fuse3k <val>               write fuse low byte at 3 kHz (Atmel only)" NL
+		"-h, help                    help" NL
+		"-HWtest                     hardware test" NL
+		"-i, info                    informations about programmer" NL
+		"-i2c_r <N Ctr Addr>         read N bytes from I2C bus" NL
+		"-i2c_r2 <N Ctr Addr(2)>     read N bytes from I2C bus (16b address)" NL
+		"-i2c_w <N Ctr Addr Data>    write N bytes to I2C bus" NL
+		"-i2c_w2 <N Ctr Addr(2) D.>  write N bytes to I2C bus (16b address)" NL
+		"-i2cspeed <s>               set I2C speed: 0=100k,1=200k,2=500k,3=800k" NL
+		"-id                         use ID" NL
+		"-icd <val>                  enable ICD (goto address)" NL
+		"-l, log [=file]             save log" NL
+		"-lang <language>            load <language> strings" NL
+		"-langfile                   write all strings to file" NL
+		"-lock <val>                 write lock byte (Atmel only)" NL
+		"-mode <mode>                SPI mode: 00,01,10,11" NL
+		"-nolvcheck                  skip 3.3V regulator check" NL
+		"-osccal                     loads osccal from file instead of using the value saved before erase" NL
+		"-p, path <path>             programmer path [/dev/usb/hiddev0]" NL
+		"-pid <pid>                  programmer pid [0x100]" NL
+		"-r, reserved                read reserved area" NL
+		"-rep <n>                    report size [64]" NL
+		"-s1, S1                     Multiple programming triggered by S1" NL
+		"-s, save <file>             save Ihex file" NL
+		"-se, saveEE <file>          save EEPROM on Ihex file (ATxxxx only)" NL
+		"-spi_r <N>                  read N bytes from SPI bus" NL
+		"-spi_w <N Data>             write N bytes to SPI bus" NL
+		"-spispeed <s>               set SPI speed: 0=100k,1=200k,2=500k,3=800k" NL
+		"-support                    supported devices" NL
+		"-use_BKosccal               copy BKosccal to osccal" NL
+		"-v, version                 version" NL
+		"-vid <vid>                  programmer vid [0x4D8]" NL
+		"-w, write <file>            write Ihex file" NL
+		"-we, writeEE <file>         write EEPROM on Ihex file (ATxxxx only)" NL
+		"" NL
+		"ex.  op -d 12F683 -s test.hex" NL;
+	strings_en[L_OPTERR]="Error in command-line options" NL;
+	strings_en[L_INFO1]="vid 0x%04hx pid 0x%04hx version 0x%04hx ";
+	strings_en[L_INFO2]= NL "bus: %d devnum: %d ifnum: %d" NL;
+	strings_en[L_UNKNOWN]="Unknown";
+	strings_en[L_NAME]="The device on %s says its name is %s" NL;
+	strings_en[L_DEV_RO]="Devices supported for reading only:";
+	strings_en[L_DEV_RW]="Devices supported for reading and writing:";
+}
diff --git a/strings.h b/strings.h
new file mode 100644
index 0000000..7c3c58a
--- /dev/null
+++ b/strings.h
@@ -0,0 +1,282 @@
+// Strings.h v0.12.0
+
+enum S {
+	S_NL,
+	S_noprog,
+	S_prog,
+	S_progDev,
+	S_DevPermission,
+	S_nodev_r,
+	S_nodev_w,
+	S_nodev,
+	S_DevMismatch,
+	S_noV33reg,
+	S_progver,
+	S_progid,
+	S_FWver2old,
+	S_lowUsbV,
+	S_HiVPP,
+	S_LowVPP,
+	S_reg,
+	S_dev_det,
+	S_file,
+	S_file2,
+	S_fileEEP,
+	S_noDLL,
+	S_openEEfile,
+	S_saveEEfile,
+	S_IhexShort,
+	S_IhexChecksum,
+	S_InvHandle,
+	S_LogFile,
+	S_FileSaved,
+	S_HVICSP,
+	S_StartRead,
+	S_Read,
+	S_CodeReading1,
+	S_CodeReading,
+	S_CodeReading2,
+	S_ReadEnd,
+	S_ReadID_CONFIG,
+	S_Read_CONFIG_A,
+	S_Read_EXE_A,
+	S_ReadEE,
+	S_StartErase,
+	S_Writing,
+	S_StartCodeProg,
+	S_CodeWriting,
+	S_CodeWriting2,
+	S_IDW,
+	S_ConfigW,
+	S_ConfigAreaW,
+	S_EEAreaW,
+	S_FuseAreaW,
+	S_CodeV,
+	S_CodeV2,
+	S_IDV,
+	S_ConfigV,
+	S_EEV,
+	S_IntW,
+	S_TotErr,
+	S_ComplErr,
+	S_Compl,
+	S_Ready,
+	S_End,
+	S_EndErr,
+	S_ProtErase,
+	S_Inohex,
+	S_ReadErr,
+	S_ReadCodeErr,
+	S_ReadCodeErr2,
+	S_ReadEEErr,
+	S_ConfigErr,
+	S_ReadConfigErr,
+	S_ErrOsccal,
+	S_CodeWError,
+	S_CodeWError2,
+	S_CodeWError3,
+	S_CodeWError4,
+	S_ConfigWErr,
+	S_ConfigWErr2,
+	S_ConfigWErr3,
+	S_WErr1,
+	S_WErr2,
+	S_IDErr,
+	S_ICDErr,
+	S_Calib1Err,
+	S_Calib2Err,
+	S_CodeVError,
+	S_CodeVError2,
+	S_CodeVError3,
+	S_ErrSing,
+	S_ErrPlur,
+	S_MaxErr,
+	S_I2CInitErr,
+	S_I2CAckErr,
+	S_ComErr,
+	S_InsErr,
+	S_SyncErr,
+	S_HVregErr,
+	S_Log1,
+	S_Log2,
+	S_Log3,
+	S_Log4,
+	S_Log5,
+	S_Log6,
+	S_Log7,
+	S_Log8,
+	S_Log9,
+	S_comTimeout,
+	S_EraseTimeout,
+	S_ConfigTimeout,
+	S_ConfigTimeout2,
+	S_CodeTimeout,
+	S_CodeTimeout2,
+	S_OsccalTimeout,
+	S_EETimeout,
+	S_ConfigWTimeout,
+	S_CodeWTimeout,
+	S_ConfigWTimeout2,
+	S_EEWTimeout,
+	S_IDWTimeout,
+	S_ConfigNWTimeout,
+	S_CodeVTimeout,
+	S_ConfigVTimeout,
+	S_ProgModeTimeout,
+	S_ProgModeXTimeout,
+	S_LogTimeout,
+	S_CodeMem,
+	S_EEMem,
+	S_IDMem,
+	S_ConfigMem,
+	S_ConfigResMem,
+	S_CodeMem2,
+	S_ExeMem,
+	S_LPOsc,
+	S_XTOsc,
+	S_IntOsc,
+	S_RCOsc,
+	S_WDTON,
+	S_WDTOFF,
+	S_CPOFF,
+	S_CPON,
+	S_MCLRON,
+	S_MCLROFF,
+	S_ChipID,
+	S_ChipID2,
+	S_BKOsccal,
+	S_Osccal,
+	S_DevID,
+	S_DevID2,
+	S_DevREV,
+	S_ConfigWord,
+	S_ConfigWord2,
+	S_ConfigWordX,
+	S_Config2Cal1,
+	S_ConfigWordH,
+	S_ConfigWordL,
+	S_CalibWord1,
+	S_Calib1_2,
+	S_CalibWord2,
+	S_CalibWordX,
+	S_Protected,
+	S_CodeLim,
+	S_EELim,
+	S_ConfigLim,
+	S_WbufLim,
+	S_MaxRetry,
+	S_NoCode,
+	S_NoCode2,
+	S_NoCalibW,
+	S_NoEEMem,
+	S_NoConfigW,
+	S_NoConfigW2,
+	S_NoConfigW3,
+	S_NoConfigW4,
+	S_NoConfigW5,
+	S_NoConfigW6,
+	S_Empty,
+	S_NextIns,
+	S_ForceConfigW,
+	S_ForceConfigWx,
+	S_WaitS1W,
+	S_WaitS1R,
+	S_WarnFlashSize,
+// GUI strings
+	I_CANCEL,
+	I_OPEN,
+	I_SAVE,
+	I_Fopen,
+	I_Fsave,
+	I_DevR,
+	I_DevW,
+	I_Info,
+	I_Data,
+	I_Opt,
+	I_Dev,
+	I_Type,
+	I_Speed,
+	I_ReadRes,
+	I_ID_BKo_W,
+	I_EE,
+	I_CalW,
+	I_OSCW,
+	I_OSC,
+	I_BKOSC,
+	I_OSCF,
+	I_CONN,
+	I_QUIT,
+	I_LOG,
+	I_CK_V33,
+	I_LANG,
+	I_MAXERR,
+	I_ADDR,
+	I_USBD,
+	I_I2CDATAOUT,
+	I_I2CDATATR,
+	I_I2C_NB,
+	I_I2CMode,
+	I_I2CSend,
+	I_I2CReceive,
+	I_TestHW,
+	I_TestHWB,
+	I_TestMSG,
+	I_IO_Enable,
+	I_IO_Commands,
+	I_SPIMEM,
+	I_I2CMEM,
+	I_UWMEM,
+	I_OWMEM,
+	I_OWDEV,
+	I_UNIOMEM,
+	I_3V3REQUIRED,
+	I_PIC_FORCECW,
+	I_AT_FUSE,
+	I_AT_FUSEH,
+	I_AT_FUSEX,
+	I_AT_LOCK,
+	I_AT_FUSELF,
+	I_AT_COMM,
+	I_W_LANGFILE,
+	I_WAITS1,
+	I_PRESSS1,
+	I_ICD_ENABLE,
+	I_ICD_ADDRESS,
+	I_LOAD_COFF,
+	I_SHOW_PC,
+	I_SHOW_STATUS,
+	I_SHOW_BANK0,
+	I_SHOW_BANK1,
+	I_SHOW_BANK2,
+	I_SHOW_BANK3,
+	I_SHOW_EE,
+	I_STOP,
+	I_ICD_RUN,
+	I_ICD_HALT,
+	I_ICD_STEP,
+	I_ICD_STEPOVER,
+	I_ICD_STOP,
+	I_ICD_REFRESH,
+	I_ICD_CMD,
+	I_ICD_HELP,
+	I_ICD_SOURCE,
+	I_ICD_STATUS,
+	I_ICD_HELP_TXT,
+	I_GUI_CMD_HELP,
+//	command-line strings
+	L_HELP,
+	L_OPTERR,
+	L_INFO1,
+	L_INFO2,
+	L_UNKNOWN,
+	L_NAME,
+	L_DEV_RO,
+	L_DEV_RW,
+	DIM};
+
+extern char *strings_it[DIM];
+extern char *strings_en[DIM];
+extern char *STR_ID[DIM];
+void strinit();
+int strfind(const char* langid,const char* langfile);
+void GenerateLangFile(const char* langid,const char* langfile);
diff --git a/style.css b/style.css
new file mode 100644
index 0000000..1e3edad
--- /dev/null
+++ b/style.css
@@ -0,0 +1,3 @@
+.mono {
+	font: 14px monospace;
+}
\ No newline at end of file
diff --git a/sys.png b/sys.png
new file mode 100644
index 0000000..b518787
--- /dev/null
+++ b/sys.png
diff --git a/write.png b/write.png
new file mode 100644
index 0000000..6ed5776
--- /dev/null
+++ b/write.png