From fec9a30e6a9cce9a17476cbd0b5b50d951ea5192 Mon Sep 17 00:00:00 2001
From: Anna Bergamaschi <anna.bergamaschi@psi.ch>
Date: Wed, 1 Oct 2014 10:38:47 +0200
Subject: [PATCH] Added jungfrau detector server (not functional, though)

---
 .../jungfrauDetectorServer/.target-makefrag   |    1 +
 .../jungfrauDetectorServer/Makefile           |   48 +
 .../jungfrauDetectorServer/Makefile.virtual   |   30 +
 .../communication_funcs.c                     |    1 +
 .../communication_funcs.h                     |    1 +
 .../jungfrauDetectorServer/firmware_funcs.c   | 2614 ++++++++++++++
 .../jungfrauDetectorServer/firmware_funcs.h   |  179 +
 .../jungfrauDetectorServer/gitInfo.txt        |    9 +
 .../jungfrauDetectorServer/gitInfoMoench.h    |   11 +
 .../jungfrauDetectorServer/gitInfoMoenchTmp.h |   11 +
 .../jungfrauDetectorServer                    |  Bin 0 -> 132672 bytes
 .../jungfrauDetectorServer.gdb                |  Bin 0 -> 568322 bytes
 .../jungfrauDetectorServer/mcb_funcs.c        | 2649 ++++++++++++++
 .../jungfrauDetectorServer/mcb_funcs.h        |  174 +
 .../moenchDetectorServer                      |  Bin
 .../moenchVirtualServer                       |  Bin 0 -> 107120 bytes
 .../jungfrauDetectorServer/registers_m.h      |  464 +++
 .../jungfrauDetectorServer/server.c           |  137 +
 .../jungfrauDetectorServer/server_defs.h      |   63 +
 .../jungfrauDetectorServer/server_funcs.c     | 3108 +++++++++++++++++
 .../jungfrauDetectorServer/server_funcs.h     |   97 +
 .../jungfrauDetectorServer/sharedmemory.c     |   39 +
 .../jungfrauDetectorServer/sharedmemory.h     |   48 +
 .../sls_detector_defs.h                       |    1 +
 .../sls_detector_funcs.h                      |    1 +
 .../sls_receiver_defs.h                       |    1 +
 .../sls_receiver_funcs.h                      |    1 +
 .../jungfrauDetectorServer/stop_server.c      |   46 +
 .../jungfrauDetectorServer/trimming_funcs.c   |  749 ++++
 .../jungfrauDetectorServer/trimming_funcs.h   |   20 +
 30 files changed, 10503 insertions(+)
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/.target-makefrag
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/Makefile
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/Makefile.virtual
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.c
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.h
 create mode 100644 slsDetectorSoftware/jungfrauDetectorServer/gitInfo.txt
 create mode 100644 slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoench.h
 create mode 100644 slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoenchTmp.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer.gdb
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.h
 rename slsDetectorSoftware/{moenchDetectorServer => jungfrauDetectorServer}/moenchDetectorServer (100%)
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/moenchVirtualServer
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/registers_m.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/server.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/server_defs.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/server_funcs.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/server_funcs.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.h
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/sls_detector_defs.h
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/sls_detector_funcs.h
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_defs.h
 create mode 120000 slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_funcs.h
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/stop_server.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.c
 create mode 100755 slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.h

diff --git a/slsDetectorSoftware/jungfrauDetectorServer/.target-makefrag b/slsDetectorSoftware/jungfrauDetectorServer/.target-makefrag
new file mode 100755
index 000000000..ce093ecac
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/.target-makefrag
@@ -0,0 +1 @@
+AXIS_BUILDTYPE ?= cris-axis-linux-gnu
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/Makefile b/slsDetectorSoftware/jungfrauDetectorServer/Makefile
new file mode 100755
index 000000000..af9c684c4
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/Makefile
@@ -0,0 +1,48 @@
+# $Id: Makefile,v 1.1.1.1 2006/02/04 03:35:01 freza Exp $
+# first compile
+# make cris-axis-linux-gnu
+
+
+CROSS  = bfin-uclinux-
+CC    = $(CROSS)gcc
+
+CFLAGS += -Wall -DMOENCHD -DMCB_FUNCS -DDACS_INT  -DDEBUG #-DVERBOSE #-DVERYVERBOSE  #-DVIRTUAL  #-DDACS_INT_CSERVER
+
+
+PROGS= 	 jungfrauDetectorServer 
+INSTDIR= 	/tftpboot
+INSTMODE= 	0777
+
+
+
+BINS = testlib_sharedlibc
+SRCS = server.c server_funcs.c communication_funcs.c firmware_funcs.c mcb_funcs.c trimming_funcs.c  sharedmemory.c 
+OBJS = $(SRCS:%.c=%.o) 
+
+
+
+all:	clean $(PROGS) 
+
+boot: $(OBJS)
+
+$(PROGS): $(OBJS)
+	echo $(OBJS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDLIBS_$@) $(LDFLAGS_$@)
+
+
+install:	$(PROGS)
+	$(INSTALL) -d $(INSTDIR)
+	$(INSTALL) -m $(INSTMODE) $(PROGS) $(INSTDIR)
+
+
+romfs:
+	$(ROMFSINST)	/bin/$(PROGS) 
+
+clean:
+	rm -rf $(PROGS)  *.o *.gdb
+
+
+
+
+
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/Makefile.virtual b/slsDetectorSoftware/jungfrauDetectorServer/Makefile.virtual
new file mode 100755
index 000000000..38dd2537c
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/Makefile.virtual
@@ -0,0 +1,30 @@
+
+DESTDIR ?= ./
+
+CC    = gcc
+CFLAGS += -Wall -DMOENCHD -DMCB_FUNCS -DDACS_INT  -DDEBUG -DVIRTUAL 
+
+
+PROGS= 		$(DESTDIR)/moenchVirtualServer 
+
+
+SRCS = server.c server_funcs.c communication_funcs.c firmware_funcs.c mcb_funcs.c trimming_funcs.c  sharedmemory.c 
+OBJS = $(SRCS:%.c=%.o) 
+
+moenchVirtualServer = $(PROGS)
+
+all:	clean $(PROGS) 
+
+
+$(PROGS): $(OBJS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDLIBS_$@) $(LDFLAGS_$@)
+
+
+clean:
+	rm -rf $(PROGS)  *.o *.gdb
+
+
+
+
+
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.c b/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.c
new file mode 120000
index 000000000..87a4f95d1
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.c
@@ -0,0 +1 @@
+../commonFiles/communication_funcs.c
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.h
new file mode 120000
index 000000000..f220903b2
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/communication_funcs.h
@@ -0,0 +1 @@
+../commonFiles/communication_funcs.h
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.c b/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.c
new file mode 100755
index 000000000..1168559be
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.c
@@ -0,0 +1,2614 @@
+
+#include "server_defs.h"
+#include "firmware_funcs.h"
+#include "mcb_funcs.h"
+#include "registers_m.h"
+
+#ifdef SHAREDMEMORY
+#include "sharedmemory.h"
+#endif
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+
+#include <stdlib.h>
+
+//for memory mapping
+u_int64_t CSP0BASE;
+
+FILE *debugfp, *datafp;
+
+int fr;
+int wait_time;
+int *fifocntrl;
+
+//int *statusreg; commented out by dhanya
+const int nModY=1;
+int nModBoard;
+int nModX=NMAXMOD;
+int dynamicRange=16;//32;
+int dataBytes=NMAXMOD*NCHIP*NCHAN*2;
+int storeInRAM=0;
+int ROI_flag=0;
+int adcConfigured=-1;
+u_int32_t *ram_values=NULL;
+volatile char *now_ptr=NULL;
+volatile  u_int16_t *values;
+int ram_size=0;
+
+int64_t totalTime=1;
+u_int32_t progressMask=0;
+
+int phase_shift=0;//DEFAULT_PHASE_SHIFT;
+int ipPacketSize=DEFAULT_IP_PACKETSIZE;
+int udpPacketSize=DEFAULT_UDP_PACKETSIZE;
+
+
+int ififostart, ififostop, ififostep, ififo;
+
+int masterMode=NO_MASTER, syncMode=NO_SYNCHRONIZATION, timingMode=AUTO_TIMING;
+
+enum externalSignalFlag  signals[4]={EXT_SIG_OFF, EXT_SIG_OFF, EXT_SIG_OFF, EXT_SIG_OFF};
+
+int withGotthard = 0;
+
+#ifdef MCB_FUNCS
+extern const int nChans;
+extern const int nChips;
+//extern const int nDacs;
+//extern const int nAdcs;
+#endif
+#ifndef MCB_FUNCS
+
+const int nChans=NCHAN;
+const int nChips=NCHIP;
+const int nDacs=NDAC;
+const int nAdcs=NADC;
+#endif
+
+
+
+
+/**
+   ENEt conf structs
+*/
+typedef struct mac_header_struct{
+  u_int8_t    mac_dest_mac2;
+  u_int8_t    mac_dest_mac1;
+  u_int8_t    mac_dummy1;
+  u_int8_t    mac_dummy2;
+  u_int8_t    mac_dest_mac6;
+  u_int8_t    mac_dest_mac5;
+  u_int8_t    mac_dest_mac4;
+  u_int8_t    mac_dest_mac3;
+  u_int8_t    mac_src_mac4;
+  u_int8_t    mac_src_mac3;
+  u_int8_t    mac_src_mac2;
+  u_int8_t    mac_src_mac1;
+  u_int16_t   mac_ether_type;
+  u_int8_t    mac_src_mac6;
+  u_int8_t    mac_src_mac5;
+} mac_header;
+
+typedef struct ip_header_struct {
+  u_int16_t     ip_len;
+  u_int8_t      ip_tos;
+  u_int8_t      ip_ihl:4 ,ip_ver:4;
+  u_int16_t     ip_offset:13,ip_flag:3;
+  u_int16_t     ip_ident;
+  u_int16_t     ip_chksum;
+  u_int8_t      ip_protocol;
+  u_int8_t      ip_ttl;
+  u_int32_t     ip_sourceip;
+  u_int32_t     ip_destip;
+} ip_header;
+
+typedef struct udp_header_struct{
+  u_int16_t   udp_destport;
+  u_int16_t   udp_srcport;
+  u_int16_t   udp_chksum;
+  u_int16_t   udp_len;
+} udp_header;
+
+typedef struct mac_conf_struct{
+  mac_header  mac;
+  ip_header   ip;
+  udp_header  udp;
+  u_int32_t   npack;
+  u_int32_t   lpack;
+  u_int32_t   npad;
+  u_int32_t   cdone;
+} mac_conf;
+
+typedef struct tse_conf_struct{
+  u_int32_t   rev;                    //0x0
+  u_int32_t   scratch;
+  u_int32_t   command_config;
+  u_int32_t   mac_0;                  //0x3
+  u_int32_t   mac_1;
+  u_int32_t   frm_length;
+  u_int32_t   pause_quant;
+  u_int32_t   rx_section_empty;       //0x7
+  u_int32_t   rx_section_full;
+  u_int32_t   tx_section_empty;
+  u_int32_t   tx_section_full;
+  u_int32_t   rx_almost_empty;        //0xB
+  u_int32_t   rx_almost_full;
+  u_int32_t   tx_almost_empty;
+  u_int32_t   tx_almost_full;
+  u_int32_t   mdio_addr0;             //0xF
+  u_int32_t   mdio_addr1;
+}tse_conf;
+
+
+
+int mapCSP0(void) {
+  printf("Mapping memory\n");
+#ifndef VIRTUAL
+  int fd;
+  fd = open("/dev/mem", O_RDWR | O_SYNC, 0);
+  if (fd == -1) {
+    printf("\nCan't find /dev/mem!\n");
+       return FAIL;
+  }
+  printf("/dev/mem opened\n");
+
+  CSP0BASE = (u_int32_t)mmap(0, MEM_SIZE, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, CSP0);
+  if (CSP0BASE == (u_int32_t)MAP_FAILED) {
+    printf("\nCan't map memmory area!!\n");
+    return FAIL;
+  }
+  printf("CSP0 mapped\n");
+
+#endif
+#ifdef VIRTUAL
+  CSP0BASE = malloc(MEM_SIZE);
+  printf("memory allocated\n");
+#endif
+#ifdef SHAREDMEMORY 
+  if ( (res=inism(SMSV))<0) {
+    printf("error attaching shared memory! %i",res);
+    return FAIL;
+  }
+#endif
+  printf("CSPObase is 0x%x \n",CSP0BASE);
+  printf("CSPOBASE=from %08x to %x\n",CSP0BASE,CSP0BASE+MEM_SIZE);
+
+  u_int32_t address;
+  address = FIFO_DATA_REG_OFF;
+  values=(u_int16_t*)(CSP0BASE+address*2);
+  printf("statusreg=%08x\n",bus_r(STATUS_REG));
+  printf("\n\n");
+  return OK;
+}
+
+u_int16_t bus_r16(u_int32_t offset){
+  volatile u_int16_t *ptr1;
+  ptr1=(u_int16_t*)(CSP0BASE+offset*2);
+  return *ptr1;
+}
+
+u_int16_t bus_w16(u_int32_t offset, u_int16_t data) {
+  volatile u_int16_t *ptr1;
+  ptr1=(u_int16_t*)(CSP0BASE+offset*2);
+  *ptr1=data;
+  return OK;
+}
+
+/** ramType is DARK_IMAGE_REG or GAIN_IMAGE_REG */
+u_int16_t ram_w16(u_int32_t ramType, int adc, int adcCh, int Ch, u_int16_t data) { 
+  unsigned int adr = (ramType | adc << 8 | adcCh << 5 | Ch );
+  // printf("Writing to addr:%x\n",adr);
+  return bus_w16(adr,data);
+}
+
+/** ramType is DARK_IMAGE_REG or GAIN_IMAGE_REG */
+u_int16_t ram_r16(u_int32_t ramType, int adc, int adcCh, int Ch){
+  unsigned int adr = (ramType | adc << 8 | adcCh << 5 | Ch );
+  //  printf("Reading from addr:%x\n",adr);
+  return bus_r16(adr);
+}
+
+u_int32_t bus_w(u_int32_t offset, u_int32_t data) {
+ volatile u_int32_t *ptr1;
+
+  ptr1=(u_int32_t*)(CSP0BASE+offset*2);
+  *ptr1=data;
+
+  return OK;
+}
+
+
+u_int32_t bus_r(u_int32_t offset) {
+  volatile u_int32_t *ptr1;
+
+  ptr1=(u_int32_t*)(CSP0BASE+offset*2);
+  return *ptr1;
+}
+
+
+int setPhaseShiftOnce(){
+	u_int32_t addr, reg;
+	int i;
+	addr=MULTI_PURPOSE_REG;
+	reg=bus_r(addr);
+#ifdef VERBOSE
+	printf("Multipurpose reg:%x\n",reg);
+#endif
+
+	//Checking if it is power on(negative number)
+	// if(((reg&0xFFFF0000)>>16)>0){
+	//bus_w(addr,0x0);   //clear the reg
+
+	if(reg==0){
+		printf("\nImplementing phase shift of %d\n",phase_shift);
+		for (i=1;i<phase_shift;i++) {
+			bus_w(addr,(INT_RSTN_BIT|ENET_RESETN_BIT|SW1_BIT|PHASE_STEP_BIT));//0x2821
+			bus_w(addr,(INT_RSTN_BIT|ENET_RESETN_BIT|(SW1_BIT&~PHASE_STEP_BIT)));//0x2820
+		}
+#ifdef VERBOSE
+		printf("Multipupose reg now:%x\n",bus_r(addr));
+#endif
+	}
+
+	return OK;
+}
+int phaseStep(int st){
+	u_int32_t addr;
+	int i;
+
+	addr=MULTI_PURPOSE_REG;
+
+	if (st>0) {  
+	  bus_w(PLL_CNTRL_REG, 1);//reset PLL
+	  bus_w(PLL_CNTRL_REG, 0);
+	  phase_shift=0;
+	  for (i=0;i<st;i++) {
+	    bus_w(addr,(INT_RSTN_BIT|ENET_RESETN_BIT|SW1_BIT|PHASE_STEP_BIT));//0x2821
+	    bus_w(addr,(INT_RSTN_BIT|ENET_RESETN_BIT|(SW1_BIT&~PHASE_STEP_BIT)));//0x2820
+	    phase_shift++;
+	  }
+	}
+		
+#ifdef VERBOSE
+	printf("Multipupose reg now:%x\n",bus_r(addr));
+#endif
+
+
+	return phase_shift;
+}
+
+
+
+int cleanFifo(){
+	u_int32_t addr, reg, val, adc_sync;
+	printf("Cleaning FIFO\n");
+	addr=ADC_SYNC_REG;
+
+	if(withGotthard)
+		adc_sync = GOTTHARD_ADCSYNC_VAL;
+	else
+		adc_sync = ADCSYNC_VAL;
+
+
+	reg = bus_r(addr) &	CLEAN_FIFO_MASK;
+
+	//only for start up
+	if(!reg) reg = adc_sync;
+
+	// 88 3 02111
+	if (ROI_flag==0) {
+	val=reg | ADCSYNC_CLEAN_FIFO_BITS | TOKEN_RESTART_DELAY;
+	bus_w(addr,val);
+	// 88 0 02111
+	val=reg | TOKEN_RESTART_DELAY;
+	bus_w(addr,val);
+	}
+	else {
+		//1b332214
+	  val=reg | ADCSYNC_CLEAN_FIFO_BITS | TOKEN_RESTART_DELAY_ROI;
+	  bus_w(addr,val);
+	  //1b032214
+	  val=reg | TOKEN_RESTART_DELAY_ROI;
+	  bus_w(addr,val);
+
+	}
+	reg=bus_r(addr);
+//#ifdef DDEBUG
+	printf("ADC SYNC reg 0x19:%x\n",reg);
+//#endif
+	return OK;
+}
+
+
+int setDAQRegister()
+{
+	u_int32_t addr, reg, val;
+	addr=DAQ_REG;
+
+	//depended on adcval
+	int packetlength=0x7f;
+	if(!ROI_flag) packetlength=0x13f;
+
+	//depended on pcb rev
+	int tokenTiming = TOKEN_TIMING_REV2;
+	if((bus_r(PCB_REV_REG)&BOARD_REVISION_MASK)==1)
+		tokenTiming= TOKEN_TIMING_REV1;
+
+
+	val = (packetlength<<16) + tokenTiming;
+	//val=34+(42<<8)+(packetlength<<16);
+
+	reg=bus_r(addr);
+	bus_w(addr,val);
+	reg=bus_r(addr);
+//#ifdef VERBOSE
+	printf("DAQ reg 0x15:%x\n",reg);
+//#endif
+
+	return OK;
+}
+
+
+// direct pattern output 
+u_int32_t putout(char *s, int modnum) {
+  int i;
+  u_int32_t pat;
+  int addr;
+
+  if (strlen(s)<16) {
+    fprintf(stdout," *** putout error: incorrect pattern length ***\n");
+    fprintf(stdout," %s \n",s);
+    return FAIL;
+  }
+
+  pat=0;
+  for (i=0;i<16;i++) {
+    if (s[i]=='1') pat=pat+(1<<(15-i));
+  }
+  //addr=DAC_REG+(modnum<<4);
+  addr=DAC_REG;//+(modnum<<SHIFTMOD); commented by dhanya
+  bus_w(addr, pat);
+
+  return OK;
+}
+
+
+// read direct input 
+u_int32_t readin(int modnum) {
+	return 0;
+}
+
+u_int32_t setPllReconfigReg(u_int32_t reg, u_int32_t val) {
+ 
+  bus_w(PLL_PARAM_REG,val); 
+  bus_w(PLL_CNTRL_REG,(reg<<PLL_CNTR_ADDR_OFF)); 
+  usleep(1000);
+  bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_WRITE_BIT)|(reg<<PLL_CNTR_ADDR_OFF));
+  usleep(1000);
+  bus_w(PLL_CNTRL_REG,(reg<<PLL_CNTR_ADDR_OFF)); 
+  usleep(1000);
+  bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_READ_BIT)|(reg<<PLL_CNTR_ADDR_OFF));
+  usleep(1000);
+  val=bus_r(PLL_PARAM_OUT_REG);
+  printf("counter %x reg: %x\n",reg,val); 
+  bus_w(PLL_CNTRL_REG,(reg<<PLL_CNTR_ADDR_OFF)); 
+
+  return val;
+
+}
+
+u_int32_t getPllReconfigReg(u_int32_t reg) {
+  
+  int i;
+  u_int32_t val;
+  bus_w(PLL_CNTRL_REG,(reg<<PLL_CNTR_ADDR_OFF)); 
+  usleep(1000);
+  bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_READ_BIT)|(reg<<PLL_CNTR_ADDR_OFF));
+  usleep(1000);
+  for (i=0; i<10; i++) {
+    val=bus_r(PLL_PARAM_OUT_REG);
+    printf("counter %x reg: %x\n",reg,val); 
+  }
+  bus_w(PLL_CNTRL_REG,(reg<<PLL_CNTR_ADDR_OFF)); 
+
+  return val;
+}
+
+
+u_int32_t setClockDivider(int d) {
+  
+
+  int nc;
+  if (d>1)  nc=d;//  nc=161/d;
+  else return -1;
+
+   if (nc>255) 
+     return -1; 
+
+  int addr, addr1, addr0;
+  u_int32_t pat,pat1,pat0;
+
+  addr= PLL_PARAM_REG;
+  addr0= PLL_PARAM_OUT_REG;
+  addr1=PLL_CNTRL_REG;
+  pat1=0x10;
+
+
+  //write high count c0
+/*   pat=(1<<12)|(7<<9)|nc; */
+/*   bus_w(addr, pat); */
+/*   bus_w(addr1, pat1); */
+/*   bus_w(addr1, 0); */
+/*   usleep (1000); */
+/*   pat=bus_r(addr0); */
+/*   bus_w(addr1, 0x4); */
+/*   bus_w(addr1, 0); */
+/*   pat=bus_r(addr0); */
+/*   printf("M nominal count read %x (%d)\n",pat,(pat&0x1ff)); */
+
+
+ 
+  //write low count c0
+  pat=(nc-1)|(4<<12)|(1<<9);
+  bus_w(addr, pat);
+  bus_w(addr1, pat1);
+  bus_w(addr1, 0);
+  pat0=bus_r(PLL_PARAM_OUT_REG);
+  usleep (1000);
+  printf("C0 low count status %x\n",pat0);
+
+  //write high count c0
+  pat=(nc)|(4<<12)|(0<<9);
+  bus_w(addr, pat);
+  bus_w(addr1, pat1);
+  bus_w(addr1, 0);
+  pat0=bus_r(PLL_PARAM_OUT_REG);
+  printf("C0 high count status %x\n",pat0);
+  usleep (1000);
+
+  //write low count c1
+  pat=(nc-1)|(5<<12)|(1<<9);
+  bus_w(addr, pat);
+  bus_w(addr1, pat1);
+  bus_w(addr1, 0);
+  pat0=bus_r(PLL_PARAM_OUT_REG);
+  printf("C1 high count status %x\n",pat0);
+  usleep (1000);
+
+  //write high count c1
+  pat=(nc)|(5<<12)|(0<<9);
+  bus_w(addr, pat);
+  bus_w(addr1, pat1);
+  bus_w(addr1, 0);
+  pat0=bus_r(PLL_PARAM_OUT_REG);
+  printf("C1 low count status %x\n",pat0);
+  usleep (1000);
+
+  //reconfigure pll
+  pat1=0x8;
+  bus_w(addr1, pat1);
+  bus_w(addr1, 0);
+  pat0=bus_r(PLL_PARAM_OUT_REG);
+  printf("configure  status %d\n",pat0);
+  sleep (1);
+  printf("finish  status %x\n",pat0);
+
+
+  bus_w(PLL_CNTRL_REG, 1); //reset PLL
+  bus_w(PLL_CNTRL_REG, 0);
+
+ return 0;
+}
+
+
+
+
+u_int32_t getClockDivider() {
+
+
+
+  int ic=0;
+
+  //reset pll_reconfig to initial values
+  bus_w(PLL_CNTRL_REG,(1<<PLL_CNTR_RECONFIG_RESET_BIT));
+  usleep(1000);
+
+
+  // bus_w(PLL_CNTRL_REG,0); 
+  setPllReconfigReg(PLL_MODE_REG,1);
+    getPllReconfigReg(PLL_MODE_REG);
+    getPllReconfigReg(PLL_N_COUNTER_REG);
+    getPllReconfigReg(PLL_M_COUNTER_REG);
+
+  return 0;
+
+}
+
+u_int32_t setSetLength(int d) {
+	 return 0;
+}
+
+u_int32_t getSetLength() {
+	 return 0;
+}
+
+u_int32_t setOversampling(int d) {
+
+  if (d>=0 && d<=255)
+    bus_w(OVERSAMPLING_REG, d);
+
+  return bus_r(OVERSAMPLING_REG);
+}
+
+
+u_int32_t setWaitStates(int d1) {
+	 return 0;
+}
+
+u_int32_t getWaitStates() {
+	 return 0;
+}
+
+
+u_int32_t setTotClockDivider(int d) {
+	 return 0;
+}
+
+u_int32_t getTotClockDivider() {
+	 return 0;
+}
+
+
+u_int32_t setTotDutyCycle(int d) {
+	 return 0;
+}
+
+u_int32_t getTotDutyCycle() {
+	 return 0;
+}
+
+
+u_int32_t setExtSignal(int d, enum externalSignalFlag  mode) {
+
+	//int modes[]={EXT_SIG_OFF, EXT_GATE_IN_ACTIVEHIGH, EXT_GATE_IN_ACTIVELOW,EXT_TRIG_IN_RISING,EXT_TRIG_IN_FALLING,EXT_RO_TRIG_IN_RISING, EXT_RO_TRIG_IN_FALLING,EXT_GATE_OUT_ACTIVEHIGH, EXT_GATE_OUT_ACTIVELOW, EXT_TRIG_OUT_RISING, EXT_TRIG_OUT_FALLING, EXT_RO_TRIG_OUT_RISING, EXT_RO_TRIG_OUT_FALLING};
+	// int off=d*SIGNAL_OFFSET;
+
+	u_int32_t c;
+	c=bus_r(EXT_SIGNAL_REG);
+
+	if (d>=0 && d<4) {
+		signals[d]=mode;
+#ifdef VERBOSE
+		printf("settings signal variable number %d to value %04x\n", d, signals[d]);
+#endif
+
+		// if output signal, set it!
+
+		switch (mode) {
+		case GATE_IN_ACTIVE_HIGH:
+		case GATE_IN_ACTIVE_LOW:
+			if (timingMode==GATE_FIX_NUMBER || timingMode==GATE_WITH_START_TRIGGER)
+				setFPGASignal(d,mode);
+			else
+				setFPGASignal(d,SIGNAL_OFF);
+			break;
+		case TRIGGER_IN_RISING_EDGE:
+		case TRIGGER_IN_FALLING_EDGE:
+			if (timingMode==TRIGGER_EXPOSURE || timingMode==GATE_WITH_START_TRIGGER)
+				setFPGASignal(d,mode);
+			else
+				setFPGASignal(d,SIGNAL_OFF);
+			break;
+		case RO_TRIGGER_IN_RISING_EDGE:
+		case RO_TRIGGER_IN_FALLING_EDGE:
+			if (timingMode==TRIGGER_READOUT)
+				setFPGASignal(d,mode);
+			else
+				setFPGASignal(d,SIGNAL_OFF);
+			break;
+		case MASTER_SLAVE_SYNCHRONIZATION:
+			setSynchronization(syncMode);
+			break;
+		default:
+			setFPGASignal(d,mode);
+			break;
+		}
+
+		setTiming(GET_EXTERNAL_COMMUNICATION_MODE);
+	}
+
+
+//  if (mode<=RO_TRIGGER_OUT_FALLING_EDGE && mode>=0)
+//    bus_w(EXT_SIGNAL_REG,((modes[mode])<<off)|(c&~(SIGNAL_MASK<<off)));
+
+
+  return getExtSignal(d);
+}
+
+
+
+u_int32_t setFPGASignal(int d, enum externalSignalFlag  mode) {
+
+
+  int modes[]={EXT_SIG_OFF, EXT_GATE_IN_ACTIVEHIGH, EXT_GATE_IN_ACTIVELOW,EXT_TRIG_IN_RISING,EXT_TRIG_IN_FALLING,EXT_RO_TRIG_IN_RISING, EXT_RO_TRIG_IN_FALLING,EXT_GATE_OUT_ACTIVEHIGH, EXT_GATE_OUT_ACTIVELOW, EXT_TRIG_OUT_RISING, EXT_TRIG_OUT_FALLING, EXT_RO_TRIG_OUT_RISING, EXT_RO_TRIG_OUT_FALLING};
+
+  u_int32_t c;
+  int off=d*SIGNAL_OFFSET;
+  c=bus_r(EXT_SIGNAL_REG);
+
+
+  if (mode<=RO_TRIGGER_OUT_FALLING_EDGE &&  mode>=0) {
+#ifdef VERBOSE
+    printf("writing signal register number %d mode %04x\n",d, modes[mode]);
+#endif
+    bus_w(EXT_SIGNAL_REG,((modes[mode])<<off)|(c&~(SIGNAL_MASK<<off)));
+  }
+  return getExtSignal(d);
+}
+
+
+
+int getExtSignal(int d) {
+
+/*  int modes[]={SIGNAL_OFF, GATE_IN_ACTIVE_HIGH, GATE_IN_ACTIVE_LOW,TRIGGER_IN_RISING_EDGE, TRIGGER_IN_FALLING_EDGE,RO_TRIGGER_IN_RISING_EDGE, RO_TRIGGER_IN_FALLING_EDGE, GATE_OUT_ACTIVE_HIGH,   GATE_OUT_ACTIVE_LOW, TRIGGER_OUT_RISING_EDGE, TRIGGER_OUT_FALLING_EDGE, RO_TRIGGER_OUT_RISING_EDGE,RO_TRIGGER_OUT_FALLING_EDGE};
+
+    int off=d*SIGNAL_OFFSET;
+    int mode=((bus_r(EXT_SIGNAL_REG)&(SIGNAL_MASK<<off))>>off);
+
+    if (mode<RO_TRIGGER_OUT_FALLING_EDGE)
+      return modes[mode];
+    else 
+      return -1;*/
+
+	if (d>=0 && d<4) {
+#ifdef VERBOSE
+		printf("gettings signal variable number %d  value %04x\n", d, signals[d]);
+#endif
+		return signals[d];
+	} else
+		return -1;
+
+
+}
+
+
+int getFPGASignal(int d) {
+
+  int modes[]={SIGNAL_OFF, GATE_IN_ACTIVE_HIGH, GATE_IN_ACTIVE_LOW,TRIGGER_IN_RISING_EDGE, TRIGGER_IN_FALLING_EDGE,RO_TRIGGER_IN_RISING_EDGE, RO_TRIGGER_IN_FALLING_EDGE, GATE_OUT_ACTIVE_HIGH,   GATE_OUT_ACTIVE_LOW, TRIGGER_OUT_RISING_EDGE, TRIGGER_OUT_FALLING_EDGE, RO_TRIGGER_OUT_RISING_EDGE,RO_TRIGGER_OUT_FALLING_EDGE};
+
+    int off=d*SIGNAL_OFFSET;
+    int mode=((bus_r(EXT_SIGNAL_REG)&(SIGNAL_MASK<<off))>>off);
+
+    if (mode<=RO_TRIGGER_OUT_FALLING_EDGE) {
+      if (modes[mode]!=SIGNAL_OFF && signals[d]!=MASTER_SLAVE_SYNCHRONIZATION)
+	signals[d]=modes[mode];
+#ifdef VERYVERBOSE
+      printf("gettings signal register number %d  value %04x\n", d, modes[mode]);
+#endif
+      return modes[mode];
+    } else
+      return -1;
+
+}
+
+
+
+
+
+/*
+enum externalCommunicationMode{
+  GET_EXTERNAL_COMMUNICATION_MODE,
+  AUTO,
+  TRIGGER_EXPOSURE_SERIES,
+  TRIGGER_EXPOSURE_BURST,
+  TRIGGER_READOUT,
+  TRIGGER_COINCIDENCE_WITH_INTERNAL_ENABLE,
+  GATE_FIX_NUMBER,
+  GATE_FIX_DURATION,
+  GATE_WITH_START_TRIGGER,
+  GATE_COINCIDENCE_WITH_INTERNAL_ENABLE
+};
+*/
+
+
+int setTiming(int ti) {
+
+
+  int ret=GET_EXTERNAL_COMMUNICATION_MODE;
+
+  int g=-1, t=-1, rot=-1;
+
+  int i;
+
+  switch (ti) {
+  case AUTO_TIMING:
+    timingMode=ti;
+    // disable all gates/triggers in except if used for master/slave synchronization
+    for (i=0; i<4; i++) {
+      if (getFPGASignal(i)>0 && getFPGASignal(i)<GATE_OUT_ACTIVE_HIGH && signals[i]!=MASTER_SLAVE_SYNCHRONIZATION)
+	setFPGASignal(i,SIGNAL_OFF);
+    }
+    break;
+
+  case   TRIGGER_EXPOSURE:
+    timingMode=ti;
+    // if one of the signals is configured to be trigger, set it and unset possible gates
+    for (i=0; i<4; i++) {
+      if (signals[i]==TRIGGER_IN_RISING_EDGE ||  signals[i]==TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,signals[i]);
+      else if (signals[i]==GATE_IN_ACTIVE_HIGH || signals[i]==GATE_IN_ACTIVE_LOW)
+	setFPGASignal(i,SIGNAL_OFF);
+      else if (signals[i]==RO_TRIGGER_IN_RISING_EDGE ||  signals[i]==RO_TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,SIGNAL_OFF);
+
+    }
+    break;
+
+
+
+  case  TRIGGER_READOUT:
+    timingMode=ti;
+    // if one of the signals is configured to be trigger, set it and unset possible gates
+    for (i=0; i<4; i++) {
+      if (signals[i]==RO_TRIGGER_IN_RISING_EDGE ||  signals[i]==RO_TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,signals[i]);
+      else if (signals[i]==GATE_IN_ACTIVE_HIGH || signals[i]==GATE_IN_ACTIVE_LOW)
+	setFPGASignal(i,SIGNAL_OFF);
+      else if (signals[i]==TRIGGER_IN_RISING_EDGE ||  signals[i]==TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,SIGNAL_OFF);
+    }
+    break;
+
+  case GATE_FIX_NUMBER:
+    timingMode=ti;
+    // if one of the signals is configured to be trigger, set it and unset possible gates
+    for (i=0; i<4; i++) {
+      if (signals[i]==RO_TRIGGER_IN_RISING_EDGE ||  signals[i]==RO_TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,SIGNAL_OFF);
+      else if (signals[i]==GATE_IN_ACTIVE_HIGH || signals[i]==GATE_IN_ACTIVE_LOW)
+	setFPGASignal(i,signals[i]);
+      else if (signals[i]==TRIGGER_IN_RISING_EDGE ||  signals[i]==TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,SIGNAL_OFF);
+    }
+    break;
+
+
+
+  case GATE_WITH_START_TRIGGER:
+    timingMode=ti;
+    for (i=0; i<4; i++) {
+      if (signals[i]==RO_TRIGGER_IN_RISING_EDGE ||  signals[i]==RO_TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,SIGNAL_OFF);
+      else if (signals[i]==GATE_IN_ACTIVE_HIGH || signals[i]==GATE_IN_ACTIVE_LOW)
+	setFPGASignal(i,signals[i]);
+      else if (signals[i]==TRIGGER_IN_RISING_EDGE ||  signals[i]==TRIGGER_IN_FALLING_EDGE)
+	setFPGASignal(i,signals[i]);
+    }
+    break;
+
+  default:
+	  break;
+
+  }
+
+
+
+  for (i=0; i<4; i++) {
+    if (signals[i]!=MASTER_SLAVE_SYNCHRONIZATION) {
+      if (getFPGASignal(i)==RO_TRIGGER_IN_RISING_EDGE ||  getFPGASignal(i)==RO_TRIGGER_IN_FALLING_EDGE)
+	rot=i;
+      else if (getFPGASignal(i)==GATE_IN_ACTIVE_HIGH || getFPGASignal(i)==GATE_IN_ACTIVE_LOW)
+	g=i;
+      else if (getFPGASignal(i)==TRIGGER_IN_RISING_EDGE ||  getFPGASignal(i)==TRIGGER_IN_FALLING_EDGE)
+	t=i;
+    }
+  }
+
+
+  if (g>=0 && t>=0 && rot<0) {
+    ret=GATE_WITH_START_TRIGGER;
+  } else if (g<0 && t>=0 && rot<0) {
+    ret=TRIGGER_EXPOSURE;
+  } else if (g>=0 && t<0 && rot<0) {
+    ret=GATE_FIX_NUMBER;
+  } else if (g<0 && t<0 && rot>0) {
+    ret=TRIGGER_READOUT;
+  } else if (g<0 && t<0 && rot<0) {
+    ret=AUTO_TIMING;
+  }
+
+  // timingMode=ret;
+
+  return ret;
+
+}
+
+
+
+int setConfigurationRegister(int d) {
+#ifdef VERBOSE
+  printf("Setting configuration register to %x",d);
+#endif
+  if (d>=0) {
+    bus_w(CONFIG_REG,d);
+  }
+#ifdef VERBOSE
+  printf("configuration register is %x", bus_r(CONFIG_REG));
+#endif
+  return bus_r(CONFIG_REG);
+}
+
+int setToT(int d) {
+ //int ret=0;
+ int reg;
+#ifdef VERBOSE
+  printf("Setting ToT to %d\n",d);
+#endif
+  reg=bus_r(CONFIG_REG);
+#ifdef VERBOSE
+  printf("Before: ToT is %x\n", reg);
+#endif
+  if (d>0) {
+    bus_w(CONFIG_REG,reg|TOT_ENABLE_BIT);
+  } else if (d==0) {
+    bus_w(CONFIG_REG,reg&(~TOT_ENABLE_BIT));
+  }
+  reg=bus_r(CONFIG_REG);
+#ifdef VERBOSE
+  printf("ToT is %x\n", reg);
+#endif
+  if (reg&TOT_ENABLE_BIT)
+    return 1;
+  else
+    return 0;
+}
+
+int setContinousReadOut(int d) {
+ //int ret=0;
+ int reg;
+#ifdef VERBOSE
+  printf("Setting Continous readout to %d\n",d);
+#endif
+  reg=bus_r(CONFIG_REG);
+#ifdef VERBOSE
+  printf("Before: Continous readout is %x\n", reg);
+#endif
+  if (d>0) {
+    bus_w(CONFIG_REG,reg|CONT_RO_ENABLE_BIT);
+  } else if (d==0) {
+    bus_w(CONFIG_REG,reg&(~CONT_RO_ENABLE_BIT));
+  }
+  reg=bus_r(CONFIG_REG);
+#ifdef VERBOSE
+  printf("Continous readout is %x\n", reg);
+#endif
+  if (reg&CONT_RO_ENABLE_BIT)
+    return 1;
+  else
+    return 0;
+}
+
+
+int startReceiver(int start) {
+	u_int32_t addr=CONFIG_REG;
+#ifdef VERBOSE
+	if(start)
+		printf("Setting up detector to send to Receiver\n");
+	else
+		printf("Setting up detector to send to CPU\n");
+#endif
+	int reg=bus_r(addr);
+	//for start recever, write 0 and for stop, write 1
+	if (!start)
+		bus_w(CONFIG_REG,reg|CPU_OR_RECEIVER_BIT);
+	else
+		bus_w(CONFIG_REG,reg&(~CPU_OR_RECEIVER_BIT));
+
+	reg=bus_r(addr);
+//#ifdef VERBOSE
+	printf("Config Reg %x\n", reg);
+//#endif
+	int d =reg&CPU_OR_RECEIVER_BIT;
+	if(d!=0) d=1;
+	if(d!=start)
+		return OK;
+	else
+		return FAIL;
+}
+
+
+u_int64_t  getDetectorNumber() {
+	char output[255],mac[255]="";
+	u_int64_t res=0;
+	FILE* sysFile = popen("ifconfig eth0 | grep HWaddr | cut -d \" \" -f 11", "r");
+	fgets(output, sizeof(output), sysFile);
+	pclose(sysFile);
+	//getting rid of ":"
+	char * pch;
+	pch = strtok (output,":");
+	while (pch != NULL){
+		strcat(mac,pch);
+		pch = strtok (NULL, ":");
+	}
+	sscanf(mac,"%llx",&res);
+	return res;
+}
+
+u_int32_t  getFirmwareVersion() {
+  return bus_r(FPGA_VERSION_REG);
+}
+
+u_int32_t  getFirmwareSVNVersion(){
+  return bus_r(FPGA_SVN_REG);
+}
+
+
+// for fpga test 
+u_int32_t testFpga(void) {
+	  printf("Testing FPGA:\n");
+  volatile u_int32_t val,addr,val2;
+  int result=OK,i;
+  //fixed pattern
+  val=bus_r(FIX_PATT_REG);
+  if (val==FIXED_PATT_VAL) {
+    printf("fixed pattern ok!! %08x\n",val);
+  } else {
+    printf("fixed pattern wrong!! %08x\n",val);
+    result=FAIL;
+  }
+
+  //dummy register
+  addr = DUMMY_REG;
+  for(i=0;i<1000000;i++)
+    {
+      val=0x5A5A5A5A-i;
+      bus_w(addr, val);
+      val=bus_r(addr);
+      if (val!=0x5A5A5A5A-i) {
+	printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of %x \n",i,val,0x5A5A5A5A-i);
+	result=FAIL;
+      }
+      val=(i+(i<<10)+(i<<20));
+      bus_w(addr, val);
+      val2=bus_r(addr);
+      if (val2!=val) {
+	printf("ATTEMPT:%d:\tFPGA dummy register wrong!! read %x instead of %x.\n",i,val2,val);
+	result=FAIL;
+      }
+      val=0x0F0F0F0F;
+      bus_w(addr, val);
+      val=bus_r(addr);
+      if (val!=0x0F0F0F0F) {
+	printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of 0x0F0F0F0F \n",i,val);
+	result=FAIL;
+      }
+      val=0xF0F0F0F0;
+      bus_w(addr, val);
+      val=bus_r(addr);
+      if (val!=0xF0F0F0F0)  {
+	printf("ATTEMPT:%d:\tFPGA dummy register wrong!! %x instead of 0xF0F0F0F0 \n\n",i,val);
+	result=FAIL;
+      }
+    }
+  if(result==OK)
+    {
+      printf("----------------------------------------------------------------------------------------------");
+      printf("\nATTEMPT 1000000: FPGA DUMMY REGISTER OK!!!\n");
+      printf("----------------------------------------------------------------------------------------------");
+    }
+  printf("\n");
+  return result;
+}
+
+
+// for fpga test 
+u_int32_t testRAM(void) {
+  int result=OK;
+  int i=0;
+  allocateRAM();
+  //  while(i<100000) {
+    memcpy(ram_values, values, dataBytes);
+    printf ("Testing RAM:\t%d: copied fifo %x to memory %x size %d\n",i++, (unsigned int)(values), (unsigned int)(ram_values), dataBytes);
+    // }
+  return result;
+}
+
+int getNModBoard() {
+  return nModX;
+}
+
+int setNMod(int n) {
+  return nModX;
+}
+
+
+// fifo test 
+int testFifos(void) {
+  printf("Fifo test not implemented!\n");
+  bus_w16(CONTROL_REG, START_FIFOTEST_BIT);
+  bus_w16(CONTROL_REG, 0x0);
+  return OK;
+}
+
+
+
+// program dacq settings 
+
+int64_t set64BitReg(int64_t value, int aLSB, int aMSB){
+  int64_t v64;
+  u_int32_t vLSB,vMSB;
+  if (value!=-1) {
+    vLSB=value&(0xffffffff);
+    bus_w(aLSB,vLSB);
+    v64=value>> 32;
+    vMSB=v64&(0xffffffff);
+    bus_w(aMSB,vMSB);
+  }
+  return get64BitReg(aLSB, aMSB);
+
+}
+
+int64_t get64BitReg(int aLSB, int aMSB){
+  int64_t v64;
+  u_int32_t vLSB,vMSB;
+  vLSB=bus_r(aLSB);
+  vMSB=bus_r(aMSB);
+  v64=vMSB;
+  v64=(v64<<32) | vLSB;
+
+  printf("reg64(%x,%x) %x %x %llx\n", aLSB, aMSB, vLSB, vMSB, v64);
+
+  return v64;
+}
+
+int64_t setFrames(int64_t value){
+  return set64BitReg(value,  SET_FRAMES_LSB_REG, SET_FRAMES_MSB_REG);
+}
+
+int64_t getFrames(){
+  printf("gf");
+  return get64BitReg(GET_FRAMES_LSB_REG, GET_FRAMES_MSB_REG);
+}
+
+int64_t setExposureTime(int64_t value){
+  /* time is in ns */
+  if (value!=-1)
+    value*=(1E-9*CLK_FREQ);
+    return set64BitReg(value,SET_EXPTIME_LSB_REG, SET_EXPTIME_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t getExposureTime(){
+  return get64BitReg(GET_EXPTIME_LSB_REG, GET_EXPTIME_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t setGates(int64_t value){
+  return set64BitReg(value, SET_GATES_LSB_REG, SET_GATES_MSB_REG);
+}
+
+int64_t getGates(){
+  return get64BitReg(GET_GATES_LSB_REG, GET_GATES_MSB_REG);
+}
+
+int64_t setPeriod(int64_t value){
+  /* time is in ns */
+  if (value!=-1) {
+    value*=(1E-9*CLK_FREQ);
+  }
+
+
+
+  return set64BitReg(value,SET_PERIOD_LSB_REG, SET_PERIOD_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t getPeriod(){
+  return get64BitReg(GET_PERIOD_LSB_REG, GET_PERIOD_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t setDelay(int64_t value){
+  /* time is in ns */
+  if (value!=-1) {
+    value*=(1E-9*CLK_FREQ);
+  }
+  return set64BitReg(value,SET_DELAY_LSB_REG, SET_DELAY_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t getDelay(){
+  return get64BitReg(GET_DELAY_LSB_REG, GET_DELAY_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t setTrains(int64_t value){
+  return set64BitReg(value,  SET_CYCLES_LSB_REG, SET_CYCLES_MSB_REG);
+}
+
+int64_t getTrains(){
+  return get64BitReg(GET_CYCLES_LSB_REG, GET_CYCLES_MSB_REG);
+}
+
+
+int64_t setProbes(int64_t value){
+  return 0;
+}
+
+
+int64_t setProgress() {
+
+  //????? eventually call after setting the registers
+
+return 0;
+
+}
+
+
+int64_t getProgress() {
+
+
+  //should be done in firmware!!!!
+
+	return 0;
+
+}
+
+int64_t getActualTime(){
+  return get64BitReg(GET_ACTUAL_TIME_LSB_REG, GET_ACTUAL_TIME_MSB_REG)/(1E-9*CLK_FREQ);
+}
+
+int64_t getMeasurementTime(){
+  int64_t v=get64BitReg(GET_MEASUREMENT_TIME_LSB_REG, GET_MEASUREMENT_TIME_MSB_REG);
+  int64_t mask=0x8000000000000000;
+  if (v & mask ) {
+#ifdef VERBOSE
+    printf("no measurement time left\n");
+#endif
+    return -1E+9;
+  } else
+    return v/(1E-9*CLK_FREQ);
+}
+
+
+
+
+int loadImage(int index, short int ImageVals[]){
+	u_int32_t address;
+	switch (index) {
+	case DARK_IMAGE :
+		address = DARK_IMAGE_REG;
+		break;
+	case GAIN_IMAGE :
+		address = GAIN_IMAGE_REG;
+		break;
+	}
+	volatile u_int16_t *ptr;
+	ptr=(u_int16_t*)(CSP0BASE+address*2);
+#ifdef VERBOSE
+	int i;
+	for(i=0;i<6;i++)
+		printf("%d:%d\t",i,ImageVals[i]);
+#endif
+	memcpy(ptr,ImageVals ,dataBytes);
+#ifdef VERBOSE
+	printf("\nLoaded x%08x address with image of index %d\n",(unsigned int)(ptr),index);
+#endif
+	return OK;
+}
+
+
+
+int64_t getProbes(){
+  return 0;
+}
+
+
+int setDACRegister(int idac, int val, int imod) {
+  u_int32_t addr, reg, mask;
+  int off;
+#ifdef VERBOSE
+  if(val==-1)
+    printf("Getting dac register%d module %d\n",idac,imod);
+  else
+    printf("Setting dac register %d module %d to %d\n",idac,imod,val);
+#endif
+
+  switch(idac){
+  case 0:
+  case 1:
+  case 2:
+    addr=MOD_DACS1_REG;
+    break;
+  case 3:
+  case 4:
+  case 5:
+    addr=MOD_DACS2_REG;
+    break;
+  case 6:
+  case 7:
+    addr=MOD_DACS3_REG;
+    break;
+  default:
+    printf("weird idac value %d\n",idac);
+    return -1;
+    break;
+  }
+  //saving only the msb
+  val=val>>2;
+
+  off=(idac%3)*10;
+  mask=~((0x3ff)<<off);
+
+  if (val>=0 && val<DAC_DR) {
+    reg=bus_r(addr+(imod<<SHIFTMOD));
+      reg&=mask;
+      reg|=(val<<off);
+      bus_w(addr+(imod<<SHIFTMOD),reg);
+  }
+  val=(bus_r(addr+(imod<<SHIFTMOD))>>off)&0x3ff;
+  //since we saved only the msb
+  val=val<<2;
+
+  //val=(bus_r(addr)>>off)&0x3ff;
+
+
+#ifdef VERBOSE
+  printf("Dac %d module %d register is %d\n\n",idac,imod,val);
+#endif
+   return val;
+}
+
+
+int getTemperature(int tempSensor, int imod){
+  int val;
+  imod=0;//ignoring more than 1 mod for now
+  int i,j,repeats=6;
+  u_int32_t tempVal=0;
+#ifdef VERBOSE
+  char cTempSensor[2][100]={"ADCs/ASICs","VRs/FPGAs"};
+  printf("Getting Temperature of module:%d for the %s for tempsensor:%d\n",imod,cTempSensor[tempSensor],tempSensor);
+#endif
+  bus_w(TEMP_IN_REG,(T1_CLK_BIT)|(T1_CS_BIT)|(T2_CLK_BIT)|(T2_CS_BIT));//standby
+  bus_w(TEMP_IN_REG,((T1_CLK_BIT)&~(T1_CS_BIT))|(T2_CLK_BIT));//high clk low cs
+
+  for(i=0;i<20;i++) {
+    //repeats is number of register writes for delay
+    for(j=0;j<repeats;j++)
+      bus_w(TEMP_IN_REG,~(T1_CLK_BIT)&~(T1_CS_BIT)&~(T2_CLK_BIT)&~(T2_CS_BIT));//low clk low cs
+    for(j=0;j<repeats;j++)
+      bus_w(TEMP_IN_REG,((T1_CLK_BIT)&~(T1_CS_BIT))|(T2_CLK_BIT));//high clk low cs
+
+    if(i<=10){//only the first time
+      if(!tempSensor)
+	tempVal= (tempVal<<1) + (bus_r(TEMP_OUT_REG) & (1));//adc
+      else
+	tempVal= (tempVal<<1) + ((bus_r(TEMP_OUT_REG) & (2))>>1);//fpga
+    }
+  }
+
+  bus_w(TEMP_IN_REG,(T1_CLK_BIT)|(T1_CS_BIT)|(T2_CLK_BIT)|(T2_CS_BIT));//standby
+  val=((int)tempVal)/4.0;
+
+#ifdef VERBOSE
+   printf("Temperature of module:%d for the %s is %.2fC\n",imod,cTempSensor[tempSensor],val);
+#endif
+ return val;
+}
+
+
+
+int initHighVoltage(int val, int imod){
+#ifdef VERBOSE
+  printf("Setting/Getting High Voltage of module:%d with val:%d\n",imod,val);
+#endif
+  volatile u_int32_t addr=HV_REG;
+  int writeVal,writeVal2;
+  switch(val){
+  case -1: break;
+  case 0:  writeVal=0x0; writeVal2=0x0; break;
+  case 90: writeVal=0x0; writeVal2=0x1; break;
+  case 110:writeVal=0x2; writeVal2=0x3; break;
+  case 120:writeVal=0x4; writeVal2=0x5; break;
+  case 150:writeVal=0x6; writeVal2=0x7; break;
+  case 180:writeVal=0x8; writeVal2=0x9; break;
+  case 200:writeVal=0xA; writeVal2=0xB; break;
+  default :printf("Invalid voltage\n");return -2;break;
+  }
+  //to set value
+  if(val!=-1){
+    //set value to converted value
+    bus_w(addr,writeVal);
+    bus_w(addr,writeVal2);
+#ifdef VERBOSE
+    printf("Value sent is %d and then %d\n",writeVal,writeVal2);
+#endif 
+  }
+ //read value and return the converted value
+  val=bus_r(addr);
+#ifdef VERBOSE
+    printf("Value read from reg is %d\n",val);
+#endif 
+  switch(val){
+  case 0x0:val=0;break;
+  case 0x1:val=90;break;
+  case 0x3:val=110;break;
+  case 0x5:val=120;break;
+  case 0x7:val=150;break;
+  case 0x9:val=180;break;
+  case 0xB:val=200;break;
+  default:printf("Weird value read:%d\n",val);return -3;break;
+  }
+#ifdef VERBOSE
+  printf("High voltage of module:%d is %d\n",imod,val);
+#endif  
+   return val;
+}
+
+
+
+int initConfGain(int isettings,int val,int imod){
+  int retval;
+  u_int32_t addr=GAIN_REG;
+
+  if(val!=-1){
+#ifdef VERBOSE
+    printf("Setting Gain of module:%d with val:%d\n",imod,val);
+#endif
+    bus_w(addr,((val<<GAIN_OFFSET)|(bus_r(addr)&~GAIN_MASK)));
+  }
+  retval=(bus_r(addr)&GAIN_MASK);
+#ifdef VERBOSE
+  printf("Value read from Gain reg is %d\n",retval);
+#endif 
+  if((val!=-1)&&(retval!=val))
+    return -1;
+
+  if(isettings!=-1){
+#ifdef VERBOSE
+    printf("Writing Settings of module:%d with val:%d\n",imod,isettings);
+#endif
+    bus_w(addr,((isettings<<SETTINGS_OFFSET)|(bus_r(addr)&~SETTINGS_MASK)));
+  }
+      retval=((bus_r(addr)&SETTINGS_MASK)>>SETTINGS_OFFSET);
+#ifdef VERBOSE
+    printf("Settings read from reg is %d\n",retval);
+#endif 
+    if((isettings!=-1)&&(retval!=isettings)){
+      printf("\n\nSettings r\n\n");
+    return -1;
+    }
+
+   return retval;
+}
+
+
+
+int setADC(int adc){
+	int reg,nchips,mask,nchans;
+
+	if(adc==-1)	ROI_flag=0;
+	else		ROI_flag=1;
+
+	setDAQRegister();//token timing
+	cleanFifo();//adc sync
+
+	//with gotthard module
+	if(withGotthard){
+		//set packet size
+		ipPacketSize= DEFAULT_IP_PACKETSIZE;
+		udpPacketSize=DEFAULT_UDP_PACKETSIZE;
+		//set channel mask
+		nchips = GOTTHARDNCHIP;
+		nchans = GOTTHARDNCHAN;
+		mask = ACTIVE_ADC_MASK;
+	}
+
+	//with moench module all adc
+	else{/* if(adc==-1){*/
+		//set packet size
+		ipPacketSize= DEFAULT_IP_PACKETSIZE;
+		udpPacketSize=DEFAULT_UDP_PACKETSIZE;
+		//set channel mask
+		nchips = NCHIP;
+		nchans = NCHANS;
+		mask = ACTIVE_ADC_MASK;
+	}/*
+	//with moench module 1 adc -- NOT IMPLEMENTED
+	else{
+		ipPacketSize= ADC1_IP_PACKETSIZE;
+		udpPacketSize=ADC1_UDP_PACKETSIZE;
+		//set channel mask
+		nchips = NCHIPS_PER_ADC;
+		nchans = GOTTHARDNCHAN;
+		mask = 1<<adc;
+	}*/
+
+	//set channel mask
+	reg = (nchans*nchips)<<CHANNEL_OFFSET;
+	reg&=CHANNEL_MASK;
+	reg|=(ACTIVE_ADC_MASK & mask);
+	bus_w(CHIP_OF_INTRST_REG,reg);
+
+//#ifdef DDEBUG
+	printf("Chip of Interest Reg:%x\n",bus_r(CHIP_OF_INTRST_REG));
+//#endif
+
+	adcConfigured = adc;
+
+	return adcConfigured;
+}
+
+
+
+int configureMAC(int ipad,long long int macad,long long int detectormacad, int detipad, int ival, int udpport){
+
+
+#ifdef DDEBUG
+	printf("Chip of Intrst Reg:%x\n",bus_r(CHIP_OF_INTRST_REG));
+	printf("IP Packet Size:%d\n",ipPacketSize);
+	printf("UDP Packet Size:%d\n",udpPacketSize);
+#endif
+
+	//configuring mac
+	u_int32_t addrr=MULTI_PURPOSE_REG;
+	u_int32_t offset=ENET_CONF_REG, offset2=TSE_CONF_REG;
+	mac_conf *mac_conf_regs;
+	tse_conf *tse_conf_regs;
+	long int sum = 0;
+	long int checksum;
+	int count,val;
+	unsigned short *addr;
+
+	mac_conf_regs=(mac_conf*)(CSP0BASE+offset*2);
+	tse_conf_regs=(tse_conf*)(CSP0BASE+offset2*2);
+
+#ifdef DDEBUG
+	printf("***Configuring MAC*** \n");
+#endif
+
+	if(ival)
+		bus_w(addrr,(RESET_BIT|DIGITAL_TEST_BIT)); //0x080,reset mac (reset)
+	else
+		bus_w(addrr,RESET_BIT); //0x080,reset mac (reset)
+	val=bus_r(addrr);
+#ifdef VERBOSE
+	printf("Value read from Multi-purpose Reg:%x\n",val);
+#endif 
+	//  if(val!=0x080) return -1;
+
+	usleep(500000);
+
+	if(ival)
+		bus_w(addrr,(ENET_RESETN_BIT|WRITE_BACK_BIT|DIGITAL_TEST_BIT)); //0x840,write shadow regs(enet reset,write bak)
+	else
+		bus_w(addrr,(ENET_RESETN_BIT|WRITE_BACK_BIT)); //0x840,write shadow regs(enet reset,write bak)
+	val=bus_r(addrr);
+#ifdef VERBOSE
+	printf("Value read from Multi-purpose Reg:%x\n",val);
+#endif 
+	//  if(val!=0x840) return -1;
+
+	if(ival)
+		bus_w(addrr,(ENET_RESETN_BIT|DIGITAL_TEST_BIT)); //0x800,nreset phy(enet reset)
+	else
+		bus_w(addrr,ENET_RESETN_BIT); //0x800,nreset phy(enet reset)
+	val=bus_r(addrr);
+#ifdef VERBOSE
+	printf("Value read from Multi-purpose Reg:%x\n",val);
+#endif 
+	//  if(val!=0x800) return -1;
+
+
+	mac_conf_regs->mac.mac_dest_mac1  =((macad>>(8*5))&0xFF);// 0x00; //pc7060
+	mac_conf_regs->mac.mac_dest_mac2  =((macad>>(8*4))&0xFF);// 0x19; //pc7060
+	mac_conf_regs->mac.mac_dest_mac3  =((macad>>(8*3))&0xFF);// 0x99; //pc7060
+	mac_conf_regs->mac.mac_dest_mac4  =((macad>>(8*2))&0xFF);// 0x24; //pc7060
+	mac_conf_regs->mac.mac_dest_mac5  =((macad>>(8*1))&0xFF);// 0xEB; //pc7060
+	mac_conf_regs->mac.mac_dest_mac6  =((macad>>(8*0))&0xFF);// 0xEE; //pc7060
+
+	/*
+  mac_conf_regs->mac.mac_src_mac1   = 0x00;     
+  mac_conf_regs->mac.mac_src_mac2   = 0xAA;     
+  mac_conf_regs->mac.mac_src_mac3   = 0xBB;     
+  mac_conf_regs->mac.mac_src_mac4   = 0xCC;     
+  mac_conf_regs->mac.mac_src_mac5   = 0xDD;     
+  mac_conf_regs->mac.mac_src_mac6   = 0xEE;     
+	 */
+	mac_conf_regs->mac.mac_src_mac1  =((detectormacad>>(8*5))&0xFF);
+	mac_conf_regs->mac.mac_src_mac2  =((detectormacad>>(8*4))&0xFF);
+	mac_conf_regs->mac.mac_src_mac3  =((detectormacad>>(8*3))&0xFF);
+	mac_conf_regs->mac.mac_src_mac4  =((detectormacad>>(8*2))&0xFF);
+	mac_conf_regs->mac.mac_src_mac5  =((detectormacad>>(8*1))&0xFF);
+	mac_conf_regs->mac.mac_src_mac6  =((detectormacad>>(8*0))&0xFF);
+	mac_conf_regs->mac.mac_ether_type   = 0x0800;   //ipv4
+
+
+
+	mac_conf_regs->ip.ip_ver            = 0x4;
+	mac_conf_regs->ip.ip_ihl            = 0x5;
+	mac_conf_regs->ip.ip_tos            = 0x0;
+	mac_conf_regs->ip.ip_len            = ipPacketSize;//0x0522;   // was 0x0526;
+	mac_conf_regs->ip.ip_ident          = 0x0000;
+	mac_conf_regs->ip.ip_flag           = 0x2;
+	mac_conf_regs->ip.ip_offset         = 0x00;
+	mac_conf_regs->ip.ip_ttl            = 0x70;
+	mac_conf_regs->ip.ip_protocol       = 0x11;
+	mac_conf_regs->ip.ip_chksum         = 0x0000 ; //6E42 now is automatically computed
+	mac_conf_regs->ip.ip_sourceip       = detipad; //0x8181CA2E;129.129.202.46
+	mac_conf_regs->ip.ip_destip         = ipad; //CA57
+
+	//#ifdef VERBOSE
+	printf("mac_dest:%llx %x:%x:%x:%x:%x:%x\n",
+			macad,
+			mac_conf_regs->mac.mac_dest_mac1,
+			mac_conf_regs->mac.mac_dest_mac2,
+			mac_conf_regs->mac.mac_dest_mac3,
+			mac_conf_regs->mac.mac_dest_mac4,
+			mac_conf_regs->mac.mac_dest_mac5,
+			mac_conf_regs->mac.mac_dest_mac6);
+	printf("mac_src:%llx %x:%x:%x:%x:%x:%x\n",
+			detectormacad,
+			mac_conf_regs->mac.mac_src_mac1,
+			mac_conf_regs->mac.mac_src_mac2,
+			mac_conf_regs->mac.mac_src_mac3,
+			mac_conf_regs->mac.mac_src_mac4,
+			mac_conf_regs->mac.mac_src_mac5,
+			mac_conf_regs->mac.mac_src_mac6);
+	printf("ip_ttl:%x\n",mac_conf_regs->ip.ip_ttl);
+	printf("det_ip: %x %x\n",detipad,	mac_conf_regs->ip.ip_sourceip);
+	printf("dest_ip: %x %x\n",ipad, mac_conf_regs->ip.ip_destip);
+
+	//#endif
+
+	//checksum
+	count=sizeof(mac_conf_regs->ip);
+	addr=&(mac_conf_regs->ip);
+	while( count > 1 )  {
+		sum += *addr++;
+		count -= 2;
+	}
+	if( count > 0 )  sum += *addr;                     // Add left-over byte, if any
+	while (sum>>16) sum = (sum & 0xffff) + (sum >> 16);// Fold 32-bit sum to 16 bits
+	checksum = (~sum)&0xffff;
+	mac_conf_regs->ip.ip_chksum   =  checksum;
+	//#ifdef VERBOSE
+	printf("IP header checksum is 0x%x s\n",(unsigned int)(checksum));
+	//#endif
+
+	mac_conf_regs->udp.udp_srcport      = 0xE185;
+	mac_conf_regs->udp.udp_destport     = udpport;//0xC351;
+	mac_conf_regs->udp.udp_len          = udpPacketSize;//0x050E;    //was  0x0512;
+	mac_conf_regs->udp.udp_chksum       = 0x0000;
+
+#ifdef VERBOSE
+	printf("Configuring TSE\n");
+#endif
+	tse_conf_regs->rev                 = 0xA00;
+	tse_conf_regs->scratch             = 0xCCCCCCCC;
+	tse_conf_regs->command_config      = 0xB;
+	tse_conf_regs->mac_0               = 0x17231C00;
+	tse_conf_regs->mac_1               = 0xCB4A;
+	tse_conf_regs->frm_length          = 0x5DC;      //max frame length (1500 bytes) (was 0x41C)
+	tse_conf_regs->pause_quant         = 0x0;
+	tse_conf_regs->rx_section_empty    = 0x7F0;
+	tse_conf_regs->rx_section_full     = 0x10;
+	tse_conf_regs->tx_section_empty    = 0x3F8;      //was 0x7F0;
+	tse_conf_regs->tx_section_full     = 0x16;
+	tse_conf_regs->rx_almost_empty     = 0x8;
+	tse_conf_regs->rx_almost_full      = 0x8;
+	tse_conf_regs->tx_almost_empty     = 0x8;
+	tse_conf_regs->tx_almost_full      = 0x3;
+	tse_conf_regs->mdio_addr0          = 0x12;
+	tse_conf_regs->mdio_addr1          = 0x0;
+
+	mac_conf_regs->cdone               = 0xFFFFFFFF;
+
+
+	if(ival)
+		bus_w(addrr,(INT_RSTN_BIT|ENET_RESETN_BIT|WRITE_BACK_BIT|DIGITAL_TEST_BIT)); //0x2840,write shadow regs..
+	else
+		bus_w(addrr,(INT_RSTN_BIT|ENET_RESETN_BIT|WRITE_BACK_BIT)); //0x2840,write shadow regs..
+
+	val=bus_r(addrr);
+#ifdef VERBOSE
+	printf("Value read from Multi-purpose Reg:%x\n",val);
+#endif 
+	//  if(val!=0x2840) return -1;
+
+	usleep(100000);
+
+	if(ival)
+		bus_w(addrr,(INT_RSTN_BIT|ENET_RESETN_BIT|SW1_BIT|DIGITAL_TEST_BIT)); //0x2820,write shadow regs..
+	else
+		bus_w(addrr,(INT_RSTN_BIT|ENET_RESETN_BIT|SW1_BIT)); //0x2820,write shadow regs..
+
+	val=bus_r(addrr);
+#ifdef VERBOSE
+	printf("Value read from Multi-purpose Reg:%x\n",val);
+#endif 
+	//  if(val!=0x2820) return -1;
+
+
+	
+
+	return adcConfigured;
+}
+
+
+int getAdcConfigured(){
+	return adcConfigured;
+}
+
+u_int32_t runBusy(void) {
+	u_int32_t s = bus_r(STATUS_REG) & 1;
+#ifdef VERBOSE
+	printf("status %04x\n",s);
+#endif
+  return s;
+}
+
+u_int32_t dataPresent(void) {
+  return bus_r(LOOK_AT_ME_REG);
+}
+
+u_int32_t runState(void) {
+  int s=bus_r(STATUS_REG);
+#ifdef SHAREDMEMORY
+  if (s&RUN_BUSY_BIT)
+    write_status_sm("Running");
+  else
+    write_status_sm("Stopped");
+#endif
+#ifdef VERBOSE
+  printf("status %04x\n",s);
+#endif
+
+/*  if (s==0x62001)
+    exit(-1);*/
+  return s;
+}
+
+
+// State Machine 
+
+int startStateMachine(){
+int i;
+//#ifdef VERBOSE
+  printf("*******Starting State Machine*******\n");
+//#endif
+	cleanFifo();
+  // fifoReset();
+  now_ptr=(char*)ram_values;
+#ifdef SHAREDMEMORY
+  write_stop_sm(0);
+  write_status_sm("Started");
+#endif
+
+
+  for(i=0;i<100;i++){
+	  //start state machine
+	  bus_w16(CONTROL_REG, START_ACQ_BIT |  START_EXPOSURE_BIT);
+	  bus_w16(CONTROL_REG, 0x0);
+	  //verify
+	  if(bus_r(STATUS_REG) & RUN_BUSY_BIT)
+		  break;
+	  else
+		  usleep(5000);
+  }
+   if(i!=0)
+	   printf("tried to start state machine %d times\n",i);
+   if(i==100){
+	   printf("\n***********COULD NOT START STATE MACHINE***************\n");
+	   return FAIL;
+   }
+
+   printf("statusreg=%08x\n",bus_r(STATUS_REG));
+  return OK;
+}
+
+
+
+
+int stopStateMachine(){
+	int i;
+//#ifdef VERBOSE
+  printf("*******Stopping State Machine*******\n");
+//#endif
+#ifdef SHAREDMEMORY
+  write_stop_sm(1);
+  write_status_sm("Stopped");
+#endif
+  for(i=0;i<100;i++){
+  	  //stop state machine
+	  bus_w16(CONTROL_REG, STOP_ACQ_BIT);
+	  bus_w16(CONTROL_REG, 0x0);
+	  usleep(5000);
+	  //verify
+	  if(!(bus_r(STATUS_REG)&RUNMACHINE_BUSY_BIT))
+		break;
+  }
+  if(i!=0)
+	  printf("tried to stop state machine %d times\n",i);
+  if(i==100){
+	  printf("\n***********COULD NOT STOP STATE MACHINE***************\n");
+	  return FAIL;
+  }
+
+/*
+ usleep(5000);
+ // if (!runBusy())
+  if(!(bus_r(STATUS_REG)&RUNMACHINE_BUSY_BIT))
+    return OK;
+  else
+    return FAIL;
+    */
+  printf("statusreg=%08x\n",bus_r(STATUS_REG));
+  return OK;
+}
+
+
+int startReadOut(){
+  u_int32_t status;
+#ifdef VERBOSE
+  printf("Starting State Machine Readout\n");
+#endif
+  status=bus_r(STATUS_REG)&RUN_BUSY_BIT;
+#ifdef DEBUG
+  printf("State machine status is %08x\n",bus_r(STATUS_REG));
+#endif
+  bus_w16(CONTROL_REG,  START_ACQ_BIT |START_READOUT_BIT);   //  start readout
+  bus_w16(CONTROL_REG,  0x0);
+  return OK;
+}
+
+
+// fifo routines 
+
+u_int32_t fifoReset(void) {
+	return -1;
+}
+
+
+u_int32_t setNBits(u_int32_t n) {
+	return -1;
+}
+
+u_int32_t getNBits(){
+	return -1;
+}
+
+
+u_int32_t fifoReadCounter(int fifonum){
+	return -1;
+}
+
+u_int32_t  fifoReadStatus()
+{
+  // reads from the global status register
+
+   return bus_r(STATUS_REG)&(SOME_FIFO_FULL_BIT | ALL_FIFO_EMPTY_BIT);
+}
+
+u_int32_t  fifo_full(void)
+{
+  // checks fifo empty flag returns 1 if fifo is empty
+  //   otherwise 0
+  return bus_r(STATUS_REG)&SOME_FIFO_FULL_BIT;
+}
+
+
+u_int32_t* fifo_read_event()
+{
+
+  int i=0;
+
+#ifdef VIRTUAL
+  return NULL;
+#endif
+
+#ifdef VERBOSE
+  printf("before looping\n");
+#endif
+  volatile u_int32_t t = bus_r(LOOK_AT_ME_REG);
+
+#ifdef VERBOSE
+  printf("lookatmereg=x%x\n",t);
+#endif
+/*
+   while ((t&0x1)==0)
+     {
+       t = bus_r(LOOK_AT_ME_REG);
+       if (!runBusy()){
+    	   return NULL;
+       }
+     }
+*/
+
+   while((t&0x1)==0) {
+#ifdef VERYVERBOSE
+       printf("before readout %08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
+#endif
+#ifdef VERYVERBOSE
+	   printf("look at me reg:%08x\n",bus_r(LOOK_AT_ME_REG));
+#endif
+	   if (runBusy()==0) {
+		   t = bus_r(LOOK_AT_ME_REG);
+#ifdef VERYVERBOSE
+		   printf("status should be idle!..look at me reg:%08x\n",bus_r(LOOK_AT_ME_REG));
+#endif
+		   if ((t&0x1)==0) {
+#ifdef VERBOSE
+			   printf("no frame found - exiting\n");
+			   printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
+#endif
+#ifdef VERYVERBOSE
+			   printf("returning null\n");
+#endif
+			   printf("lookatmereg=x%x\n",t);
+			   return NULL;
+		   } else {
+#ifdef VERBOSE
+			   printf("no frame found %x status %x\n", bus_r(LOOK_AT_ME_REG),runState());
+#endif
+			   break;
+		   }
+	   }
+	   t = bus_r(LOOK_AT_ME_REG);
+#ifdef VERYVERBOSE
+	   printf("before starting while loop again: look at me reg:%08x\n\n",bus_r(LOOK_AT_ME_REG));
+#endif
+	   if (i%1000==0)
+	     printf("%08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
+	   i++;
+   }
+#ifdef VERYVERBOSE
+   printf(" out of while loop!\n");
+#endif
+#ifdef VERYVERBOSE
+  printf("before readout %08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
+#endif
+
+  dma_memcpy(now_ptr,values ,dataBytes);
+
+
+#ifdef VERYVERBOSE
+  int a;
+  for (a=0;a<8; a=a+2)
+	  printf("\n%d %d: x%04x x%04x ",a+1,a,*(now_ptr+a+1),*(now_ptr+a) );
+  for (a=2554;a<2560; a=a+2)
+	  printf("\n%d %d: x%04x x%04x ",a+1,a,*(now_ptr+a+1),*(now_ptr+a) );
+  printf("********\n");
+  //memcpy(now_ptr, values, dataBytes);
+#endif
+#ifdef VERYVERBOSE
+  printf("Copying to ptr %08x %d\n",(unsigned int)(now_ptr), dataBytes);
+  printf("after readout %08x %08x\n", runState(), bus_r(LOOK_AT_ME_REG));
+#endif
+
+  if (storeInRAM>0) {
+    now_ptr+=dataBytes;
+  }
+  printf("lookatmereg=x%x\n",t);
+  return ram_values;
+}
+
+
+
+u_int32_t* decode_data(int *datain)
+{
+  u_int32_t *dataout;
+ // const char one=1;
+  const int bytesize=8;
+  char *ptr=(char*)datain;
+  //int nbits=dynamicRange;
+  int  ipos=0, ichan=0;;
+  //int nch, boff=0;
+  int ibyte;//, ibit;
+  char iptr;
+
+#ifdef VERBOSE
+  printf("Decoding data for DR %d\n",dynamicRange);
+#endif
+  dataout=malloc(nChans*nChips*nModX*4);
+  ichan=0;
+  switch (dynamicRange) {
+  case 1:
+    for (ibyte=0; ibyte<dataBytes; ibyte++) {
+      iptr=ptr[ibyte];
+      for (ipos=0; ipos<bytesize; ipos++) {
+	dataout[ichan]=(iptr>>(ipos))&0x1;
+	ichan++;
+      }
+    }
+    break;
+  case 4:
+    for (ibyte=0; ibyte<dataBytes; ibyte++) {
+      iptr=ptr[ibyte]&0xff;
+      for (ipos=0; ipos<2; ipos++) {
+	dataout[ichan]=(iptr>>(ipos*4))&0xf;
+	ichan++;
+      }
+    }
+    break;
+  case 8:
+    for (ichan=0; ichan<dataBytes; ichan++) {
+      dataout[ichan]=ptr[ichan]&0xff;
+    }
+    break;
+  case 16:
+    for (ichan=0; ichan<nChans*nChips*nModX; ichan++) {
+      dataout[ichan]=0;
+      for (ibyte=0; ibyte<2; ibyte++) {
+	iptr=ptr[ichan*2+ibyte];
+	dataout[ichan]|=((iptr<<(ibyte*bytesize))&(0xff<<(ibyte*bytesize)));
+      }
+    }
+    break;
+  default:
+    for (ichan=0; ichan<nChans*nChips*nModX; ichan++)
+      dataout[ichan]=datain[ichan]&0xffffff;
+    break;
+  }
+
+#ifdef VERBOSE
+  printf("decoded %d  channels\n",ichan);
+#endif
+  return dataout;
+}
+
+
+
+int setDynamicRange(int dr) {
+  return   getDynamicRange();
+}
+
+
+
+
+
+
+int getDynamicRange() {
+	dynamicRange=16;
+  return dynamicRange;
+
+}
+
+int testBus() {
+  u_int32_t j;
+  u_int64_t i, n, nt;
+ // char cmd[100];
+  u_int32_t val=0x0;
+  int ifail=OK;
+  // printf("%s\n",cmd);
+  // system(cmd);
+  i=0;
+
+  n=1000000;
+  nt=n/100;
+  printf("testing bus %d times\n",(int)n);
+  while (i<n) {
+    // val=bus_r(FIX_PATT_REG);
+    bus_w(DUMMY_REG,val);
+    bus_w(FIX_PATT_REG,0);
+    j=bus_r(DUMMY_REG);
+    //if (i%10000==1)
+    if (j!=val){
+      printf("%d :  read wrong value %08x instead of %08x\n",(int)i,j, val);
+      ifail++;
+      //return FAIL;
+    }// else
+     // printf("%d : value OK 0x%08x\n",i,j);
+    if ((i%nt)==0)
+      printf("%lld cycles OK\n",i);
+    val+=0xbbbbb;
+    i++;
+  }
+  return ifail;
+}
+
+
+int setStoreInRAM(int b) {
+  if (b>0)
+    storeInRAM=1;
+  else
+    storeInRAM=0;
+  return  allocateRAM();
+}
+
+
+int allocateRAM() {
+  size_t size;
+  u_int32_t nt, nf;
+  nt=setTrains(-1);
+  nf=setFrames(-1);
+  if (nt==0) nt=1;
+  if (nf==0) nf=1;
+  // ret=clearRAM();
+  if (storeInRAM) {
+    size=dataBytes*nf*nt;
+    if (size<dataBytes)
+      size=dataBytes;
+  }  else
+    size=dataBytes;
+
+#ifdef VERBOSE
+  printf("\nnmodx=%d nmody=%d dynamicRange=%d dataBytes=%d nFrames=%d nTrains=%d, size=%d\n",nModX,nModY,dynamicRange,dataBytes,nf,nt,(int)size );
+#endif
+
+    if (size==ram_size) {
+
+#ifdef VERBOSE
+      printf("RAM of size %d already allocated: nothing to be done\n",(int) size);
+#endif
+      return OK;
+    }
+
+
+
+#ifdef VERBOSE
+    printf("reallocating ram %x\n",(unsigned int)ram_values);
+#endif
+    //  clearRAM();
+    // ram_values=malloc(size);
+    //+2 was added since dma_memcpy would switch the 16 bit values and the mem is 32 bit
+    ram_values=realloc(ram_values,size)+2;
+
+  if (ram_values) {
+    now_ptr=(char*)ram_values;
+#ifdef VERBOSE
+    printf("ram allocated 0x%x of size %d to %x\n",(int)now_ptr,(unsigned int) size,(unsigned int)(now_ptr+size));
+#endif
+    ram_size=size;
+    return OK;
+  } else {
+    printf("could not allocate %d bytes\n",(int)size);
+    if (storeInRAM==1) {
+      printf("retrying\n");
+      storeInRAM=0;
+      size=dataBytes;
+      ram_values=realloc(ram_values,size)+2;
+      if (ram_values==NULL)
+	printf("Fatal error: there must be a memory leak somewhere! You can't allocate even one frame!\n");
+      else {
+	now_ptr=(char*)ram_values;
+	ram_size=size;
+#ifdef VERBOSE
+	printf("ram allocated 0x%x of size %d to %x\n",(int)now_ptr,(unsigned int) size,(unsigned int)(now_ptr+size));
+#endif
+      }
+    } else {
+      printf("Fatal error: there must be a memory leak somewhere! You can't allocate even one frame!\n");
+    }
+    return FAIL;
+  }
+
+
+
+}
+int prepareADC(){
+  printf("Preparing ADC\n");
+  u_int32_t valw,codata,csmask;              
+  int i,cdx,ddx;
+   cdx=0; ddx=1;
+   csmask=0x7c; //  1111100
+   
+    codata=0;           
+    codata=(0x14<<8)+(0x0);  //command and value;
+    valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // start point
+     valw=((0xffffffff&(~csmask)));bus_w(ADC_WRITE_REG,valw); //chip sel bar down
+    for (i=0;i<24;i++) {
+      valw=valw&(~(0x1<<cdx));bus_w(ADC_WRITE_REG,valw);usleep(0); //cldwn
+#ifdef VERBOSE
+      printf("DOWN 0x%x \n",valw);
+#endif
+      valw=(valw&(~(0x1<<ddx)))+(((codata>>(23-i))&0x1)<<ddx); bus_w(ADC_WRITE_REG,valw); usleep(0); //write data (i)
+#ifdef VERBOSE
+      printf("LOW 0x%x \n",valw);
+#endif
+      valw=valw+(0x1<<cdx);bus_w(ADC_WRITE_REG,valw); usleep(0); //clkup
+#ifdef VERBOSE
+      printf("up  0x%x \n",valw);
+#endif
+    } 
+
+ valw=valw&(~(0x1<<cdx));usleep(0);
+    valw=0xff; bus_w(ADC_WRITE_REG,(valw)); // stop point =start point */
+       return;
+}
+
+
+int clearRAM() {
+  if (ram_values) {
+    //#ifdef VERBOSE
+    //printf("clearing RAM 0x%x\n", ram_values);
+    //#endif
+    free(ram_values);
+    ram_values=NULL;
+    now_ptr=NULL;
+  }
+  //#ifdef VERBOSE
+  //printf("done 0x%x\n", ram_values);
+  //#endif
+  return OK;
+}
+
+
+
+
+int setMaster(int f) {
+
+	int i;
+	switch(f) {
+	case NO_MASTER:
+		// switch of gates or triggers
+		masterMode=NO_MASTER;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				setFPGASignal(i,SIGNAL_OFF);
+			}
+		}
+		break;
+	case IS_MASTER:
+		// configure gate or trigger out
+		masterMode=IS_MASTER;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				switch (syncMode) {
+				case NO_SYNCHRONIZATION:
+					setFPGASignal(i,SIGNAL_OFF);
+					break;
+				case MASTER_GATES:
+					setFPGASignal(i,GATE_OUT_ACTIVE_HIGH);
+					break;
+				case MASTER_TRIGGERS:
+					setFPGASignal(i,TRIGGER_OUT_RISING_EDGE);
+					break;
+				case SLAVE_STARTS_WHEN_MASTER_STOPS:
+					setFPGASignal(i,RO_TRIGGER_OUT_RISING_EDGE);
+					break;
+				default:
+					;
+				}
+			}
+		}
+		break;
+	case IS_SLAVE:
+		// configure gate or trigger in
+		masterMode=IS_SLAVE;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				switch (syncMode) {
+				case NO_SYNCHRONIZATION:
+					setFPGASignal(i,SIGNAL_OFF);
+					break;
+				case MASTER_GATES:
+					setFPGASignal(i,GATE_IN_ACTIVE_HIGH);
+					break;
+				case MASTER_TRIGGERS:
+					setFPGASignal(i,TRIGGER_IN_RISING_EDGE);
+					break;
+				case SLAVE_STARTS_WHEN_MASTER_STOPS:
+					setFPGASignal(i,TRIGGER_IN_RISING_EDGE);
+					break;
+				default:
+					;
+				}
+			}
+		}
+		break;
+	default:
+		//do nothing
+		break;
+	}
+
+	switch(masterMode) {
+	case NO_MASTER:
+		return NO_MASTER;
+
+
+	case IS_MASTER:
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				switch (syncMode) {
+				case NO_SYNCHRONIZATION:
+					return IS_MASTER;
+				case MASTER_GATES:
+					if (getFPGASignal(i)==GATE_OUT_ACTIVE_HIGH)
+						return IS_MASTER;
+					else
+						return NO_MASTER;
+				case MASTER_TRIGGERS:
+					if (getFPGASignal(i)==TRIGGER_OUT_RISING_EDGE)
+						return IS_MASTER;
+					else
+						return NO_MASTER;
+				case SLAVE_STARTS_WHEN_MASTER_STOPS:
+					if (getFPGASignal(i)==RO_TRIGGER_OUT_RISING_EDGE)
+						return IS_MASTER;
+					else
+						return NO_MASTER;
+				default:
+					return NO_MASTER;
+				}
+
+			}
+		}
+		break;
+
+	case IS_SLAVE:
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				switch (syncMode) {
+				case NO_SYNCHRONIZATION:
+					return IS_SLAVE;
+				case MASTER_GATES:
+					if (getFPGASignal(i)==GATE_IN_ACTIVE_HIGH)
+						return IS_SLAVE;
+					else
+						return NO_MASTER;
+				case MASTER_TRIGGERS:
+				case SLAVE_STARTS_WHEN_MASTER_STOPS:
+					if (getFPGASignal(i)==TRIGGER_IN_RISING_EDGE)
+						return IS_SLAVE;
+					else
+						return NO_MASTER;
+				default:
+					return NO_MASTER;
+				}
+			}
+		}
+		break;
+	}
+	return masterMode;
+}
+
+
+
+int setSynchronization(int s) {
+
+	int i;
+
+	switch(s) {
+	case NO_SYNCHRONIZATION:
+		syncMode=NO_SYNCHRONIZATION;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				setFPGASignal(i,SIGNAL_OFF);
+			}
+		}
+		break;
+		// disable external signals?
+	case MASTER_GATES:
+		// configure gate in or out
+		syncMode=MASTER_GATES;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER)
+					setFPGASignal(i,GATE_OUT_ACTIVE_HIGH);
+				else if (masterMode==IS_SLAVE)
+					setFPGASignal(i,GATE_IN_ACTIVE_HIGH);
+			}
+		}
+
+		break;
+	case MASTER_TRIGGERS:
+		// configure trigger in or out
+		syncMode=MASTER_TRIGGERS;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER)
+					setFPGASignal(i,TRIGGER_OUT_RISING_EDGE);
+				else if (masterMode==IS_SLAVE)
+					setFPGASignal(i,TRIGGER_IN_RISING_EDGE);
+			}
+		}
+		break;
+
+
+	case SLAVE_STARTS_WHEN_MASTER_STOPS:
+		// configure trigger in or out
+		syncMode=SLAVE_STARTS_WHEN_MASTER_STOPS;
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER)
+					setFPGASignal(i,RO_TRIGGER_OUT_RISING_EDGE);
+				else if (masterMode==IS_SLAVE)
+					setFPGASignal(i,TRIGGER_IN_RISING_EDGE);
+			}
+		}
+		break;
+
+
+	default:
+		//do nothing
+		break;
+	}
+
+	switch (syncMode) {
+
+	case NO_SYNCHRONIZATION:
+		return NO_SYNCHRONIZATION;
+
+	case MASTER_GATES:
+
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER && getFPGASignal(i)==GATE_OUT_ACTIVE_HIGH)
+					return MASTER_GATES;
+				else if (masterMode==IS_SLAVE && getFPGASignal(i)==GATE_IN_ACTIVE_HIGH)
+					return MASTER_GATES;
+			}
+		}
+		return NO_SYNCHRONIZATION;
+
+	case MASTER_TRIGGERS:
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER && getFPGASignal(i)==TRIGGER_OUT_RISING_EDGE)
+					return MASTER_TRIGGERS;
+				else if (masterMode==IS_SLAVE && getFPGASignal(i)==TRIGGER_IN_RISING_EDGE)
+					return MASTER_TRIGGERS;
+			}
+		}
+		return NO_SYNCHRONIZATION;
+
+	case SLAVE_STARTS_WHEN_MASTER_STOPS:
+		for (i=0; i<4; i++) {
+			if (signals[i]==MASTER_SLAVE_SYNCHRONIZATION) {
+				if (masterMode==IS_MASTER &&	getFPGASignal(i)==RO_TRIGGER_OUT_RISING_EDGE)
+					return SLAVE_STARTS_WHEN_MASTER_STOPS;
+				else if (masterMode==IS_SLAVE && getFPGASignal(i)==TRIGGER_IN_RISING_EDGE)
+					return SLAVE_STARTS_WHEN_MASTER_STOPS;
+			}
+		}
+		return NO_SYNCHRONIZATION;
+
+	default:
+		return NO_SYNCHRONIZATION;
+
+	}
+	return NO_SYNCHRONIZATION;
+
+}
+
+
+
+int readCounterBlock(int startACQ, short int CounterVals[]){
+
+	//char *counterVals=NULL;
+	//counterVals=realloc(counterVals,dataBytes);
+
+	u_int32_t val;
+	volatile u_int16_t *ptr;
+
+	u_int32_t address = COUNTER_MEMORY_REG;
+	ptr=(u_int16_t*)(CSP0BASE+address*2);
+
+
+	if (runBusy()) {
+		if(stopStateMachine()==FAIL)
+			return FAIL;
+		//waiting for the last frame read to be done
+		while(runBusy())  usleep(500);
+#ifdef VERBOSE
+		printf("State machine stopped\n");
+#endif
+	}
+
+		val=bus_r(MULTI_PURPOSE_REG);
+#ifdef VERBOSE
+		printf("Value of multipurpose reg:%d\n",bus_r(MULTI_PURPOSE_REG));
+#endif
+
+		memcpy(CounterVals,ptr,dataBytes);
+#ifdef VERBOSE
+		int i;
+		printf("Copied counter memory block with size of %d bytes..\n",dataBytes);
+		for(i=0;i<6;i++)
+			printf("%d: %d\t",i,CounterVals[i]);
+#endif
+
+
+		bus_w(MULTI_PURPOSE_REG,(val&~RESET_COUNTER_BIT));
+#ifdef VERBOSE
+		printf("\nClearing bit 2 of multipurpose reg:%d\n",bus_r(MULTI_PURPOSE_REG));
+#endif
+
+		if(startACQ==1){
+			startStateMachine();
+			if(runBusy())
+				printf("State machine RUNNING\n");
+			else
+				printf("State machine IDLE\n");
+		}
+
+/*		if(sizeof(CounterVals)<=0){
+			printf("ERROR:size of counterVals=%d\n",(int)sizeof(CounterVals));
+			return FAIL;
+		}*/
+
+
+	return OK;
+}
+
+
+
+
+int resetCounterBlock(int startACQ){
+
+	char *counterVals=NULL;
+	counterVals=realloc(counterVals,dataBytes);
+
+	int ret = OK;
+	u_int32_t val;
+	volatile u_int16_t *ptr;
+
+
+	u_int32_t address = COUNTER_MEMORY_REG;
+	ptr=(u_int16_t*)(CSP0BASE+address*2);
+
+
+	if (runBusy()) {
+		if(stopStateMachine()==FAIL)
+			return FAIL;
+		//waiting for the last frame read to be done
+		while(runBusy())  usleep(500);
+#ifdef VERBOSE
+		printf("State machine stopped\n");
+#endif
+	}
+
+		val=bus_r(MULTI_PURPOSE_REG);
+#ifdef VERBOSE
+		printf("Value of multipurpose reg:%d\n",bus_r(MULTI_PURPOSE_REG));
+#endif
+
+
+		bus_w(MULTI_PURPOSE_REG,(val|RESET_COUNTER_BIT));
+#ifdef VERBOSE
+		printf("Setting bit 2 of multipurpose reg:%d\n",bus_r(MULTI_PURPOSE_REG));
+#endif
+
+
+		memcpy(counterVals,ptr,dataBytes);
+#ifdef VERBOSE
+		int i;
+		printf("Copied counter memory block with size of %d bytes..\n",(int)sizeof(counterVals));
+		for(i=0;i<6;i=i+2)
+			printf("%d: %d\t",i,*(counterVals+i));
+#endif
+
+
+		bus_w(MULTI_PURPOSE_REG,(val&~RESET_COUNTER_BIT));
+#ifdef VERBOSE
+		printf("\nClearing bit 2 of multipurpose reg:%d\n",bus_r(MULTI_PURPOSE_REG));
+#endif
+
+		if(startACQ==1){
+			startStateMachine();
+			if(runBusy())
+				printf("State machine RUNNING\n");
+			else
+				printf("State machine IDLE\n");
+		}
+
+		if(sizeof(counterVals)<=0){
+			printf("ERROR:size of counterVals=%d\n",(int)sizeof(counterVals));
+			ret = FAIL;
+		}
+
+		return ret;
+
+	}
+
+
+
+int calibratePedestal(int frames){
+  printf("---------------------------\n");
+  printf("In Calibrate Pedestal\n");
+  int64_t framesBefore = getFrames();
+  int64_t periodBefore = getPeriod();
+  setFrames(frames);
+  setPeriod(1000000);
+  int dataret = OK;
+
+  double avg[1280];
+  int numberFrames = 0;
+
+  int adc = 3;
+  int adcCh = 3;
+  int Ch = 3;
+ 
+
+  int i = 0;
+  for(i =0; i < 1280; i++){
+    
+    avg[i] = 0.0;
+  }
+
+  startReceiver(0);
+	
+  startStateMachine();
+
+  while(dataret==OK){
+    //got data
+    if (fifo_read_event()) {
+      dataret=OK;
+      //sendDataOnly(file_des,&dataret,sizeof(dataret));
+      //sendDataOnly(file_des,dataretval,dataBytes);
+      printf("received frame\n");
+	
+      unsigned short *frame = (unsigned short *)now_ptr;
+
+      int a;
+      for (a=0;a<1280; a++){
+	unsigned short v = (frame[a] << 8) + (frame[a] >> 8);
+	//	  printf("%i: %i %i\n",a, frame[a],v);
+	avg[a] += ((double)frame[a])/(double)frames;
+	//if(frame[a] == 8191)
+	//  printf("ch %i: %u\n",a,frame[a]);
+      }
+      //      printf("********\n");
+      numberFrames++;
+    }  
+
+    //no more data or no data
+    else {
+      if(getFrames()>-2) {
+	dataret=FAIL;
+	printf("no data and run stopped: %d frames left\n",(int)(getFrames()+2));
+	     
+      } else {
+	dataret=FINISHED;
+	printf("acquisition successfully finished\n");
+
+      }
+      printf("dataret %d\n",dataret);
+    }
+  }
+
+  
+
+  double nf = (double)numberFrames;
+  for(i =0; i < 1280; i++){
+    adc = i / 256;
+    adcCh = (i - adc * 256) / 32;
+    Ch = i - adc * 256 - adcCh * 32;
+    adc--;
+    double v2 = avg[i];
+    avg[i] = avg[i]/ ((double)numberFrames/(double)frames);
+    unsigned short v = (unsigned short)avg[i];
+    printf("setting avg for channel %i(%i,%i,%i): %i (double= %f (%f))\t", i,adc,adcCh,Ch, v,avg[i],v2);
+    v=i*100;
+    ram_w16(DARK_IMAGE_REG,adc,adcCh,Ch,v-4096);
+    if(ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch) !=  v-4096){
+        printf("value is wrong (%i,%i,%i): %i \n",adc,adcCh,Ch,  ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch));
+    }
+  }
+
+      /*for(adc = 1; adc < 5; adc++){
+    for(adcCh = 0; adcCh < 8; adcCh++){
+      for(Ch=0 ; Ch < 32; Ch++){
+	int channel = (adc+1) * 32 * 8  + adcCh * 32 + Ch;
+	double v2 = avg[channel];
+	avg[channel] = avg[channel]/ ((double)numberFrames/(double)frames);
+	unsigned short v = (unsigned short)avg[channel];
+	printf("setting avg for channel %i: %i (double= %f (%f))\t", channel, v,avg[channel],v2);
+	ram_w16(DARK_IMAGE_REG,adc,adcCh,Ch,v-4096);
+	if(ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch) !=  v-4096){
+	  printf("value is wrong (%i,%i,%i): %i \n",adc,adcCh,Ch,  ram_r16(DARK_IMAGE_REG,adc,adcCh,Ch));
+	}
+      }
+    }
+    }*/
+
+
+
+  printf("frames: %i\n",numberFrames);	
+  printf("corrected avg by: %f\n",(double)numberFrames/(double)frames);
+  
+  printf("restoring previous condition\n");
+  setFrames(framesBefore);
+  setPeriod(periodBefore); 
+  
+  printf("---------------------------\n");
+  return 0;
+}
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.h
new file mode 100755
index 000000000..48918e428
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/firmware_funcs.h
@@ -0,0 +1,179 @@
+#ifndef FIRMWARE_FUNCS_H
+#define FIRMWARE_FUNCS_H
+
+
+#include "sls_detector_defs.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <unistd.h>
+//#include <asm/page.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+
+int mapCSP0(void);
+
+u_int16_t bus_r16(u_int32_t offset);
+u_int16_t bus_w16(u_int32_t offset, u_int16_t data);//aldos function
+u_int32_t bus_w(u_int32_t offset, u_int32_t data);
+u_int32_t bus_r(u_int32_t offset);
+
+int setPhaseShiftOnce();
+int phaseStep(int st);
+int cleanFifo();
+int setDAQRegister();
+
+u_int32_t putout(char *s, int modnum);
+u_int32_t readin(int modnum);
+u_int32_t setClockDivider(int d);
+u_int32_t getClockDivider();
+u_int32_t setSetLength(int d);
+u_int32_t getSetLength();
+u_int32_t setWaitStates(int d);
+u_int32_t getWaitStates();
+u_int32_t setTotClockDivider(int d);
+u_int32_t getTotClockDivider();
+u_int32_t setTotDutyCycle(int d);
+u_int32_t getTotDutyCycle();
+u_int32_t setOversampling(int d);
+
+u_int32_t setExtSignal(int d, enum externalSignalFlag  mode);
+int  getExtSignal(int d);
+
+u_int32_t setFPGASignal(int d, enum externalSignalFlag  mode);
+int  getFPGASignal(int d);
+
+int setTiming(int t);
+
+
+int setConfigurationRegister(int d);
+int setToT(int d);
+int setContinousReadOut(int d);
+int startReceiver(int d);
+
+int setDACRegister(int idac, int val, int imod);
+
+int getTemperature(int tempSensor,int imod);
+int initHighVoltage(int val,int imod);
+int initConfGain(int isettings,int val,int imod);
+
+int setADC(int adc);
+int configureMAC(int ipad, long long int macad, long long int detectormacadd, int detipad, int ival, int udpport);
+int getAdcConfigured();
+
+
+u_int64_t getDetectorNumber();
+u_int32_t getFirmwareVersion();
+int testFifos(void);
+u_int32_t testFpga(void);
+u_int32_t testRAM(void);
+int testBus(void);
+int setDigitalTestBit(int ival);
+
+int64_t set64BitReg(int64_t value, int aLSB, int aMSB);
+int64_t get64BitReg(int aLSB, int aMSB);
+
+int64_t setFrames(int64_t value);
+int64_t getFrames();
+
+int64_t setExposureTime(int64_t value);
+int64_t getExposureTime();
+
+int64_t setGates(int64_t value);
+int64_t getGates();
+
+int64_t setDelay(int64_t value);
+int64_t getDelay();
+
+int64_t setPeriod(int64_t value);
+int64_t getPeriod();
+
+int64_t setTrains(int64_t value);
+int64_t getTrains();
+
+int64_t setProbes(int64_t value);
+int64_t getProbes();
+
+int64_t getProgress();
+int64_t setProgress();
+
+int64_t getActualTime();
+int64_t getMeasurementTime();
+
+
+u_int32_t runBusy(void); 
+u_int32_t runState(void); 
+u_int32_t dataPresent(void); 
+
+
+int startStateMachine();
+int stopStateMachine();
+int startReadOut();
+u_int32_t fifoReset(void);
+u_int32_t fifoReadCounter(int fifonum);
+u_int32_t fifoReadStatus();
+
+
+u_int32_t fifo_full(void);
+
+
+
+u_int32_t* fifo_read_event();
+u_int32_t* decode_data(int* datain);
+//u_int32_t move_data(u_int64_t* datain, u_int64_t* dataout);
+int setDynamicRange(int dr);
+int getDynamicRange();
+int getNModBoard();
+int setNMod(int n);
+int setStoreInRAM(int b);
+int allocateRAM();
+int clearRAM();
+
+
+int setMaster(int f);
+int setSynchronization(int s);
+
+int loadImage(int index, short int ImageVals[]);
+int readCounterBlock(int startACQ, short int CounterVals[]);
+int resetCounterBlock(int startACQ);
+
+int calibratePedestal(int frames);
+
+
+
+/*
+
+u_int32_t setNBits(u_int32_t);
+u_int32_t getNBits();
+*/
+
+/*
+//move to mcb_funcs?
+
+int readOutChan(int *val);
+u_int32_t getModuleNumber(int modnum);
+int testShiftIn(int imod);
+int testShiftOut(int imod);
+int testShiftStSel(int imod);
+int testDataInOut(int num, int imod);
+int testExtPulse(int imod);
+int testExtPulseMux(int imod, int ow);
+int testDataInOutMux(int imod, int ow, int num);
+int testOutMux(int imod);
+int testFpgaMux(int imod);
+int calibration_sensor(int num, int *values, int *dacs) ;
+int calibration_chip(int num, int *values, int *dacs);
+*/
+
+
+#endif
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/gitInfo.txt b/slsDetectorSoftware/jungfrauDetectorServer/gitInfo.txt
new file mode 100644
index 000000000..921890a70
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/gitInfo.txt
@@ -0,0 +1,9 @@
+Path: slsDetectorsPackage/slsDetectorSoftware/moenchDetectorServer 
+URL: origin git@gitorious.psi.ch:sls_det_software/sls_detector_software.git/moenchDetectorServer 
+Repository Root: origin git@gitorious.psi.ch:sls_det_software/sls_detector_software.git 
+Repsitory UUID: 046a469b1e6582c4c55bd6eaeb4818b618d0a9a9 
+Revision: 55 
+Branch: separate_receiver 
+Last Changed Author: Maliakal_Dhanya 
+Last Changed Rev: 14 
+Last Changed Date: 2014-06-03 12:26:45 +0200
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoench.h b/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoench.h
new file mode 100644
index 000000000..270653967
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoench.h
@@ -0,0 +1,11 @@
+//#define SVNPATH ""
+#define SVNURL "git@gitorious.psi.ch:sls_det_software/sls_detector_software.git/moenchDetectorServer"
+//#define SVNREPPATH ""
+#define SVNREPUUID "046a469b1e6582c4c55bd6eaeb4818b618d0a9a9"
+//#define SVNREV 0x14
+//#define SVNKIND ""
+//#define SVNSCHED ""
+#define SVNAUTH "Maliakal_Dhanya"
+#define SVNREV 0x14
+#define SVNDATE 0x20140603
+//
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoenchTmp.h b/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoenchTmp.h
new file mode 100644
index 000000000..58e48f497
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/gitInfoMoenchTmp.h
@@ -0,0 +1,11 @@
+//#define SVNPATH ""
+#define SVNURL ""
+//#define SVNREPPATH ""
+#define SVNREPUUID ""
+//#define SVNREV ""
+//#define SVNKIND ""
+//#define SVNSCHED ""
+#define SVNAUTH ""
+#define SVNREV ""
+#define SVNDATE ""
+//
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer b/slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer
new file mode 100755
index 0000000000000000000000000000000000000000..3e613e2463a7e32661fa92dbc0d1ead3f4a181db
GIT binary patch
literal 132672
zcmd3P3w#ts)^AS|NKcqRCp;VoNC!{@q7D&tU~!oQR}mL8U_^Ya!(#<q)+NenKpvAQ
zis+{^fC`E_gZpq@{C0x4rZeu{0a-+0*FoL8etY@WX&WO7>VU5a0(1YTs(ZS7^3dJA
z-|u(x`*o(P>eQ)Ir%qL!I(4dg?xjDh7X+aQ&n1FmSx|5!#tV+OLxLa)>|H3k2WgJ_
z%J3`r?eed9;UrZMF2?hHJd^QUTI~q=J!k%`II!&xcePAWrDcV9K95aNN8oM5vh!Pf
zs>dPF^ZuE?`li<v>KA|PgU7u|I8-PIuCdY&)g^y$;qj@Be-QB0d#0<IKT0!8@xS>m
z>3*Zbf{<OHI7_6m>XJpbuHW#Znc=y@=&<6<44(!HO7PUWdb@q<a^zqBhq;0na6jod
zBna_dsF^_JP>9|Qc#5lam9RWD>WM#6J_mm13YV*{WllU|Sa9`m8}PNRUhWzXVVRl3
zWyMSHt+CdKpzYdVlqDQ`0C62LArOm;fi#{}e1)7+ns-ahnTY6@s-<v^8d&DQBWM$!
z5nSg<DMj=+=eI^2Vjsz;E?OqgqrI^~40zk`&JL_Z`h0u-hmilFWwoj|QGiF#_B|=M
zE<@fB^5W69Zg2)BAn(_mN{%6C3=k)u7F_4%mE4Nlc(nh}OMVx*^GiN}{09K@-^gDi
z38-No*{2>sPCVLTz1%p<nTo4QYotkRs%VW!rQ_Y1h*Vv>i0bdX+kr>W+JL1>lGSK&
zC{C#(SSqjGHJ%X*1nnl&jJR^i-2y$@WSzFPvJi;G!-`K`j1)ZD?Hh=i39_t4fGw>E
zuKsQkgyUPw!(-I+$;Yp&Q6nffayONij@5buZOH~nwx(}K`gTkD{0&sX0hEA8tJ%Qu
zP|o-k5#>`0N0g(Apj|G6ltitdJt8OK(^T=*5<Ce-TAx7L<Vun%pDHaE=+XXreaAd%
zohn(-G(nOLcquGs6DpJOB=S5Z#Mtj|M#Pj#)teQ?Px@Qo{xrg;%D{(5duhGEB*lC1
z?yMn)jlG0JMM5Svp+(R>uM%A);GqZbc(kY1ivh^Y76Jc<j}bjSbt+QuXvy`mDu{wM
zfW_7$7LWF)_1>u9x)L=AAO?^23QA1Jz4B4T;gRY@KS?KKyH51D1Hn2$``@Dp_tDY$
z>0Ukk;OJs;kh{CozmAqb(;}3$Xn8;IdiDA=<S>mktx@|44s~*^=zO)pr#=J-JlX}I
zhU)F5o`0wq{g2wE&J$hG8W{mPUK*K-rxc;IND>2y_$WE41Tk_X!Pl%HI*Z&geu?Wf
zs{2(39;wcOemXPU8ks9lsiI4i_CpRfqC7m>#h@n<Pbdbjg+mU3_)#Vkg;pFsb*NLo
zBjswq%REvs4R9rRAiscE?3CKaVw^JKb|G#Ta+xth`v6a$P|S>pAtu%*X^AN+71W|q
zsl|jzAtqJox5P;OAcOrvmY7|L+0`#;iE)()s;f-eX5tw;Kv2gH2)$^=>>7w%1Cy4R
zcLoXSJA))kjDN78`Um?hF%Jzviw%+5%Pn<H4F!!urS^fAIB7Vj94@uHEpdqoK}}Rh
z?forrRi_JT)#+0EAWPh&N<p1eDYXx_#2p!d@o9wAKGYJoaHOCv94WOAv&0=l+(E=u
zSmMMp1XVmkYCqi)_YUITLELalT;xnajhrd9%a*uBXF-O~lG-aRap@{SO;<_nBQ0?^
zj1|-y#!Bs@EOAQ^w*+w`EOABWpoPzo+Rw1W`OgEF&y(8Ew8S0q2<jn^)P9yF&Rs32
z?rN!hv?Xrp`RMoOOYLJUajEfWkMUA_l_hTc1%f*M0;&CMOWX#;Z9v>Pmbm9G6x8P~
zl-kd;#09;A8uUu-=UU>ViD=)6QoF|zHy&~05jV~fw{Q~LXp+=kZHdcVEU1}_rS|hJ
zajEZv=I=}G<1KM}CJXAG$x{0TmbjD;a6YO1LQCA98o<?9C3#J)psuNv+9eCr)G6T9
z6si3p^mMb|7wKb-Pj$Zr?!H!|zOvkbrwyad^P7xVK^qmW^Qii06sW`)@fyaN*DyM%
zP$9HyDrJoDI#!I@#`tCAxUABrzJsv`kCqJ?SZmaSDC^+zWhiUOrhJ^|*l-?qv_d2C
zwmVM=&_`&j8ly@l9>1<NGR?zj7+FapUC`A}GVy-_{9i2pJMdq!iF6U?DepmGaQUTa
zs=T)Z4`wWv2z|-BuLKVZNgOlHk)xks<F0Eo;;J$<|4J(ycxpY@0q2lSCKk~(4mb@g
zqH9bp$57-Lx}sJU_7>nFtWSh0WCP!Lq>cx^THrgjk<;kPrA|WXB%~fks<v^AItnzf
z8YBFaOgtc}OdhO9Ts{wO0FE10>_m>8I)37T(N?|DR>Vyqkc^vrTY@}GR=kfq&uyHh
zj$K}YM+&E)7nn6Hl-$T;&QVv(q6agLKaF`vbh+Gho*lZpOwFbAmGfJ9VlFLd%tnVw
z7)=q-6td710!^V6AA_bJZLIUm0dC@1l}z)Vz13rYjIDSJI>-l)kX(l1A?Q-GrI?b!
zoR_AV)K%_ID_&PWw`eOPiJZw5?<41)M|`rib%)wocc4VM%b`ygy~f_k;M*gF`E<;u
zg62Oj0?r+2E5TD1PAd+vh?QOn?K5QKX>af}6fcx1Z=I)7=ihU~lc)jbX^kHD^l;Gw
zKKqmL&O8m}(n2|&ij1e$Ha>y6o>);bN6>!%c%7$7#~U2ZC8%$gy(s#)h&E3sv3LwT
z?B$Mus@`r<7PNQHO~pmfor?Ej{|U}2Exn~Aa^%a*_fT5Cw2TAwX(mUVYc?{MmXj9f
zONP9dts$>;sPf7J)NLy2X2?o8_(-zSb=}TK-MGv}K<R{>v`|a;#yUgLMvM-{&x2GL
zeSnV~<~ULeDAJ^-R)yjf7U>aO10ZJ+i!A3$OZZ`G^9VF?0eY^rghIC)@pT@f-M5^c
z1QeHrO1;fCp5DDItj(oGa<V}BWoBLy{VQRi$p@bKR!#)Z{_`=j?>3&^lRRvCjP%h2
zsOB8%Gdjtnm&OG{qAmx9gidi(r+6}`>aLB)<<d<3bTQTfPQlxfnb!fjRYp0DT4swc
z1oaD7uEmH@2kPf6@J2`AeQ=M|Ph`}`lt?_P40e^eBT8jJ6i>&mgq5YBy?Zv5bs?mC
z!dTJMF`Yt5Ma4>3c(^yPpE*|Y6nGqg`)0j4>#evJuaqMJ2jpIjzolq^Drgo0m#G8f
zVzsb$>#X8H2ZQP>w?GqLz7lKqm4epzAH+dX&u6y0$ofix@sZc%m&2@l^hRm)dvaK3
zJ_4G}$^Vf{<9zh6wS|j~1F?8!9?3e%K+3|!jo{+Om2Uv^)<^3+4!yPR9M)66dHhik
zmV%(NINqR)>pQlrK`E=ldK&dRvXZYtW(ubK`g_FH09*;yx>imMw#?R|s~l^fn1$y2
zzI6DZFXf10j<;(>8s%g0E#SH_T5m@^w}bnCeds;F3fiXGf~(l=45XAMAGkFufjL5)
zpQ8S#eR6I0X`f%$bsEX$X~29`sZ|?=0`-+Au!j9n*RbdZY-I@9bADJsIs3Dmg0|(x
zZ_jbKf@oB4>Kc;LKAPKg+FV%zuWy2MzcVHgzaGD_vt#jV@cYVziTG9c-Glf#*_?-N
zAKH@~tcP8LEC<HuD7yZ+cI)@hU^#?#b0<phu$3c!3n$_(xe2Ye2Qr06`^SUSo>ZC}
zzkGbB-aY{I#q^QJ7=22Hc0V?rs4&uE`q)S|hf>%a$TDL}i@3_6imRwsRBoVNkztz0
z;R@0XyPHj1;6?<!B7vFPJ`=ia(p&~<ww9GI&G$Y?qy2byLYZAhBk}0K(mGKrhW=2g
z)(O|*-HDlXM{OD{J+?AY8;SRp_bU|oc_p7u20>TpoU0hIg4Q7?YGatO>HY4?SiD8S
zyeg7jLK=(Fl7h?4W}$&>j%tBSyI(87GesS>su0g>$d!(bYbo&b@tg+zcFcp+-!sf|
zF%4WY=Bqh+oDY0Q|MI6Sx(lG$s8yXy<MS1>h+vL)>f@H#Dgm@gVAb<zm09b}@kQ>j
zRcc^2ih-UaTDNf(thTH6qvpR~OHwl!_LS~;%(*oe+)C)&Iw&WYto6}HqY$u#7`8{&
zme_Ozn!&A7x?@PHla#(Zq%%j1wbgHOX@-;v0?DbQ%c*@HjDah$RkWhoyACV1n=_HQ
zcz+aSb}y^HUq>>y7_u4!XE6687xkxQJ?46n<r1{Njiz4Ya27I2CjF{N3aZ&`l4gBR
zc)^UgUug=6C1*-A*vzmdh_z|Zm>G!rb0Ak(%V0c8$Ip`8_&-XP@xM~8!vE7{5B^uk
zUi^2<KKvgDdu;;zPORF2*8AH7rc5MI`^2i9h&}Xxp-*`%`czkAQcu0_PY*DQ7_@?7
zDWH(7v|Sd97t3?d!)Sdm{1TET!Bx%b4%-<ZM?iD*xJoVh^FdH`aMfGTtQ_lx$uXtM
zmMRCKs|MF0^;ozsvkCVB%p66W=`JmD2cUfxvi?ZDs0>t4|Emuc;CWT~o2}o?e4w-B
zaov%(=e>hF_r+y{J4>F?7Z>Hy?0u2z5Trk(Eu-W<)MH<;8FKS5Yz3q{)Z%?M%Ise9
zmWHjPq@cA_aak%tUksw&l$v0gg(u(;MR$YZ#cwhAL9#$nL$YuH5_KR*vao-RDGLWc
z&w(Jx!ux9sS?G;Xk6Q7`OR3#NmlLh@1#*9Z+|-^eYpkPQzV3a{ZRH>OC+hcicW3?~
zg^gwVa%r4@66?2oeo0w4=Wc>6rRfP^I~t<dHWPu3K<|4+Zqm>SQCH%l;2I*m3_6EZ
z-7gkGt08)XQvMbqYw$eL$wRSRKa8<_W4@&qSn0{1gKF3Gk+E)$B^6IgNQo-jK*7q(
zf|eNqt3X;IF`YF<BZxlIU*V?JHeanc^tc*uC13Y9B<}oNT8hoc+#W7<8vDnBV`H0$
zW3$1rIXA=3jrS2KE#2*mJS9Y9zXzk752KtPwtyHY?h6?s4h3CKx1cqgMXiak3|!}H
zTt2>&G?Kj?yoT)Ylv0*6ffUi5FnFI!Etf9yByPssgz>^EQ@ycf=6tfw2``_P1~stK
zlhp*ZfiB~YS!PE=qMkj?;GKOgD4kC_i?==VBz8aMlNNR=TcRHN+2hxJjMk`O67|Ah
zO7|YjJQ>8wokJHvu8dg0HIT{HXJ_6I`vi}-N>PONAM|*$Mj|BAYA5Lrt`J7EALdI_
z#r-bqU!-FxNK*u(8THT$uJE>ZJZWO3l{HaHJ9KV_kJl)L8fD1hht?hjo)L@)E6y0T
z<H?zqm}&iTd@^kahKxCKX_TAnV1|y-m&qBexuR$T8ofFO^(0Y4VB<+Zl9KTNvn+9G
zO5~(z+L@*_B`}WBJ|N|=OA}8ac}YQDhF)RSp|P%pY;k!Zx(u!M8PJ8<mC1|B<i&eh
zq6>L>aF8J{31juo#-J+b4l?R@?Yc;OPauH(uKIPcxPUpxzb+A{lpn66wPC0&Gf&Vq
zd#E(D1!$2`irKb4^g~}0X~r8KhRv!CJp@n~Cu~qR0O|$?)x@A6Nq~wdJ{wdcpc<Rr
z0<PN_6!nuL^cKGjY6GA)FsSPp6!d{MjDu|?_es17u!(NXa!C-hx80$(P-_r)s4g^$
zQkY44EA*Q)?iWiS(V@1MR-YPc!fsTPp#5%jjB+p?CdQyAe9PDwYBM>KFYUirJw(2;
zdd{K;+Qz7@pley%bqgP8ZD@6j7dCH87088q1h=?O*etG#weDzr3skMXGSX)D1R7b1
zVzQitfa4c>-KYm_9+--UT18i1$p3Se_|U-4bCMzb&ABwRg7#(@T-Nr5(Yo5}VYHsM
zI~;1Y_K6{^PlT9E)M6#ZrRCx<qyy420XAWhmJ7l(&Qp8gzpcGY3AqQBju6IYf=Vlr
z4a$^|#S9Ac04iVFObNM>L4jUC<x86>A=4O?FF<mUU=k8zvSL~`oC9MRce`7|jbZtN
zun&b$(jfHRP&@+YGRzb=j1oPV)t!AvvJh*uO)b_xw_cgoe#p(*4?Vb2x2gQE0Wo03
zt~T0^+LUbgg7(6|5craBBY$py=)vsZk5Mnwz6?=29Sece+Gio~Q#%q08NK@u+4D&+
zFeNgH9+PY$Tj<V*Ol$o^1Ng}1vgoPiZpjOP+@Vu?3n23;x(O8VIo!IJL^kH`%DxvE
z=Kv$k(^vLb_RlP3pWQ{-m0gzIhsi0;sl;I#yDJ9tWUZL=5MK$R2VqCR+FoSoH*C5h
z=EM-Q^b@qn)BIlEa?fzsE>yI|TC5OvC~4isA7maTvABehhgz>jO`|o^P46q8V+M41
zN<971>UZ7~gM?V^zTEm})ewHwKM6_2TqotX#iss-6{8PqHBEY}J)DcpX$psWF&<fE
zqpI1VRyEW3z5PKe4?0_Jthw@QUwu!JENH(TLmH}RTiaX${FgM-n11hro!2H@Q-p4V
z^b7mb2!gS!Q~gGxCS2CIPRM<uI@cwDvI5OJf$PeDqb~cJsV=|lqArcV-^h4%`nS|2
zS>9b;UM>G_b=iQjHZ+rM<IviFy<Ki*b$PUlx@-mht<BqjzqJc%g|%I7?Y1sAc3BtN
zTd?mX?m}6+nzx{==Cy*hW^@|;=-p-k5ABs?nvN<#RR}ujxrfmqq#R-?hnq-Ox(c=_
zXFx=%SE9FY9letW+@yQpC2^0SJ>Db(ZZd;w%B4PpR6N=mmg+$&e4CgL(Yr{&qut#k
zAm2!6GgbG(2jgC%riGPBdsn9+2UhcXS!)1+N1M|`Hd80^yo(q-+U%w(#3a#w2Y{xk
z)xflxFg?^{juyVv(2`akL+n#coqGXUT%vlfeX%SBTwV3@UzHhiy0w=-nTt&tGXQL5
zG!9#(X1r}gI|m^No;%X3VnAANQkmbYFKfbXH@u0YS9uTpaasPzb3>VdX=b=B{_{$V
zo3Pl*3ED+pFTqwadYU=_F$0)2SARp=aJP|900s6^s)3V3mW8LOUtrJli?(w3F$vlk
zWwi3Dt;ASSnTYR??^l|jPbV=tkCZUt&U2I$;dh*CD6DU0{a~Z1l;)E+mSOv!jn<gG
z8g`?g5eHjo(4EUA*|>5qpzmEh1hePJoSjL~ZVcL~{#&O}>n}MjmxX=mbC3%>T2s)V
zjW~7yWxCK3u2+c<u3Sh8i}Q^XX}zEg8ZEev^`E9zftOX_uE8O)k@K2Te#8RT0ETOv
zY^U#jP}4P6mvxaMg&lqa-o(qP;$@hz)JnV#Qn*R{Q-z={kW=xaY#rW5I;u=S>tI)O
zo`}}Limy}a_~ou!N3^uguU4J$t*uj^v;4sRw91rz+WRoL<nAPG-}K9u>0|v2XluLu
z5*RtBsoiojD*77tpUrBQ!mH#2c5e*73i5$5selC^d^WX;@7f1fud=t}vz_RDB1iAc
z@Nw+G!%yVQ)<{;{o+TR@^bqDjO!nfw%w8O_XffL%+uK*K#mM~9{ie-kRX?s7cD+j;
zxu3LP(lhuj$ig0>A7IcSjE=<^9eEEFv{Nf7W+gac>@bLs5-Wd(N(tEM0`Z3U97s@+
zv{=`{tkma^SD&rCT2_@N*swi)r$|lA*6h7cP`&pVwr0X9XuXC<;w_jjcxVI*dG*j!
zEHq9J9cQ62dZ>YgXudE;l0D$xp4IPze*;-P2kMZuGL_JmR-5tnExV2f0e=vqz!R+g
zl7%BbUup6JYX$5WgxH#+uLWk_N}qZH;|LyY*vbm{Cu3g*qwGEKN+5ogyUB(*1=JPd
zxlEPrE5=jcNyo}Og&y)k{n1KpT_k;LW#2Sgf4FiZm$5=@K#B-WlB`CxfV_o4nrlLm
zr4lAfF^eqK-{(;4?;}}y<UUiDu0`H-x9h8A_mNhtf<p_@PI$DVD`Ke0EQ}PiCqFgd
zD48NfSxY7Xk<7KEPhEpB9&O_aK|A+!nh(Aw3)(97MmzQ=*xNX~T|b;s$Kq`Zi#rQ%
zH8RDGz}rfeIt*`*vo|;1o?vhN@%9pXqn3<y*^)0YdPTI-M$m&t^RMVU!^h$uD!grC
z_Z6x!Tbnelpmh;=AAk;Cn#R~7z@BA{N=BRfy427csb!45x0%7`T88-zlTKqwXa=p4
zx$h0&-nH6X(LIcO-M7l`R+HXk%A@GYUlFCyqUErgSWC+9ja4gpk%Ve1&q^}eQE5(+
zYt#YvJMhq|VCm|i;PQwnZUeKzcmU(MzYX*5g4LZlYPE$8Ms3IzW=b;j6=r{TA%*y5
zXjerHQXio)c5h-ng$ejV!1jeTGwpiX_cRuQiiP*Lfznan-yB^_`_x4%o$jm#{TTmZ
z7_mmddL`FM9$05Oj1_(oc~ynt9irL0Yt$f03f^Cf`hIpV=j?O$Lua^O(9T*;;RNJD
zvW%Dl?A7qH01O^&;Bq%$%+=o`D5YzjG$W-i>)qfI>b1-jVKg4aIR`<z!)4kD1<V|@
zo;Uf${j8{*9Xcm&arGogYgtW9{?F_Y`VIz7^}GvOUC{MI%-iPtkS~J-@oh5Le)ky2
zU??6|s<3NR>JBTki_{mt4)8Jw=^P0wj2qTyL7P?{gWm<cRl+7jJw9RU@h8weC&1}f
z?&f0?VRX5p3}Y#N9ax#e-pKG}U^5-T@X=cb;=0GT;cm0lw)g2yl7Ed9l4L^ypJ9-C
z%jh;AT1Ob|@>Cyl3~;Y;sO~i*AXz)_G23EgA7hL$ddtuI<gX#@J$w@IOj<+!VNU~(
zLCL~C9Oqof(p<bZ>5_3}C;UI?W0fuLcS<YGsGegA>Xb&S4(QS%HUA!;I)9BokM{I3
zvNDkbTm%_0v?>8R_&#{p3V3SN=k_}A5Um0{yUh4CsKpxKSciBKGLXx^z6@=ivW%S}
zK!(;Be!GJ9$7QBGl3gC7n`OU?_olZ?_{zWYShO1{CD6)c&?WEX(62CPvws;rnwfcN
z@WtTd%O!lY>6$O^Hp6lazTnZy!55MOqivq(F=re(-$711+Luf7{WUvVfRYy8<d62_
zmW{-oHTEA1MJJA3SahBYxR^l+@-japqyg*eB<y1ZAw3|_qkX+J#?BpG)tk3}DJ-g1
zj~Sfuf<BatpN;lO#;v$VJ>XDB0mHGS<WYw=7J74OT4|Xliv4YLOakmAz#d?*cw-@D
zsVRS7I!UIwnnw;H#ck<*DTHaXoFrP$Gu@aA!MeTP+LsJll~sO7$0O<Ap-cboooQHE
z1xSYg>1YP8UO-IF;-&kz(p=RskJeXq*vFko#2jgJ;Ni0MFpFt@*rB#Q%wtxwm^5J0
zI?Qqw^95qQ&|~gE43z-iMsLg_Ned8<RUAggn+J#DQKVFY?pjcJT`pxsUdr@b%CWo@
zUoPeHA$Dx%=Th48@|>AVS)Z3@Fj8{8m`*=p{Ky{#K5DX#J+wBXdEPwH@U=*5rYnsT
z3_<`p?o6Szg?mV*<FdLr>uvvi)*MyqAy4%WJP!_>)-*=VoWlGbrIQH91^B0lJ?RJ8
zAjvW1x#qeWbrJ9^dSHzD1u)cjW<pE9Y!$~>>k0k1MqP~b#YjJbbV~K=sj@m>nC5Z#
zO$;d=;;bCRV>*O^<Dd>PC<n18561x=qSq=xJIwY;xnEC`jm&&cEFGVCuoawWL?3E=
zfMjA&Bj!!lM9hCp!)YCYHI_`acj`+f$9{pD{NjP<F@LNK68!1Xq=SFRUVJc~{r<sM
zvfhJAcEZ87?8JjFXAK{~{^7|ei9E}0Z+Wrh>y{!<sb>&)@aa%Ns~t}5L1mB+#{tlC
zfYFk?t3;l7kXlMui<w|8(YO1q{GLanWOP9*^AYYS=KbDcS&wr4@kp^@b1TJ(jCa8s
z*2ZY__i`z`pUcd*R;<pqeR|eHi(N~0)}o*}qW`71C#~tTReUTqY+uvhOI4z#FETX9
z-}RU~$#N$YZ~HfY_8$D^&onF2FLpApKEydma0QPx>8_oYQF<!qq}b_qQQ6cw=UH^k
zuDqstnhnO>C1E9O(oH*CGnpR{`7#+LSob^lnpbZXrk9?JS~3Z;oFf?puBW>>889f9
zmK%B5dMJa@(!M6T0d>7$?M}4G#8u|#U(_R4&j43@UK5cW^4s*$r|(3+fIOZ#lEw$l
z3#-<?9W!9pTKlh&Li(RETRg)c4gHU7?w#wo1od39wgCNYH`e`-cE;C`KFfA(-Dz3*
z|Dv8_^m>jO)pb36-PZH`yn3E(t7mW4zpOgi2GnuG+P|YM>n(LWy~jFEMjeSR0jIjm
zaiJ?2x0aNz@wEQD1Z_D+J^5$yJ0S_LIfJm$j;@K7%e8f$-`R_6i2VU&^l$?U-ve&x
z)xDHIn@h`S23W@$y0kgg#=w`@+V{biJ+LnrZNCm>lZM@O+rPNN;LE6ggD+!$&SiWE
z<A!}#voklor*ot8uHU(xYnt1?w6D?kp|1PZk~LxG3R4f@?P;zb%Plieep|k^glbOb
zmf%xS&Sj(fwf0R*?3&wu74a7Ble46ur*Z#3mSXDnh8}3A{}AXuw3ci%$Cm$V^xv-2
zF964+Z>2wbhn@bV-O|4(kAA+lmx6|99sP?Qbf`rS9z)sdmYZ|j4anQQtgV1egY)^{
zk+rYx=!JPk&}Or7=G$bgmtIfHJg>J?rqJkdw6|vTmQQlA*1pzP@V+$Rm($ckZSb#a
z!%m4<B*o?}j{gSU%g#UnxUgvz_d5_Faa9juKkz|8`@tQLL%LvdR4(%b7o_2P<!Nzv
zoPlz{-?B;yG`6Q<uNSm_D?@SbFX1P=va$VWmi$zbN;Bd|uL`ogO9S7qJE#qQiV<iu
zQa!5#*BtcOq1Yc9%68vQL)ooZ3AgS|WA;noh6~c(`K<u7SA=m2r(04=2mG=>uShCY
zSGqklfW~TJFNZ1*?^iN`ntCy?#@9T{NNe8RpLuSVW4FmDjrOYacf^jusoGI{lUM;6
zvE||K{jx^&K}viNCM{kM-`wss`MACqcJ+F23y=2c?Me9jE;e>FaW?_oQ9`~H<ndbw
zA8C>;vtO0z^ItF!z`Bg!GV}cL1(o1Gcu=+1pnilJ6mXZt-LTdQIMMysV(=!2wF9Ra
z`&+ofq!#c6lrNBukw+f2Q;CP#^{ECbm8=G^M1WE}+O@Y=SCW(ug6{iC1Ko^L2@mjo
z(16=nNYMVWoNlLR1Uw$C>GmOj7fMeXOe>3$O5%JCN`n`Mjqi^75|6_N+grVFis1U(
zZM0BlNZvw;Db4i;9<z;Tm6lYl@$7_O;jtCe-a*$UP`Xj4Ey!pKfi^ta`L_$&gGgcf
zUWj`RaibB}#Gpl-{;q-NY^C~RK`i;HRKu+DjSrz-4;lL_(8G}rkM`$=xoFQcLU^>@
z4c8--K?slb$A)@@MC8PywKhygNJ0pY*3xh(LT-fcXwNrHMo2~okM?YX7ojSI@MxPG
z#v$ZE2#@w?!x)4nA%sVJxPf+QrXqw#yT4&5LVkqsXu$^Z7@v(09&Kp@c{2tO!lT{Z
zKvK96Aw1eo8Zz@*V;9JmdE^D6rxKDOK{BMhK}d!KdHC(}RG0lm{g!^irL8QSQi^wp
zLQeW%F%aj|O4cfk&}E&UmZ#tY>9@!`-*beVyU7ai($88WUG-ljV)S1w9lUp&(qZ-=
zJHG$;7x59dj6N@gGYfL>>v>7Erp64|($O+;TWd5KZ;ir=5~cAe5tk~xTVmMz5M5R7
zn6jp{7ye7GdG0L6_vYPVGkD_{tIc=xv`2%rKG@bf#ZC83DVQZbo{6RxWLn^i!0s)=
zc&F!=n(3W-st<R)V3nA~DlywsZ^E&(>6DhmD3Qg*Qox5>aOj4ZuJAPP4&G~~QtsfD
zlp_;Ofr1F5z}-yi7G4AXE>)L@uZlG9u6?9=_mt+kS$GSUc}$8NR~xj|UQO8Txn6y^
zdH2qyV&r<Y(BqkqqxHUegX-7n2h6$=R9qf2b9YsKGs?e*mERmhO-k>pYu??|@BTV7
zmqF=0YnyjBH}yi9_Z04|-CH|o)=l35e*w<G%AV1zo$Pfe6q<MUVbo{l-B&LJOo}tn
z1UN_Ie5NIVUID9DR4DzdoaBhDwDo=Wj@ZPOj>yC)^@2fyDbHlzv8UPR3zBzApBU|k
zP~PLWnR!Xap)?wwX)cj5mn7m-;eRmd!4f=WVQ;i}m&2FBT%L(c^}o;dO>Vr6&kZj3
zgeYdFncfyUgXh5MeB3)!`hI_``bz2kBv_>JU{4<-zO)x}N+VhsaaN1<4;sn)-B?4A
zk4`a4=b9|d-ASBa$XT<PPE2=orQ;nD%#N5RM+CB3L)Oq}aAOz7E;D7mEv3eia*Zuz
z&U~E40=8OUo0dyKotQrX>&fhnFnhTd<RJ6Qt+J(9%dN1b%&}0^H<xmJYgyE+LxC;+
z_|{NF!brf=v)bpUjJoHjg}l)DL4K#%@vX^7B2KxI`0vLkbbPCXamdQQ{lJ0I$d7Z<
zdHmaDOR?7DWm}519?#oSnk+SZ%9awfq=alKJ1i;p<Wi1r-5<qiIlayAvc#8dG2?$?
ziJxJKzsV9Gw!~kRi>JEJ`7y^ta&W0FC2C2TkV_$&VE?wX$Jv&&vMniF+AvGnj4ilr
z%#yF4B`v%K8l@%8kxPpi5{WjZ^;PG-&~eg`hy1oYVoRy9@c2Dj${am~c<@#(B`00X
zHs28=DWZL3E?X&^JiUxu7|Hw?$@1jsd0UE=hNo;P1`X7^L%9@tzqr>DkNLBO%lLi;
z>zA2n>^djml}vs((!<cU9>%!0h;-2b%%PSr*?D|p4qF1=7^C42DdC)mZ)ptuC8dN=
z-?FH^H808KAXv%Mq8NShqFhQ0>$MHoZHmBW-WW>;v35hhjHcVb#VrE$%PkWAhqlPz
zs0VM!h@ZldApR4ddC#@>*<L8a10H)i@i=qBnquYgVOxro$N#XUG+AV0zbz$dN!evf
z*<nd}IhR8H!yL(eYl$zzeSAh=e#R0%!xF#V5+An2-=B-m@3YHnDb_yw(_G5&t?AYz
zq(xAqZQ!or$A4J~;eRsXi`OWA$WI_XL-FbIGamATNBjFvs72`BhaezA@g`-l4p9#X
zJlgAkkfP+v69Ys7=gZOROa>bPfk$fvgdf^qXDQtX2t3-ae}XlB=|Ejd_eUePk)R}3
z3zFrt-IJhik(?g6i)4xSg8fnaT1JobH-<bAtmHY`YRIXUOG)D-j;|3`inbW;S1ijL
zf8NZ&1@uyR?`XM;WEc86xS2oJy_Cztdxs;}JD$s>2<RQXSgAipsWZ0tY;<qP!G&0<
z-;)EZu6N!=eZ{XN(I;nY@!Rq&%jF?h$y1gq^{2TM38lUP%YUkEB1#Q!S!}~_Z4S<(
zq}oQyAy($3yJVCZWaB`1OVF0Xm&-x0lBY6P=J~l48D)l8nJISOND>xeeb7hnsjr~j
z@o2xj)u-;m`@V-O)dGoD;LW$t8rI9bxRLTMpf=u0zFCi8-IhiS9_<mt@Y98|>To<)
zw-~ydGZ3vC0t^@2!f$MuruuQ;mw%tMeg@Vo`g?c=^n(4^ot}U*3`wl?>BdRn5ol+R
z2-^Hxoq-nIl7agW5rap&{#GMrS$JjyD^tYdLHS1f!0@by@lM))zre5SCi-24#RYvl
zOZ~O#q(=(y@S79(&Q`;%Re?r!&w~iQ6$XslgTmKDs*$r-!QK8_{L|D$pnegkmsMO3
zt355yx?wiT$D`GOZwv8`M|0lFPpi^MTZKI;;;}<$Y-x=4gg+fWu1JsO=W%$vFMoSJ
z?{B5Yxfd*zXUxeHTUw)y?I*IC2(7wWBQ>+U(W<(dS&dQ0taN<o!4uiElGXO*_Fw7d
zPp*e|or9pC)S-<!Dc_-1tx@<>Gmj=l-9N*Ru)z<qw+B@L+G7$_q_QNFf{WQPVSn=`
z$bPa2{Kum`a0_G+-akp$O)9Ih+HbLAS*gl+`xR<T_r5^0*K?(nHR6$qoCmSaJ1U8J
z8<bYNWp#!yyUqy>;QlOsci_DV`=uNQtqy1<Fc{W8Ufvy9dZY4g%RzBJZl1%q)swux
zn#2z(3{0?V>Uw@LdSnQ-!K1yuP@EH}qkXX1pm{d4H1>7})zy0>$ZU};t7VmGtWC1o
z)zHv0^L%vIX+7UhEX3&zX5B!}Q7q>`+(;^`_hce<j#=cbrXpWOcE7S_-n*8V^6UWI
zXCkXFI;?QTfO|KPu)v)<Mdc30trI>q0(v8lkgxCS3$6SVsokE7VK;x3kRnS<j+P?a
z;5*rYvy5s#+(<S%u&|ES5s6w6wnSMSgt!#e;6be7X-yYHNe55S{U7`Bw&N6q4<HPi
zD@tyCgl-~u$Sj$i$LN5TE@&?|EQQ5&IBd02yaW&3B)snt>|bCMAbW5#cI$roGi$04
zf=5WG4S9dQkSxemSQXQbW->kqd}(F(G5a?OQy!QjiY3z00PcXDNj6(!=Q_!(N=XIf
zIuBJKg^e!6>mTDLMaxPO@<#rCR(|nyaz}*5q^vgm6#P=a11@=4?FXl1w#(745$k01
z>auA@idRo5K#DcTSUvu$yLb*~F2`^^<)gbWqCr|OIF*UPMi_#PFmybkp!Nr`e`&?l
z`&1@k$SCRk_SCOWa@uxuD(PcAW&2&k$1=z)m3Q)F8m-66JEl;1TNl9A!))Z2gL9u$
z*zv!15|Y4s2>3>45782(PT1qf7n|RZ+e<2zGxLJ+U2?~~ruYt-xEO(i2~`RFr=A>(
z2SGy!x1@9|KzyxZRuWn<$<*T~W2`@{$1nBqM?f{v`5Vy5YgT_3W+L!sXox%<u3ivQ
z7Ed#BH|n{U=(!i`x!1B<jz_NXEZ0PoiUSPVxp(Dgm}$~*wT@+mj%B)zWdXzD2NplW
za+;2%&s|~kQ^9Xy7_VdS=orT87%pWP76HQ|hT*H5IUOJ0=>tD_%?Igu%Jn>BS)O~5
z=U$fQz|FK<H{nj7x*2hsS=?K|V~mhro#5}pz4QsP^Fv3~$243ek5STuO#znp@cf;m
zDP*;K(KE8zUr)L5|E*Ip{=bPBv%T~B3F|r5bi<z72lBvWp|_+&-o-iltoHl~{=4hM
zcgOc_<$YT^pG&<MyR+Jw6KQ7G`Wa|*moAbp7pqef@cu~feIMLmzCIJ7QR*5ggB~Z5
ze<3&=3mI1aY3d~yH!r~$?uHMt8KRw!-V(Q{T_#MDaT`2Zs8+ZL)+-|iymh+Cajq~@
z&oNp!-I7DX`FD<Um{6`mxP?+c_&|k^W)dykzn9Em`Un~LuI&+Mti8gp2p$^1bO~sP
zs7E?fS6z9VGoEgnyU?i|?cy9hZhFTU$+>m(8|-%C%(CPh25tmhL)=(jRZqi?|A^b@
zCeJcYv#-D-d6ov!%3#kuzCur83XQyu`r26>!?tgTmR>npjJ>RWjQ_4q{HIeqg%~$1
z7Ry5eK|lN(!|-nm6ZIW!DNx_hs&+$tN~eC^H$+)Vr>wR<1$t{iFX5gSa68YzoNUyF
z&g=~XO?GLJ!jJ^9%pH%IkmZ=OxWt%y31;fda0%!?{*#ipkn3;c*GfM2WJ#rcOY&7|
zjmUjJE~8PEBy2Y7HXEnT=+5$)f*~(x38v2shwUM&t;k~E%uR2N*>M<?%Rs$B371_?
zZ7;x3ukV!wRnV}~in}ybu^p!qxfB{$Zvxi*{BHOPca9~=?%Sy}YJVCZyj|d-8*e(}
zAz9|My?km|7r92GoUY18ZN*-C&L>WpwTe_+{+(*o6W;FXb@Qo<x}fme>UG7bp<U$a
zo~uT!&a>6(AG!YDQ(N^^D}&F4r|4X8ek*rZi|%-lI{B~FY8SKwLjofecXX=Nf-Y$L
zF16Zt^0F>+{<F3E`N>gTVClZCO1tR+Gc2{-SV1%Egf8&XI5LLy-c2W|j&y@zR$G6P
zWV;BMQ@G)cV%DCd8-?j@^+^fZcN)7LeObzilWv?Mq?E>!)Fb(d!sPJoiUjtzOWaBP
zFNSwM`2onV4R~M?BJT-nJlPCJ@pul86K4cZH}$!#@Q9~dk0ivqSUlafh`XQ|ym1$l
zp;s95ez9AL$m(=xcv)>*#(3MCG2lpFHDVJPnvaFj64XqbCVGtc$1*M%@$ha%yvO-N
zBYtfT-?PXGpAPs42-pcGe;V2`qt$3v<ve65XQQQ@xwdjP<;t0rE9Ymd95Jx5uG^BJ
z0nxr0r;)FV>oaWC3cjb5fTg@K87Ee!*jLDvRGCSlO(y{!>t@UYi^6n|#*sNHX_Jzp
zp6{&Dt!7kT`o;|1=955eX+4xMY6}|fhhFDxUzr`Fp1`+KMyTHiwYZ&E&=$c8;y}vs
z?1c6e@C;s#QkG*D+Zx6#2+$vHo12PrpX>LPS`TS#xD#?AT3*Y};qf(U46v~<-R|<`
zPtv&01Mw&W_q!tISGOAJ<iqm;($laAeAb^}uDPy8-HyE5jW4(`AMdLddJlq{gDVV+
z2h>l}IhC)Cwks5-&LR1U88N7z6KnBTKsz37=p1Tma7fH*Pk&83uTc+d#Tl}}bR+0~
z`1bAtBp&UuIVD&r`qV=R<IyJ1Az4|2HEtqKy)}$eDc4=+z=OGIW)d8w709fwX+7Nl
z%+^$PJD)hv{WeN7^VFzC>)->n?wG~9$HhuXW7X`(s=3CWR<M4@+L>cNi(#+*+PHC4
za=)lh4Sc}kv*9@uAZlSr=qKPY@)xuGBlLRr>*qk4DE4u`g?a|p!MA4}t%}~z^QP0#
z`_e|<kG`Us73q1?X`F{h8+msj?=F^iE6Zz)F6LKTZmob^xcW<2Ew0Dv6sPka55V4r
zcRbn*yc_Wk2I#~~2J1-PrgUz$7_CgJcX&N$zwTq4=<km+^xUFn-gzK}VgG|{9a@N+
zV%RKVz(`@Q$H+-gh94=}5;m-dKkWKrG4fjCcd<@|{zv5-cbw6;r1(wrrj3Wz51nEm
zZ-tPzeW)28?chx^?wg%mR|zT2e97NQ%R2UDZso(q0NOimjd(GZX7Im1G)icrQL;Cj
z^HnAyOs5^N3~tiKeS-1E=uyO1e&vlWjhZ?#-SyoEcYQBy@kX<n=c^Rpvf9|Ms8^B1
zQeJ)oH)_W2-rgC1J6@|ET3>+Y?q~{9n8w|5Bx#FVT5v1vgecvz^Xg3$L%d)&VWWP0
zT_nS!3HQFnS|c5iHv+e!&uun(rOtz*4ftls2Am(hDX0puCRJ$7YX6yoxx`_7r-*7?
zBzdD=+?Sh)OhBE6-{AICda#0;EU2UR;)_k{(?2RuofU;17bx0Xk9%>hr!O4I>Me{0
z%5`htcF=HLR?vhVb8qqs+K;cN`iu|J<_M<)6edC8yIJi<V0iEPp2}|ohD%HgIez>k
z$B*ad%mpn2a&;w{KnW?7a0qRZi|>gCPxVN{5b&Tt=fQ#;51wG<zIzI1MS9GA8fu_j
z*98v}pm0xC`#->NV~-fVs>8X+9EP6iF`-91zrPB0`0IFE&dJqdNT3<~TLLPE^qBia
zP_ZgUg{3V+sK>^vb{8;oT-Q@ut^<Z2nHX|yIWO0iYZ*_^HNO18WE*W6K?%>%-ac`W
zZL;B)@1r|Rn+KpFVwgp(P-ZwMdqH4ZlhuZU-e`~XP6WNZbM#XF62T1%#pQtpa4dV0
zc4CA;$Gna@I_>tV@{aPp(!c(gQeQ85*3K%x*T`zsAMe5!RWAHy9^E@lH!hIoMpobX
zJ(hg(O4x<3C3w1h(v%(AN9c{c5!y%KHtSx{4MpgZC9o1Ufsf=PE~_;{0B_J?df1^M
zyFT~srx7}>C>RS0Z{{N<-+9R6r|zG^#?HQ@Bxj&CLbio1nBfxwP8UPR8z3d-Y*7mE
z)<^ONcw9d>AH5Rs0rEy>o0mW#^`iv)s-1|DOWZ*A%u8-OK5tumhMb8=(=!<B24imO
zdzt9rUq2IJ@u1V2hD9SWh3p<d*GP<G6fZhY$GApcM}xlQhwb=tea9Bo{f>x{i`_#8
z8>R_Kn#8!z&2Uzm`Z;-Ha61HPyV*iVeI^E~>gYfD02&h3*o&lszWT5fJ9v#P9)0G7
z%)Yyn*7u*&+i1KApOZc~MW(sIDN}6IysY-+F|-~$DrslAN&K?HOr<>Sd8r9y25bsc
zOS;9A^cL}9U`l1R&yI=kEppTs`)Mb~n)3d!=G~clj5PRnz*8-uYyzHmg+b-EW6%Y)
zZ?2)fi~Y!=2xgjs03ZKbr{lXv*BEskA2Q}>vX^wkWOWMKk-X4IOOn;w1c!K$TYq!n
zBWXBueg^y`E7j`+QKUDo>vH#Gd|g6T9|P>!3>I(BV!+Dy4uL})>OPO9Z^ygL()X~p
zQQ#fdOZff*>DnXV(T;Pkcsm`pai`){cpHqnxG|sOZ2)fKPQ|C<t)J}2+ibj*$Uaqu
z#NpBQU4L}mj`*cm!+2ryOEPQrSn!-?{3`rrwJFEQYJM#&jb}-Q9cU_YPu*bHfrLP7
zY$W9QI`CsSes9BX1%4axdm4Tp!*755ZpUvw{KD=Rqi;ESfW^b4{`Kn*!RAybE0G;&
z87^6*hxNw&B@<efwV;)Pu=QcaCVNd*>o_WUg7a$Xz0sOk6n^_C{r?oPjgSD+WW4ar
zQx$KNRv~1|8jBu9-x110<T@`TJFEQ-(AY=HI_fWDI9eEveMjXh4J?$SFR)+-1NV>m
z)JD*YN2|V`FcxBcMB@)p%kMv?wH5JEl#D$q+UX;&K)!=TK7v^-d@QStK4#sUI}Nth
zBJ492VH6qBi#+m0ghYh;BIHMJk>L@aj%Uz*gMh7jSUR&O<AzlZdlb6*9$ye+OhO4x
zr(f>#j2?h5XY5d(W0vj<j`H6+@B{a?ppJMn;reN6rmX}I*>;R~Ll-3<;r_ahFxn;(
zh~s~HG5tRj#C#BoFYa;N4Z+Ia)3_Xod!MDdhyv&}L0?wW(!JqBfp;OR{dYQm*2|=6
zRpq?63iH#JTTN)+RP0ad&^|G%?Pky_piLM7Fl{;vt;@DEm^T44am)9%z+=}z9<NU*
zp>~JBV+sTwBR%Owy6?W@(aHF&Z7PJ9?PUzISfG@kp3=-x?q?~zSxQ1r*~wB~V=29a
zOq5C~656)JZRPgSV~lb`?YPr}mAq`rAM;9v$0RG6r&vqI_=J?ieLTflazCMQ3zghg
zc!E~%V(6tOl<)`r1?oMXX(4?1kcWfw9QC57D&UyK<8X&6`=TP3Kq>r$BK`ge1tT{8
zhd&r7Wc2(4kw5hO!s!d^LP(L-#X<;QI($M|gZxAAi+=HP1{5UWZvY(I0R4eOxOB=B
ziht7&@IUlHv2Y3d?JfAGh}9I+OPIo9iV$;|`il+4csimJw|o`5pk+x*%O5^(@oX!G
zw*Kt31l@;W3w=-`aC}Z3pP0kfPsi7n;oAdzdp0cH($)#z-3(uaP%{N<bMy{8S_9(V
zisDXsgumF(u|?1pBBp$cPc3>BYmi4tkGSdD2zp~k38FWa%H*lBqc+BTRnv-uxTKO^
zK;ws4dW`uUOZ*$M7Pw;E)j)ZI(;e_|rC-7Ib^n->m_pyTNGRak%XC(F0LsLpoe3Ib
zb+zh8`!zlbUb430V+pmDA78#C-uv4J2+vcymq_cMNB({Luy)+%k3Fx<4utUEr;a>L
zP=%pMya&~3d!-hFKG4gLUq}E8rHhmJ4F;rbl$I&<<2M!v;lD4CWdEfX>D`b2xFrk!
zLxCjzqvi3n!zYx?ywHngkMu3fYDYiiecV@-)ee73eZ2Q))W<JyQ6G;jG@)fc|6PZc
z0sRhx{_Ioo72snQAEyi-bXrSW<H_HpNI?B1%FDF|TD9sL4c1Obb7SoI)X;HE_*Xu)
zKmt!Mti8vB|9G@BXTv`BnYrf27x}RFH8x@Fj_50MXr@_h%%|qsd=%b^mWOp(=qypG
zB&%!s3)=XFY27wmsm>Eb=RYdQW<@ty-GEYWc$DlXV`ir@HqM83L7q_eA|8+S-Zf;A
z>5KW6a0h_f^gSw@?Fgu*1yZj^0y*($JFg+j$1vn1OF~%y^Xn%jwSUGtQT8G2g#+{X
zpE?5%u=_lnn49%)Br#f3Ia&_^^C3p-JJ(ogl^%nK>tpc0vC&#$qcwg_KCMREef5da
zcASz=5yp8U;KZXna}B5Y0nmSkh5ny@lCy+hsYLpHW}ey3w5GCzzb&213b+tM*=~3a
zIO<JYOpcJY1!+NccdC)bbsOR`D2JqlKS{+elC#=NxSenyTAt$WN1O_eJX%wnE3w<x
zP_u=oSvA@x8NZfV7I1d}j(7@Ev<@HLJ_Y}SQ(ovclsf+tx>IvGaxQ<2?v@(>{!<&J
z^xIl@SLCF$3+q-n?2uEg#%Wi`F}p9cv<$immujmGjP9W{WZg>Xf6p>{!_4sCZMqWq
zV))=)Oj<Lo3aCcY)YQfjJcRim-VSb*!aIDX#cPj`JVxK18`7cE&`;8BGsA14P0&um
z58Ta)94K)1!mWZ%tUOh@86!}ExX9h4GzZGW)$Vth{#=Fo2V)qCrE34C*7ht;bS7|*
zEKYD@k2A#Ll@GGn1Xe!<*oEaXM&~(bmBLpKJCq34Dj!y)5J#g9UqjMau{Gjb6>oK0
z3f*CqUy4*`ltZ(xy&RNQ+FdEnuys_q1*2HKKUXhd3g%6nW|O`o=sQ%=%yM3A$thKn
zrb=szu`E`^2`Y!5pRF*sWKu3xo9|L}|8N_)rGg`SeApt!?+zc<i^3XTL46@k9&sMw
zf9cy5oQL1m&O3b2s+}$U&t-I4TgE7v`%}?LQ1V`*vtMRidzK-N`)~b2#%PZoPWwTo
zU6V$HX^<<DEzEDwefhhg`||Z}sbH+c$hs1YhnY6&sdGT4TjI|u+cDFnV<Rvs^EIS*
zGFeKZm|NGNFXGYauD$|tNcMg7;lt>yBH3wgJIrI&943Elw1OzP?}5cV@)*7+|Jdz_
zArG`Z=*j0@on}4x9%Tdc{B&%m!b{5f=zJRN1+!>Z%BLn#Uh=UfWgTXUfmc)S>>~(j
zJnrzP;?2r>1rk2r@O7nnv?$<B$&3BjuPEYP#~{ML?azKiK1-TwV7`|ol+sBkK1vuT
zp?HYNmBp{37^7_mR{i(FUd-RhzNFEJ?&zZVie@)@Bg;%~)Nu_3cEe6Xc8MLn6r_zt
z3^NuoQ_|N0m&Es<%yfeFU=;Jf6NT@N6iL+YR|3Ykua|66ZF3}?lh$L<_C^}r8*PTn
z(JqPmQ*^xOKZ*D(wuh4f&+%wC)|<5uT|Tsi@VG#aCgoCyLv}iiGKrqsyQPQDH@koh
zkM_}3bT6`zuWRb)%&Y;w|El~wxf19x^MMVIw(}~IZE6EqT`thr9HV(^0R7JjbV`7%
zYqaZi+Q$iKqt=+dAG48Mrf)QIuN(5Ti6~;d73!OhXa{chJZHe_kApF_UI}1-X=Y4u
zd#>>Hfjy_D-he3ZTQU5dVfZC580D~1Y%qHm%=&qJ)JZCF_|j~zFmsrc5jCsk<=5`H
zkBs@6#t4(Yc3Hq$Ibfvmw&XJ*lYGMttNR`XarVOLI?D||eAlg*l^m|EuoX;#Tuw@G
zc(T}FAI|3MrTfcB=zAC;e)<XT_v9~gxZ)wSJI_!3jx>si-Q+(TCHYX2FEKOx1lA=Y
zBs#1(OM6Kn^f{-yLJlisu#kilH@=)fR8VObe$o$b6Yw_flM=jLj<>O&(3c3W#oJjH
zTK-gVX^s}UoBO-c@;vOjL`#&>647bFZL**xVxuK}glKW1+`~tRmce*yKSH$7n|j3L
z%bzL?uFyTuE#P^HI|iQr2(~nbE5dsIvzT4du(Wo~?OF@BNOQsWOx^n#g-J%?dFbb5
zpgIW(hq<dD?>pklfD1mVM<zfQp*s)~@dnv}_}f_g(Ic1V;(yHI=d$<@j=;92!(Yqd
zXMr+)qrTyl@}J->QS0l5TKcBB(Y7CBG^KAXsf=10S$n%r$4oQ0v_k3!TVW!8CM)+h
zN62fs4D_AO%Hw_=PakpXvA9<kuo9!F6gdo9{%GOt8_<W$KEmx^WLa{$&T}U)<M+Z%
z?+(aT0v3PCHQT)d-|t=HRv;&w+V3j!pC2~MKU}dXm*0^2v%296eZ!OY4vhNDtBWLg
z-(kAL-H4Z5<lRJ4m9UiZZpF>HQVePS?xj#K+0;cTB&YvjE9LxLDRk>Owefc^<yv67
zxtmh1vz21-n``0uvK(WwJekSz9q!+t#nt$8Oy17xhOe@XuO;ALR%<$J$bBmQfQ`T8
z8v`GO!z6D`;HG|JNK>+c=9-3oy0mGBd2b@y_slLzn|PSZv5NhM{L&`=)1~!4%=;+a
z$U|QYH)V&{t&o*A7<F@XDy@+56Pg_KO4_%h{i|ZOe+63&W>K;y^kfT7#j&3I8tXc&
z=FZ9BTViZvxd^MjFC2n43Nr8nQakzwVTa9Xi`uPPk>qK`o<4myISF5$vLAAoN$ofv
zgng>47X3P_-HqI2PgsK4ACLBG9cc;=A%sVJrH)1c-pkFiI8M+{T7jvz&{_fC^0|?(
z=DvH)Ch0Xxe9dbXiGN?O*~>SfzLuJ0KVa4}oL}Iz_^%Jl(j}Bm^*qB?&pjU)^*jgl
zEY7QEovofzag%~^)|J=uAlgYT@ovL874QO&b|Jo({R-akXdY-kyFW{{9c=^u(?Yx~
z?%hJ)9!Fb!Ms{gh31qd)(?URo{^Y^_j1P|=PXOV??2+Wfin~s%e&jk?ZT*{Az4kg<
zOVC-j#poY&vkvz3is)1W`5cY>B&)st)kZn1y^osAfp3)zf17te4<79hzGbDaz{3$>
zkHs&8^^or5!0d{ZZrP)IYJFGMU@z3+DVWvRp2@z1wW7WB`ta2_iD~AM9>up<v>nsv
z<_a%toQtNFd5*;-Pj7Zh{W(}?Q0NlRbgV}9O`=st^X_3mYkkVr&y2-T7qVXRy8OPv
zgRmz)9`!i$GjIEmFDJBr@}>9SCtuQiXA|%{!F8JCJ$U3x`W8hm_U3WXz05NDLFs4G
ze6sNzM6K~?FI?%wj7EHrHo}s$5qrv4!XAhB@f#~44^LewWByx!G6k)48m(@K_lLoE
zZ~NgdCmcNdWfS@n>3#HG<DY<7FW!99eK=3+@FeQQnRF6vF;>Ig_K%VFG3e|KIzRrh
zWBvp^rfRyMK_3D%IO_4kKdX6nRWs!Z;4Yrb0w3Da&T9#$80ic2E0p|{0pY77MDI(N
z8+?ylZsmK!WFDehHt`KJghbB|Ja+8F_k6rmBEGqFd1L#j?A-@XW%JYNbmV2KZ(}i@
zJCz^cG;ul>fPc;%@Xa~aLOX+=Z4I!n_w@`!x#{T*;1711{bbL8gw+w=r5~Kai8mqb
z@b9RtRjyJ3z%dS9GqfvD-_XL`tJNqoSv-%;YVT<~YnOr^p07Y0?9PYyiw11!@{I*}
zrYP6wSdFh(|8}~)x0F}ltO+Dw^Tu)D;^yhZ%YHdtme_c?_xt=Vm*)VFM_WDJrzY@@
zN1Hr7)q1oQ=f*w}lrqd;^FB34f^pNi4e=NH*-7k`ev-y$$UU}T-(P<e+>s#<WU*Ry
z?KJfUXx=v@=o}x#G$1B`m;ho3(&Qt3<8dxh=OcAKgD30vwTM}Wn1wkEe#9(7%p%0l
z4Ei=^C0<53{4$NQoBbu#MozL$Rl&D!PfPcZ93w%Jr@pwYdq_^b0Xek?NL~|8m9?G)
z{x#j?DzEkhq;9AzuNDLT9@3Jru4yi>hJ4Krb(@MBV-?;N2g_j_b6`)S?8Tna{V#@l
zNDs9@Cx@j_Rno8<o(&B;@m2|*sR6e3hpqDq*gB`FyAZqUEqmNzoFQI}GsKwfa&Su!
zw<Is_736&-FK;X2S`nAkF8P{EEbV=8zagCX54UZV*5gEaq;0DoXVOFXrTZe1k+Nvp
z)?};<bG)v#u)8byogFxNPH+*2llH_j=q-4(=dPf==dn1KZek%E`K6GomdkDWofI{G
zXSH!ZMUB4<cQP6FLMjD1lk;$YI**#vwI}j4p>LW@0A*O|zJNQNuuDv4e0oP&>nFb8
zhd+!F=Z~Ovv57D2$8S=nc<LtX4{U<{4HQS>r{sw*gprzGA0JEo45?*N;EnRyhL9JJ
zHjbsHkU9gY{=C!?EOkFpCCb|Zng|NNNumSvgs4RNjheKE022bt+gk=ai`wP9Pwtvb
zFvz>5>{;Z798P@Us%JOYV1BH__@4~}hGda6fMG=67OZ>gIB(e(F~KXkeSpV0tL+ft
zdOlkd$70}qsy|tC2oJy6B_EFwOL&ZT-ik@cdlD@aj-c%ro&>|QKZ=!LCwh!n!ehL1
zJXl4-TZdW!Iw-@FVtDwi4f*sKv4qEXw@MYY7fDqLQe|j+%qx@GfPLz_Xy11?DUqyp
zT*X&A5IVv_pR3c*->A=#Hw4aL<F04;B1^Chqfe$;-!=NA*=NW$>QjX$1U!T@37i8E
z8o)xYBV?Ah^Is`Jw_W2-17NLUSf2*gNeE41p~r2Z5JD#811QlPQOr^1U#+K!`398Z
z2MvBk!_~IXl{OlnZ>aMDIiErLK#|GMe}kef_)?CN8c|XsE2)o-iXxP&m&U&6_HUG|
z%h5w9=^<9q|4u<`Kq$gOZz5!-?MWHsk{#q<kTBGfe4~Bpc9gK4mGE?mMn>|k+Jm?~
zEN(+8jb23SOstumpI2Dn?*m0<3#<Y~rc9W#(LXN}`E<?9(RBcH9bj}#?SZa|HoDFS
zU8ZFGJ9P0rY4WQ#%1MKwG@~f{o|QM5_i{5blZ$_+T<*i3!6<MRZr8|auVB|PjU5Vl
z|Gj<!lHcy|HM9d>68F5~yocu{&ij71amOs{=t+hjr=pFrmgpz=%(A$&|Ep#3``RY9
zWFqW*)Q`y@wRyLU{lg$`eaOV<TTPQ>B@kiv9l$5pSK@&`9sE&~Sec#XhR4j4@R)gW
z0?rQjz<o0`0U<sDQ(E<VgCNsxz`7ai7^Iq^kqC`N+E|u0^gXP3=hOJEK;Cy&v_=xp
z&2{}5=Vx!kP7dcPJYLs(qs<u2rEW%ZFJ|b|0nasix>azEI0)lD$5xIo-T8>Q2`ivx
ze|a_O{t0+bP6W*#e^e!VqrA;VN;D(WE{&0sR@z<V+=jKrpFiUBuvso{+Z5l29l+4X
z$kw`$S!M!t{%L8fYm?x!ajyjDa~l50<N?k3>;r#%PtrW}&_8g8FGBS!v>G8ZZRJ0R
z&*oTuCsG#zb|HiP8A4{-!hi5to^CfLJ`)XtZMm<p<@VchU!Kc74d=E$$klBz^Cuq3
zEM&)9>Z+S=o6sf%CbmlJC$v^B`k#20u}ka2ewRO<o)^Hg7*8lZMvdWn-(yhr7?eF4
zWsm+Jc$d{Hg+v>CJn^LPr11!Ge?UU{A(TG^We!34gHitA|ABWo;BR|35NK<hv$!o5
z2;w)?2CEr6JKubp6i(t)4-d)U2id43d`sSp3+Zv`xDutEJKC2$iWPU@Jlr1?b@=^Q
zz4~kTiHPiELA|(yPS-rUxIiuW8{e;XUL<IL^3krr@n|Fb<}Me=-iSM(dd&6KMDD5W
zw0UZ47n03{Jjpo~!_E`5vKp)Pr15-$NTG+qul_u7KJM_grSH5DXIXsI%f^TJ`6Kex
zfu|<(L#EN7H|`Ey7R4DUZG2%P!jfflXvF9sN|Z`_+#i3Kik|_?747LAgBLNyr9Sjx
z{Og!k5P%QchsDf0nN~!6hBo^<-7?f(VL<)~n4q_UD(-tu>!6{6Pu+l?x#7vW>N&S5
zZIQMy3zgPr7k3T7{|9i(pB$rZheSQm76jy`)}}5Xg#fH{-$d&|_;!%-9*gf_Hvv#R
zj1@55LhvChkjXfG8`oGh@3+_;%B%C&G5se9rRCsN*U+@Op;GCqz<g~?YrBDfH$qZr
zUyQp(h}*m7LPBTYE|+MIGP)1lw0@LV=dYBK-kzwS^%K>1xQz<8jf%2PRLI~f?-?^9
zl$)>KLP``ewh`rdz$seK!J88?k09nOoPeZLGg<B3c0o(%7CoN+*YEM(@`w-X2A{bO
zymkV`M_^G~r+a!Vx<JsXCa2g;T7>hvX~@x0g+{X)e+qU6(M_SvSqeFvMedS?Z?w@J
zSF|!SC5?Q7POre3y|x6q;f>ZqBwxcI^FDPKBxe_su-~+WAUD5h4R;|oK6NYLw(1hL
zwrw#WA82jp0@9GGP7)S@&pP{})gKDXRt_>>dZW#y($hQf-YNkGoM8*iZ<SQsS82!}
zN$@6%G+J$Don`l>i|kTkhc;w)q)loD*`%gl50n?nR<0Nn+U<CqCHW^k(qu^TZ8n+)
z+h{89L{q*b*X1Z9xu)Bd4IT&ay&^Ltm3})evzCO*%!^z3ZJ540r-VRj`&QDU(YJVS
zQ!k`j0Gt5@@vR>q?F#ax{T_6$*7leV$$Qzp9ApfTNMn#^N;Ix#F3#_1PhO<=$%MU6
z{`P!|PoPh3)BEI9*v5Z!F`W*{MCeS@`{?Jeai8G!KeN}7r(oL<XlQJvp?yK_hlcxU
zBdu(v*n7~>^=QpP=XL3v?bfgPP1-n@bDY9|`I`PmP3xXu&Q~;B^#gCMx@)mC0kaeK
zUOq_0N3gkx#te!X_5saIv}@)5z?hfHx}28|VO}D*BH%D*rSDem&7I1<F<0*F?^y07
z-ITiwCjz^gkNJF!u@?D^`FKK<W@PXWr4vVJKHifnzq|R^fPB$L0ks{ix!{$^zjB7L
z@Bs8>_<z+@$_my)&L-R{kG;W9vPwh@WTx@k5`s7(cvR_FfUmI6JF3*oqOY;jI{m2P
zLw>>`Xp?GmDbUN{HrUhIy75<ErI|OW;SCvNr=w^;hR4v&H^))Ob33S}3ZS_a0Q>aL
z6xtAXcYKvwQ2>8mCTBi1g|br^^VQpKiTmT#3vW?oD30;M=5470xp0r*7S{=z#dT?R
zI}lDtNhGnfu9%cHZhjaj`Iwy-bTCcwecZxCQ1E-t!4$d)CZ*KC`-ObjPM}mg+C4t<
zJrdzjm{#ciAb#rz&a43%dwZL)x3`(Jx8M1UF@)RhjgiUV7s(@iOP$V-wMILl^nKaP
z90&Z+Lf~4mkUXnn?0pY=Pq6m{d#7_7&AVIKdkXLV>2&%m2u~3@<G$vrURc*H#oHAb
zI(^Aw@Bg|NT7_auGE1XdloyrP6!ObVVGk{>pK#}A{f`T<X0*X>i0{&1f9c~O)}J^B
z{uTc{?Q6p#Ln}x4g#V4Gr&<~34r%Sz28(qv-Ui!!3jd`r>1O(#5oWgQExn%R_p78N
zZbR`SwrlNcKeM%8+->^$NcTDE_JdnSlUJt0Nq(Bfeh+EkHGb>fmLGegfYMjW<cHZY
zo%RT5pP{RJLbx4cB6fSsnq3Vqh}++zyGb3+I^0^ozdvl$N{Lu?zx@%6Q_e}2TG`XB
zwX&z|k5H{nRf!&)Aaqt(YK5<LL^{_BP<pM(!X#t#^&9)$V3IzD=PVCfV0qZmlRd|<
z0+BboVf(_J%$Um}aT$AAvG{qIkGZ9YU<|vR1NVR#@%YXSAVnvgNYt%Y(5ibg9CXuH
z-y8-BUIQi!?bsW(NqhN}H-WWsGJX#7a@&!;beeH;*3?oe*$DBHakIp{BrDm7C+m#y
z&UI66ow1i(f|65!G;YO6!-v4&rkw)v)HN{}@D9cW9#3lvk>R6O65*fm>Ifqbt#8eD
z8ZoW%cPVZxS{$DYf3{%!0y(0D@V#3jy*%8Y1iO&=P)_E_Hs;0XO!w;g*uA<_@xL|d
z$Nx-pHY{e+`VdBG8mnT^;NPwYB1B%JNrYanSd0+)g{KkvV+HhtIW#^}FQD(BNpa(@
z(%G9G>g>&Q8|k^<r`pwzfL?=@D(;BI_!-(fVM|tf;IBUQ7YO}=g_{4`50)El38vI#
zNNq)GD@(oOuXNs;taT>DEjEa`2$^Zu|COvrW?5I+%K9NfX4((_S{3lcodKWH<U_Bn
z_s9LZ#ma;^-<E%@E&my;EVJxkNHr-Rgpirm@2}*C({ouT-?8%LD}+osK6{7iW#an~
zsb*Ozgv_-6dPn-!vR<>5m9Uki<dxN8E9-e%S<k*Bers7_TUl#uW!;lk*4?(Ume|Vr
z={v%=mUX?Yta@8n)AP#ufvv3X+seA=9ax0&<nA0B{FyfR;S9IgUZ)||lyM0mGtK#q
z{H^u)`fY3eG(u+nkKVS+f{IjA7XFTqDGP7E-Ky8a%>TL#_f8w`cpmN-ZMe7EaR2gc
zY7Z|wkf{e{qFwi(b+*zTw3T*mUTMp1rTyGi+HG(9Fb4VH)kL=S-4)~)_K)85-%)I>
z@pYgo!1kf`VHDZNMiKwp0ptzD1G#-DlS8$D_ryJhm!y6dDD5kF;;j*1d});QH9uJ%
zrw5>mEd~Xod3j(hPaN$f`;>8byXSKX-+7Ggk-b<}qQTr=GijzYGl!sKH}B>eUxdAL
zjW5RDxyF}Z?=f8yOe?der$8C}?v8~O((7owmxNY_nV`j^#9HXfbL899_k=N8FUI)1
zqr$JuQL3S-{zzzK`WyLP&|1!}wdsC9(AsJ-Zy9SfS|3itm~Ln`c8kOQ2x(hm0MB!m
zhmS(rGIS8~>qw#$(h|ty#n8wIhv|W1YGVa{XpqpsXw^zHd(vnH(2H~DZ0(tATj;lo
z-ohzhYuh4j?pu7`3gx#g((2#B>{I%fIr|`P+FQAvh0qj)^qzsxB!-`M5_I`MTs0u{
z-i6TF2$^Z4a%G1hlOJGZBbE*_=PJPWx8-)(a`ystQXc#_`>myYfsk3+C;KzFk=Kr2
zv%w#*!T%NTIGyOU=Xk@G<5gRZSN6AJwx-$E<jFQb=pz~G^IL?>v|sGEj6_J?Y{UJi
z4fn&g(Ea-jO^5G<^{kI_9nG$l{r{v7R{vZ2Ak~D<q|xm$23NY$1<n3?CUn6FY{dyB
z79WT_MqgxKQPI}}r16Q+_(-#hVf5oS={1QTRYVY?6HTPcy;qUd{)BTx#@dzdfl2xv
z7~-*axC39|^TfyD1jPWi2WNkJN#k$=rH^}%>|v*0U5Ld#9B$Vug->i6p6D|EJF#v~
z$9u~`{4azxFO9J+Qs?n_J=y8olvkDNS$EGO+?gmosoE*FG1@sU*B78AE=bbcL*54F
zD1T$pm>~>r19OzGWAL?d*&JW){`(HxGN;C0RCXzE;pV9Kb2mp><R2wfCv)<T(Afx?
zGwG<LMgEaG6shJ+JP;w1g1$NG%Ah;H0$&I-O-LH;?)?s{v+jDsVyq{E|MKc+F(fc(
zTOBR7t&W1ZwTZnS(&{LLG-I_BiU0e(Ap}|?w%$M`7%M1}UPI=|ntrAmb`tc4#Y(`|
z8)m>?*O-}Fv0E-SV>U!@;JUyZteB`b_|Y5u@fk`)?+xF7pZ5lR7f!#kkXAbU+-3qY
z$9JMTU{xCVCahM_Gg6x=G}IOvh>!`{_e~mGofuoc0Q?sWzUWPoA2WR7FV-AiB4nn0
zYD@d@F9ts_hkT2Fh5^~R-R!H{f4|+n%P7Y63Tn5(7{!v<IWlz(`wkkul>qN=T9?ze
z5}Vk!PZHRnHO4C85PjE|?9;eY^C{e8_7v`vyRb2eJA9(F19rU}g9b;dXf8SAAz{2r
z;htw4a}{q|KuFS)7D-S2Kalh!B%SWcFzKQaOi540m;I*{mg9|Er0Nliq_Bs*)#A;^
z-sa*Bx+zkd@fKijTky7+z3s$XkiET+w@~~tkMCx>U(5Za!E<VdA?_sZ&FpV!haI_{
z%mRO%r)GXuYr=V3@`v03ZLdi@4DFlnjQY~MMQ;u4RFi(m?SW<+TlZa$=CIcK$s&6V
zPVCa1#B}<aTk}azCEJ@ZHj-`k_CM3yK_mSrwDG8?C~o1O)1ZcC6#Ga|Y1aYXpo!!1
zBA=J#`(X~(4-xl67FXK|mkB?<2V7_7a0P%Xz;F%i0axEVT-=^cy5<t(U-A@<A1C(V
zls-ahSm;ZH%(PGU@j7$=Dbs6(_5h6U8q!@J2Ddf?&t`^azn;_JmH`n1M2tZsauA!K
zFMbY>7|wAM$M13woZ~6*pS;THt3a>i<}#|o6Z=g5)0zWkA{ZsqHV;|Sc-!#$QQAtR
z@ltmIei!5ClDtw4eh~c4J>Z(1!}Tt3y~}W2nZw2FXvO8T;G(<r5}<_J#NX6y<p1Xs
z51)ibTMXxFeUK=UDsCy4kw1yu_ax4cCDAVy?Moq)h>ycbD7uYt2drogc3y?=kC4};
ziq)L?1@FN)p=yN@tL<U>#;z0l`1~6Z{CmUHAK|Z3`j-kmN*Z%;S(q&Eq+wWT{L5Z=
zwSnd%I?cQD!vAY;3~fqUB8|17yxhM7v=!U0_vTs|@<-pSkkxEI>XE$f(H=+{_CTmj
zIp@ZF>{ErO1w0+F4wjB5{`^GV!S0#yVXw40x9Z?Ly%QyJO^b(bLzu5ac=+bL@Q?D~
zXXS;j+)LjB=Q<b1@B=_t!xtmWwKtxAL0<TrJoq#6!o&9RF*2bzq2aC1^$L!yFF2Nn
zZ_lHlaBn6;qhD5=xi`in=w8@UlCY=5=uS_3(+k)FB5vY22PasK_#nn%zMDs9^=LP*
z0lRq(*v)IeZe9c8xV5%cm7gxaqbYx5wu2yS2MxIInC}K%aXueW3|xWu9Hj}k0ysBD
z-e_}xYYuEC+;Sq6j>j2x$f%Fs3}mGzl%t0<DZ=3g4nJ_r0FD`PKX6b=K0P5DJ%u_w
zNkEe=fJT~S;G(rne)5JrJP%=O8(#m0wGF1_wZRVoeFJ3hhNq7yB!zFlYm(oMAHh82
z2t?x%Cck{Yi|&~&#qFXrOZn92ad*k{&!_RW92k~AO}95cU(IFvl|!^QG9CNb$j|sg
z5<LPE9RY0QX)Xb!D1AG^+x2j-yzt4_?eJf|UYR$}907#24<F16A3)gJOW%1t0$v*a
zs4d{e9+baFFaJ-k6V<`IGTQQRY<t}srPj!5jyDpJ&{%vnBs2yI#rOpY9R*(>qt^IB
z45XB&HC@f$aLYk`t$F}*c;M-`m6rjVj$LSxLa{mp8dH!UNW3mvbiZu`C15l`3B%x5
z@z3G>$2g8N2F!E<lqBg_sJ)eUm)dx<5~)@>x(HlwKLelNXWmz+rC$O@E-4`<DdBjC
zNeX%DnPXiH(lH6SCOt#a_2f7%9WQ)HGsE|A)}49|NyZRJMgVYuXSietC~XPCOZ0GN
zk3BuThx7#QJI-@_2ng;y&cp8^Y)${$9-|jks@ZwuBWs6$Z4c4(Y#!EE_K-Jq8g1R@
zb!zKWoJJ#Pe0p0~LsK+IBO^Wt{rvy(_9b9ZU1$GyW|)~f!ytEHl#7mXF&amsaJ)4s
znr#4$NEC*VMa|NSU_fK5Nx!znHVvRglcouTT9<5~Ni}U2uxUSr(G<|2O-zDGvoA7^
z60<dAEw1zbz4y+*KrqeM|Mz@6&t>j%miIm9J@0njbI$kUMw=ed2R1$OrSAjqk=~}k
z+$d(c)?1OX{yjG$T{J>5#El~G)b_*k@3_%mcm{K$y;#{z)T2=ndOz-$L)viSkTza|
z@6mlQ5`A(Ay?W@8Ju0`UM~N5WHbg^-YRo{M{~FfRZ)GIbB{DtEs5o6F6s}bY3bDF(
zLrv%8dn^1EzSAWYemt-Dg1?r+0xpFu0e)Lp;9sLG_0<#(pL3&sBXVw3bKVL`firpi
z)yN6SQFse-)*z<=-deF-EEn=9iel94YgjjC25WuvMnH^aosVJ-yZjn`U)h6^1w21_
zWM<=O(0vN_oTK=G%R%?O&;S^G>8qRRT@!ezPN9gGzw{0sZ+9Hj@+9?83W|%z9^YSS
z?_R*WZht2BZKk)^e?X@*OglrG#dL7o49tMHtE)z_*1Qh$?)*iFlLgoLRs=w|uiY~^
zJ)KnLY|!BX-8X5wTeYQYBc~U=Ph)}fs|XE@$5;~JyXjK<5vR2hFQ|On|17v#-hkv#
zeb<`Q@HAjGQUgWg{4QOC{|_g$-zR#s-(Q^`+!CidBR(x{WPgF@XwLLeC-GpC4AF0o
zBGqctwOU=Nfjx$Y<a)W2SG4jvPHA+lu8Rj}cz28jhuAZ?#J_eT-sBAlF`bypy&C6P
zz5!qRn_9fT7gk0a*7+atVMh5|?F_k~>bht_TK`{%XFd(KK5_XA<!JX@=u322)L-k-
zU+WuaCPeG6lWA=znKWUI)BQE94Wp0Zo*aYz3;y`>2=5*&<+a$i1n910i&cT58!!&s
zSd-riKK=|^^O=UzYTx}eji{3RJK*5>{puy{_r@-GUoaO$E!Yd+6a4ddlGGAL;0fM$
z?60#1luGMuCgVxlVN7fB#^c)Wt}sRX;?$`IwIo18W8`w2oUt0Q23o4$oxuL7-|BY+
zun+3@ckmod7q31S>G#e)588?5xV3hQ^!x7PtMQ)nNG|S$Ff9~@AscaGaA{9G2RrR`
zjV2~sg*fupRSN{Wc+i+!_y%dPtNp7$oA09aa0TC*#=}or4SH$7H^o0sx@B0JQ9v`q
zVJL<S^a;8l4>%xWmU0EVu8}4HZ!P48j-Mb_0pcp?YNXp-sJwPhX5cH(%2(*a)u0xN
zhU&t+nKoyJeIuqR$WL>ET6;V*rU9dRgqRrsN5OTgk9a}@a_Jb2-)E)`w9~dRO`xmH
zSyjjp3t7Ih5vLM?_f`8oZ=$phPopn%=8{|07BVqs81YGH^fn8ekSLBkoo>)e7f#XH
zih8%Al#E8AZ7OH&G>z`MU)1QWCHy=7<pH|u8bo&#-!edVv=iL`-F5kAHlqCyd!|uT
zX;AyE2>136`y%`rvz$Zt^?RQVri5Jww7lnngK0MKrS|^w;NbN49l(BoXr->kQ^0G)
zH27&=)98r166?@jQ#mc@h;)zi*Sl3Zs)(Yazf9#p{kMURYE?SQ{0=%IeV6E{J4{Dy
znr_)oH?`>Z+V7;BH_;Psq9=%M+CTwKQFPNZbuiuR9a9^o8)=6wAnnlThI9$754TPo
zpqs`q5sE3?fmKjD1}J93)NW9eI5R>w9+hs$a?<FAY!RW~7U|`%Zm^fQR29mp+Cds>
z`Bbgte|~JR4e-i-8k07(<$PHG^TXEv!Tk}aNH_ihnoG3Z(6WDU?=|(8q0P2vlH{@e
zGH4wYl@ZN(ey`@a0{SC#40Zf!dT+Evv>x?DTSULYbM*KB+E03KG-Nj;MYI-QhUe(-
z*Y(3hQ39m(M*9%vBXzV7VK$zlzh9xk>_nZ>m`q2iXd84go}<5~_Sd-`?LcegR{JN8
zPX^vPFR$)_uk9?^hW>IR*3|ug)_z8m6a9RyWAO9W9mFFd)>qbkqWmWRlCbqvi;>)b
z_^dW?M_w6NcZZY4#RgDhHuj=z^G#=+?xAVO9&6a4$3^zoH!6=C@Cvvu!MK5>z6dd9
zoJ|t{vr@)}OKCz`WPx#UkD)K#1+~7b#vX=(cLLk!=U)$b{&`0g@($qN(eZzSf7_J*
z4g4PpmogatUf|yw#@_^dqo2>W4}SipeK7u6|3~<{|5xxIJ1qV&JF((+r$+sE0^jK8
zUk`cy`4Id&+W(LGfAarI|A$K%-2c&B!vuVzxyt#r!Cd8=wg`t7<MfWVrokV9))RMX
z{)iu=d`-hpR7pX8I+7IRkNCE%cv_VeS0MitJ4sgLO&-iO+uDYc5r652U^p4^havDj
z++RktjHvG~V>lVHUd{8}GU8U$6D=cF;5k}GENvSqBNih?w2UagbF_?@*ALThGGZ1|
zN6QEq&(ShsiVE{k8Igii(Y=|3=jh&!@2_(}Ms!KT%ZO-Lzx*3Kmgu+Z!=vWoA<scP
zN2h=1ZzMBnuu4Gl*-dKu-yAiocj^PHcMc~tCc3`=sJU<{`fw?cQA2e1DC9;ohAV(^
zbnh-5(gI8Vrt!@xM5^2l`;W&8ioty`4>_XyDihDqeKqrM10ydTwLgLOe<D2YnkQ-F
z&Z;cMxZ_~a42(OjKXwqhF7n_CZkt4YiY%n;Mx-RI{>47JN6B|G88b!n#EyPDIu2U8
zYC&f-Y8G@vFUKft?p5RdG%rfRNz#`qKJS90r2b9~+`;jdfAsq+sQo&r4a#X2JQCqY
zD|}m^rS$q+;XmPFY2N!8K}2irx)Iy2K{@)U24DC46yf)6D}N}ASf#7_dWOQ-_5r~-
z@^g(o(0XxQfG89k{~rB+PyPSN=M4%MJagISKAIQarapajnO1+p`vcgKC-bQ>bD44z
z_5wz%Wv@R^g?SEknH|pK6M+$Nc^+P-G&&C_XW?{qTD?g-K2Z-mh8pPi=J)^eo>=g~
z0Di5*w)hjnzIB7XPJ&i&1+y=PwFe%q`6aY7=_$6M7vFIOe~RzDI57)rkkDt({4<)S
zvfq!UDbxGZw%7Ik=lGoH8EEzIOH<E)rn>y?=n<@08bnK9y{ENs>wEtxEm>5L$o3w>
z>$A@W+L~zT+tl3=_G9$EquE4%d{_Hz=_NWlc&WCJ63(blpZ|7gmrv74R=lUt*7;t-
zp+Lo9?*A8U{UVI{mERL{)I01b8ru`Wna1>g4~zBV{hqH>)#raj6m5;1I6zzEYmTf>
z>qA`ATUaIDjWs10<$*Pab+{z#!B-+@t=jId^5d+Zy1NlMbGL8&%DeG2e&zQ6=pE&Z
z;Gmr-b7)K-BBF2(Y*{bP;HG`lIGar+e%eb7>xYcwJ)^Iww4Yc5rO<iEQ$_1}q(Ddq
zpS6c(J9EI}dnqa#{sW45r6{YIN1<yzigoZ4sDxgeeK!GL-TAq|&x(t7L_|D!eqTl8
zjRz6S+PA(kie8S~cj10Dc063&20KeVRZV-MS$ypFg%wcY66<vQ_%Qqh4UxAVc%+lU
zZ|nNsV%Il5g6om~x7aBT`!cjXN%chPB%e0gA^eu;--6kq8Nd!#aPou*7l`gVIvZo4
zHxYSVPP-}!a#GY=9&bhUZ9>#r>Ulw4ifEzCz!i_`a7CXLEKksSZ~!)n7Vj7nc^2x{
zJ}J~=zpKO8@9Hq|GIb_Zjp?B{EgDtm^Eg@yjA*!EpPnK_wfprJ>ZJkxXHxyLl&1@J
zFL{J|{n`p-F8F({8@?<m;SH2P64@;Dl0Ga@YKkZ#Y53h`!5@M)#1-6lQKZ}zYPo%-
zT<}Uj^PiPVG;I+hyYB#^;E9-S#Gz4plkP42`;yi6qIH4D<CzSO^^J{A48)m?IAJon
zjVOkO(h2!F9w{*UoX(Ss)JJUtsc1iiiQ%=V@E^Cjl!n$mrKuHtl!~3gzR3)<{!JGc
zJI;gIBX_|0F&CJYof)uRtqUBxjOK-?JvHCs+Wl+7I|@-8-0IedK7pvSR+F@*aW(DU
zQm(X?wybW^d8_bUI}e3cTYlH6I<EBEe%%CTp<>sTlyqUpn^EZ!AZdUXOY`j2s-C^R
zGNHZ!W0;~rhdX<vs-@lCfYk~;iG5{UD^j<T6p&i6IzgvXSZii0Yw2xrx3Ffe#ojU=
zJFZSRMpSmIgfj<TSl!ZulPig;EJBm&PZZQzYq2Lz6KZYpH~W;9YW}mZtl9dhCS(5V
zElJ%U`*$+dKR+J|^3QX&bBWr!yYbHbLL2tGz&>0rz`u<;rbEim4uz36ve#js0Cxl<
zI)|tYTFYRcraI4MZ37f-7r-5PEN>)6!}%h#LY$qI){9)UCZ!3m-!q0F7@taB=C0NN
zcKOj^A0VCD>jYI9po+At2GzjnNYPN$sx6ZM$jR?2g#E61iyNLOdNcUD6#ibrGa>pr
z_<!&hW3@eVx>^D)Sl<&*P(`OnsEdBWE<tXrbr0w1ZP5Y41M!4G7qINYoX~f-P+ejd
z^wAL_{s(6bs`*R;)$Ei8W5fj~jivX^Ee$P)P_s0a>cU(-IEnITGfHVpg`c_=YZikE
zV`+y54j$w$TD1L!{xT{Ww{gi_@J?rKYi$ed>{HtUnT=C)M~Trj+Up`K_-ip@t58do
zTFX!RYdPxF%H)DM@k8soeH6Ws0*_R!i8@pE-UND!9S_}H;Nl<Bo=6iVec)#^H5ezx
zGk>O^p!rhATL$2Y6Q#gE^#sKefZ_=iic3@|n$X6PvGDHbTC~AmrV04JXPSinPfzpo
z@9n~!6vK0E-DtCSQO>)M(rkbk<<P9!y!OaGbHrhYvLi9&O^_0O4Q-GeT3w($Zx_Bt
zsF65Kgxh@k+^&C3Z9si}sITu)npJrjBhF18ag{c~K_Kynm$-q6`vT)>0G4*Q8)NHO
zBF)DA37o<SY0N){=;Ox<fNvwMz6P)1)HxOb{(E;Wtu~kZ)BO@?fni>N=rjRx{L`Zv
z$9U*<?RV!J+V4+4)_(Ib`${|Qufhs1%ORXadT@Y~EW^7oe<wa43U2v(EhxPTo?)^_
z=`57Un5|MdNu-t9-3mB~8*@=KCN;c;x(wSCL3^W(QhOcNj94WxI+X|d-_SICzRnsa
zdN6*l8*fyJ6!{g2u^)hBps!RYEKem?p|z{vzivXb;iEK%65KY`gLgDTNvn$&jv<^@
zNman``PXRAi2GhAFV%JGn|9nQn1QCR3*Q*1XE4Tg*3r*N?RBfMH&>Qt_%?_Qw?UX1
zN`-ogN{+_MUKefQRz+Fi`P~ZOR-!0JfmZZq%=LtVr(Ro)Z>#%hm7v(fKZ0)q*xyGp
zkHOKH0n#*<fxU*;Li=gM3;-yo;)ws}kh0WsWX;n2C>QJ=O=q9CVJ*-RU$Z|3(ou`{
z8l39I(KO<FL4C)<d&Qhhtg?MHCI%-xpQ>o~YaC~w)W3Wy{jG^y+((IY8ai*eD9p39
z^bvkcPrN+1B-+z=0Fs2Ttk&w(%KFooHI2>ae*?;F!wSnrw2cAMwhJ?MU3k9<-v>(2
z&OuXm&E@DEU}%WVr_e&0Zs>yj!Uao4OKdW5rCcql_k`MM{%G2Jtq)vz?&#<}*?2*F
z(ss1pW#fYTlDjdcGzr<)Sk1o<sY$&;Cwh|IG>g0HgTIHaVGWR#z5P1Sg`#w>?s*|}
z_3;-%r%ULLVs&QqJRiz9{(NXA-e%x_Cf@gz&BU9`!kKtpqs+pW3&rkS-SZ;Kdr>X#
z#c+9tQQl#c_ae%}FH%r>ht={9tK}i(FcCdUc}CAm$oo=ARHJ(6X(pbUzXw)bfTBx<
zqALu=%P8q(<nIC$`0eRZp?Fz^;$;;Iq`W{x($zh$puAVq@?Hs-cLe1fL3yvBJp3XB
zVRb|;?}%C+QeFV7SCRMCeym<aDX)gwzXw*Y0gBgDC|(Og@eh>r59EIhP~f-cH5H0~
zs8IYvg#sxrh}9b??+vxQH^Sw;j`Chdd2gUR{Pw(|miM|^-s@_4NO=LQ-bCIv`>}cx
zrMwwB@;$J68&JHhLh*JOinmbGTgd-5pulg>+bR@qsZhM7LV=VQ#Ohs?_pVyryW#TQ
zL3!_>ymwI^etX_k%X>#H?;W)~q`UxD?;-Dd{aC$+Qr-&%T6yqx;`N?zj0DNUrm!7y
z**<U;JPSB;maLNj$=n7lfp|v~#xKRCAd=7v-cT9}&OfM0)RV7hzyEwy`+fEU?RWdD
znxt)=iZ#Orptm0wkhD#Bchhs4q&@bWq)OcPpJUK4Ie(pG_Fdicen|EWNFZ*I%%zh<
zYdo`hj)n$O49G%~PkQuWL|zYkp*dYGR+LuI4EH^v849hma_75JV8vxcQftQXqaj^O
z0xXXsX9aeoCFA(}A<Zk0P;c;Yz9TK+r@BB(O=n^i`2iB@IbU=5y%wh;;7xn@4f#K!
z^I?y1=s}LhNDCk9<j@P8Uxzv9YW~NN?*Y8M-&pGpv~;O!<5OD${qeB87y!rC_Nrp7
z7I@quPrQ6;)l8(6T4X@}UuQkg<ffvQsj9a1(HIG(-tJ=fzt-hVrM@mk+?w}*)~~%s
zwBK*S{odK5J@0r$>+g<B5Kp)tXU**&=<gQ1`^f>Vzdt&l^>@z!26|Lb_iWTX`>|Vm
zHK_4VV}Oa@nkx9*t<e-93_}6lVSAbSf9bGazJLF({$Bn6i&jrdY0Ir>!&lBw@4F+t
z{T+QD>8a`q^i=J)dTJX|R<+!ZS{^y$@eBPlWv}x<V|U|Cgmxg6ZHdsixHyYA@Rs~u
zyfpAkTKT|}Q0Kx<Qf{C50JmP~r%Ry@&sBQM^r&*|uo8JM+02?%Mb=Bm(189cNB@;S
zW=HQG9u0jCwk7s110Nau?OFBPK+PusM`9FQYWc9q2cU36Lnf{zfa(RmU8VZ3Mr*pC
zgxW5dL^SG}q`;qG6mRiWVN^Umy0_)2ma9(uJwzIYw&s9zjA^RB=Bf|ghMv&`J);}^
zuom>!(9i2GtZ)3M+<Ev|Vd8C9gHMqD@_v}xYaDwf-e&ZGU*kPV=J!-?|DMY2k#ZPr
z-wl1^D7gL6er|sh-2UkIkjzP~NiC;Kl3GcB(zlYYhHJIM#?rN97V28pC<!eWl2$)#
z{ULJxP|Z2MRce{uBDGFO&Q#<~MNSzxhl_P~x4K(2t;pS)*>VK!Pxk34#2ODso}u<>
zMx&~!tF~}k*glQeucVDe^Y#e87V5~0uxp~Hzh?zl{NI(fZlVIo#`$N%))V}f;lJc}
zf&XhZp1qEwkKoJn4Aju>mSFYuw)TRn3pI*r?GoqKo;_jf*NxR%LcIj)l>kdbnn=*c
zUm2s(^gtZ~-X0he;qPR>wT}6h%6qqhm;SC@<FWF~+HXde_RAmFeviMb@!pupq2R-9
zq2QXf0p5Gsh4akYHQqb5gQ>FC)!|k#z8$i*q&4f`NZR4KDe>7`|3CR`)%W7F8(S6Z
zK3fA0IPR3d+FLw>_-usxVXxppGIrp7v<&^F7~RIzW8P}n)=H}*G`)ZqkMv8)25{nm
zC$bhBk+QaB2jF<SZ#DSdJ>YxyKyG1AY|Qr5;?0A2^WbBR*r$;TULz7s@$dr*{?p)d
zI#{lwyEy!hdzmQg#P^~wO8?uJHM(LdUEvh>D2}i9R{5i;kYvC}p-S~2M878~V3DHV
zkQ|79CP}bWtWqU`_Fkjoh%C4aEob+Q2Rvim6xiULdYnETohPX-`n$a@E3o%5J+3cX
zs$elsZ>GI=A}i+hBt@qssW4iK)YS9Fw`zj+8C?_h1cHpH^>_PDmkJh#*jL)^&kTI>
zm=4!?Um|ocElN2Oq5R7v_#j%lA)y??ccrUHA{&^}l14Q!f5=7oD9*hx+}IvD?AYc8
zjqPtnH-IZN_(^^py2y?H&s|ijO0h;nNLTYQqdj=%zevIVmW#Suo`pnvdqAS8a~Unz
zpOgtwz&;7HdNJbze>K4OIST9CF{}1pZR)Cg?GD~3ZN~3fP+a(H9mP6u!9_@a=oKq2
zN*}&c)AyG3`hOs`AQC@KtwT#+e8KWhB0Zg@Ik<e+1<UV7dYV%rzBDkWL~EM|;Bc3d
zXR$M7;5(gl75VOkPtDVG;cr5H<lCV|HQD9^dhTxgx9V#;`!?KdnJvc3HJzt68aoXp
zeP?n_P3LXv^){zq?BrtfokEr2z~~s9PR85ByYlWd?C91@e3rFS;HtCRZ8~h*$Sag8
z@<e4CJM}Ra9T;t@>0GxlQKqlFw=c)CU`Mx6iaDTLuQy}2j5ceh$kA^kr_RdhtFzas
zWmf3ix=bC;oD9je(`!52cJCw|O>zdIzwq4YJyY1Mosyi&^tNS=IO}hn#QTj_-PqG*
zS%`KYX{}P)6~SybWh%Vc$UJVWGYT~P!HNs}{BNuF>TNbBS88L|vtKd6Tj$PpZ*gyS
z$CgY&OKhli$scAV%Q5QtkH-@;n08l}crAmp!?}<f^Q-dA#X76m>GGVdFj@@`optxf
zO$!&`1W7LV0&-|~YZ4biGVrKnWB!|2=3>3oBDy@Mki#hGtvc3M!K01VSG5=Gm5GuS
zs{TgcG0VEqd8#ZEcvw|DM02u=hn_7Of``s4%GtKxId)j?6K6A{^&Y1Iv~0kxUDV$@
z;Zri&Ob*g6xS*WqVpRH-*0ONvasQ^3bY7P{$M&Y<iG?S#YF^rKSDT;XVk>Pbj*Ee#
zc4tcDnM-biUNE>_&aKkgB?axGrM$X7&nF2TzJJ#)b68b=d+|cHEnPxO=&hLwr%+3@
zD_kjWUaP(}s&A>EwYLwaLm!93n9>fs<<eu(DnG-y4K;4$^~SMGcR}%Fc_G{Eu6Zfu
z@Co2Wlu+ls26PZx{9|@I>-BHQ3uXPcKTgH=SV9KQq@=#RFQFNjO7H+iXu#?$Vgjf@
zZ#9An49>F^f@jl0Ep=yqzMrc3YF^?FeCgvjjT&@Tlk;|#;W=Glwyt+>T1b?TRdUSN
zmGxm3sPMj;yi}IL_PdX`54f*Iyw>{aOwXo{Rw>pR<HSxpu={H|tE=^%J1wP76JH{Z
zWqL&qEH|iF7O@%Vp#iMAup)26U7uwg^lQDb2C!*&6BBqQsy*1HVwC~Pwt%wFpa(Ua
z&a83)CoT2${rM~j?Pv?a>D4HlDCcRSaJ4l~S5VGujItZhpO3ip#gk-Fem`wCyN*@o
zAIsY6F7Rx!>`WZX&Q$1?ooPDjuToA|WO!~%KZ~3tY3ERLcbYcttsLrl>GGX8=MCe3
z5=OtlHs4{ju2o0B-uk)o`;C5`m$U5}X{bbdteY%<l(oYjgP!fR)2OAphwM8*of<XI
zEw*BmFZaY*V^Gs%4{xdqkMcLw^h6UI)b!dIr}TF_*P)N@Q&(*nthHgN5(kYo!?$>n
zHrlp3c3NVbG?p#GeD=8adhhkD-ooj13&+c|(O;2qt?wV#*VtW5<9;`NZ~SRo2l~e~
zY(LHr9@jqxR$4!gw%`Aqt)QhU>QAp%)6WN|JCyb9R<nB-0%M&Te@1-C+>Z&3*w`T>
z_LgDC@dN5x>yWfUdMv93#TT(!Z_P`_whmweeqSugHvp5_Y@3^&9&&g4U-Qpq*RrkZ
znD0fZzh~XdirpLXQe|zlekMdl`GaVC8s*(lqkQ27NBOJ$`Kr`>G$MjgBf{joj)@o(
z2J7#gF^6?|G+Jn^>x<j7-p-oLs`A$5z2@$4zvaHCV;z@^QM~~p-5MU{`_)mt&QqO#
zGApxSi)E2BiT|az#e0K9BVCk<qYWMFO@57IQ_pJsR1FxlyEK9NwMoTn4X8CnrS3du
zU3h%2>`$4jrff#a;d=CXoXxw=eUV(ZFqkIFHuM4U9kdcCHXEa-7SdFb^U{v^;=I?f
zCEg7dy}rPEpV!4c_r)BJbMHqhR9kfVTtM$}+u3%vP+Y_c+z|@bSyzA)h@OgcZQM1b
z_xg5Q-b&Fc-RT@hXILA!);&`KA?OmN8<w!qMQ6$~Sau*DZEN{Wa-o=C)0wg^r`R&%
z)Q)L#%}b>lT6S>U3iih$eBY3gKVFWPGuT^&WAabt8H)8YI5{PM8NW+>#;cD@6-~C+
z9T~-(?F;AW3cc--k&D^mY&G+Hf94%+74@9H-8+@dV*Z@DW65uM2e+=sWV_g5CO#6+
zEt??eZLxM+`3g3*@N5Mi*Ohz=d)8acWa}cf$V>UF7e1SF+t}soY40p+GZXbc_0qfD
zGL>qwy_=%y5%D~0uQ;vPEhWh*tnH?CZnF|+v5kD(Yb`&gOtJhWnJd-v$C9Ohn-jb=
z3Un-^SYN^G7rHt9n<YlYpjeePin;J&h4EX&c$QiouR=eP?e|#AmtoGzpL4H6#<|Be
zogYK*`>Z;%1b6E$LaUA|<m28E3A=c%y=Z$8WD7e}M(x|M;Amk(zF4e2Rn>I<;a;&Y
zqqr=)Z~mG5t;I%lWLp`XAWUufI@+?_2^nsV;n#{e%$KW^_m_^g7{*qzE78Ih$ZFnv
z3v2dlV~ad{!0XyQTH9`O#+6e(BcGqlD>a>=b!N;Ow9e;?YdTK@+S40HvO^`-^81J{
zm~H&EqR9NY2Kl+tDVAEtc}2F&Og5HI;lF`*j#_9nyVGq#3-Nk=1x~Zj7r1kZIi*^<
zjjd4}j9STBK9y}_jK4W)8CvGQQmA%4zf6>wfBuN_pQIB-d<d%4+YUG~*+$PIP(_X9
zW={m>KcwHq3YZ<K{x)_IyBxo_kGu^fPDDB50~|jq{r>D2+XHHAnE0{DccC>bGpIFg
z7)d>PK<&}4aF5=l_UK|Jst`X8h>P5nfcQS|B9;xh(dcluoJN$GwqT)u{zzsm=hNd*
z?{mp|+hro=B+DMjr5-$p9!yC$DrV(kz%n}B!)76s*7l3pZ@iDQIo|p-z3nMsDvK+>
zm0gP7zh0!Ym-4k@CYuXft1Zp!&%l-Rj??J((;F>$BUw9o;H9((otTtQ(zwzT#(VFD
zF7;*ceePXpTHjxq^vm>7sB@~rsHCct8KbnN5!R23M8{LZSm%W4n0jdua9-$M1e|-*
z?qZ8sGV<T$7zHc|>qYGTG=gvj|K_L#=|nSSY0&%9V{BI@MfxGdsr5t1iLvJSBQW6f
zKlQYG{5d^NwA%bQB|%x07GukFG_!eZ1j;|)(Awt7l-=?oX2b~k5ik<G@qp_Gti)~6
z-|5!re^|WGeF!7Ws(8|tF~W!XcTs=JMa-gK=Pq$yUaZsS6uZIU7N~un>3AIVP!IW4
zJP3<)Ks^EYX_TWlG>Aty&XlcS0gSjiI4V0vnVd#+l*XSNMUX{kN=PGm{4!}dbA!^J
z_Ac^%*$>5PKyfFaxT+tD`DyCd=2wZ2vwgX7Gule^mOC7$6szR{wHJ1U$I69h&j&hK
z<Y`q$Dbd}uez-MS+LNY@>J8)Ov1)cQKRGX_xSEN1TXPDXtJ%1`hjTm*H{OHStlLz)
zTQ-67h#1SGt8v|Xs5pYvW7D)&xCs5W&pQRQPCa*{x83W{$#OpJb+cL4)hZ`#_wJTw
zsr~euX~YLc@V`$QXq{@TaDF?D#vt|8+G*5QpC&D4m4NOM&m7MK{UcU`zc$^@{yUxe
z8}PfgvE^z%7P&7`Td*4an2FxHEG-c|_~5t$-<fhnI;Z?7eR~m&y3%Qy4m$$6E1k?P
zVPw*{%z`wsR_)Gn!S1wHSNZ4IoDQOnC!9u`UNDb0LZTeR2B?3kIHn|8^o~o$PlY7d
z;EqwGfc~uLH7hRp7k)!!f<%(Ah`&^PEVrg}Y}JQ(IVDm+cUF)&#hJevDT=P^E1R{G
z>g*`0dC6LJ3evEqbJ0escRG_~gKeTC9yQ<WG~2qyk|g_0f4!%ZuR^UG-6plxH@!M#
zoJ3FxN;2_ozgsC)wwkw@;L9_+%!gHe9LrxR?gA|1){P@cTy;o=XTL|M%w{z{VNtC=
zn_;(1d0s&Jg9TUJjovyhHx*dyJ8?W@f>h9?&6|ZJc^Vdw#Q7B?>OEQ*Dw`XKuiBZP
zQ79JQ9F{w#u-qZ-@`wGfVRsO7hWTK+MKPfl_T%>!e~e;OE~>mOo$86Hq?%qxe<;V`
zd?e@hW8>Ji+<hmyLo?V|X`_#<!`0AJw)iJ9-ga^fAGar2ust<KwCNoQ<Fy`)DWr1#
zn0~74JZ$!O&Zubbb%lh>!|6Kqpnnnzq$kSD<SVU?*^@_J$xlq?4s&gfLOVOVYMR^x
z%WN*jz%|vRwN~Y|`LD_U#(ypQd)5(uyKfG9qA>Oi-$Amp4z&Xsdb2II5$BLr=kdj6
ztJMjuD{O(9!xm`FVRIg(rGC6L_BG#gl>2bx&Dz+V$o*CpUu=X8`b*fL=V61685?uh
znD+&8k#=e-S#$h+D3G=3`Aw-FKw6Vm^V0h2rMSDN!^-{g#7Ch`9qXjqPka)(r(*+h
z+zCrGXNcCiA6jc~R&~K6mc7mt{=dbT!<Wx)LitS#O{(-tlWP|Kl3m3cliPiy@pN0e
z{bb`2oL#_}-c5*I0LxLsG~OBTErj<u=CGa%01~~`<S;{nJyj9#3!Z44{nnv4bFpNB
zYB*c_aW*>OrEs2y#aX!!p3wX|OFqw9qvD2nLU}E)Bg~>PzC*=$BbNoeeHe@jys&G#
zvZ_7%EcZFD<bN)jav}c=g6z0%cHCNVjbbXq3Ig6Nj(|4S3_coDFr6I$^&OaRTRA0g
z-dt$;^{AT8e}W%=Qd13WY<`uJM-+BjnhveeZsnGpnnrhfamUhTSl<~p61?N=x|+^&
zRl4G{`6K5v_@D8=k=EpEvbY^z`}X)&cpgVRL?bPpo7vfl%@(Hv)~F+qpC)ei>e$Tm
zk?cdItzs%$?5%Mxa2J)VcORLSq`tdKeV6ZkqvTGvK5YtrGU;Ewcxxc#czQfW%1U;3
zn$db<9JSvuXb+<tkiY!Kq>bq#tR9CB{)pIgUYXA}c}d5SoLhWzi?k7!ke1D!1J!M{
z*qkD7#mb4xp>-WgKVP;yowHS>c+*m>vm7aWY0~GuI?JWbUf(~``xL!pu1Ff4H!P*D
zU>n_L#z;S6T!l_Q+Z`y;s~WG?#-#E3fP0N+CTq<Z>!fzHsU!ZCX|$fJ8sBbaE|1{Z
z>OEVbW6z|0?z7~7?W6Xh_xk~%j{P~EG~=4ikJSFi4fjV(Wz#g06C)reoUkKF-s|)~
zC@zFv;9$>!_dk<vQ@P3U(7&cpJQ>H$+C#Pq@i3Kxaobf}WM<KA*k9GE+9(;|%BPB4
zY<uCUym8QIU&+#R(D~4!CGzgsE^>0pylmpui`jMAu`*|y?1<$jIYwC~I)2ZaomW^>
z9amtFqP><$LMD0y^O)iIvL(z3zG%?vZAX*RamVSYocB^VTY^Jp`y>T^!f?t=+X>7K
zoJ#kyDb~|TOW2<*@2H+<@ON-mt(-rn^p?GvPUX<uOR&lQGaNJeaU2C4ohptgVH{KY
zalF)-X&dJx`1;BS2CDZ%%^MyC6X6z&!Yu&Y5`o+CDBLvYgGtY+*uAD=m!OucVHeB4
zkTlBj_av<?pG&#|`vUK^^d@H7+EL1Tz%yuMObp9!T_H(s3nVx!aqQ(>^OB|d^d64u
z^=I40ITo<#fV0jy$M)LTIqY>m7Yy*P`ZCzl6(^K*Nb|(;WYt|F8&tWP0ckGEANci^
z4po{j<S!TJu!dZ+WXHjh)#Q0h<z#tG{wMxdm*^||%C1%=x)~BZzUsUt(XoG5e03Tm
zy52U$F$484aK_jk9{Z~QdDYL=00^E}VK}BFS>8*Y2+6+QZB!v>fn-mSG^jP%9#Ca_
zt+@`eT{Q28Bqbfo%8wQwg=}|Lja6aeRoPwx*?uc)E*S-xu0W<MfA|&rq$Jl5E;i5b
zas-Q3DyO*2lKCS@W1|wI^rTyrV}65TtQ=ptCH-Vpg3QV9XWi3b;x^=A2I0O`dC8JZ
z9cdCQki1PDk4PhB#HV`h=}6aM%Sai1SJfLT%_x1i5dIzFzB*4ZYkeMf**zWOboX>z
z4C%C?nsR1(3XpG?F5+7`SU?_Bvqzk9GV5pT>#Q~Go{oLG>ikKv&hs;NXWkkn%*bM!
zI-Zs8=`cd>-Km=mu1}>5Euj!TaINNhIwo?Qd{4(ix=kGyr`B|CM9mLN4ms0fFBl(z
zRo=1WI#$Eh<-O^-i@o3xt$kULxi$6h1Y~+ldMdvX_aDRB8f(49^JCnb^}qFugw!<Z
zN8rCs-|ERMPO@rVVNri8wBuVmuHsDCX1Ue#^4lRfuC30^uPJV0*XHjpj)l*mrsQBw
ztka_8VVAe_&^2ID*H~6=Dv8h2BviqY%(#b#kx&OAp$<Yq9h`4bB~*c>%2_K<1|5)2
z^=-eva#c$UmAzLuprtKgns*>tOAD2;0LPstT@Ir<Vy9{)zm~p$Z9|<8=KS9Ijn6dW
z2k^=NGrjf1+0fU%1i9O1RNwHnM3Ki1k%DckDB9j1qiJ3Ti~b6&t5BXj<5G47^tR8E
zbl~}B<xlBJ$Vnv~$DNMR*Q4nXJRXGH`Blo%^qQAUZ5XK-=CNjO*{i<EX*6<36EWcV
zdEcwPrD>Xc{!Enz`BgQY4foZ`zk;Nj7nXEx2idjPs<Ns$EUU<V)J4gvxo)2-t4xI#
zDPoj9P~({nS(S<wwy02h(n&TKvD>^q!2Cs?yBISU>)a=&(OU;_xD7Hp&poPSgF7Wn
z!+1%0t-KL3i*$&H%+g@gRZdnd7Lr*hQ8KH<y{ROLwL)e!fxn$leQRq~Sw;3W`PJki
z^8AqJY{0XYlCPWL+p%Vc8Gf`W@>`&)(hcNI+f!r!ZCO+~hj~Nz)yDBbF^h563UU$u
zN7chN9=!fN$2>L@JfTnZvHfx6BKX&u*lq0BLwszWC?DG-)yH;~iCczMB{m0qY^v`^
z^|HN_td)?-Mq97x_p+@U`v`m`P4FH>ylgANUbc5sFPmtJc-cy$ylf8D%SJw=Hq|Hd
z>G$-qJs9O>+wU34c;#pCR+x&&(^mf-p0+^P(^g&d_8?E&`%#{@UHQZL*&Yk~+1^Ks
zu5fCeuxfEJJYlhNXQ^zljlG3kg;v(=+cnJR+1hWxYkszdem~pd@AR|XtNOoElE$bq
zz{clA)l%;u?d<AgQ>o0K2~#{-(BzRMPtIcSC(V<yURpEA-?kP0wws`BEMU4Kf6l6~
z&+VqL&uw|SMk76{*R2!2kw-i&Y`f(a_G|D)%~SYD`X=U4y>1<27pq>kJ4UWyTl+mE
zvg&zx$f<cgq~t2rlFQ9#FSS~JH1dox+R~}^@T=h--lRgkDC~9H1h_Rn;eFo4@Hu3M
zeGV&BuiKt}uN$X&-Tn@*TZT9ty1~P$*X>U9W-`2PCS?-Fkt2O@Pu%C-s`~NnhUVO)
z`rSy^Ge&vd>O?m@Z;Ro1Yr25v?LgS`R$XLPjt}v?Jrwr5v83C+<#}sKqyBnar2d)~
z#(enx`XFr+d{pFlyIb{G5$228rf}IWkGfX%ye)=TBo>~x%afW|j_OB~oCT_nk%K4n
z5fAlP3)=G6Lws-Ls_!k5XTL+s^F+!Dd9muTDeU)U4d;8C6Xko$?@zgSknb%MKAT*X
z0^E)WCK2D;Vm1MAC#Tf{!_mO-M-HurMmQ$J*B$M9lhQQb(uq+7S;R|a4Ex^PY$K?n
ziuHa64B27N+iG!u{_b!P{XM99-X0H+nhVjN4|EXid7ID=wKlSw(zKDXZd?u^(L8Te
zVb9wwVb5D;zvpem1wC&MOw-2D1o-Qo^;XfGMVRLOIoZzt1}|OAn!>!a-Mb>}d#eij
z-ZsOx7HOTI!}s=98jVEqy{!uS-q2RSq>61%kF@$w&sz?1RJ+%?4d@jMxQ3|u-m1`#
zSE09lp!(h(2>aeHoVF6u?1uEW;e9hHCDTrqtu|&sf*mQ$fXC6Y9#{1r^HKxn4P=*D
zEhY!2T0gYE(KXppU~G)uVsVl_5xT?VA-jXV#A3DM4`KxG8Kp5-v{2M<BAznA<xIA~
z7)n)@P3h*krNF0W^qy*WeDRm*k-F=OhOax;nGHM4vP=q$i$Oe%g?AWiqYyJ3snuYM
zcTl|}Ft?`FY>TS-({#-$8d`54y;7Cq8H}^d6cK0h8>6i%JHtdCp@;RUs4LS;rSjg>
z*i~+-S|ab==#J=6#EYtn3`#6T6@2H+Ps9VK3wz*PXaNIS-KZQ(Pr)1^wS~?zcSy<q
zNT*n214r;B3$Sbvx1xFc-Y(QBcD7@|j{NQ6Ii_9t+Y4KZwWyX;^VLY^;1%D(AwG;l
z67(bui<&~hq8(Vg5(P;T%Np{1f4X9%*nxOJV}~9?^s(eO<HOW(DsQC4f>{e-#73w%
zk_9?1+b*XDu8fJZjB<J*=LN3-s}QR;7upP`%1-5<SwK4bwuR3wjLt>t?B$roT%#pb
z?bDNJ{Y1;vD&#JelBk~D9-ARXKcgVaHW|^BR3gpw{2}|!L1meg^942oVgm}s2VOk0
z+0&<t25pDd30^}*I{TeF)4k62kUO<xi+iGJoh^xtGG*D`O42hIB158KqW&>@?CeMG
z8uxUTRD2_>!M}y=T)vpr!OcV;{S}b(`m1d(ix<o3%xs(BAf5O&9nW;2+^axGE_n**
zsmOAXBMXrfJZM$4929Q{#)&Z*-aEr>erFN&$-$z1(B)&4`y`^rVw5ttjH4-20+*qz
zE1ly5&!4IFoK+lN*tIp)@ChQ0pjeVeGs5x);24it<HvwuGG_c!13!;h?46HTn)B6_
zZhfVlr89lS+os>T$FX{Mjjgie64S-3#&(Z;sp*TodPQ5Acb?<X#5Pduuh`j=Y{Zt#
zfkk^+%mQ}ETgVJ?u__iHoiTgj5XrL5J=dLIvfaH#LBtKbdH(t2&$GhUR0qG&ezc@N
z$Lx%QtwbLAn?(P7=;6@CKd#Z0#I2<H)f?D&d`m1mw~CL;>DT<`ur9S#5F-Z~Faw(C
zk@sy)Ff#69qCDTw;Jr43MG^I%`*r%3>_ZD>ruEn4lxx#3hQDlmcsyQ%{&=>8<^!}I
zX;<q$m~Mj{OpMZDZeVv7y{dlm!DCK+rfD;KV4)oe_o4~56?u&*nlJ~vW@s$o1Oeyx
ziijuF8xABRmQdfxR}GFO6u5V?5@p_dS6)XpW+XQB&5J}D>N`iTr$|A;Bd9g}&teM&
zj-m<$I0xNoJmJ$r;t7fSk7jEd>n!o29WggsEwQ4A=se9ACUAnvg%Noe{uR_%8_K1(
zCSe4BJ2GvF+u9#%NSvAC4Rv0DQ)LNqQDkByqVJ<H4|D})>Ked%uyaJO8SzF~v#t~5
zmTc?>Uav*U5YN;2C952q@(b?UDLHPoZVq<lFyPxScL2(G15WthQSLi<(}eivzOs>0
zP3O+oD|Wa7ZQPm0EY`re)cTET{Rfe5clJ5dug&LQT05hb;x9EAM7FkhdX7N=eM)N^
zU&(S+8jwF4{$0aCh1RfRgl6igT|&p+3H6sZ1gA~I<?hGH6_}yBea96$&NL2&`NtQ4
znPNqZ+^nZ1d9p0CEStd*qfC;B@*Q=@{Y4F2;OZ=+Rdi+s#$*HAz`FOj;J+@;U|aGg
zA(lJ(?I#yY0n3#v|DgN!g;L<8;W>8&``Uk?!l)2TXLig6-y1cgCB_fIh2kP2cuPa@
zwhc+Et=S=J!!BJN*rlt3T5ce}E8rbOH=*Fip>I=z)@QCj(U7#S4U_h3qYHk_k=z`c
z#aX$HvzeUN1fFR%(IqVi{IxX>*UwmPz=0FF9sZ=cP;d`Q$!EHo##4+1)<P#(S#xHf
zrS+R8Gb=)CwzML)nj^UX0?a=((rMo0DWwy=i|SnLCp%2Gk&fHh++}lFW<Z*s8({OR
zDy;ag!&4Gl%H`tM%&hpolry4*Ausq0mSM9xJ+K<#m*F$er=c>v6kl$#SsZf#AC+NI
zsFbCc1EboXRNI}#1nm?=Q1B>I@Ru;5ZfQC8%~7e6+LqGHYA#_lcx#NjMV$GpW;@Gg
z)#aZzohsvkCKV^GFAiqY=?d}IFUw|{68&pD7X`YwU-oo|XjcZe-{V*Ox4^$?Wpi0;
z<2pZg6BjJd3y`5!G1JGe<G8_bsv^^$i+$IG2MAU@qn`g7bjx!Lxu{*T0&Cg`FQtOo
zMUN*9JM6TB_tJc7AMA?Mwv?L}sBN?0%B{;n|9Ki1Z*tIXbSq@LR3vj;QQaIw4~BxT
zohM#kk~ppsX}(Ny)d}@l+bR8RHwR~l%wbPAaKY2DCiV-o_7Zzfg&BGf#mwj0t850$
z%~+&R@F|p*s-PbJ^Av5)f%^NbaWd$M&ihOa{DQ08Mp5K%RnR{5mP#JE>Qxwo`aL-3
zV4Gh-nVwid_V}}GG0?~r|88k6YpdXb`vuPSkg(0SfZcav!in>tyZzQm>+CJ+{aQbK
zOTkC&Skr6c9jmb_W92#88)5mm_0n9lh#A)aZD~~HRw-;SZJ|#Q`^MRRpq7z)?rz^U
zUoOu(vk<WX`oKz(Q1I$=xoBA{uA(|KT5iP?o`z6x#<?G(O;07QeG>D{&F(;3Yi8h3
zYgXWJ>lb@DJn8VH#}gO)G)_W12N!%Tew93D)qM2l9A;5$_$}wC{P=U`xQoTb*eOlI
z7lQS^rWL*j7D+63FVTS3^U>pCG1e_<a8XYe)KjVDoJFEl6V*5^3Hv|9>MK`-caz+!
zj)hND{Tu6b&q?xvz#@MfuC&dZG7+QrMLu3Jd)@hLk!#COPDqIHM<4J97tYQ9*Wy(@
z5;sv@QSgLX4)LeVK*KH_t`1dBa>rgYaoi_HoT&%?*|3X7l=c-T>|qw<Srg8&(Z1j}
z{3ZBj6EFf_k^J+4cTt@U|2LG5P?99#4rW%4U`DfZcf+(TyPHooyP7M(XBu|>WDmx-
zS~J%Fnx;K9$M#`Tq@1EUEBeT_ndQVdY1Z6|!A&W?Nup6k&_5SL{La8V-r#E7gjE4X
z=j3KeSuaouSL5Riymv#40G}wOGjo&K_%O%H_?{d~tDkpJspsvOe{+V)%+eghlRNNc
z0i@=Ic^3Khv{=U&PLgLbnVoxTW{yS0<rUMN3th|<7vo?I^F|WUmASBjwe*BSS7DYn
zMhaCRC{Bz4B^08jrFP!-uaxr(f5_V$mm;45<I4m%Mlkxi(0;H$<CB_vqIDK|+>}7~
z`89izuA2-ie>PGb*Hzg@IIce45+bd=4xUra_9|jU*5Z_O+5S>$yqe0OU%(8NdMR!t
zNst)llv05|opb|><>SQ{7MjB~>sY*+Z<IZQZyqVguP&j~PbM#5Q%Wu6yHDsif!{fn
zAZT4Ov!^9QWBgXV_DuIZI^S_qNGE3;e-<JCeXC54DFGI0U6REt(!6p?SJRnX)w(2?
z={)fNOZVL<^qdd5%PlKso%mbm2;Y}7^F&)H6Snn7zUxTyiJy6VZ|KZ|%)&35FjtN-
zu-X2j)Z0cp<j4&i*k#3a_ma&gLZJdB4!h+|3Y2hh(k$edk|W{1v^2v!6SlRSlaZTY
zT0X+!SPYr;w^EZd51i~W#UMSIeWQ|b+!vx<1ofq@Jx9+QvGDDy^M2e>8bA<ZmNwpK
zKi&}{Xmo`mSpeg9f}P@p=CZGwe%RasPI!}j*73HGBu^RPa4OrDm-2iDpfEf5+>D;R
zA=}DP3NP`PIWZ|Q5|<+>%ruv^RJi1ssJq(6BVLEnPn<2~jB+N7V2F<y4M_8pc<CZ#
zG-v}{$7*pX+p1Br!C?X93vfopx>9AE$lDz*#bjB8GOaeVV}78kby}qj|8pcA$}m>W
zmWr6&n(4fOB`?gE)>alkM~?KERNmY4k<T4)GY%JPUbDkq=WXDEYam0KMe6_E(%s1M
zC+Bwj-z^mIANj^P3hQRuY!0q;e&Eg47PQojm@m8(b-vk}BGI~FU&wrb*As2tW7L(p
zWM4RqAn8jz+gf_ogg9kNU`?o{=e7{FIpvS5oORtCwpdy383DWP5@nplu0Y>6)p#<F
zw}u3)=7HrUc@|#FtR9y~lv_?5JzoPFHaMmh7}1A&Lt@TIfh(nvb|urR<IEz?#cCdl
zLL=eHc;5C+%9UOhKL;gc2U>O+aD9pK1-&wcXWDq#9$%%FaK$hs+@qFog;(MyI7ky)
zfN@17SH;7w=0~GFE>!ob{<_VMD^Ik97O<<*Cd-$now*s&R^Vt99d!=83>H1{WJE1)
zg*0-;>~8F<*xkH9POs1Wv0KTl+|!L!UiT--4rwyzKyX-BdPsIVS3t6G!KXOLeMA;m
zNCMXBCHl(QK2AzkrNX{&9aO{9jgxy4IWzWf;*{OZl})>wK2!OtnR~jK;Gwj<{9Fvl
zkWG!8ZBs*$gS;m=?b~5Jk;si-Y5gFPJGKf^t;fM_g61_P;Nfx_PUYK|44)>a$yk{t
zJ$_^Dj!Y$PCC|H@yoE|KI|SPpQHV=+&QxqtDn=X6WA@Nu$D9er(+-$3%X!}F$Wm+U
zK#c_rTzzJfSsH+Wt9P&DxaXgIjqgesEopFC9Gi|$;Bv6nB_~%e5$Xs=f{*9v%fzTJ
zIZeP3`=MGKRoR=G_(n08o6k3Mr8#O#kd#4J7$wLV3+&AXe-q~3JppB3m%rP;tFg2W
zk!qC&<wTi)cZHzP1#-@|0ve^_a@i`G*hyLqpe&c;Rz9*s=s6eCDON~@^YJ<h*5a^k
zchyZEPu$9_@{+n0+eXXVuNO9pIlW1nz|#czlI2TKPJuj2k`RkKLeRz8oC{>jO0#Wd
za=YJrVCD$DWJcLG$sEV*3#_M8a<<W!_-0IjY(~sLZeYT0D_zR+ZJw>zWz-S3^3~$6
z;T0gtFo@RtuP`HdMmHH}O}1t4FWik<iLxF}(kY&8UX+yNFx%o`bBxD*2=$*62_qiZ
z+y|BObjS!QTfu)JtdObQP2dW*mR4>P_!y^7K3`^nw4vXhr%#9We;EAw@Gg!6EZa!C
zj$28&36gJ;aQf9Q4j1Htmya_$B5870#-VR(Pgvk(aIYs>wAVQ=VB2lM1v$s%prjd)
z1vcPm+ijnXxn2b=>&#@{oL;Qsn-}1amfM}W=hQ08N~E@&LtVY7t9O?Oj{t{!9P-_@
zWZ{y`K=-bk%{u(I$U<@5l7h{AA=TCEr`n7X<>zdjNtN5Wn-X)XOSw{=Nogjjpf60E
zFBVJ9ymC`h!`|*@N>?eG<BG*=15<a$;<}kVSAI=k_HM4yIKzZrPn^ZE@y6N{CqwI(
z)b>o^+}TFydEXbSY9J{y06*>bI~RH{FN@5roT<3y#)2IiZ%jCTE~MutiaK5r?ff_~
zPOg=|SmoJF)V9QWCTaBSEXFS|VGoyrZJ)2o*$nO|F2?)h*_q+@^RnUhu*5iG<$G?t
ze-FR%*pt?k9lS3oR^pY0o{PEJu%+C~0u|$-S^iZQx3ar&SM#!Zp<EBX9^q6N5a1#G
zwpiHWsx(4NhrQKXCita5Bew>Y7Oi`p%cip_%v})*ww$J2>gW0=`HAOVsW*F=YK6^Z
zzwnR1Y6r5wX4zE@5B%qZaf+(jxv-0wW{uAJp1Pe8Yif#6L+!uS;>ZWVbLXC-I>yWY
zGn@D8y;KirX}#ZB4{2^+8_BXAu&)`b+<~YY=j6tdjnx*DV3&W9J!<=uebd1&$aY?a
z5-(Bp>%kUMRYel4W3ry3t&E|in8KxGp_JjRZn6QtQtb@dA#J>@L$roVPKMk_ZEPTj
z9Cq2W)wO;6zF28C;CXLUhRx`Zz?rPhcnPQ5XBQw^GDaj_wkK&0W7Zf*64wKI$)sqp
zB+sA*4l->rq7dkG?=XxgcTIK@Fufdgkp*B<HSjBKoNc;8wRmlpI6rLI-Js*gI$e!A
z*vNAj_TV_h*;4U+%9BakU7M%ubLWW8H7X1a_4|kT9*^{W6|UwuDWClfI=~!6q*_76
zw^@nPt;vp1Fv&KWg8@v80k>0VrLUVzED0Jp*&-QyUm4BEMCkBSwViGUjZ8;m{Q%6t
zSk5+1Kx~|7hBe+-HUe;7`?c8`>-d-32rZf@@Tal#*8O#?imjOI+7b$$_(t>fX}(L%
z|8cF3lau8HdDaL~)Xiuw{xY94j1-Q{KDBC$vb``t););z-Gbo|C+hCkJ*c}s%eGZE
z3O|MKFAI9>j&6gLyj8cIp7Dorx;#|UyzJ3RZJ{3XI7epJbY`yCAF#)aKVYAoC{t<r
z`#ro~5V%Cl=WX{U$gu5El3vnnM=A3p%$)GDo9PAJ_Jla=?4yag?YiynLUJfZUbf49
zH}l24fO4$xcy|(KsZFTGTsk)wmz|FnP8D*8MO#8GpfS9)i0&=8mkcrBTB$3?uWVn{
zv8oDDMwYD!TX%HFau$8eVf!@}C_QdNmp9X(7ZSGKg*a!sS5oPS^bmm|YM%3K#l9g)
zU#zmo)|EM1g$FpCt9k~rC)8W;3$xP|7CF~T>8<5DIcF<mznbQBe;V?;QE5CI153*S
zX-y|oS;~{)i#?SzH*o%ZcA%=tE}H|P^9I}@ZEc1}#Md(^xvUnx_CN(F%3(*it3}=f
ziwM>fp7?S>eb$Gcg>qhfHsJaFB&04U7&YG^oz=o|B7=S|aLQFu4q{&W%6M}kO94y?
zGReer(ON!Bh3Oi=G#8L0$R@yK#@#rHpkkg3d{4qW7eRFlP>sa>M-{av&V^_^Sj%hS
zli}czqq`99jG~<(a?TP+v0C+Jok{c(Of*MHzE4g2<br(IH>bfWvQLdt;8)=J2^cZ6
zn8BJTEC?vO<8Z|?_^E8_ig`06y{&TFsU)-wtehmNsjRn&{4R;$L9y)gf|Ib4UbVX9
z%z$UN4%e;9UzN?PXmr<{H`+KQ!%X*bh%e8uW|)OiW-{Aio#a_e!u!?dZ!Z`LJ*pNX
z+XR0=D46-RAdjloxDAb>12L23`GLxP)UuqcgZHL#UnL*s<hBWNX`O3Z-Sq{V1-b5e
z&*n_84jw7c8d^C<gf_bJ6Lq#$$JRsJTVtFXc(B8ai=<pUyC1uY-2uzGzxPmnR-mgx
zkBi=M$2=pcZSq+v<QI?L#@rv?Q=6VcKijy;atZwFy24}le%zG7R{LD_RldrmTHo%b
z2H(l17R0Xa?h&}(uFS{k&E*x_!H0h5&?zev?8kCmtC_e~_zz{rbOQRkNG*gh=KJu!
zy0g8yx-+vTvpA;H;tuEdAEYPWW(=p3^)m$9On4$n<d&YZAzh_GIkw8Ic$HMFZmqs4
zPnmADJA`drZk-457aVWBL=YY@AYR$Ba$@Cj%LE}7y8JEBBU1zeVgT_Dk*U^|Ne>tl
zz>N|7Uee+?yE7m02Bc|(g4O4EXvLvm$yb6b1xh)Z3DHX$ha_30?Jwcmb9#?py9e6d
z-alJ$37gmSd=r|>R#)hhwMqr3WZgNVVyrB$7%BUn$_#v5pbMmI_!+ZbCvD?`Z;iIe
zuDq&c)ukiKKU^Y$EAYIu&FRPt96qcIym%P<oQ%$3DS3BbC-lRI(dz2EXGe>91<E1!
z!G#-_r95zTc2%jF|CxET^k1IIpyWu-KMj+!F)C;J10%|3cwF+NZP8`djxJEdJSyA7
z`0|a*(jS=ZvCA&`meRQLv2peX;#NMGQX(%|^~WXTfsO%wJI~GB$zyFuDA@6(Aa^UV
zQr`|6-fuWZUfUMD(^^k!IkGAva~iI|tReFZjYvKGT$U?v`H-}~`Hr-1q~+MaEED$Y
z8zwc)ebIPw1?K9`Hu@VII7yw?iov`V&MZNWhU~ML*V1N9X;v#TKQeC!EOUk_o%pF4
zBkv}$y^Ob(3Giz8v9CS6vJnrwbMI2j)`)xaL2)=wYcKX3*JWToY%L9kUwAlaR>F2Q
z=&QTKimTU`RM!GsJj2sh;mbZ$#FuvEYCLUqb37Xjx=sFqVaDSUoI5dGT}klbX?6Wc
zH@NPZ7pU9hOp<$j0_3|HGXY&+2(p4%L475S?JTD8Y0c+pz+BLlLG`8|2Zsk7OSu!P
zs5a=4_@4wVWTlSwS<!G3>co6YU9~075rLV?j^O{8(aUAB+$Rn#tSB$V9DR8?=H;B5
z8fu#`WBNo+1D-@rlL>aEi1rfq(w;owJM8Kd?^u9Z;&4r=%VO62c+{Pyi<ei_6<og@
z_MZkpV%@gvGZmM34i&|g-&2%s9pOy(E-vM*DV_{7!Tq$C;EqFHK{vyi=$xT`HTU<5
zP<Q7-O81PK4lNu!i=G|Yk5^fF=dZmQ?|jV29lI)q@FdTz7Dp>V_8QT~OW=uuM-J_+
z#mPKo3>|y>yi3ODDw|neU9?CsSrug@+LoD5tV*+9=8V)u^g`{n6f3_fJ^xf;LTdvu
zE_erY%1Am&6QQjbG2P>;pCR>Bm@sPpaGvHhXx{S@=|qJM7Ema7_B4(2_|PPl3N607
z++`ix-&4^wuJ%wH{6%d8F8Iq~S|BYvmI&wPAR9S3P)3r%RVS9`6fRP9z>7C$)ul=t
zmr!@NWsFnDlw~y*!BOx;CVIWLVH0}24l^lu5_6iskL#_>AX&Xa{SubwRmvyVL;7>x
zC$g||MdLWCw?x*on+heX?qcaymROhKHF<dJI0yKxV|00USyth1EMr8fZJj0l0=3zw
zHYpZ$C6kV!*7A0eL7m4is3YNH)hELt3dUGjidmmbrj(n(8<)%T0RO3^EGg6G7H?9P
zvo}1Jx)EL@;`uWixgPSD&apAfpCLUz)$zwCT$quAmu0VBDy`4-+`V@^>dSe;ZL^CU
zXl;~SyJRi996qQyNL7hc3Q}#@>yhK7(b%zL+Y-;-&3g^v3Vc~w?}kQEgS!IRUN1;H
zD&8nal9!gxu_e?OsHs+=9VgXi+VtYxd$m#hC-e{TIt%uHBx>N53Y_&RlKpLO^IH@F
zcg^-LzfReNyC>}3n5ns4pTVjy-r9YXZioGdk5WBs-=vUldb_=^Yz}DpBIpqG{eHVn
zE#+SPQW<yK`x-Pp7Ck36ct)(8(`Llx>or(b+cij5+7WNmln-xdphAzb&gwI;>arIr
zBB`bu!jLQuLsDed_Rb<rl5jMu7Aei5Wd$<!(VSUTc-}N)pJvzM)Hl43aP5qJWa<6`
z-1r|IUg{;M88gqCO-t!%HhC$>1<xT>Uz!zHmQC-Zxn(Z+85DCZ)~-Z$vD3}d*|C*o
zB^PrD@#U%IXlc<dpGuD}ujx#x(gF7UiJY7-2UdnE1ld$SBM`%7&KSS4>LEPWn_*+*
z2Hpi6?{*jwNsArsf*<Or|0t@C<GuuLmC(Vc|4hm~61RLByxW{&S^np4lMsXXgFh~T
zPP2+rF2Va=f54w|-E4LjYMlT-`%lFwfxh!4*Kt^rM^<B+p0h27T}$6N%uRU&Zu!mf
z(6Y#Xz6IVQN~J?79+a~3{FWu~e<@y+GFKo92?d}0j3U7L@I?Uj>2=g==XB}y8PXjr
z<M;z1-gdCU;fP0%q7ASV0(&_QljAsY&}wEX2W^NLC@%Q6&I~&@2KIJ)g$}tNMQ)QV
z4iOtKjzzx*Lgl=L*2HxCstfcIyn(8Y`e(FQrEv~Lbx=$PVn7&X-MFA-6vcLY5Z>EK
zKPnQ_K@lC#F6?yAW#9PQpy_eJ)%`7>8Ti#cH!dA64%ay&58KZGUtw?jWZ8r{fOz@0
zSm{J^{WN;;IC}87N=ZZ|xq*{-KB+z%Me5Cckbl}Q^{Q$~s2oRq3csQ6^o$*-RSUt2
zU(8F{Mk6|j<e?_z;1v|;33ezhjVf~kTS22+L8I`Fq7<zzDvR`612m%Cz?*>R&5pjE
zlvjhU1^212>8Hp!pgta#ZROG%GwWB>$?VFVXIB-#lls_=S@qEWLL(sOJs3%zeLSKD
z7GU<<fqkSG;mx9bMfH5$ZKa4c8j%|)#GAr>Wc|Qut=CIMsO@;inw``-LjAR9$yi*}
zvec^AB5KfxeVKaWjnbdcnsF;h=CxQ(rx-CJ<K$BA`{&3FxTjcg!Eb>cpmp%ktu*k?
z228Z^HUgt<HY?>q!R~Xez_VNfT3;L2E;a(OpC)-A#_3c_D0t~VNv{>^zl5(s(;@qo
zHw@8GFH+MC7ss`za-cNQOh*ipGE(l^<|dRp9?@YLOi=aMe|>sko%%XJK3Grg9wv39
zY*%2%x6&W_j`SWt60L*p`Hr+1(0#0;FoFku4<nrxd6pn$BVOuh@Xo;{{dSm=w03m`
zZskamkFNLU!=wg*!>TkWUp9q;$3v0v^NBilAItrChY^uR|Fd~}gMg@C%#w4#W3lk1
zHiUv#eNtuXE4u@e?v+jE3QfXXfjw=tcqKjJ87NkXJf{@nFd$*B@Dm^S9b!j**M`|F
zj0TGSF!x7)xHe-R3bP}acP(~pF+yjY%Sh^!11Z<$)rer&joN>B`VKa@R;@;zD#<QX
z>sHjdHC!t}O0{Y*LatghZmGp`tTs+py{H+CPWt+TK#^4xC-AQ(E#ha6%C$86;1lCH
z=y~8KYFyncHV3itW?P!L(UxQyX<on-!24UYmJzeN2NxDy_eFZ+6UUx_Z#P%kVx663
z6A@XHVclXXP!JdNfE!jaX2CbRbIihN%%G5_6u0ur^c_#6?n7#Ju;5u(uhgdmsa^gU
zoGca;kqX-IU_R^I4xS$?jz^Rc=7by<Bg!xdvwWqP+Ebrm1PObwe?l~vZ4>HWb&8uS
zbGn?_kV3ybbr{~{I{4SJ5SP0Yenq~#)?ABcSPS5JrrZ(b*)}_7=-pf>$ep4+7oS1I
zHYbT&IAv>7Hs&!x!C(J#1Fb?-HszWM`SSSkHH9}cg(`IXb4h*K7`ZV*A%hRi3_nvU
zTJ}^tXKTT#r%n0h!aGYwKm)(hwka2$C|GjXzZ5%P&i{B(Q<d$>G4~?A0Q-+Cf+=}3
z)j0`eWfq<<dbuQ78G)MkMN<C3k~d0H;PL(BW0$<BAq`P^pMK-c&nOnRq}6Y2p!MCz
zi86Qe@oXz}KMO&x(|O)(5;w2T6}RZ6H=Dq#{aYKhHow^{HZN)h*Y*o_i}p|}UFG}*
zyR)CtiE7agpf{pC8=lHlN?(9Caky{>w0{{lK&2D>dc^#YmqSuhBK`-@%P<zSSRdGl
zdlslPxv<`%#NlokX99gL<MfiDQk%6V&6Pv!AkEXjvWI`%wK*qeo&#}fHu(D+Y>q<<
zud-fc)<M3L5AWWuT#Xr?sS@usSucUT6^E!y_-yc&d0fpd(AW>q4+Y97jO+36u1|%I
z9txiMl(S6|8GM3QnXdBADWDW&)qV-T{uuFgPp0?Yg|0@#xi>o`j-#0aUeqJsQRE{}
zqy>C}Y9bna64u=<=QVmIpJ61<Xv*d(IW};^q>lwT2NH?KHhJs&%BD!7q6dYHaVF&0
z9m^YOPQu`@V#TgEhsQ2O0=$-_lS~EWoJb0kxi)7O?rxZjSSX5wLVp@2Z=RmZ7f#+n
zy5Y%&lg&|<lB!|Y<r-UpxF{#V0eaL4yuHrgn3rvm@T3>`Ls>l9Pp6EO7UdY7&^$2z
z9Z%nM_Bx7vu=J<gq^3NzAi`fETY<42tA07%+Qww06&^q|31-!kG4_OdZxgT9VW%&k
zwa9L?q>C82D|WhMn(tVT5vImS-|=X+-Wu!V6zn*uu6x*$ZBY&`4EPQ3)4?Xe?2ipA
z>_Wl6pX|k6mUNf!p(w|$yq2Z%Mn^Ap6UKhJm1&6LpKY6fy%foBrTZ`gF%)$7)JaMH
zDLapu6MFjk<mbLS3tkRCHJm(HK)d9Hf)AXWTVPUC96y=CVkIs0`?%Ncesj{ra+Gtc
zu=@yBq*g66NVn~b_qZOIukP)1AgS9&I?uUPm8Gr+&~IoT%|}K!r*j!kuh~O5yBjia
z=1XQ>b%PXG#<ldE4C$CF*Vm(jIPeU3Cwcz~B{aP}*3@oe$|f_X(6^Z%ypDL5zEE2O
z#rZ5Mg;xR6fnq}XU<tJJoC+D0k*)t~8U;+qGtwvk7N=VgTCbG8Zqj4kjNbkpZ$~-c
zRW*!a|APO#F&}%QzeC?~=Gf6H%rsQ0C0-2g%$b}0{W-B`H@=!3DXg;e%(YbK<?yea
zGc>4Yz){)op&$LcNeI`z6!naAWIWB4rUn#_1EsF!Xs3Qyajh-Dj>jCa&?1!!h?(s2
z2`xJO&-6?QYzo<1ORkF@pQ{jEVGV<vT{#Qq$y|=}WaxaE%)pk+KG<~Y-=I@wJ`dv+
z3O@UOm5siO`S1fklRfU^aV=n*mUv)`l7<%wN=I`8FJ@W;%U-0@oM;^gcq8(ScVu91
zX~S$u;;@Ioai2xaSsj%#<(+w`*MeFp=jUq9MCAN`?7ew>Rn_(Xy-sqH+{6F@A_Pp~
zfS_T_B~lD2Vn#@iA%ut+QFD`fGeAgU1`Jebh=@oL859B0F9M}VDMqvi0Wl&XrIaF4
z1f-NOiIgv;l-hvEect<=dozjF@Ar9L&-2Ici5@<8@3V)s)}Gd0d!2Lq!ehw!S%$CS
zv`=BTbCffXz_1=s{qVaw<_;XCzJl|s$XIF>YP}4#>d6!O-(M=($FKtlS%CahoTBC8
zF;)6)1rOO5<@jdC@ExC@@#ULVc4e_ScE;c<kJ)EK?Ef&+52H-?>AUOvDfer$_1->V
zK*8tkWM?mXG<p5<S{0~o0zGJ7I8IrG6FnB^XWJ+%bZVx5RDJA3yKh>hOI~eyzr0Oc
z-rZ57IKzoK`-MBGAl@GH<rnPYws%$Srdrb$7#v!|?=5&2bmk2#zAn{=x6w!M!uY9D
z+3|vjK6}_58(h(;z9^cW+n!Z9hgG?a8K01G4Nnd<ot&ADxp4mZKdw#wX0op_m^`X4
zA8=PXs`9q*ji#~KM<0snT%_UO_F~5J!Z+~mvUYvfi}3PDRi|&tBjws1e{h5ae%*0+
z)SSY2-VOAK-BzF*kJxW>rkbZZnoPo@%c8JV0j~!LT^-#2CvkS)z&^K!rK#^G-3@&~
z9xC;)4@hftQ~y4r-W^_4>5x}%i?Y#shucr)cCV`z_4S>Qn%Jf41cO7%#4Y&VjIw_i
zY_Q4}%M*5^Cb?$5twVV0wEJqLm0#$!$-V1da^GfT*2LEFE>Nztn&KK2yVCv8BO0D~
zacF-kJjZRr+BCSvmJyd`<$CCmn70nBG?H8KR+HO86(8M^bcih^ECz|iw+c4vjNm=+
zdDXFX%tBo2s$B(Rc?!J>NgL1`v3Nm(x@*;~?rP{Iiq?q5`PJ*Ty9ydx&ySH?OMUIb
z$EK-oOU<;k_LLDrC@8IYInfDsAv+E{!=4G=PM^@jerA8v;cNU?!W2g?(%)XR<=nsB
z9Ws54E|~$WuFNF|D_u8=j90DDrcYZtqwQUS|It-~FLz9j`W0tz*Na}_Uq#*ZqKL(X
z)$5_JcU>hG3AIM4Z)e4&WfiDzXI%*VH$Ai7&GY6y!&!}1N^S1gw4d?4s2IK^63v%H
zv{rY7D}KUQRlWSXqWUPVtDOa{jlpj{<G?SARYbPfQl&;Wf>PC2NL<)8iroR34?R-x
z);ea9UJEN$O<I{L`76;6@#pn3Tm^p`dp7VNT`fDXn(MVZHBYbTe>d%;<()U*VQipV
zm-8f0@48s?+gPt;46t{Oif7gB&e`9?m-VRFjj{IVFJEN#xIJ{pkMu%O-xLpKM*moo
z%>Ge|-qxAV^UcdG=VqB>=vnvHvvqjL*wVM0tK(}bvFPc^_>f6W@irS6x3JeTEovtI
zU=hh7_!iroqj;N11gDt`&A5Me+>(iR1-(4Uh;V4Ol-pYsL@ZO@TYjO{nJRvO5urHB
zxbMs3Zu~n>U&2rLfljulEoY!0c+?}^!qtpu$9Fhvq56i`odsd|W5s-V)cwk1m9K>`
z%5_88!4d`zW)_V(dz8_Bxg#FCeD7^3H8bmE#@6){^*t9`tR&wN`U`t*j<O>?OHH?h
zDQ*-egSW;n95K-bA6GgmsmSSvHT6Z9t@x096Xvs}WSdX0JFGfWm803thH1eep%#r7
z!?U(_wtq9q`qJ15x7tCz{7s!vfsa?4P>VbKmFy16oPs6tcvxldr&!>Q7z;@8=P;`j
zKT^(dM?d0g3}MDxnu+%m-i&d`JIK}wdu#DF{PZ%noZaU(UNv(>>7@1Y(iL9*(NS@A
zQ;PX&#S7tY8Y?N|C!t05Hkq!RK;{B(KJ|Q{{)iuGb#fIqlfYcF)h={(;S(3JtXth<
z%(lK^0hzvp+pzPFy&0V`P3=jvSk{v+f2XIUsdSH$u1{#qxz}#CD!3b~?xZl~UEC>j
zRMeYiG_16bN+1V3ZNt}bMlpwT9UFeZy`rr0)@8JN)wXP=?cZIMUt)e##L^JYodw)c
zWk=vYdbp#-Nqb}PRx95eo{qC@nXMbRvqdTHf=%vT#?$nIr!7k*AlV4vElsbgZ@O)z
zZ`sVz*}6f3Go%-__+z`3(-WD){WC-HA5?yhdT0doOzogYX)kw5wwWPYxPP*Lcw2NQ
z{BRgGTNovh+$KDB>sV~tvjTZ`A~<8K&MbS<&6xxq0X(gIMvcwyK4YXP@@jb@QGv{L
zN+(`eeV}^5x!c9|GMXCuXf!pMbJkZD;L93Y*SAKv7Q7v@iSLP<KA`xOn7VWbU%C!?
zd%@Y;B?L`N)qK08u2f$wQRhcCGkjoWeeQv3uMV#E7xm_DJYsQ#>77&=+&+9ACGd20
z=$jh?-<X59l^<SFAxneaSF+|?!+JEFu#+K`ZNxh2sL#I5$g76ROcgrM*Kp5Q=dFw|
zy?V_P7yKQRr-84eWct08x2!UUT{~;6Z)O{wsPpCAet6x!;DEY6?E4u{vHQGroBh++
zkfoJ5ds2Nq7?bJq*4SklD}8K2bkN1F$qC))U4h}Tt15%HgkH|}Jr^Ren?^G)_<RtM
znNr7h+PJF76}SvfLiC8rvq{3;@jf3^o=cLyM+O$yRNuk3^ipKynItiI>Q*u<&n1eM
zIWDuC5s)0a%0Il4H^yGhj@|Tiq&;|6m@i)1!!x6Uei2%^>A%s(_5};nYJoxQ5|6}=
zO{mP_9fnY#L5-p~ZJCdU;tO3<>IOp7z#8^CZ`qc$g(lt!Pg>=#sVKSHF;?B>N-=#)
z1Cc;ux;RqO`e$s)zjS^|U2@HH?*#I1V`&38c}%Ve;%b}tusx;jacX<K#>Xt(7jM!L
zgo3!*CXPir&Esxf&BBRoU#{ByiB<*wzfTAm&ljuMM=i+o4fKQ8hmz0dhWX3tQTC7C
zv8CPSq4SfD=vk+|);QIJJU$;$YIkyvRBReiS5Z^@RuKPoimJ+p{_-=odh#JTxEKC7
zb9e@DPK~mgd~#Fiy}g!&E!1qh!+@AoH%D+Ui0eVlQ$OjZ<{x4FPTM%=Od>t8_9w}!
zZO-I(_N;n-wNK`i>K%s4wfbh*!b<k6_1SNCQx=ziuu14~I;RZj=s#P|rMp$C1vh)w
zJ?Jh<FzWu!b1oepVXw|=qMlMPLe>3BN{JZJy{-an$Y#bo34K+ap3Q7;){=g+Vq>Kv
zZ1LdC+SN9CCr`@HjIbv;bt8atr3W*s9AWHp+cHloy))HanOT_NZ&Ngg&np=^?^%uc
z@}S!=DjmkFs=j3EQ?+038qBPEE;8M&z9t%!W<Cc=`OMYJ)f$}YZj<R_1Uprp{x`iV
z)x!(p7pi&MNVZ{nu=&*85oe#1V-NgG*NTl6h4+{|T>DndcLB-WeggHT47+s7cWgO>
zWY|q>nE^(xyy&x^xs!SF+-9G?F(qMALMk#&edqI4OIEYyrzs9DSF7_IWj#pI)xJSl
zncSy)*4Hy1{bVDnKbj$L%7243@8YrFZaJIEJQ(^&oA5~PtJd`k@4WHBpyQ$OtRRYy
zz2BaToQb?_wl1Mc9u{{Wd>gi~%E9+9Y}ZVggcu|3F?>_CZCbawSoR9KDU&vts)RSc
zz0GJYVI|*B-QOplFFf-3ylX&m|IoaInXKq9@os>8=(E{-jcChOptrNFZ7!Yx3+SN>
zYW#R!buqsd*BHxHjm6(~UdX!-MyM4+59z+VRl&a^wcw=i5p^%qV_&X$&{hyS6g!1W
zIxSSY@DSU*q20`u9tU5Q!H<SL><H$00^RJLexX*WN#9y>Q0wdM4SgfVlmt&bnQ{m;
zmS?J`N;nNPDe1#qn>nkDAig3&X}kTIxl~ITufCEoh9|?~mG{W$G`(V@diuv|`LOWH
z)yg)rb7Na<Dy@uZ8&i}2xKR)9wRjSq66&i?JYQmqSUi2B)dLjQM{oF>z5mZQE;sl&
zDeYAG<le^lW*k<zcr13xs^>i+ZE4k07CmLzQ#QK>`*rXzW-G5<Sz6uC^DkCe*!Mgq
ztv$9W%V0};-`ItId9&;6m03}@8;qZq?dff>+^T07f(_2SL+|F4C~}hxyQ7Y8J^T4f
zZKC3Mw!}J%m0V@FR%fxQcEO5`U7Ir{FJ0=};4M9o)eNV+gimu0;I%rc6XFML{$V}P
zf|7W%k&mHgCQ-5<*X>cius_#e?^IS!4er%>u(Ifn<aaQal8UpbM6l>9JEpQ=D*L)i
zZpUv+Nw<fY-?D<LGAxOxyp{!Y+(Ik8e`dd^ST*ACR*s=xrt>VMvciU7A^3U2UchRl
zj&>L4Cr)8xX<;wx<82f8<!i%!*xH;oUOvsr7=Du{4Mmo&#HRbQePq}xP0I`nZz(5{
zJ2oZ+*RncXx!In4$^*GI`vJaJ>M6}e>^dxq+!-11iq`{M^(V`|sl2b(p=aC~-YGMJ
zXBv2Z-1NF`?JvP8Xc~Q9J{BK@hQ$}7(rr;{Eq)<m;Ta!^z>dBS?Mk!XOAWo=$a_Qe
z2;Q&41M+tE!hAy!8)<~0teifS8o=(&z>aKebD!?OTLj)*iLPR6751k2Y|+PlSiHmY
z-dOi`@85<j?ft&;)AsskKh8ZJZQYGVXFX@&)oa>Cr6l+S2ZX6_RQWEwjd3o*nW4l&
zWr!5}MX`5NZ>w>ie*CL{d!CiF&OtKqXYFiHO;s9Sm(1x2fyT95EedZ?HACCejBj#%
zsdE5yU+w6NS2}js-LZI1^6tr5b012qyE!ANPMi5*qK?n4AN?`J9$4_s$%v4<4E5ZT
z|AY?{jMTUZ`K;{W;S0|An&%tw_AqBpWVHb4sq>C_dx-NVW?1utZO+>Xhd@PO*y&u6
zX$dytdQk|opD(EcjL!D<_%QqOM2wgx&zAplvEOK(Wv33#*VUXBWT?@jW!mv<!aou#
zLbTn7)q`iikYqi(6?NZ|gYxNA65=Tg-b(8e8cDxaDgW;G3BD=H)7Upuo$Xt(bO&@<
z^0O+%_(d%CGt4vE<&!*byinel{82jZ#x;~I<L#~BC>gKLYaOkpdGs)zpRs=(X>p*^
ze`7vxJ_0Jb<1y2T`@QSR+@EK3ud5W>0;T0A;Ej_)D?W8T;!HOzktf^{XS$mfNj3Xu
ztkn<L6FIZ$U3VT21RujEFBU(P0K4*Z81IV}IXH~HUx%=flzf#G>X|{?B7E66x2Y8O
z>D2SlXSTVGbCk`Kg2uV-j8i3}Z6-fTdrpD6!NG09q?LMuRICI928L+(ag?!Jx8-j=
z*;;}P_i6vXS{hnEw6+)V>bO=EviMq&;^v`82E#{^-Eb;9ZZtcjJMhojcaRYO%IQ0h
zY+z>H7^D)QxH!4(m5czqo73R>37$XI!xYWl{%`4id<QwVYWLBZAyM_2ap_pMpm<K~
z!pGV!w58j4_mJX1$+u}bl_oAdD0AUsAq(g7^%hPu8hjX<rt_A!@Uc0uZ5P%i*wPzQ
zDvi^RHx^{RA7<aWsXKND-W&VAdUiM;o5YBPRpwsyTE_|49c-+;oFRny=J^@7<*C!5
zRt379nV6Zby*-T8ByU+d&+z$%wYRsXguG>zK6n+4#5e3g{6`+N2ajo0P?;I9%ShJk
zmvh@YaD5LAwqF~i-n#UUZ9Ss!P_XAO8*G0rry}8j%&?%~@LnU56Yj*;8O91e99z3l
z_on;9vC|UXu%(2U-<$GnRnP%1<$rGdXLY*yUL`rb2`#IWy&^%&Of}!obdUW`BQN1(
zZ2i^`dE@ME-u3?ROl^ERZ)@89%w@dzmXjVWo(J{S`<%YX)>0GLiiQORp{2%G4mZna
zwY%-S*<;_1e83*P+Lj)M4ftPw;S1W1Z+Y*0yT!jU-!iymV=Vq&K8qi)C-byIK=>$5
z4)wfN_=TvqcesCXV{$9?eYw>>JQ4J$y$f$o@4|DI>T6T#g#M3|7vd<em)r5oFiTKR
zZJswzVX6}}pFL@j_In!M9HnM`@%T%t_ESF7m$w<7_6sgZUbttQV_B!DrDhA(n=Kd=
zmPb44VOnP0wgAJHcb+pHE$^#s!392f>aG08wtYLfxA8RN&@ayyZNNVikB|hVW%C4D
z!JNFLz|Ns5bv<Hv&Q6r=-Ljz%{%kPM*Qk`0IquW5k9yA@+@~-7LD|uR3o@5!30l<e
zw}zQkuCU}kbu5OCz>p(bW9d7k`MMEYaD3Z;M?M`qI`rsP-hLe#U$>%WIDY*;pkH19
zzdG9=jgq|E3c4FXQMQ7a8Ot-&jCP0lRM5zyYB%FP9r7pj&8S{>b>7m+{>=k@@UvNg
zcDbTvJ*h9}N|c^aziqQIi%>`2jGBy(7_(a{w5N`k$hQz)PF+?Rui5_8^^U0DsPdzd
z9x*X^XUA8K=krDd`iIxAs=#k-ea7`2f7yzJ!g?lNTa{#wOTD(qJaY=?OKQ}cfCeiG
z-Oy&0O(!vG<yrGI8~xR0T6Nep<JWK<oiHfVR*=k73=c8a8+GZL^|WX`Pm4}S4J>$I
z*&R`T-1-`A7?%8xj-STXuZpwTQtSNdH!1Hts|E0r@|EBb;n!BpWX<RmrQ<7JnSecl
zo&DXMY>1D4<||{uSj~CICzj*{_B*yvbv|XaU-|w3{0qFHw1cY6c;<XmuPE;smizSZ
zgX;OQB>X=c&zh{<F$Yz9tKXcBLWg>@N#1eQlS3BY*rrB=Z`if1armgVYH|*DgL%iF
zc^Ll`G%fiE->Hvy4@{I6+&bK5jHuIz(ajj;gIvEeh|7;(H~4j9XWNC7qP7OM<z&k@
z%zZlPQsiQr<8pO<ww*Iqug7-m7lvs!vEH>2X0PzmObudX?)0}qS}UDKPIr(HV@rPX
zcPF_|2SWX={pF{>9Z~leY3>Ph<%{p8ZuITh_#MBQW4BDt=?$JUZSDW8zCKD$7n)uk
zYJC5<xt<2#IcIs#3~tavl^@CXzo!Q+?ziiI`zf~5p=ht`H;m;g6=Utsqjwc2T*oWI
zH?;TLJ&opC;y0{YT~Q0r9F-*}xl`ymv>jy$AF6CwE7$SVYp<7;o*3v<)@)l;uUB5k
zSaJ^i@#PToQRVsPcMIEG<0-u2NBO_bSQQafx9!Td4yI?)SR_)NseH6X7;;N5A?s~1
zY8TM*eMFX)>~CtxU;IU#bhhS+AEj@8$o?&vwfXiiE2Ml4HW6;c^X9xi1O3=KzgMUC
z>U}1>N1zGyu?=tFv9yP#J_K-^92!!eT@|b>`5^(yE9uc=_=L6!3YFl9mpM;GTh<Nb
zSD=|IvSwFWZb+2n%@!CHmf6<S&V569>!P8aW#esL;R{##!vEMeLf-I6n>n`4!Y7&e
zTiYL48Rm0sl#dS{(rK+0Cs&7IMGQmZyf4Tnd~?EVbU4n9kE!QD9*_{vQ&N_%s@Lb?
z&6O8c&P{Wle#8Cd%3g2BrRFzz-rbuf0!xVUi})oaHTR2XXV^KdQM-^n$oFc;#{Gwq
zy}+ZTby#}*$9f3fNUASisZL$lYvH7ooQudzbRKoK)tEBRuM<5UeTL`YGSG~%i+c3+
z`;0*6V086=cT{U{$oN3C^~$OwwDe(0OMl1@E!`h2JtKkK3j)y2Bhb#DKs&GRIyP#~
z8J>?Tvb5DOq`3ggxzf*h^J;F08MgHGIJ6J7o3ixzFFMAt%TPL&l3a7zf|}5lWJqv4
zPY^2l{^g-h?ItR#cyiC$MLeXQ+*7-VN1(6Wf*9ztL*IdfO{pOh;>N38#MQ3x_Jz=S
zGPjd0oHLM4_+g#TUC0yPoou0m+Y-J^_$J|C!hwYA3A+iib_XBw>=+cSHq%~>-fFbR
zN|d(LC-_E3-aq0T!7rY{<SmU~n@_x{xun7`ktcKf@S_j1KW_ghH==Hy+<2p76E8re
zh0Hx_c~#bDE6bc8wtT)fKFZfPx%D6B*O3P<P(I$3d)g-cb0yEA?Fkz>5HFhBc1dNo
z0ngO>$}_cXZI!hlVRsC8W_RV-nYAIKXV&^m@HIm!Rp0=fw+VLN7hE-Pp{3JS*4o0X
zw6<Y0YqbgLw@UfTT8UP4XEJ9r|8~dn2h}_4)jQ6o@#O{CGi{Yf^r|49<*4Ev=*!c2
z<6giu^=*&m_{v+@r}64-k8OF9zBLvHn>ixYZtFhYiW6_wZU62#);>02LV||${W<sS
z%Nw)B=f5L+@+QWwI(l=T>X^p6IVJdHN4`OkdBS`?R@sK^XpUJk)w`{aJgCn0+K5kj
z8|Pnni)qmFVPn1;t!Pi?YXDtlxpQyhJpo2t<&95Lc`t<c26j{L#FlQE-RUo%CJzYp
zvBxH~w|5$CYc<GxE9Ecb!*m~eT!Je17m}5*b&PNN^)a^b=5AoT;=z~qS61yFRB7{3
z-|*6W)UNg?mF?Ll#*OFfEdB1xXxnF9+w*SBAm^W~FZtRc@S3tYKOGsHplaIJQ41a)
z<`aB>SSNgWR6XyE_=s9Rj^yn{p|`8IQHJ{R#kio%w<1;O*IlWh>h~iQ<%;e<M*3#f
zXK&=+UZi;~a!mF%>~5DcC#2nHuh0Bogccaa`;|3Y_ptW7LuzU4KXXEm@8xWsNc9;W
zJ8eAgW#jFYR?Q!#OXl;DSR0(YNj3Jl*dW^Bf!KiY6U<agk^8AgAG>enlaVQP#qS4l
z1z{Ken75bs%5-c8`B5JiWyysF(|K}O$;e|{;I4Q7M0a9O>&rfILW27=C(@*%kC`!T
z5}Ktlld6B*{51q_@uOdHo}<)NnwOtbCZmgt#*mSlKh;&(-$<&+FUv2?<p^4OIz_UJ
z$_t!EVNsdkbY&MgT~-dmDu6Wo%3P&oAZ4jvMs`u5lLCqgZ&BWp`DJ;J=N6Tf<vB_y
z`nzQ}FQLDYT2xw^pH<*893{EsQ(T2*r7=dcLK?`G(z2rBQdh}TS4q=yi;7)^hPq`~
z_hO9l!pVh2PZk=*MJ0-CzM4Hw-5zIV4H`pwm~WcJfEAV4=;;h1ea}*UnD?y`jk|6U
zX9}e`r7B%eP(o2*SxHer%jyuC8SN>uX^oyJS4l}xNjK^rUR31Fn&whJC4eiTp?#(}
zij66*DMcmI)V--OhP|R^g(6vUiW>v*<)vmr_3z(blG4(~q#@CgqB576y01~<ayT0@
z4$CjhFU@nQrjjH@fZ?ieWtXe&VU*>$jGXeqY_qBFQ!)vX2MbH+Be{k7(_KzunCB)G
zWET{bno>1|+`mQGTehlNrOGKOnqrg|WlwgMk#}5qcDBpqbSdE{y2@PHWsp&z?mCUE
zX-3ad;)gl%3sizeSwM%2?rc(-T{LBiqfq6yczCkJ?BGUOk*5|(a1`EM2J2<zC53cz
zPbFp3id~dx-Ya#L8HMFjvRoxbQI0XC$XQ<CQZ;+ayanxuMBTUYXXiNzb6uW{-jedE
zET3Losz!_IT~^v$>YC!H@TO`}Un4!PiZWM8p`*Yk&CgYkQ{c$;mZ9ivxUU3IUYMWl
zFxv{^VXHaM`ARxG`Qdt^Jii3NdIw3q(`wiTK1yAMPKeIUFQY;=TFrc;OnIoJ&iqmb
z<CWqb^o+Bni4n1<0>!P!thT&Qx4nqL6~Sfaisp*tviMYOMJpDOGdI5!e$DzGYHUGo
zyxC`s9J3=d?a@Y7xoX+QPHmNI#(49ZWqMn%p(f8LNb~ecZ{nsEsf>;7kr<aigqLqZ
zMt-5wRiVU^L!TX0<SNY0GwVtzoa!h*w&RNm${e|_{^QLMapkU3raH!A-@*320|szK
zas8Al+TJ&c*Mf*V<jOB`8fIFHuPjIQWP|ea%M50AbEeL6sacOMFwGo7GR{?Ij#;N8
zTT#={qX>9qMRbFt%*NT@Q3T!X2d~$;zlLi)S2fpWuI*eqx%O~1k#$@m!nu`flt6}i
z=yN!~L!YNfoAzrpmI_@3WVFgx<E1gKalLXBFikk<KCo?#)mz-7%J03GotIy1-n>OV
zRiSy$)Av1-Lq3yhQIS!=dgVg8(3lOeES{=0%JNEBc#Bw0RezXb_6JE&GlMlbnvGQY
z<C;g6%bZnO=3r%VWHYQv%~jXzU*lTFHb~K=$IQo?*DRa43O0#plBHQ)YMd06TjSoU
z#}m^e11)0qw~}(T_&UnUkreA}dR+R0<L>Kek5;QvzyJJaE>HhCnMzU7(@vp3B5hhy
zT%s{5E+IK(bdnMO;JAmsKhKY%F)=PZ&PW+;3`-d{=7);<F|?&5j!gRgGMe6D%rp&t
z&u{N=vzowAg8!bBEuvK?Y7up-;6rgK=_#X!-|AM2xF1(u+JmD<|LF46sP`~t&HC^+
zkUns$c-7$wi<k$>90r<zVfD+R;$j!`pPHUa98;Ki3tTx?ziv7VN|pXmTAEW{P%zEN
z@hC(HNEL?0U=DK6SX4ut_1s#cTEsOO@<C#z@~jT!o^?`97Um?OO7M&&#MVSdZkW%~
z;zpUp^(;_RiAg)-3xz$5>n^T=T=86~Tm@VfElM(t^m)gqiZMA?dagwn5;5gyj$w~%
zOu06uwM4GyYm94}pLtMGhnx<v_q@P$mFp%KmM3Y)70#s=v>2|txEkf<oL1<VlAmpq
zD3wWdMN=-#Vw=o0jXK|V<fBy7=GjVJ1t^d%MOR}!q#mhcQ&N;qe43>>I+a$8GTNy0
zWlclhG3A~%CMC$yC1V=2Tw~w>wFrAxT9O#ZK+XKD!AAa+;sTf2zqp(<yGIr1Cc}zK
zvRy`bF@4FU_-q)k#b~@nu|qX2IuCuUseBsdTl77PAZsZJY9d2RPe*eq$)7UCRH_?R
z9C)<!U{y{FecOmonsqNlOJPx=Nt3lPG8_de`Lvdr_Yam;tTbp<*bmfKjDXGh($%tA
z^rW@b@<`n~COq3Or3ad8YGd1Fp<*@e&Qh&yS_84Ptl57O%(aqDR!)9yIqDVjzZu`N
zg1uWo0spH0VBJ*`;eNAK*l?72Dp4y}(=lmoEgN<WP3H}0ZLDyLBiqV%t2)dX$g_iK
zq{BrXqjB=_(4*3-8O+j@6fq-<tX9m&X`UTfLpk2Q<kdk{+Qu<9#i5jGbIZWm+!$Xv
z4IPz^pFh3nW+9EHhnsTxZ;6qmx=3S1X)ZNu-TG!@J26wEr+9W{<^<XF9=b@=TTRAh
zHkxr(iBjU2tJ!Wil-g$+L1<HRcxBTsxozzixrKnd-6couUQ~LQxp!rLDo}ffLgo`S
z4Mg-Z=R5S_^0IE8KFZ+q-ehG^3ZB(>iFdFL6qBiGyk(6bi?Ta-QuI~rUP$?BS6AZ7
zDKBL#d+2ylZPqOTx*WNV{6c8UayWAojVhNTiymz4w_Q1o@&YUru6#@b>VCf3G=Nib
z*zAIIB@2tn6!Rnz*O=7NW75Yxh<Ax3jUE&K;IMHDM<tCi!{gFOla!h^CVh;Ecik~%
zL;R}YBK?z_UlpFXNuchz_tGuWHO*Je{e4_J{zJN^dH&!2-L3_nE$cV_!~K@&ZxufF
z1N@)=fqSZ~*`E7fgDsaK&rYY*J7Szzf;@xgyK9!YgZaVx=2ohd_W#~8)b8nr?yDUX
z_cg9jj^bi9e|oJ@kxtjtNCMoFAZrpvgK`?)cxA-${x+1Uj;`-X=P_m}YnIv(JG!Z~
z3FA`jm`0S|rhbpfa+JE%GOG+-s4Qk&eB8LC`%Dv((s#`z!<@7&U6Eb9X9J?<g`gDg
zx~!-+O`(=yQ_Z&4kd=f2m%}s(Dh;1JY-Ejb506ej{<%~<U~r6OWJ`=2>y7%UCrXUo
zy?YzQ<z-AThB?k+SpBn$N{}@RildC_lsU;&m|K>ok}8sfSx2!V-We6nsEJ7jE)wkK
z5^3J@D!-oiy!_leYZh*LgK`oE7(aARExF$*uW{jOD9oHkE%n!Eh*W|-_c(f{=c)qL
z^{(eq_kQR)%zgEz`i>75=eMGB`EmJk1#sE80=bk-ZsQ8(Qh)!`JewSpl_he5>s?mk
zx#(00=9+J$(UN8(=I2<P8?LfEyYZBfTjDA<k{@z7oh5`Yd>Z|nMtA<}mtzbVz?gxK
z7%s04k<JRGdeX4e;c+THC%?kf<E(}*n%u3Mxd}7dx%oYFlsDXtOHWT4m6{%dc_vVm
zWjM>HOqr(ofoTJ?R8y6@g8syc#_Fs(tT_gLY+j|#eW!r_LHKC>Z|b&J*oRsFsm}Yq
zEyGiU-3a<od-)cd%>PM{{^TLj7{H+zf2i_G(uog_8uhS|mNYzNTzXQPG3J48%sk$9
zW#bhSsBC80MaB8FY)*a-8mT$SSW}(~lw$q%OdiA3ePtyzHI*it046gUbI`zuo)vw2
zR`gQY)c>fWX5Yv~A$ZcX^W`g(on`Fv%tv0^;Z)0Z_#Jy7oyIJqhDo`W>oV6K4<7K~
z5f7g9;CT@HjAgZ9Wl;qrVEj_ODn%)MiUmfAcV0s^eOzf{F^Xa+C%)<bX8kHnX-W3?
zCdn^;ysWIiDiH<x@qErGOfisKmEANVCDq8IyP{%c=ee>cmzGaynDtE?9CN4o8>f^^
zHU9X4N;t~F@>l4x?)8QxVK+ppDZ9U^j;bXAo4l2bCNtGRRbY@OkAj3T4~|SUP^%2=
zS83+I=}BG-Qj>J*r>esfrOavOTKFSqQKwViN6PooGA30K^!=n*^?I38<#X_(w&j-j
zO$v&NCOgWoHLxOj&xy<x)004TTP4dZvNaKn@H@s}Dq{AqR1;6{REurX$;eZUnj6_W
zOv~oHgwe!aqv5=&VZTn1=H?p7t8r0QGL4GW?_t<j3cM>PyLq;5Q_AUzSsVy@lnj<n
z$7HnsDXu5g{cgs?MdgOIpJ^!H#knTd4R%LrL(SMrWnOobDDGIzsi(QDJZ7lx#4GdM
z58A~frO-%d*s!E}HY}9Wpj(*)sJ-?7gSIHjZ)%HTH)gh*V=5<UZ2CR=qR}%yqGx_z
z^MAF4$u}Y}<8oBP(Or%a(KDx4uRyVyl1^f^Y>Ny*V%dUJZq<&a8slOwN=;eQh|N(A
zsOE|yQ?|t=uBrJ&bRQN~>qwZ}5Noa7YF$@r_)T?S&EM#T)3pW-m)WPZs9c#yAjveT
zmtaFz`@UPIRkKEZp}B9R+@|GOGueMG3v<7k@|qRYSdLPJ)$RXOjyGMiVq`#zKS*pD
zhZU?voLy-dE#vHFoV9B4uV?*I=~SE<Y#wKYn#VO{S3j)0o&-(Pd44ymgJUW4uW33J
z;f?2K11;Z;8}Qw96x1SJb5U94HH-7q(L9cKQF&xw(t9iVTE?k_P2yC3nfH9`ANTQh
z=K0v=%lPZ|d~Dj5F3<jL?A@_zith{he0BHOpNDQ7UU$7;?Ef^qvg0-VQ~h7*xk~p{
zzfD_1jCH~{UY!P7^Q?KoXKrbfMRPc2gUE)pnpL?WpJ}jca!09!<t);sLcm$R%SdlH
zfl@1h(=eXQ!-&A1$DEXzR<m4XPpZR1yJ=+_bWb<&%11S^`h!g3JVLXgn)jb(aSh@%
zW6ivt``$8|$C)?H{vE_(l8?Iy7WXpiynUKA?D1Rh76F=sG?dYVEN@&>Qay3>!NwB2
z>6%h%#i>M%2^-U?yjJ`z;u^+g(@H$)$kejDW>Kabz3Z;&U<3D_g9GJoK#K**IOVxR
ze2mwbfM!(Nd^M$KaRyA#Qtg$cxp8lxO!^IZn`C9$c3LYeicj;p)vnb#sBEYlMobnO
z*=Xz!E#oW^H^eF#ShTA?*@S{0Nqj@zCRv*iPx;O1FD=8A_Z<!_`Wwh<LVxo(t3I=g
z{{^*PUM(7|{;MS2oZ@tkj%6N9(bV6Oc!QC^a^+F!P0hhd8)K-$V~)Zb8@;&>rgjtF
zI=uFTmMv;EQ)6SPc1rM=dX+rc?6j<;Mb8TQ;X3-FvneMCXz}VjIh1c6gs2S^dyl5|
zc~YxZb~UTp>L=gRyDb_FZ$VA^h{}fGEgG7O-=zCid2W^1D@RXTeW$6sZ1!!@W?tqK
z(PdK#$1tXpRR1HFw;sfv_B1HWDyy+)dByX6wBIVvt<oy$lx7Tr>UPWSB5*+b4-AQ0
zQf?jvTJyFVW}Zn|^)<8SnQ_+S*gVcksN$6T4Jsc6QH@+TZ%{AoImNl`4@ii%){qw2
zdFpBy=&Iadr2XGAWYVMx_yMB4Cm2emcu$oUl_<|U)L_r~TGRWg4b|Nz9VN=-7^6;k
zES(%nltUf9nCkCO`=g>3xXfna(2_IDqWn_R4&}r;Vf_!c$jp2CS8lrBWw{(vl%FO=
z;(X*C)-77NiJ8`Gsch-D(y$!dDlJv2WyrLGv?yBbzpc|qPosGBcvCGh=cj`FDffBo
z7m9XkJqwaiE@wV!f78}9leLU5^<*AzQH)EJi?busyY3#m8ZnXGW9mZI{t#a@1c9;U
zd-<DU)obcXN}wK^*he=OY?<E7Vug7|dG|Q;bCmhm7-AH<o@@viDypA(BJ1VLqC-ig
zp*2X;Fp?X*>abXtiIiykLp15zMw6vne67#Kb4|kPp1M?=y1%8#wT9pQJ8JS$C+jK$
z=X$O%&>L32RlEw1XmSnWw`e{-zWnK)Kfe}#{{P`G;Q!_y&!qi-`lrT~_fP5U-oHN5
zPYkhFh<yUD*bcD;VZ+QT7&&Qr*%KM!!{;MSQ?_Q4u2{F*1mLvK7j2ZqJA^Qn?uM`y
z&?cm9yY`{P78X}bC@QBr4Ra;s4tK;Qj5Ci~#OP!1cjw(H*v9=RL6u`}A#|bC012@1
zwpLB|;UE6I=fLLqgMnUR`LhU~&YrQMoD>L5$;V9XRPzI;&Ux52Q8=+5IB^J7KDW~v
z?i804DUTSe9gKpK@?z!GP&y4&lU|I?g?NrUB3VBGOSNps%6U*e+j)vrHg#1<oX4@-
zJesw9=Wx4_B>ark+B1cdcaw67XE$Tg#I`!SB)=GvRIv;eMx2KvS1Ilrp6xm0a1M->
z2e+N_LdR4N#+7HP@)=YNHyDRJXH}_6063d-X6wWS96_iGy;R1VXWky_y-uvSBYU}l
z70Xb8wQQOUQ=)TKV5?U`^31j+xU%>2lu(dgIJt#P2trg7X{X=`+BE1X$Lk0$%3lJv
z=4s}+nJF2jB~Gu+hPc&TNa5tHq^P(gpQXgeFUl^nv}21X7T5~(eMNdB6AiwMCbh*5
z+D<u1DOVv+u9SiTS1v}nQkQEo!go0P6&0F}Qk2t@7R7d{#FrFJW`|jvU+hvw8dnL9
z$psA#{-zGBY%oPr92}1~CP2iThkI|EzCn$R?WAI}i5ydl*fct=CcuqI`3@_;61o(f
zMI}M34Sm7uqTbRxFNxkxZ{DFNl}&3DX#w`c0?QIKZAw;A0j^3GXQ~SP$V!zXhGM~0
zYC2OZFBnOoSC!@G<g<pC;G;hk8okQ9XBA|?s9Y9jBUK$nlv#bFPX?K+8~5PqTcAd(
zH;8mxWik>0HyFp77MF^Le^EBi9XLzyiZ3yX<@gcHH)TL|!nhPn&?V*Bc)(*@Z4i)`
z3{P#|&g`mC%0n((d3vQ95=uX7GB%SuX?RG0Ie|JHg=qBO$)O%8X^1Q>D8l2x9O*m|
zVRc4p67Y^SbLc8kJ*teUjW^PpZaUAoDvFihm8z;FYNb{O=GGuB<(!&n19J!qyDE_0
ztPCrK*glF%CQB*~)v5{AEwzPas!)YxO;V?}WKr#hzm_R%<#FxtwnnZbi*tfy`J78z
z)7H3>DQYw22_-c1#J8qoYFA$M7^OXJWMv#hZ_m$DUb;-nbU?~Z8#c};Ep}zojk24}
zik>bfmc^)H$eOCV)5V!B^Rp=@vm=gHgF>;!69F`uV&2QRId3&Kp_)!`PO;7=7;B1a
z?~G{bE4k3bbZYe`(@T;mtI&K{1Cx?NJxE}B@33~nnYWb=?7$q{uxd0<)SuMI!t$J<
zaz}qPCK{4UoFxfW3L23bbBaX8usIPnt1_Rpz%$h=UpT65c6*v<YAu-7(D_)D)Zx7H
z2vDa&O8n|nLM>KLDnk@qzQlp^U<o;Hx$reHqtVsW2@~=eXLi+6bGq}iS-O{CJcCL~
zWgL?d9#ptLc-CXpB1MJ$JRVJn=6=l5Vm-?dJ<xiL0>#*xZ5k%IhE8Nz@KuYO{lHUL
z!)<dMH4O7+(WT|Z%7IGJZc%0yqB1nzX|6mp#y1p{g9j(eK=WL2)|!v+*mrNLXL*V}
zBY;6<DhCaIe6%vM^0udgWja^6R+)1Soy@yRkG2M|8lz4g@scLta-K|L(3={7H`>Ws
zh$o3Up76SBA$n^j9aof7#x9IjcbNWLP12Y?T9_;vGMPC{`dxGmX1c8MoE#?EQggj*
zGC47|mzut54EN$9{JIpSUdKvL4TwGcmg$rz8`F5Yw)r@YBZuzD2H`uUm*$n1nSyBO
zak!%~OBJHNVOsG#m{80DhHM-8Q69af<+y32$B|8vi<ssc1k7_e3{mp|ojh(dQ7XM`
z(R4H`+gEhGroHA#HFO*9Z~%wCFq-+zR6tl<oTzGy9nXrSCKb++Jgzv%Sm{a=l18UY
zFw`Q?$*tMZQC^h%tsA9yP!{JEQFD_8Ek$WnEwgy0wv@;*o)MauUpm=%qPz%qah5uB
zLR00c?I1_bru9l5GOg{ND061@?gajSY$gGoif#U%;cM`sB=ukO_*;iEwOaj${ySp(
z?tjhG|Jl~~-^aEe_g~Wz4%-_4+im-C|9SI^I@<X^`mfSG(_Q6$#y!jZtb4ZmIrkj*
z^X|FsU%KbHUvSTNzvy1zUg%!rUhIC!{jz(B`xW<6_cHf#_p9y|?$_L}yZ_6*(*1^e
zm3y^&jr&*bweDZL*SX(xuXq2(y}|uk_eS?y?rQhj?oIA@-0!-7=icmo&%MRH)m`J>
z=HBjp-@U{AfxFiIp?jzMBlj-%$L`(kPuzRlzjyC-|G~Y_{YUqH_n+Jc+@HD+x<7Lt
za{t+V*!{Wti2JDfnEMO&ara-`C)|H^pLEx`Pq|OK&$!RJ&$+*JpLc)dzTp0w`=a~5
z-Iv^dcVBk@!+pj5Pxn>#zuaHD|Lv}KUvpn~f8)O4{?@I|w$;g=kGV_t<E$@$J$oR&
zY<xyUT1jhZ!}Hv2rJb~wP`O<?NJj~iPSRQKkZ}2lbdj#u6uL=wxl?*bPq|C(mI&!3
zy`_)z#oo|gBE>EPBueg)f$~!sB=<_R48|wzXEH?Ylc93I#EL_*B%5P*7ay|El|0Fp
zNitaqWQr6@k?_uW{MbsROv+`dJSi12O{U8uGEp9t$K-Lz{9on&xjZFL%MAI2RLV@L
zl4oR=JS(&1IhiBR%Ut=T%##;nzPu<4WT7mQ#qyH8EKB4SSt`q9xx6YX<TZI+{!3QM
z8?s7P%NqHWtd(EOI(bvp%Wq_Z{8l!~TT(4=%O-h8-j(0UW_eGx$X2P5ZL(e7mmTtf
z)XImlQ$CVi^0DlePh^k$UiQi#WS{&|_RF8-fP5+k<uf@Xf0o1Yxg3$Ba!kIE<MJ0d
zA%B&VQYWYQ;N2NHE9c}(UXbvWT#&!XMfq>JB!8F7@(;Np|CFopFZo*jE%kCuuFE%a
zL%x-p;+Fiv97!2HObQ(+Bypo@v%a4Bphv9r<6#Tud}QLR&tHj?%9Hm_`zS7<W1-*g
zez#@uuzy{<|0~}y(W9b%V!xLBWL3tH4@!UWmoc}OD?4&;>_8qnQ-hfaE7L7(M}^s?
zkI)-2FSTobJ3T9e)_ID57tr@!^4P3!1GD}lqA<TeJ(vO6c$#wv%TwikiU|&8Jz+n^
zoBE3}@PRB<{{=}Tk7Pua<_Z5xzigiC^^_A)$Ue|~(!<PRzNY}Ym3p564r<nW3shMB
zb;l&unrp%~?3-LixV*m=HvMZJYP{1lUQNP=Ct^jdCM!PVQrP5D^|YL<o0fsuRaDr_
zyVFyKD#vpv8h<c9H(TCsq}KY?@_y6$`@Y{a)H3J)q2cclNz>?)HJW&@1Mg~LUhjci
z%I`=?&Wnw{#oAMM2DfIe6~>0hNK$?6i)Es9cw%sy9xn#2w!IKA&;OTx&*`&$pY@rg
z>QiZBxe|RfX|4Zo+8(6iQ4UED&}0)1An~okDA#z=wmRSi|9Oq2sxn{VvbENPcaZ&H
z{RZi3x%5zt`AVe?q0F!s{Z}`ZXApme>pW@BeNP%yrwxV<+^)$9i;w2KW_Tn(I>pC8
z(pGoY<dDfnD0POv7_i#^g~nQW){k@(NjIyT#*BlETHBuUnXOS$$cy@FU-SM`N{HPx
z)}Qa*H;7xo{R-}{<ad1QVCo5d(Qmc>obPO(XH`~J2g6yy?$lUYR2rQ$!7uu*_IXa-
zH@HsnV-5G)fyl?(deC9Y$!tTNLAa#{=OiHQ-JJL2M&4C<cGA>7sj+UE<=s-=>7<!Z
z0pHE*%=6YsRxJ3Y8~IRO{9>796TvJn2b>B{2j_tEz~$iU;0CZ7+yU+c4}gcjQ{Xx9
zDp;?JKds^)1oD1b|8TH3*dH7M#)6~4G;l6BAEaJ?>h*seTm@3UKlS@>0yl%Z!M)%y
zknZ7s3B00909*$6gB`%mAoT=LPry(x9^}!Zfbn1sI0>8%&H(3wi@;UjT5vO11MUU)
zgD1dK;1%#|4mjY4ZwQF3GuQ=W3A9Cl@!&9UJeUDa0t>+zU=_FsTmr5I*Ml|S4sbts
z5IhB*1Cg5zxdqyI>L8f;K-0BR6{3xLO4mk~i8iuA*HR9MmU2kf?rAOBJ?(U@PhZjc
z#DMW&vaa>zlLCFyKqr`|YyIYk)^7p$I=DvH`VSJV{}3<(%+$5Wfuco{Kk@{45xfds
z*R{blq7B{yQs3aiy2dK2#q<ZsA4C3__24G37Tm3C3FkyhxS(r^L82u>S0W#BO&kx-
z2Iqr&!Tq|H<S$wh_md8S$8>GjP|=3PgE?R!SPi}l9s-ZU?^EzQ7hD0Z)U`27L>mJi
zV>W=)KL)zTQ16(VqNV!iT539&1D1ivD{YTxY0#f`9)!QN>!OXb>Dt6t(I$=t$Ac4f
zE$4O7ayEcFK={eI0AAI#+%2Nz?gEiRE^^PkAzGfUYk4EVG+ir!&XQ9g=}Ru_TIqJt
zO80{BS9*kYvC}StK<Mf76zxL3z8N5V_T56e%%feF(jMWoM-MO+Os5@A(GKTzUhgh^
zL6~-cuEEeT_!9Uva_@oMdxOv)^BA}htO21T<_hwfg}fGl<V)F!e3m08B|q9}41A?_
zMn2uaiQpt~0SFyw2awYVT^mRF<N70?MC3C<*B(D2+T$mY%Ua~}E^-)wJW@gU%7w4o
z_25SEB8VLFRv@1>$c20*l!tvrD<xei{iPK7mPLtH7Q@_go+;=eco*0kR6bDyb<r40
z8e>T-0jGjXz~#F5l%dH~5Z*|56Uf}7G52T}!OPr7rSk~|DbI)Ud??3<a(tM>e3-+0
z80$Wabsxr_4`a{g5_p9#u~N0K4IBxkf-At4y4=RtzKyZ%yN~bz@EmvnyrE`J{%Z}k
z1DR8F<`kWLI{Ew<zJ4K$W%vn%pFrvlr2ate2Xa4<{6XYzMft5LzjYUp*4=e!!(7#d
zxhe!cLg1q<^tXlnw$R-cy4yb{(mqR<&;qoBVqH4;h;;DRr6Y4}N9Nd$qro&?Ix**T
zV$QkaCaaT=E?rW2<9E6)-Jz#D^xVlDc_(w^oy<vhGAH$b-X74~FA>c-8AR^=kbC3;
zo|1b>mjTFg0P>8=;lnDEbh)Qk<eoC{b#Rp~Kiw|!(^_2y9TFLIM3;M!%e}}YW;V;q
zTwR7x&k*Vvat7p`heKmTh7Q%`{_Z08-=#~eKN?JsE^){q4ml*u#WQQZE<x}U1V2HQ
z;4EE&sXv(dTfc<7mLivv$mI-jS&Cd%AeW8EWs@#peOZm|@E^sy;s@#S6Y~Fr{6-<G
zaS8mU!|w!LdLr+h$onqpy^DJ9x&U6{?eG!27qqV~eK&~otwtV4kjHW4K>Y)#{~pra
zL%Mq@=U&RWFH7XU9QdLi45c63PxyYqvBThN1bjUPUs<}uw_~;L03HMn!{=W3+z)@q
zF$g&ZA;%!(sGc^vO$P^p(cm6%A9w})8acpUF#NTm-CNP_t*(Og^dIPM1Kn-TffwjU
zjGGX~O<U5pC4IY4-hdE>yr{Q5^|qZ#{B-0NkKBgoa{EM)+cQD<y&Zl#P<{u>?*QK&
z;Jd>m@CyCxF#YTpcoDpeysMD+Y;YyG20R2F;XeJRBmJjS9{sTZJO!Qu>%kkkbT&jf
z_W)OcYiTd?-9f&t(9sn-y3G*jRz;ZdyHb9)HH6m@UPpKXVfg3<A6@qoK1ld7;j6SW
zaxjp?oyhS{<ap;(U?uH7pLSnFyNA>621tBQ;(MM4FVg<WwEsx(U2uyocO$R6k=Nao
z;4JVZa4EPE+yo-0yOGn~UxU|mi3mX(4+Xn}cY%zj2*y*ycrXJj0E<ERiGZKpr0-4o
zK9tvo@_G*?98dT-;gf`C5uQUo96~>gr5|>tA9m4&^;`Ns2F?ZN>%td%asD8@kMIEy
z`SwS?{ceE5IHvs~X}?J17m55LX}?I?&rZCZc>6qX0r9(u-%FT$1IRaE5x4~04AwCI
zp(6@9qSk`z!7bo+@HlvqevSO%kzaz1ejTjKz+p`1Bfur#a^?xz<EOO8Pf7Pv(*2b7
z`zh@=s5SFOJ1`m?0-gfTF}}hXUj|4&xR-u#?^19DcnmxNo(C`L67A31yMjR4E1LFV
zU6dH)9mBYaVO+(W1kdR5vmPQpiy*v%@J_-$g#Ez@;6!i^I1fAno(Jo}8_ZizF>h5e
z&Y|-@=)8||?xUQcwBJzLZz$=8lJ0)wa6fX0y~?<+XWUb79QDSpL@sNPOD1x0>M|1k
zN5X$1<t9>YBJGw)yCu!Wqkb;99^9zQFxqt(?K*50I7gS^hRE<9;6N}Mq(2R(KMiNz
z8P2>j9Qubt|8V3z9C;641Fi!%ft$fva2L2AJP1PXaOfR=0lWml$8h*aMxM#YGZ}d%
zBhTdSApJSn4h|&UMABvIGPWJ>;q9P{dc1$!c(4qt0I7c*^^e;EZl_&t2)0389<1g~
zBkzLS!CLSzcnqW+AEX_})BnfEgQ;LTm<JYs%fZ({(v2tG&z&Ma&(q~8<o^`%AAgnj
zdR-<^{{-rPI9}x8Vc-?;Yh5ysQwDO%SP9Y&8MJ@KPF)_U5qV^XE)#pROY9HQuO`y3
z9;MtzDfdzO(W4pQQg8)GJ3UG}J$e#6qs!ye^EmZn28m?02KRvbba5be2XfEdAd*|H
zOCEB{Lr!^}!7ku1ka3Zh15N^~z}X<}l1IDb(GGdEL%vNUKNy7HeE7|$ynM>bzYJd0
zWl~>}Np^4oI1wxc%RtgkBK@R`;ALGVBiG5ubu#jsjQk3qy8yb2X_qHxm(oI!(h?AP
zl_IZF>M5n3vQ>Dtuhpe|Hg9d1t4l?HcEVBM46q7>&kFdgco*CP?gsbjGA)MhcnsBL
zdX30*<ok0w?KKcg21kPM`*ZmH`El?hNc;Vq_Irx^PjUb0?jld$1?~e6fD^$?T`Hl!
z68dL$5t-Q?gzuT~T}8So(p8-UFX-~jK#^ynLFDiZa(IUNo}s>9R*L*`mM-)1c-W?Z
z@O;9H2u~$E9b68+uFC@WS^!`3))HQ?%L{`<UWn0UeqWLKb`W{aN1pRXfTMMJ5&67`
zd=?nw>j91gQ^BXeN^lN1PnQ|G$PAk<zqly!i_7o>zm@QN7Cz3x$Jt%r9$n5Y;pz3|
zU@f>ymoMS>OZffr6nIXTuaNUs$oT^O^aB0#!a?w`E`LK#f6D|Z=Wmqrx0B!*T`ofB
zMd-XTOytT45dN>g{}tqN1-V>V1+E3jcZGacq3bGiT_xRB(p@FpRnlE0-Br?ECEZoh
z)id7e8E^F~!8PDv@R%;w=<nC)@7JoqcfkYTA@BltNtf%4m+Op|>&Wvu^86;6FQN?5
z<;EqE8&{B1Yvj}pIem?st|O;3<TM`nIFU~txF0--eC8mZdEj1fKk}ixFDdU!<ohM^
z{fhqg75(o*XXMibL>?EA$KP_0%OnuF{SCQYBz%$Zm2~)@0G5DL!Fk{Ua06HkQtuV&
zy*eKLGeFW^CEZohT_xRB(p@FpRnlE0T|M%vM}GA$flEQ;R*&4SMIeX1;0|yncnmxN
zUIpusODJ*)0|$XI$mcHP(_5Esb&+pvx-8i&vZO|rSHeVI2?t*XSLw3UpRXtdfsD7M
z1Htv+MqQSXZW-y8Z2~vzvfL0^-UA!~js|yvyLEZBzsRdmAmiZG*L7Jj3+vY$T{hh0
zOYuIs{5Bjkz!l(1T{d<Q+1Oc^_vVYdw+Mv)_uzjE^lpLP8q(E}u7-A~*`dp}fqY*k
zT9@s}XFKxQei6K^b6Ub%TXe7sNIze6U1ZTsT^6?%S=<in4&DVKkHyGiF?276?pMm-
zy8^!G2g~ROzm0{iM34f1i(EGn-bna8>U)p+wxmK=I`kZeo|Dk?81!W6@;-dL4<9>{
zsedHpBj3fy_odlbLFa<B<4d&TOKZS&Ao6+%c`ZRcOOVeJ+HFZaxCmT=+-ScQVT6wm
zJ`SD(FF@}Q=#2$)z)4^&xC^`hUZTCyX|D-jF<7R{Yx6{2qhGzY4%`6l1^0uL_ZsDG
zk3xQfz=>ccNIPs_1g-}+QZ90OMagLbI1xk+uONq4;Qtl)f2AJ0f&8W;zZvv{cJzY|
zy8I?s<ToL@yaj)6!QWeJ!Sx_~zXjjbL$SQZgBjpsAoW#KU-fQquP$#R&$p51+tBwm
z^u1jL&IVrxSAmznE4pk764}%m>;iTNW5A&x^52B~Hys2I>+%kCy#rnE^arEBN^lmq
z0$d610{4Kl!#lLY?^cTZZVh+<WZv0Kdu*mXHrqkQ#pX0{JXi>pfY7%Y`Zhz~X6W0z
z3ET`Kug%D7^BM3w{YdCXIv5Kkg2??n<o@0yuuzw+$YCpT*m?{+K|dp14e4q~S3|m*
z3h*giK6pvwgQXyJe*oPdCW?HRtjkA?hmRN!AKehyCA#eD3);aUU@VBdcOmax^p9Qi
zkB@6bKHdeM08i<%$HswHur7a~o<C5}KKR-PU;9>pYr!qxcJK&zT$ev0|34!C{naA-
z-vyD^e&qEh+T%~O$EOh@pY{bOfD?83jCTEucKvJwI9iuO$n_9%Jv0!E*5wFtID#CG
z%mwG`a+LNwN_!qf&PS2+v1pNFLqN(qMtNT#*DsLkab4uNjeeg+zs~{pfd|0z;6)I5
zE=8Wpki#<Mu&e+q1`mNp=(prwPX6V@FDHKa9B>};Scg0|fP27w;7yU=`{=TFq{!Y>
z@~4tN9i*OR)U$j#`DT!A3+cCm#P1<~Z(q{enHTGs7jH1W{TbguU=J_?i~<LNwD$_y
z`?XBQrxSb%tVBN0bqKl+5k92C^S}k%M=q}+m)DkquY*TGgz?5ikvB3y<oX73UA;qO
z^-gdJ2(#<<@_oDgy1dz%Z_2d;k@uU(d%f^RTphd%?9F(E&$r<7tsHO?cn~}cUIMQ$
zUfVHVJAnPcC~yW?1wv0X^i*E}FEL)>_igxndpwu{mVi^io#1Zp1bB+^I)d>!8l=8W
z)VB$`HbK{>wcvX29C(3o>ccqo2h+g`ApQ9r`t$GT55J>7F#KgRe7qORxC#U9;6TO?
z;Tpm<glh<YMEM_4{zuUJ5%hkv7u*jX15eOTq3bi~`s^n1_MzWV?=k8<)*ZYHIg}xX
z3h*R&27V3r?E%t0)wEAF?OjcKzwLy-Jn#T`2tFpj$3$=`xB|Qi*26~@eB{8#75MlX
zx~b<q>Zt*1z>n5L*G8}g+yPy*!)LU^G1}o6?eNwj=vV^23vQu)+OL}StKI@`r+)g|
z+w`}$7l1E;H>g*rzb|M9cY%AL13un?k9X#Si;ySvZ>IjunV=IS|7P-Ut_632(7RdD
zI~sb^pckwGcLg)ggn;3o!925)d1eh*4Zcf1hMq&vb7VT>eFl6a!^cR*HS+jE$>Rw1
zA4eYW^E>$2x`TOfC-V<{?t{<Ip!+lEKAOt>kj}al%es{aQvY`9-(C!sftBDaa0R%M
z^%_3khtChzF@J6VPl9K3sSOdS4FxH;mU3$uN41Qjor8EYbPPzp*h#<mC=B_BgArg~
zU3R}NvU?S{A3UhbCq5#d_=D|0+U4Luk%Nb!*B^Qr2cIE_&yd4swcsxJ{~G?U!$)uU
z=nq2QQRq8*20V{k79f|GK++#0{THi{&suONxEuPB*9XY!;Cbp{zB!8Ak0STlSm;j#
zE5TVH{MW+&hflFyRDv78YH$y@53C1okZwNd7J-MsW5jnRz6+QMI*BJ;E$Kdlt`DK>
z!{gvd<Z}V}Tmr9yH<8Ci<gp2)-FDM%pK$*Z?tfMd-|s@_A?Q2;ADiG~GxD5-JPYYB
zl(&oWJ}#i26oZ$*E0klWoPpp(FcX{yE}*<Z$}0h(`!nc1O8+=Y|2RsyM=5tV<?N=M
z-SE8|zCW8mx+?A?$D_z`_eJ6_L!T4+^1v<NcII!|c@OQpXEc}wP6elfOTgveY;dkF
zzlZMML-+6D`}gp@7y9->-yafLN0Y&u^j9DHE%Ez^--o>SA@BXP=l)%+qZ?UAHxceY
zxHIc#I_u{I*3A{Hn=1*^@BVZ`mjfZ3Zij;L;4p9wIFEFBq${BP+tL0Vz+`YFSO!*r
z+re7K8~x-E{p8OvB7YtV68<yc!-NkLK1}#9;m-+wPWW@epA$Yp_=rjmpMQqWKTii|
zfOEn5<Rktt@rQ{&O#ETu4-@}6@t+g_Iq{zp|2grW6MtkK<!u1ZgBR)7E9uv3K>Eco
z`o$N$=@0$EVz7+$-C%w10j7f!bU9JU+t6m|a`HGQ<0lD|{{;E#=&yD3*HiC`oZ6zx
zY1;2J?RT2~dYb-v9=V-IZs)20JoSIopZ#4FNV|STyMD#`@)hgL1=3w0-9JZ&{Btz>
zDEifP`qe+7@1M|jwJ-ZKyDtBt-~5Yy^R*2xi(t|*UavD=uYV0*XFp1N-Jrd0(BE#*
z-)^i0*XvpvL$o$Mbgjcx(K;Ys_Z&Pq=INSnekYvY;U0#2g|7L|7R`6AuIZfb=>|wx
zCww>g?yl#&kMp?x7dY?Z_$rcf$w<!SA~~0f<XkS&scQp?AE@ivfSsZZ;N0xq64CCR
z3UXd|?@PLdy;F<sO!x*UAm^OeLpAK78un1_-tB~I!TsPt;yF)@=3H+O^$w!m=sdy&
zAm?+@oX_1qU9|gWfJ4D}U5g`s9QhyWE!snzLuQ0?EC(MMOTiW3N$`xWJwo^q6()ZM
z`5&4=`YLb>xLwyW!$ivr*EI*{$Br0qFSsA%ywJgUVO9sxvbdks7o?u7XmAL~Ib+sn
zkaNx~&P}u41v%%;f}bq-$+`qy(KT1GXs$Al`d!rTS_!VvwW7_U73~0TidO8SYrShl
z>%9x4{@&Ezn|A1ZlXKWBv;*=>L2fDS2!Bl&x%0AREu{nD>x5~al-7iichoV_uy<?s
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

literal 0
HcmV?d00001

diff --git a/slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer.gdb b/slsDetectorSoftware/jungfrauDetectorServer/jungfrauDetectorServer.gdb
new file mode 100755
index 0000000000000000000000000000000000000000..b9ae0bd11632f7973a022ce9cc2e6bc56c5c304c
GIT binary patch
literal 568322
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

literal 0
HcmV?d00001

diff --git a/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.c b/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.c
new file mode 100755
index 000000000..88cd7a138
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.c
@@ -0,0 +1,2649 @@
+#ifdef MCB_FUNCS
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <math.h>
+#include "registers_m.h"
+
+#ifndef PICASSOD
+#include "server_defs.h"
+#else
+#include "picasso_defs.h"
+#endif
+#include "firmware_funcs.h"
+#include "mcb_funcs.h"
+
+
+/* global variables */
+#undef DEBUG
+#undef DEBUGOUT
+
+extern int nModX;
+//extern int dataBytes;
+extern int dynamicRange;
+const int nChans=NCHAN;
+const int nChips=NCHIP;
+const int nDacs=NDAC;
+const int nAdcs=NADC;
+enum detectorSettings thisSettings;
+
+int sChan, sChip, sMod, sDac, sAdc;
+const int allSelected=-2;
+const int noneSelected=-1;
+
+
+sls_detector_module *detectorModules=NULL;
+int *detectorChips=NULL;
+int *detectorChans=NULL;
+int *detectorDacs=NULL;
+int *detectorAdcs=NULL;
+//int numberOfProbes;
+
+ROI rois[MAX_ROIS];
+int nROI=0;
+
+
+int initDetector() {
+
+  int imod;
+  //  sls_detector_module *myModule;
+  int n=getNModBoard();
+  nModX=n;
+
+#ifdef VERBOSE
+  printf("Board is for %d modules\n",n);
+#endif
+  detectorModules=malloc(n*sizeof(sls_detector_module));
+  detectorChips=malloc(n*NCHIP*sizeof(int));
+  detectorChans=malloc(n*NCHIP*NCHAN*sizeof(int));
+  detectorDacs=malloc(n*NDAC*sizeof(int));
+  detectorAdcs=malloc(n*NADC*sizeof(int));
+#ifdef VERBOSE
+  printf("modules from 0x%x to 0x%x\n",(unsigned int)(detectorModules), (unsigned int)(detectorModules+n));
+  printf("chips from 0x%x to 0x%x\n",(unsigned int)(detectorChips), (unsigned int)(detectorChips+n*NCHIP));
+  printf("chans from 0x%x to 0x%x\n",(unsigned int)(detectorChans), (unsigned int)(detectorChans+n*NCHIP*NCHAN));
+  printf("dacs from 0x%x to 0x%x\n",(unsigned int)(detectorDacs), (unsigned int)(detectorDacs+n*NDAC));
+  printf("adcs from 0x%x to 0x%x\n",(unsigned int)(detectorAdcs), (unsigned int)(detectorAdcs+n*NADC));
+#endif
+  for (imod=0; imod<n; imod++) {
+
+ 
+    (detectorModules+imod)->dacs=detectorDacs+imod*NDAC;
+    (detectorModules+imod)->adcs=detectorAdcs+imod*NADC;
+    (detectorModules+imod)->chipregs=detectorChips+imod*NCHIP;
+    (detectorModules+imod)->chanregs=detectorChans+imod*NCHIP*NCHAN;
+    (detectorModules+imod)->ndac=NDAC;
+    (detectorModules+imod)->nadc=NADC;
+    (detectorModules+imod)->nchip=NCHIP;
+    (detectorModules+imod)->nchan=NCHIP*NCHAN;
+    (detectorModules+imod)->module=imod;
+    (detectorModules+imod)->gain=0;
+    (detectorModules+imod)->offset=0;
+    (detectorModules+imod)->reg=0;
+    /* initialize registers, dacs, retrieve sn, adc values etc */
+  }
+  thisSettings=UNINITIALIZED;
+  sChan=noneSelected;
+  sChip=noneSelected;
+  sMod=noneSelected;
+  sDac=noneSelected;
+  sAdc=noneSelected;
+  
+  /*
+  setCSregister(ALLMOD); //commented out by dhanya
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD);
+  clearSSregister(ALLMOD); 
+  putout("0000000000000000",ALLMOD);
+  */
+
+  /* initialize dynamic range etc. */
+  /* dynamicRange=getDynamicRange(); //always 16 not required commented out
+     nModX=setNMod(-1);*/
+
+  //dataBytes=nModX*NCHIP*NCHAN*4;
+  // dynamicRange=32;
+  // initChip(0, 0,ALLMOD);
+  //nModX=n; 
+  //
+  allocateRAM();
+
+
+  return OK;
+}
+
+
+
+
+int copyChannel(sls_detector_channel *destChan, sls_detector_channel *srcChan) {
+  destChan->chan=srcChan->chan;
+  destChan->chip=srcChan->chip;
+  destChan->module=srcChan->module;
+  destChan->reg=srcChan->reg;
+  return OK;
+}
+
+
+int copyChip(sls_detector_chip *destChip, sls_detector_chip *srcChip) {
+
+  int ichan;
+  int ret=OK;
+  if ((srcChip->nchan)>(destChip->nchan)) {
+    printf("Number of channels of source is larger than number of channels of destination\n");
+    return FAIL;
+  }
+
+  destChip->nchan=srcChip->nchan;
+  destChip->reg=srcChip->reg;
+  destChip->chip=srcChip->chip;
+  destChip->module=srcChip->module;
+  for (ichan=0; ichan<(srcChip->nchan); ichan++) {
+    *((destChip->chanregs)+ichan)=*((srcChip->chanregs)+ichan);
+  }
+  return ret;
+}
+
+
+int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod) {
+
+  int ichip, idac,  ichan, iadc;
+
+  int ret=OK;
+
+#ifdef VERBOSE
+    printf("Copying module %x to module %x\n",(unsigned int)(srcMod),(unsigned int)(destMod));
+#endif
+
+  if (srcMod->module>=0) {
+#ifdef VERBOSE
+    printf("Copying module number %d to module number %d\n",srcMod->module,destMod->module);
+#endif
+    destMod->module=srcMod->module;
+  }
+  if (srcMod->serialnumber>=0){
+/* #ifdef VERBOSE */
+/*     printf("Copying module serial number %x to module serial number %x\n",srcMod->serialnumber,destMod->serialnumber); */
+/* #endif */
+    destMod->serialnumber=srcMod->serialnumber;
+  }
+  if ((srcMod->nchip)>(destMod->nchip)) {
+    printf("Number of chip of source is larger than number of chips of destination\n");
+    return FAIL;
+  }
+  if ((srcMod->nchan)>(destMod->nchan)) {
+    printf("Number of channels of source is larger than number of channels of destination\n");
+    return FAIL;
+  }
+  if ((srcMod->ndac)>(destMod->ndac)) {
+    printf("Number of dacs of source is larger than number of dacs of destination\n");
+    return FAIL;
+  }
+  if ((srcMod->nadc)>(destMod->nadc)) {
+    printf("Number of dacs of source is larger than number of dacs of destination\n");
+    return FAIL;
+  }
+
+#ifdef VERBOSE
+   printf("DACs: src %d, dest %d\n",srcMod->ndac,destMod->ndac);
+  printf("ADCs: src %d, dest %d\n",srcMod->nadc,destMod->nadc);
+  printf("Chips: src %d, dest %d\n",srcMod->nchip,destMod->nchip);
+  printf("Chans: src %d, dest %d\n",srcMod->nchan,destMod->nchan);
+
+#endif
+
+
+
+  destMod->ndac=srcMod->ndac;
+  destMod->nadc=srcMod->nadc;
+  destMod->nchip=srcMod->nchip;
+  destMod->nchan=srcMod->nchan;
+  if (srcMod->reg>=0)
+    destMod->reg=srcMod->reg;
+#ifdef VERBOSE
+  printf("Copying register %x (%x)\n",destMod->reg,srcMod->reg );
+#endif
+  if (srcMod->gain>=0)
+  destMod->gain=srcMod->gain;
+  if (srcMod->offset>=0)
+    destMod->offset=srcMod->offset;
+ 
+  // printf("copying gain and offset %f %f to %f %f\n",srcMod->gain,srcMod->offset,destMod->gain,destMod->offset);
+ 
+  for (ichip=0; ichip<(srcMod->nchip); ichip++) {
+    if (*((srcMod->chipregs)+ichip)>=0)
+	*((destMod->chipregs)+ichip)=*((srcMod->chipregs)+ichip);
+  }
+  for (ichan=0; ichan<(srcMod->nchan); ichan++) {
+    if (*((srcMod->chanregs)+ichan)>=0)
+	*((destMod->chanregs)+ichan)=*((srcMod->chanregs)+ichan);
+  }
+  for (idac=0; idac<(srcMod->ndac); idac++) {
+    if (*((srcMod->dacs)+idac)>=0)
+	*((destMod->dacs)+idac)=*((srcMod->dacs)+idac);
+  }
+  for (iadc=0; iadc<(srcMod->nadc); iadc++) {
+    if (*((srcMod->adcs)+iadc)>=0)
+	*((destMod->adcs)+iadc)=*((srcMod->adcs)+iadc);
+  }
+  return ret;
+}
+
+
+
+/* Register commands */
+
+
+int clearDACSregister(int imod) {
+
+  putout("1111111111111111",imod);//reset
+  putout("1111111111111110",imod);//cs down
+
+  /* commented out by dhanya
+     putout("0000000001000000",imod);  
+     putout("0000000101000000",imod);  
+     putout("0000000101000000",imod);
+     putout("0000000001000000",imod);
+  */
+#ifdef DEBUG
+  fprintf(stdout, "Clearing DAC shiftregister\n");
+#endif 
+  //  sDac=0;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return OK;
+}
+
+int nextDAC(int imod) {
+
+  putout("1111111111111011",imod);//cs up
+  putout("1111111111111001",imod);//clk down
+  putout("1111111111111111",imod);//reset
+
+  /*commented out by dhanya
+    putout("0000000001000000",imod);      
+    putout("0000000001001000",imod);
+    putout("0000000001000000",imod);
+  */
+#ifdef DEBUG
+  fprintf(stdout, "Next DAC\n");
+#endif 
+  //  sDac++; 
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return OK;
+}
+
+
+int clearCSregister(int imod) {
+
+  putout("0000000001000000",imod);  
+  putout("0000100001000000",imod);  
+  putout("0000100001000000",imod);
+  putout("0000000001000000",imod);  
+#ifdef DEBUG
+  fprintf(stdout, "Clearing CS shiftregister\n");
+#endif
+  /*  
+      sChan=noneSelected;
+      sMod=noneSelected;
+      sDac=noneSelected;
+      sAdc=noneSelected;
+  */
+  sChip=noneSelected;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  //putout("0000000000000000",imod);
+  return 0;
+}
+
+int setCSregister(int imod){
+
+  putout("0000000001000000",imod);  
+  putout("0001000001000000",imod);  
+  putout("0001000001000000",imod);
+  putout("0000000001000000",imod);  
+#ifdef DEBUG
+  fprintf(stdout, "Setting CS shiftregister\n");
+#endif
+  putout("0000000000000000",imod);
+  sChip=allSelected;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int nextChip(int imod){
+
+  putout("0000000001000000",imod);  
+  putout("0010000001000000",imod);
+  putout("0000000001000000",imod); 
+#ifdef DEBUG
+  fprintf(stdout, "Next Chip\n");
+#endif
+  sChip++;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int firstChip(int imod){
+
+  putout("0100000001000000",imod);  
+  putout("0110000001000000",imod);
+  putout("0100000001000000",imod); 
+#ifdef DEBUG
+  fprintf(stdout, "First Chip\n");
+#endif
+  sChip=0;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int clearSSregister(int imod){
+  int i;
+  putout("0000011000000000",imod);
+  for (i=0; i<10; i++)   
+    putout("0000111000000000",imod);
+  putout("0000011000000000",imod); 
+#ifdef DEBUG
+  fprintf(stdout,"Clearing SS shiftregister\n");
+#endif
+  putout("0000000000000000",imod);
+  sChan=noneSelected;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int setSSregister(int imod){
+  int i;
+  putout("0000011000000000",imod);
+  for (i=0; i<10; i++) 
+    putout("0001011000000000",imod);
+  putout("0000011000000000",imod);  
+#ifdef DEBUG
+  fprintf(stdout,"Setting SS shiftregister\n");
+#endif
+  putout("0000000000000000",imod);
+  sChan=allSelected;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int nextStrip(int imod){
+  putout("0000011000000000",imod); 
+  putout("0010011000000000",imod);
+  putout("0000011000000000",imod); 
+#ifdef DEBUG
+  fprintf(stdout,"|-");
+#endif
+  sChan++;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}
+
+int selChannel(const int strip,int imod) {
+  int istrip;
+  clearSSregister(imod);
+  nextStrip(imod);
+  for (istrip=0; istrip<strip; istrip++) {
+    nextStrip(imod);
+  }  
+  sChan=strip;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+
+}  
+
+int selChip(const int chip,int imod) {
+  int ichip;
+  clearCSregister(imod);
+  firstChip(imod);
+  for (ichip=0; ichip<chip; ichip++) {
+    nextChip(imod);
+  }
+  
+  sChip=chip;
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+  return 0;
+}  
+
+/* DACs routines */
+
+int program_one_dac(int addr, int value, int imod) {
+
+#ifdef VERBOSE
+  printf("programming dac %d value %d module %d\n",addr, value,imod);
+#endif
+
+
+  int i,im,idac,bit, control;
+  int v=value;
+
+  //  codata=((((0x2)<<4)+((addr)&0xf))<<16)+((value<<4)&0xfff0);  
+  control=32+addr; 
+  value=(value<<4) |  (control<< 16);
+
+#ifdef DEBUGOUT
+  fprintf(stdout,"value=%d\n",value);
+#endif
+
+  for (i=0;i<24;i++) {
+    bit=value & (1<<(23-i)); 
+    if (bit) {
+      putout("1111111111111100",imod);//clk down
+      putout("1111111111111100",imod);//write data
+      putout("1111111111111110",imod);//clk up
+#ifdef DEBUGOUT
+      fprintf(stdout,"1");
+#endif
+    }
+    else
+      {
+	putout("1111111111111000",imod);//clk down
+	putout("1111111111111000",imod);//write data
+	putout("1111111111111010",imod);//clk up
+#ifdef DEBUGOUT
+      fprintf(stdout,"0");
+#endif
+      }
+  }	
+
+#ifdef DEBUGOUT
+  fprintf(stdout,"\n");
+#endif
+
+  idac=addr;//sDac*2+addr;
+
+
+  if (detectorDacs) {
+    sMod=imod;
+    if (imod==ALLMOD)
+      sMod=allSelected;
+    
+    if (imod>=0 && imod<nModX) {
+      detectorDacs[idac+NDAC*imod]=v;
+#ifdef VERBOSE
+      printf("module=%d index=%d, val=%d addr=%x\n",imod, idac, v, (unsigned int)(detectorDacs+idac+NDAC*imod));
+#endif
+
+      setDACRegister(idac,v,imod);
+    } else if (imod==ALLMOD) {
+      for (im=0; im<nModX; im++) {
+	detectorDacs[idac+NDAC*im]=v;
+	setDACRegister(idac,v,im);
+      }
+    }
+  }
+  return OK;
+
+}
+
+
+
+
+
+int set_one_dac(int imod) {
+  int control, ibit;
+  int bit, value;
+  control=13;
+  value=(DAC_REFOUT<<10) | (control<< 12);
+#ifdef DEBUGOUT
+      fprintf(stdout,"value=%d\n",value);
+#endif
+  for (ibit=0; ibit<6; ibit++) {
+    bit=value & (1<<(15-ibit)); 
+    if (bit) {
+      putout("0000010001000000",imod);
+      putout("0000011001000000",imod);
+      putout("0000010001000000",imod);
+#ifdef DEBUGOUT
+      fprintf(stdout,"1");
+#endif
+    } else {
+      putout("0000000001000000",imod);         
+      putout("0000001001000000",imod);
+      putout("0000000001000000",imod);
+#ifdef DEBUGOUT
+      fprintf(stdout,"0");
+#endif
+    }
+  } 
+  for (ibit=0; ibit<10; ibit++) {
+    putout("0000000001000000",imod);         
+    putout("0000001001000000",imod);
+    putout("0000000001000000",imod);
+#ifdef DEBUGOUT
+    fprintf(stdout,"0");
+#endif
+  }   
+  
+#ifdef DEBUGOUT
+      fprintf(stdout,"\n");
+#endif
+  return OK;
+}
+
+int initDACbyIndex(int ind,int val, int imod) {
+  int v;
+  const int partref[NDAC]=PARTREF;
+  const int partr1[NDAC]=PARTR1;
+  const int partr2[NDAC]=PARTR2;
+ 
+  int ref=partref[ind];
+  int r1=partr1[ind];
+  int r2=partr2[ind];
+  
+
+  v=(val+(val-ref)*r1/r2)*DAC_DR/DAC_MAX;
+  v=initDACbyIndexDACU(ind,v,imod);
+  
+  return (v*DAC_MAX/DAC_DR+ref*r1/r2)/(1+r1/r2);
+}
+
+int initDACbyIndexDACU(int ind, int val, int imod) {
+ 
+  //  const double daccs[NDAC]=DACCS;
+  //  const double dacaddr[NDAC]=DACADDR;
+ 
+  //  int cs=daccs[ind];
+  //  int addr=dacaddr[ind];
+ // int iv;
+  int im;
+
+  if (val>=0) 
+    initDAC(ind,val, imod);
+ 
+  if (imod>=0 && imod<nModX) {
+    // return detectorDacs[ind+imod*NDAC];
+    return setDACRegister(ind,  -1, imod);
+  }
+  else {
+    //iv=detectorDacs[ind];
+#ifdef VERBOSE
+    printf("mod 0 of %d dac %d val %d\n",nModX,ind,setDACRegister(ind,  -1, 0));
+#endif
+    for (im=1; im<nModX; im++) {
+#ifdef VERBOSE
+      printf("mod %d dac %d val %d\n",im,ind,setDACRegister(ind,  -1, im));
+#endif
+      //if (detectorDacs[ind+im*NDAC]!=detectorDacs[ind]) {
+	
+      if (setDACRegister(ind,  -1, im)!=setDACRegister(ind,  -1, 0)) {
+#ifdef VERBOSE
+
+      printf("mod %d returning -1\n",im);
+#endif
+	return -1;
+      }
+    }
+#ifdef VERBOSE
+      printf("returning %d\n",setDACRegister(ind,  -1, 0));
+#endif
+    return setDACRegister(ind,  -1, 0);
+  }
+}
+
+int getThresholdEnergy() {
+  double g[3]=DEFAULTGAIN;
+  double o[3]=DEFAULTOFFSET;
+  double myg=-1, myo=-1;
+ // int dacu;
+  int imod;
+  int ethr=-1;
+  int ret=FAIL;
+
+  if (detectorModules) {
+    //  for (imod=0; imod<getNModBoard(); imod++) {
+    for (imod=0; imod<nModX; imod++) {
+#ifdef VERBOSE
+      printf("module=%d settings=%d, gain=%f, offset=%f\n",imod,thisSettings, (detectorModules+imod)->gain,(detectorModules+imod)->offset);
+#endif
+      if ((detectorModules+imod)->gain>0)
+	myg=(detectorModules+imod)->gain;
+      else {
+	if (thisSettings>=0 && thisSettings<3)
+	  myg=g[thisSettings];
+	//	else
+	//myg=-1;
+      }
+
+      if ((detectorModules+imod)->offset>0)
+	myo=(detectorModules+imod)->offset;
+      else {
+	if (thisSettings>=0 && thisSettings<3)
+	  myo=o[thisSettings];
+	//	else
+	//myo=-1;
+      }
+
+      if (myg>0 && myo>0) {
+	//ethr=(myo-detectorDacs[VTHRESH+imod*NDAC])*1000/myg;
+      
+	ethr=(myo-setDACRegister(VDAC0,-1,imod))*1000/myg;//edited by dhanya
+	// else
+      //	ethr=-1;
+      
+      }
+#ifdef VERBOSE
+      //printf("module=%d gain=%f, offset=%f, dacu=%f\n",imod, myg, myo, detectorDacs[VTHRESH+imod*NDAC]);
+      printf("module=%d gain=%f, offset=%f, dacu=%d\n",imod, myg, myo,(int)(setDACRegister(VDAC0,-1,imod)));//edited by dhanya
+      printf("Threshold energy of module %d is %d eV\n", imod, ethr);
+#endif 
+      
+      if (imod==0)
+	ret=ethr;
+      else {
+	if (ethr>(ret+100) || ethr<(ret-100))
+	  return FAIL;
+      }
+    }
+  }
+  return ret;
+}
+
+int setThresholdEnergy(int ethr) {
+  double g[3]=DEFAULTGAIN;
+  double o[3]=DEFAULTOFFSET;
+  double myg=-1, myo=-1;
+  int dacu;
+  int imod;
+  int ret=ethr;
+
+  setSettings(GET_SETTINGS,-1);//-1 added by dhanya
+  if (thisSettings>=0 || thisSettings<3){
+    myg=g[thisSettings];
+    myo=o[thisSettings];
+  }
+  for (imod=0; imod<nModX; imod++) {
+    if (detectorModules) {
+      if ((detectorModules+imod)->gain>0)
+	myg=(detectorModules+imod)->gain;
+      else  
+	if (thisSettings>=0 && thisSettings<3)
+	  myg=g[thisSettings];
+	else
+	  myg=-1;
+      if ((detectorModules+imod)->offset>0)
+	myo=(detectorModules+imod)->offset;
+      else
+	if (thisSettings>=0 && thisSettings<3)
+	  myo=o[thisSettings];
+	else
+	  myo=-1;
+    } else {
+	if (thisSettings>=0 && thisSettings<3)
+	  myo=o[thisSettings];
+	else
+	  myo=-1;
+	if (thisSettings>=0 && thisSettings<3)
+	  myg=g[thisSettings];
+	else
+	  myg=-1;
+    }
+    if (myg>0 && myo>0) {
+      dacu=myo-myg*((double)ethr)/1000.;
+#ifdef VERBOSE    
+      printf("module %d (%x): gain %f, off %f, energy %d eV, dac %d\n",imod,(unsigned int)((detectorModules+imod)),(detectorModules+imod)->gain,(detectorModules+imod)->offset, ethr,dacu);
+#endif
+    } else {
+      dacu=ethr;
+#ifdef VERBOSE    
+      printf("could not set threshold energy for module %d, settings %d (offset is %f; gain is %f)\n",imod,thisSettings,myo,myg);
+#endif
+    }
+    initDACbyIndexDACU(VDAC0, dacu, imod); ///needs to be fixed dhanya
+  }
+  return ret;
+}
+
+
+
+int getDACbyIndexDACU(int ind,  int imod) {
+  /*
+  if (detectorDacs) {
+    if (imod<getNModBoard())
+      if (ind<(detectorModules+imod)->ndac)
+	return (detectorDacs[ind+imod*NDAC]);
+  }  
+  return FAIL;
+  */
+  return setDACRegister(ind, -1, imod);
+}
+
+
+int initDAC(int dac_addr, int value, int imod) {
+//  int i;
+#ifdef VERBOSE
+  printf("Programming dac %d with value %d\n", dac_addr, value);
+#endif
+  clearDACSregister(imod);
+  program_one_dac(dac_addr,value,imod);
+  nextDAC(imod);
+  clearDACSregister(imod);
+
+  return 0;
+}
+
+int getTemperatureByModule(int tempSensor, int imod)
+{
+  int im;
+  //for the particular module
+  if (imod>=0 && imod<nModX) { 
+    return getTemperature(tempSensor,imod);
+  }
+  else{
+    //checks if all modules have the same value(ALLMOD)
+    for (im=1; im<nModX; im++) {
+      if (getTemperature(tempSensor,im)!=getTemperature(tempSensor,0)) {
+	return -1;
+      }
+    }
+    return getTemperature(tempSensor,0);
+  }
+}
+
+
+int initHighVoltageByModule(int val, int imod)
+{
+  int im;
+  //for the particular module
+  if (imod>=0 && imod<nModX) { 
+    return initHighVoltage(val,imod);
+  }
+  else{
+    //checks if all modules have the same value(ALLMOD)
+    for (im=1; im<nModX; im++) {
+      if (initHighVoltage(val,im)!=initHighVoltage(val,0)) {
+	return -1;
+      }
+    }
+    return initHighVoltage(val,0);
+  }
+}
+
+
+int initConfGainByModule(int isettings,int val, int imod)
+{
+  int im;
+  //for the particular module
+  if (imod>=0 && imod<nModX) { 
+    return initConfGain(isettings,val,imod);
+  }
+  else{
+    //checks if all modules have the same value(ALLMOD)
+    for (im=1; im<nModX; im++) {
+      if (initConfGain(isettings,val,im)!=initConfGain(isettings,val,0))
+	return -1;
+    }
+    return initConfGain(isettings,val,0);
+  }
+}
+
+
+void showbits(int h)
+{
+  if(h==1)
+    printf("%d",h);
+  else
+    {
+      showbits(h/2);
+      printf("%d",h%2);
+    }
+}
+
+
+int initDACs(int* v,int imod)
+{
+#ifdef VERBOSE
+  printf("\n..inside initdacs\n");
+#endif
+  int iaddr;
+  //  sDac=0;
+
+  for (iaddr=0; iaddr<8; iaddr++) {
+    clearDACSregister(imod);
+    if (v[iaddr]>=0) { 
+#ifdef VERBOSE
+      fprintf(stdout, "voltage %d\n", *(v+iaddr));
+#endif
+      program_one_dac(iaddr, *(v+iaddr),imod);
+    }
+    nextDAC(imod);
+  }
+    
+
+  clearDACSregister(imod);
+
+  return 0;
+
+}
+
+
+
+
+int setSettings(int i, int imod) {
+#ifdef VERBOSE
+	if(i==-1)
+		printf("\nReading settings of detector...\n");
+	else
+		printf("\ninside set settings wit settings=%d...\n",i);
+#endif
+  int confgain[] = CONF_GAIN;
+  int isett=-2,retval;
+
+  //reading settings
+  if(i==GET_SETTINGS){
+    retval=initConfGainByModule(i,i,imod);
+    if(retval==i)
+      isett=UNDEFINED;
+  }
+  //writing settings  
+  else{
+    retval=initConfGainByModule(i,confgain[i],imod);
+    if(retval!=i)
+      isett=UNDEFINED;
+  }
+  //if error while read/writing
+  if(isett==UNDEFINED)
+    printf("Error:Weird Value read back from the Gain/Settings Reg\n");
+  else{
+    //validating the settings read back
+    if((retval>=HIGHGAIN)&&(retval<=VERYHIGHGAIN))
+      isett=retval; 
+    else{
+      isett=UNDEFINED;
+      printf("Error:Wrong Settings Read out:%d\n",retval);
+    }
+  }
+  thisSettings=isett;
+#ifdef VERBOSE
+  printf("detector settings are %d\n",thisSettings);
+#endif
+  return thisSettings;
+}
+
+
+
+
+/* Initialization*/
+
+int initChannelbyNumber(sls_detector_channel myChan) {
+  int reg=myChan.reg;
+  int ft=reg & TRIM_DR;
+  int cae=(reg>>(NTRIMBITS))&1;
+  int ae=(reg>>(NTRIMBITS+1))&1;
+  int coe=(reg>>(NTRIMBITS+2))&1;
+  int ocoe=(reg>>(NTRIMBITS+3))&1;
+  int counts=(reg>>(NTRIMBITS+4));
+#ifdef VERBOSE
+  printf("Initializing channel %d chip %d module %d reg %x\n",myChan.chan,myChan.chip,myChan.module, reg);
+  printf("trim %d, cae %d, ae %d, coe %d, ocoe %d, counts %d\n",ft, cae, ae, coe, ocoe, counts);
+#endif
+  
+  if (myChan.chip<0)
+    setCSregister(myChan.module);
+  else
+    selChip(myChan.chip,myChan.module);
+
+   if (myChan.chan<0)
+    setSSregister(myChan.module);
+  else
+    selChannel(myChan.chan,myChan.module);
+  
+   initChannel(ft,cae,ae, coe, ocoe, counts,myChan.module);
+
+   setDynamicRange(dynamicRange);
+
+   setCSregister(ALLMOD);
+   clearSSregister(ALLMOD); 
+   putout("0000000000000000",ALLMOD);
+
+   return myChan.reg;
+
+}
+
+int getChannelbyNumber(sls_detector_channel* myChan) {
+  int imod, ichip, ichan;
+  imod=myChan->module;
+  ichip=myChan->chip;
+  ichan=myChan->chan;
+   
+  if (detectorChans) {
+    if (imod<nModX && imod>=0) {
+      if (ichip<(detectorModules+imod)->nchip && ichan<(detectorModules+imod)->nchan/(detectorModules+imod)->nchip)
+	myChan->reg=detectorChans[imod*NCHAN*NCHIP+ichip*NCHAN+ichan];
+      return OK;
+    }
+  } 
+  return FAIL;
+
+}
+
+int getTrimbit(int imod, int ichip, int ichan) {
+  if (detectorChans) {
+    if (imod<getNModBoard() && imod>=0)
+      if (ichip<(detectorModules+imod)->nchip && ichan<(detectorModules+imod)->nchan/(detectorModules+imod)->nchip)
+	return (detectorChans[imod*NCHAN*NCHIP+ichip*NCHAN+ichan] & TRIM_DR);
+  }
+
+  return -1;
+}
+
+int initChannel(int ft,int cae, int ae, int coe, int ocoe, int counts, int imod){
+  
+  int ibit, bit, i, im, ichip, ichan;
+  int chanmi, chanma, chipmi, chipma, modmi, modma;
+
+
+
+  sMod=imod;
+  //  printf("initializing module %d\n",sMod);
+  if (imod==ALLMOD) {
+    sMod=allSelected;
+
+    //    printf("initializing all modules\n");
+  }
+
+  if (sChan==allSelected) {
+    //    printf("initializing all channels ft=%d coe=%d\n",ft,coe);
+    chanmi=0;
+    chanma=NCHAN;
+  } else if (sChan==noneSelected || sChan>NCHAN || sChan<0) {
+    //  printf("initializing no channels ft=%d coe=%d\n",ft,coe);
+    chanmi=0;
+    chanma=-1;
+  } else {
+    // printf("initializing channel %d ft=%d coe=%d\n",sChan, ft,coe);
+    chanmi=sChan;
+    chanma=sChan+1;
+  }
+  
+  if (sChip==allSelected) {
+    // printf("initializing all chips\n");
+    chipmi=0;
+    chipma=NCHIP;
+  } else if (sChip==noneSelected || sChip>NCHIP || sChip<0) {
+    // printf("initializing no chips\n");
+    chipmi=0;
+    chipma=-1;
+  } else {
+    // printf("initializing chip %d\n",sChip);
+    chipmi=sChip;
+    chipma=sChip+1;
+  }
+ 
+  
+  if (sMod==allSelected) {
+    modmi=0;
+    modma=nModX;//getNModBoard();
+  } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) {
+    modmi=0;
+    modma=-1;
+    return 1;
+  } else {
+    modmi=sMod;
+    modma=sMod+1;
+  }
+ 
+  if (detectorChans) {
+    for (im=modmi; im<modma; im++) {
+      for (ichip=chipmi; ichip<chipma; ichip++) {
+	for (ichan=chanmi; ichan<chanma; ichan++) {
+#ifdef VERBOSE
+	  //  printf("im=%d ichi=%d icha=%d tot=%d reg=%x\n",im,ichip, ichan, im*NCHAN*NCHIP+ichip*NCHAN+ichan,detectorChans[im*NCHAN*NCHIP+ichip*NCHAN+ichan]);
+#endif
+	 detectorChans[im*NCHAN*NCHIP+ichip*NCHAN+ichan]= ft | (cae<<(NTRIMBITS+1)) | (ae<<(NTRIMBITS+2)) | (coe<<(NTRIMBITS+3)) | (ocoe<<(NTRIMBITS+4)) | (counts<<(NTRIMBITS+5));
+#ifdef VERBOSE
+	 //printf("imod=%d ichip=%d ichan=%d addr=%x reg=%x\n",im,ichip,ichan,detectorChans+im*NCHAN*NCHIP+ichip*NCHAN+ichan, detectorChans[im*NCHAN*NCHIP+ichip*NCHAN+ichan]);
+	  // printf("imod=%d ichip=%d ichan=%d addr=%x reg=%x\n",im,ichip,ichan,detectorChans+im*NCHAN*NCHIP+ichip*NCHAN+ichan, detectorChans[im*NCHAN*NCHIP+ichip*NCHAN+ichan]);
+#endif
+	}
+      }
+    }
+  }
+  /* remember to clear counters before programming!!!*/
+  if (ft>63 || ft<0) {
+    fprintf(stdout,"Fine Threshold is %d  while should be between 0 and 63!",ft);
+    return 1;
+  }
+  /*cal_enable*/
+  if (cae) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+  }
+  /*n_an_enable*/
+  if (ae) {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod);
+    putout("0000000000000000",imod);   
+  } else {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  }
+  /*trb5*/
+  ibit=5;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod);
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }
+
+  /*trb3*/
+  ibit=3;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod);
+    putout("0000000000000000",imod);  
+  }
+
+  /*trb2*/
+  ibit=2;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod);
+    putout("0100000000000000",imod);   
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }
+
+  /*trb1*/
+  ibit=1;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }
+
+  /*trb0*/
+  ibit=0;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod); 
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }
+
+  /*n_comp_enable*/
+  if (coe) {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod); 
+  } else {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  }
+
+ 
+  /*trb4*/
+  ibit=4;
+  bit=ft & (1<<ibit);  
+  if (bit) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod);
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod);
+    putout("0000000000000000",imod);   
+  }
+  
+  /*out_comp_enable*/
+  if (ocoe) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }
+  
+  
+  for (ibit=0; ibit<24; ibit++) {
+    bit=counts & (1<<ibit);  
+    if (bit) {
+      putout("0100000000000000",imod);  
+      putout("0110000000000000",imod); 
+      putout("0100000000000000",imod);  
+    } else {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod);
+      putout("0000000000000000",imod);  
+    }
+  }
+  counterClear(imod);
+  counterSet(imod);
+  putout("0000000000000000",imod);
+  for (i=0; i<10; i++) 
+    putout("0000100000000000",imod);
+  putout("0000000000000000",imod);
+
+  //getDynamicRange();
+
+
+  return 0;
+
+}
+
+
+int initChipbyNumber(sls_detector_chip myChip){
+  int imod, ichip;
+  imod=myChip.module;
+  ichip=myChip.chip;
+  int obe=(myChip.reg)&1;
+  int ow=(myChip.reg)>>1;
+  int nchan, ichan;
+  int ft,  cae, ae, coe, ocoe, counts, chanreg;
+ 
+  
+  
+  nchan=myChip.nchan;
+  if (ichip<0)
+    setCSregister(imod);
+  else
+    selChip(ichip,imod);
+
+  clearSSregister(imod);
+  for (ichan=0; ichan<nchan; ichan++) {
+    chanreg=(myChip.chanregs)[ichan];
+    ft=chanreg&((int)TRIM_DR);
+    cae=(chanreg>>(NTRIMBITS+1))&1;
+    ae=(chanreg>>(NTRIMBITS+2))&1;
+    coe=((chanreg)>>(NTRIMBITS+3))&1;
+    ocoe=((chanreg)>>(NTRIMBITS+4))&1;
+    counts=((chanreg)>>(NTRIMBITS+5));
+    nextStrip(imod); 
+    initChannel(ft,cae,ae, coe, ocoe, counts,imod);
+  }
+  initChip(obe,ow,imod);
+  return myChip.reg;
+
+}
+
+int getChipbyNumber(sls_detector_chip* myChip){
+  int imod, ichip;
+  imod=myChip->module;
+  ichip=myChip->chip;
+  
+  if (detectorChips) {
+    if (imod<nModX)
+      if (ichip<(detectorModules+imod)->nchip) {
+	myChip->reg=detectorChips[ichip+imod*NCHIP];
+	myChip->nchan=NCHAN;
+	myChip->chanregs=detectorChans+imod*NCHAN*NCHIP+ichip*NCHIP;
+	return OK;
+      }
+  }
+  return FAIL;
+
+}
+
+
+
+int initChip(int obe, int ow,int imod){
+  int i;
+  int im, ichip;
+  int chipmi, chipma, modmi, modma;
+  /* switch (ow) {
+  case 0:;
+  case 1:
+    setDynamicRange(32);
+    break;
+  case 2:
+    setDynamicRange(16);
+    break;
+  case 3:
+    setDynamicRange(8);
+    break;
+  case 4:
+    setDynamicRange(4);
+    break;
+  case 5:
+    setDynamicRange(1);
+    break;
+  default:
+    setDynamicRange(32);
+    break;
+  }
+  */
+
+#ifdef DEBUGOUT
+  printf("Initializing chip\n");
+#endif
+  putout("0000000000000000",imod);
+#ifdef DEBUGOUT
+  printf("Output mode= %d\n", ow);
+#endif
+
+  /* clearing shift in register */
+  for (i=0; i<10; i++) 
+    putout("0000100000000000",imod);
+  putout("0000000000000000",imod);
+
+  if (ow>0) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);
+    for (i=0; i<(OUTMUX_OFFSET-1); i++) {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod); 
+      putout("0000000000000000",imod); 
+    }
+    if (ow>1) {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod);
+      putout("0000000000000000",imod); 
+    }
+    if (ow>2) {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod);
+      putout("0000000000000000",imod);
+    }
+    if (ow>3) {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod); 
+      putout("0000000000000000",imod);
+    }
+    if (ow>4) {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod); 
+      putout("0000000000000000",imod);
+    }
+  }  
+#ifdef DEBUGOUT
+  printf("Output buffer  enable= %d\n", obe);
+#endif
+  if (obe) {
+    putout("0100000000000000",imod);  
+    putout("0110000000000000",imod); 
+    putout("0100000000000000",imod);  
+  } else {
+    putout("0000000000000000",imod);  
+    putout("0010000000000000",imod); 
+    putout("0000000000000000",imod);  
+  }    
+  /*}*/
+  putout("0000000000000000",imod);  
+
+
+
+
+
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+
+ 
+  if (sChip==allSelected) {
+    chipmi=0;
+    chipma=NCHIP;
+  } else if (sChip==noneSelected || sChip>NCHIP || sChip<0) {
+    chipmi=0;
+    chipma=-1;
+  } else {
+    chipmi=sChip;
+    chipma=sChip+1;
+  }
+ 
+  
+  if (sMod==allSelected) {
+    modmi=0;
+    modma=nModX;//getNModBoard();
+  } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) {
+    modmi=0;
+    modma=-1;
+  } else {
+    modmi=sMod;
+    modma=sMod+1;
+  }
+ 
+  if (detectorChips) {
+    for (im=modmi; im<modma; im++) {
+      for (ichip=chipmi; ichip<chipma; ichip++) {
+	//	printf("imod %d ichip %d\n",im,ichip);
+	detectorChips[im*NCHIP+ichip]=obe | (ow<<1);
+#ifdef VERBOSE
+	//printf("imod=%d ichip=%d reg=%d (%x)\n",im,ichip,detectorChips[im*NCHIP+ichip],detectorChips+im*NCHIP+ichip);
+#endif
+      }
+    }
+  }
+  getDynamicRange();
+  return 0;
+}
+
+
+int initChipWithProbes(int obe, int ow,int nprobes, int imod){
+  int i;
+  int im, ichip;
+  int chipmi, chipma, modmi, modma;
+
+  int64_t regval=0, dum;
+  int omask;
+  switch (ow) {
+  case 2:
+    omask=2;
+    break;
+  case 3:
+    omask=4;
+    break;
+  case 4:
+    omask=8;
+    break;
+  case 5:
+    omask=16;
+    break;
+  default:
+    omask=0;//1;
+    break;
+  }
+
+#ifdef VERBOSE 
+ // printf("\n \n \n",regval);
+  printf("initChip ow=%d omask=%d probes=%d\n",ow, omask,nprobes);
+#endif
+  regval|=(omask<<OUTMUX_OFFSET);
+  regval|=(nprobes<<PROBES_OFFSET);
+  regval|=(obe<<OUTBUF_OFFSET);
+#ifdef VERBOSE
+  printf("initChip : shift in will be %08x\n",(unsigned int)(regval));
+#endif
+  /* clearing shift in register */
+
+  putout("0000000000000000",imod);
+  for (i=0; i<10; i++) 
+    putout("0000100000000000",imod);
+  putout("0000000000000000",imod);
+
+  for (i=0; i<35; i++) {
+    dum= (1<<(34-i));
+    if (regval & dum) {
+      putout("0100000000000000",imod);  
+      putout("0110000000000000",imod); 
+      putout("0100000000000000",imod);
+    } else {
+      putout("0000000000000000",imod);  
+      putout("0010000000000000",imod); 
+      putout("0000000000000000",imod); 
+    }
+  }
+  putout("0000000000000000",imod);  
+
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+
+ 
+  if (sChip==allSelected) {
+    chipmi=0;
+    chipma=NCHIP;
+  } else if (sChip==noneSelected || sChip>NCHIP || sChip<0) {
+    chipmi=0;
+    chipma=-1;
+  } else {
+    chipmi=sChip;
+    chipma=sChip+1;
+  }
+ 
+  
+  if (sMod==allSelected) {
+    modmi=0;
+    modma=nModX;//getNModBoard();
+  } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) {
+    modmi=0;
+    modma=-1;
+  } else {
+    modmi=sMod;
+    modma=sMod+1;
+  }
+ 
+  if (detectorChips) {
+    for (im=modmi; im<modma; im++) {
+      for (ichip=chipmi; ichip<chipma; ichip++) {
+	//	printf("imod %d ichip %d\n",im,ichip);
+	detectorChips[im*NCHIP+ichip]=obe | (ow<<1);
+#ifdef VERBOSE
+	//printf("imod=%d ichip=%d reg=%d (%x)\n",im,ichip,detectorChips[im*NCHIP+ichip],detectorChips+im*NCHIP+ichip);
+#endif
+      }
+    }
+  }
+  getDynamicRange();
+
+  return 0;
+}
+/*
+int getNProbes() {
+  return numberOfProbes;
+}
+*/
+
+
+int initMCBregisters(int cm, int imod){
+
+  int im, modmi, modma;
+  if (cm<0)
+    return 0;
+    
+
+  putout("0000000001000000",imod);    
+  putout("0000000001100000",imod);   
+  putout("0000000001100000",imod);     
+  putout("0000000001000000",imod);    
+  
+ if (cm) { 
+   putout("0000000001000001",imod); 
+#ifdef DEBUGOUT   
+   printf("enabling cal through sensor\n");
+#endif
+ }  else {
+   putout("0000000001000001",imod);
+   putout("0000000001000000",imod);
+   putout("0000000001000001",imod); 
+#ifdef DEBUGOUT   
+   printf("disabling cal through sensor\n");
+#endif 
+ }
+ putout("0000000001000000",imod);
+ 
+  sMod=imod;
+  if (imod==ALLMOD)
+    sMod=allSelected;
+
+ 
+  
+  if (sMod==allSelected) {
+    modmi=0;
+    modma=nModX;
+  } else if (sMod==noneSelected || sMod>nModX || sMod<0) {//(sMod==noneSelected || sMod>getNModBoard() || sMod<0) {
+    modmi=0;
+    modma=-1;
+  } else {
+    modmi=sMod;
+    modma=sMod+1;
+  }
+ 
+  if (detectorModules) {
+    for (im=modmi; im<modma; im++) {
+      ((detectorModules+im)->reg)=cm;
+#ifdef VERBOSE
+      printf("imod=%d reg=%d (%x)\n",im,(detectorModules+im)->reg,(unsigned int)((detectorModules+im)));
+#endif
+    }
+  }
+ return 0;
+}
+
+int initModulebyNumber(sls_detector_module myMod) { 
+
+  printf("\ninside initmoduleynumber..\n");
+ 
+  int nchip,nchan;//int ichip, nchip, ichan, nchan;
+  int im, modmi,modma;
+ // int ft,  cae, ae, coe, ocoe, counts, chanreg;
+  int imod;
+ // int obe;
+ // int ow;
+  int v[NDAC];
+
+
+  nchip=myMod.nchip;
+  nchan=(myMod.nchan)/nchip;
+
+  imod=myMod.module;
+  sMod=imod;
+
+  if (sMod==ALLMOD)
+    sMod=allSelected;
+    
+  if (sMod==allSelected) {
+    modmi=0;
+    modma=nModX;//getNModBoard();
+  } else if (sMod==noneSelected || sMod>nModX || sMod<0) {// (sMod==noneSelected || sMod>getNModBoard() || sMod<0) {
+    modmi=0;
+    modma=-1;
+  } else {
+    modmi=sMod;
+    modma=sMod+1;
+  }
+
+
+  /*
+  for (idac=0; idac<NDAC; idac++)
+    v[idac]=(myMod.dacs)[idac];
+  */
+
+
+  v[VDAC0]=(myMod.dacs)[0];
+  v[VDAC1]=(myMod.dacs)[1];
+  v[VDAC2]=(myMod.dacs)[2];
+  v[VDAC3]=(myMod.dacs)[3];
+  v[VDAC4]=(myMod.dacs)[4];
+  v[VDAC5]=(myMod.dacs)[5];
+  v[VDAC6]=(myMod.dacs)[6];
+  v[VDAC7]=(myMod.dacs)[7];
+
+#ifdef VERBOSE
+  printf("imod=%d\n",imod);
+  printf("vdac0=%d\n",v[VDAC0]);
+  printf("vdac1=%d\n",v[VDAC1]);
+  printf("vdac2=%d\n",v[VDAC2]);
+  printf("vdac3=%d\n",v[VDAC3]);
+  printf("vdac4=%d\n",v[VDAC4]);
+  printf("vdac5=%d\n",v[VDAC5]);
+  printf("vdac6=%d\n",v[VDAC6]);
+  printf("vdac7=%d\n",v[VDAC7]);
+#endif
+ 
+
+  initDACs(v,imod);
+  // initMCBregisters(myMod.reg,imod);
+ 
+  if (detectorModules) {
+    for (im=modmi; im<modma; im++) {  
+#ifdef VERBOSE
+      printf("im=%d\n",im);
+#endif
+      copyModule(detectorModules+im,&myMod);
+    }
+  } 
+
+  //setting the conf gain and the settings register
+  setSettings(myMod.reg,imod);
+  
+  return myMod.reg;
+}
+
+
+int getModulebyNumber(sls_detector_module* myMod) {
+  int imod=myMod->module;
+#ifdef VERBOSE
+  printf("Getting module %d\n",imod);
+#endif
+  if (detectorModules) {
+    copyModule(myMod,detectorModules+imod);
+    ;
+  } else
+    return FAIL;
+
+  return OK;
+}
+
+/* To chips */
+int clearCounter(int imod){
+  int i;
+#ifdef DEBUG
+  printf("Clearing counter with contclear\n");
+#endif
+  putout("0000000000000000",imod);  
+  for (i=0; i<10; i++)   
+    putout("0000000000010000",imod);   
+  putout("0000000000000000",imod);  
+
+  return 0;    
+}
+
+int clearOutReg(int imod){
+  int i;
+#ifdef DEBUG
+  printf("Clearing output register\n");
+#endif
+  putout("0000010000000000",imod); 
+  for (i=0; i<10; i++)
+    putout("0000110000000000",imod);   
+  putout("0000010000000000",imod);  
+  return 0;    
+}
+int setOutReg(int imod){
+  int i;
+#ifdef DEBUG
+  printf("Setting output register\n");
+#endif
+  putout("0000010000000000",imod); 
+  for (i=0; i<10; i++)
+    putout("0001010000000000",imod);   
+  putout("0000010000000000",imod);  
+  return 0;    
+}
+
+
+int extPulse(int ncal, int imod) {
+  int ical;
+#ifdef DEBUG
+  printf("Giving a clock pulse to the counter\n");
+#endif
+  for (ical=0; ical<ncal; ical++) {
+    putout("0000001000000000",imod);
+    putout("0010001000000000",imod);
+    putout("0000001000000000",imod);
+  }
+  return 0;
+}
+int calPulse(int ncal, int imod) {
+  int ical,i;
+#ifdef DEBUG
+  printf("Giving a cal pulse\n");
+#endif
+  for (ical=0; ical<ncal; ical++) { 
+    //printf("%d\n",ical);
+     for (i=0; i<10; i++)
+       putout("0000000000100000",imod);
+    for (i=0; i<20; i++)
+      putout("0000000000100001",imod);
+     for (i=0; i<10; i++)
+       putout("0000000000100000",imod);
+  }
+  putout("0000000000000000",imod);
+  return 0;
+}
+
+int countEnable(int imod) {
+#ifdef DEBUG
+  printf("Enabling counter\n");
+#endif
+  putout("0000000000100000",imod);
+  return 0;
+}
+
+
+int counterClear(int imod) {
+  int i;
+#ifdef DEBUG
+  printf("Clearing counter in counter mode\n");
+#endif
+  putout("0000001000000000",imod);
+  for (i=0; i<10; i++) 
+    putout("0000101000000000",imod);
+  putout("0000001000000000",imod);
+  return 0;
+}
+
+int counterSet(int imod) {
+  int i;
+#ifdef DEBUG
+  printf("Setting counter\n");
+#endif
+  putout("0000001000000000",imod);
+  for (i=0; i<20; i++)
+    putout("0001001000000000",imod);
+  putout("0000001000000000",imod);    
+
+  return 0;
+}
+// Fifo continuous read 
+
+int readOutChan(int *val) {
+  int i, j, k, v;
+  int nbit=24;
+
+  setCSregister(ALLMOD); 
+  clearOutReg(ALLMOD);
+  
+  setOutReg(ALLMOD);
+
+#ifdef DEBUG
+  printf("Reading out one channel\n");
+#endif
+
+  
+
+  for (i=0; i<nbit; i++) {
+    putout("0000010000000000", ALLMOD);
+    k=0;
+    for (k=0; k<nModX; k++) {
+      v=readin(k);
+      //v=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff;
+      for (j=0; j<NCHIP; j++) {
+	if (i==0) 
+	  *(val+j+k*NCHIP)=0;
+	if (v & (1<<j)) { 
+	  *(val+j+k*NCHIP)= *(val+j+k*NCHIP) | (1 << i);
+	} 
+      }
+    }
+    putout("0000010000000000",ALLMOD);
+    putout("0010010000000000", ALLMOD); 
+    putout("0010010000000000", ALLMOD); 
+  }
+  putout("0000010000000000",ALLMOD);
+  putout("0000010000000000",ALLMOD); 
+  return 0;
+}
+
+int getModuleNumber(int modnum) {
+  int val = 0xfff;
+ // val=readin(modnum);
+  return val;
+}
+
+
+int testShiftIn(int imod) {
+  int val,i,j, k, result=OK;
+  setCSregister(ALLMOD); 
+  printf("testing shift in for module %d\n", imod);
+  //for (j=0; j<10; j++) {
+  //selChip(j);
+  for (i=0; i<34; i++) {
+    if (i%2) {
+      putout("0100000000000000",ALLMOD);
+      putout("0100000000000000",ALLMOD);  
+      putout("0110000000000000",ALLMOD);  
+      putout("0110000000000000",ALLMOD); 
+      putout("0100000000000000",ALLMOD);
+      putout("0100000000000000",ALLMOD); 
+    } else {
+      putout("0000000000000000",ALLMOD);
+      putout("0000000000000000",ALLMOD);  
+      putout("0010000000000000",ALLMOD);  
+      putout("0010000000000000",ALLMOD);  
+      putout("0000000000000000",ALLMOD);
+      putout("0000000000000000",ALLMOD);
+    } 
+  }
+    putout("0000000000000000",ALLMOD);    
+    for (i=0; i<34; i++) {
+      putout("0000000000000000",ALLMOD); 
+      
+      k=imod;
+      //for (k=0; k<nModX; k++) {
+      val=readin(k);
+      //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff;
+	for (j=0; j<10; j++) {	
+	  if ( (val & 1<<j)>0 && i%2==0) {   
+	    printf("Shift in: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2);
+	    result++;
+	  }
+	  if (i%2>0 && (val & 1<<j)==0) {   
+	    printf("Shift in: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2);
+	    result++;
+	  }
+	}
+	//}
+      putout("0010000000000000",ALLMOD); 
+      putout("0010000000000000",ALLMOD); 
+      putout("0000000000000000",ALLMOD); 
+      
+    }
+    putout("0000000000000000", ALLMOD); 
+    printf("Shift in module %d : %d errors\n", imod,result);
+    if (result)
+      return 1;
+    else
+      return 0;
+}
+
+int testShiftOut(int imod) {  
+  int i, j, val,k, result=OK; 
+  int dum;
+  dum=0xaaaaaa;
+
+  printf("testing shift out for module %d\n", imod);
+
+  setCSregister(ALLMOD);
+  for (i=0; i<24; i++) {
+    if (dum & 1<<i) {
+      putout("0100010000000000",ALLMOD);  
+      putout("0110010000000000",ALLMOD);  
+      putout("0110010000000000",ALLMOD);  
+      putout("0100010000000000",ALLMOD);  
+    } else {
+      putout("0000010000000000",ALLMOD);  
+      putout("0010010000000000",ALLMOD);  
+      putout("0010010000000000",ALLMOD);  
+      putout("0000010000000000",ALLMOD); 
+    }
+  }
+  putout("0000000100000000",ALLMOD); 
+
+  for (i=0; i<24; i++) {
+    putout("0000010000000000",ALLMOD);
+    putout("0000010000000000",ALLMOD);  
+
+
+    k=imod;
+    //for (k=0; k<nModX; k++) {
+    val=readin(k);
+    //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff;
+      //printf("%8x\n",val);
+      for (j=0; j<10; j++) {	
+	if ( (val & (1<<j))>0 && (dum & (1<<i))==0) {   
+	  printf("Shift out: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, (dum &1<<j));
+	  result++;
+	}
+	if ( (val & (1<<j))==0 && (dum & (1<<i))>0) {   
+	  printf("Shift out: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, (dum &1<<j));
+	  result++;
+	}
+      }
+      //}
+    putout("0010010000000000",ALLMOD);  
+  }
+  putout("0000000000000000", ALLMOD);  
+  printf("Shift out module %d : %d errors\n", imod,result);
+    if (result)
+      return 1;
+    else
+      return 0;
+}
+
+int testShiftStSel(int imod) {
+  int result=OK;
+  int val,i,j,k;
+  printf("testing shift stsel for module %d\n", imod);
+  setCSregister(ALLMOD);  
+  for (i=0; i<NCHAN; i++) {
+    if (i%2) {
+      putout("0100011000000000",ALLMOD);  
+      putout("0110011000000000",ALLMOD);  
+      putout("0100011000000000",ALLMOD); 
+    } else { 
+      putout("0000011000000000",ALLMOD);  
+      putout("0010011000000000",ALLMOD);  
+      putout("0000011000000000",ALLMOD);
+    }
+  }
+  putout("0010011000000000",ALLMOD); 
+  for (i=0; i<NCHAN; i++) {
+    putout("0000011000000000",ALLMOD); 
+
+
+    k=imod;
+    //for (k=0; k<nModX; k++) {
+    val=readin(k);
+    //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff;
+	for (j=0; j<NCHIP; j++) {	
+	  if ( (val & 1<<j)>0 && i%2==0) {   
+	    printf("Shift stsel: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2);
+	    result++;
+	  }
+	  if (i%2>0 && (val & 1<<j)==0) {   
+	    printf("Shift stsel: module %d chip %i bit %d read %d instead of %d \n",k,j,i,val & 1<< j, i%2);
+	    result++;
+	  }
+	}
+	//}
+
+
+
+
+    putout("0010011000000000",ALLMOD);  
+  }  
+  putout("0000011000000000",ALLMOD); 
+  printf("Shift stsel module %d : %d errors\n", imod,result); 
+    if (result)
+      return 1;
+    else
+      return 0;
+}
+
+
+
+
+int testDataInOut(int num, int imod) {
+  int val[NCHIP*nModX], result=OK;
+  int ich, ichip;
+  setCSregister(ALLMOD);
+  printf("Testing data in out for module %d pattern 0x%x\n", imod, num);
+  setSSregister(ALLMOD);
+  initChannel(0,0,0,0,0,num,ALLMOD);
+  putout("0000000000000000",ALLMOD);
+  setCSregister(ALLMOD);
+  initChip(0, 0,ALLMOD);
+  clearSSregister(ALLMOD);
+  for (ich=0; ich<NCHAN; ich++) {
+    nextStrip(ALLMOD);
+    readOutChan(val);
+    //imod=0;
+    //for (imod=0; imod<nModX; imod++) {
+      for (ichip=0; ichip<NCHIP; ichip++) {
+	if (val[ichip+imod*NCHIP]!=num) {
+	  printf("Test datain out: Channel %d read %x instead of %x\n", (imod*NCHIP+ichip)*NCHAN+ich, val[ichip+NCHIP*imod], num);
+	result++;
+	}
+      }
+      //}
+  } 
+  if (result)
+    return 1;
+  else
+    return 0;
+}
+
+
+
+
+int testExtPulse(int imod) {
+  int i, ichan, ichip, result=OK;
+  int *val1;
+
+  printf("Testing counter for module %d\n", imod);
+
+  setCSregister(ALLMOD);
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD);  
+  putout("0000000000000000",ALLMOD);
+  putout("0000100000000000",ALLMOD);
+  putout("0000000000000000",ALLMOD);
+  for (i=0; i<NCHAN; i++) {
+    putout("0000000000000000",ALLMOD);
+    putout("0000000000001000",ALLMOD);
+    putout("0000000000000000",ALLMOD);
+    extPulse(1,ALLMOD);
+  }
+  clearSSregister(ALLMOD);
+  putout("0000000000000000",ALLMOD);
+
+ 
+  // Readout with SM 
+
+  //startStateMachine();
+  startReadOut();
+  usleep(100);
+  val1=(int*)(decode_data((int*)(fifo_read_event())));
+  // val1=fifo_read_event();
+  //imod=0;
+  //for (imod=0; imod<nModX; imod++) {
+  for (ichip=0; ichip<NCHIP; ichip++) {
+      for (ichan=0; ichan<NCHAN; ichan++) {//
+	if ((*(val1+ichan+(ichip+imod*NCHIP)*NCHAN))!=ichan) {
+	  result++;
+	  printf("Counter test: channel %d read %d instead of %d\n",ichan+(ichip+imod*NCHIP)*NCHAN, val1[ichan+(ichip+imod*NCHIP)*NCHAN], ichan);
+	  }
+      }
+  }
+  //}
+  free(val1);
+  if (result)
+    return 1;
+  else
+    return 0;
+}
+
+
+int testExtPulseMux(int imod, int ow) {
+
+  int i, ichan, ichip, result=0,   ind, chipr=0;
+  int  *values, *v1;  
+  int vright,v;
+  int nbit_mask=0xffffff;
+
+  printf("Testing counter for module %d, mux %d\n", imod, ow);
+  setExposureTime(0);
+  setFrames(1);
+  setTrains(1);
+
+
+  if (ow==2)
+    nbit_mask=0xffff;
+  else if (ow==3)
+    nbit_mask=0xff;
+  else if (ow==4)
+    nbit_mask=0xf;
+  else if (ow==5)
+    nbit_mask=0x1;
+  
+
+
+  setCSregister(ALLMOD);
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD); 
+  initChipWithProbes(0, ow,0,ALLMOD); 
+  //  initChip(0, ow,ALLMOD);
+  for (ichip=0; ichip<NCHIP; ichip++) {
+  setSSregister(ALLMOD);
+    for (i=0; i<NCHAN; i++) {
+      putout("0000000000000000",ALLMOD);
+      putout("0000000000001000",ALLMOD);
+      putout("0000000000000000",ALLMOD);
+      extPulse(1,ALLMOD);
+    }
+    nextChip(ALLMOD);
+  }
+  setCSregister(ALLMOD);
+  clearSSregister(ALLMOD);
+  putout("0000000000000000",ALLMOD);
+
+  // Readout with SM 
+
+
+  startReadOut();
+  usleep(100);
+  v1=(int*)(fifo_read_event());
+  if (v1)
+    values=(int*)(decode_data(v1));
+  else {
+    printf("no data found in fifos\n");
+    return 1;
+  }
+  for (ichip=0; ichip<NCHIP; ichip++) {
+    chipr=0;
+      for (ichan=0; ichan<NCHAN; ichan++) { 
+	ind=ichan+(ichip+imod*NCHIP)*NCHAN;
+	v=values[ind];
+	vright=(ichan*(ichip+1))&nbit_mask;
+	if (v!=vright) {
+	  result++;
+	  chipr++;
+	  printf("Counter test mux %d mode: channel %d chip %d read %d instead of %d\n",ow, ichan+(ichip+imod*NCHIP)*NCHAN, ichip, v, vright);
+	  //break;
+	}
+	//printf("\n");
+      }
+      if (chipr)
+	printf("Test Counter  module %d chip%d mux %d: %d errors\n", imod,ichip, ow,chipr);
+  }
+  free(values);
+  if (result)
+    printf("Test Counter  module %d mux %d: %d errors\n", imod,ow,result);
+
+  if (result)
+    return 1;
+  else
+    return 0;
+
+}
+
+int testDataInOutMux(int imod, int ow, int num) {
+
+  int  ichan, ichip, result=0, chipr=0,  ind;
+  int vright,v;
+  int nbit_mask=0xffffff;
+  int *values, *v1;
+
+  printf("Testing data inout for module %d, mux %d, pattern 0x%x\n", imod, ow, num);
+  setExposureTime(0);
+  setFrames(1);
+  setTrains(1);
+
+
+  if (ow==2)
+    nbit_mask=0xffff;
+  else if (ow==3)
+    nbit_mask=0xff;
+  else if (ow==4)
+    nbit_mask=0xf;
+  else if (ow==5)
+    nbit_mask=0x1;
+
+  vright=num&nbit_mask;
+
+  setCSregister(ALLMOD);
+  //printf("Testin data in out\n");
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD); 
+  initChannel(0,0,0,0,0,num,ALLMOD);
+  putout("0000000000000000",ALLMOD);
+  clearSSregister(ALLMOD);
+  initChipWithProbes(0, ow,0,ALLMOD);
+  clearSSregister(ALLMOD);
+  putout("0000000000000000",ALLMOD);
+
+  // Readout with SM 
+
+  printf("mux %d\n",ow);
+  startReadOut();
+  usleep(100);  
+  v1=(int*)(fifo_read_event());
+  if (v1)
+    values=(int*)(decode_data(v1));
+  else {
+    printf("no data found in fifos\n");
+    return 1;
+  }
+  for (ichip=0; ichip<NCHIP; ichip++) {
+    chipr=0;
+      for (ichan=0; ichan<NCHAN; ichan++) { 
+	ind=ichan+(ichip+imod*NCHIP)*NCHAN;
+	v=values[ind];
+	if (v!=vright) {
+	  result++;
+	  chipr++;
+	  printf("DataInOut test mux %d mode: channel %d chip %d  read %d instead of %d\n",ow, ichan+(ichip+imod*NCHIP)*NCHAN, ichip, v, vright);
+	  //break;
+	}
+	//printf("\n");
+      }
+      if (chipr)
+	printf("Test DatInOut module %d chip %d mux %d: %d errors\n", imod,ichip, ow,chipr);
+  }
+  if (result)
+    printf("Test DatInOut module %d mux %d: %d errors\n", imod,ow,result);
+  free(values);
+  if (result)
+    return 1;
+  else
+    return 0;
+
+}
+
+
+int testOutMux(int imod) {
+  int ibit, i, val, v, j, dist, k;
+  int result=OK;
+  long pat=0xf0f0f0;
+  printf("testing outmux for module %d\n", imod);
+  setCSregister(ALLMOD);
+  // Clear outshift reg 
+  putout("0000010000000000",ALLMOD);
+  for (ibit=0; ibit<10;ibit++)
+    putout("0000110000000000",ALLMOD);
+  putout("0000010000000000",ALLMOD);
+
+  // Clear inshift reg 
+  putout("0000000000000000",ALLMOD);
+  for (ibit=0; ibit<10;ibit++)
+    putout("0000100000000000",ALLMOD);
+  putout("0000000000000000",ALLMOD);
+
+  // input pattern 0f0f0f 
+
+  for (ibit=0; ibit<24;ibit++) {
+    if (pat & (1 << ibit)) {
+      putout("0100010000000000",ALLMOD);
+      putout("0110010000000000",ALLMOD); //write in the data 1 
+      putout("0100010000000000",ALLMOD);
+
+    } else {
+      putout("0000010000000000",ALLMOD);
+      putout("0010010000000000",ALLMOD); //write in the data 0 
+      putout("0000010000000000",ALLMOD);
+    }
+  }  
+  
+  putout("0100000000000000",ALLMOD);
+  putout("0110000000000000",ALLMOD); //shift in 1 
+  putout("0100000000000000",ALLMOD);
+
+  for (ibit=0; ibit<20;ibit++) {
+    putout("0000000000000000",ALLMOD);
+    putout("0010000000000000",ALLMOD); //shift in 20 bits 
+    putout("0000000000000000",ALLMOD);
+  }  
+      
+  // check pattern, with different oumux settings 
+
+    for (ibit=0; ibit<4;ibit++) { 
+      dist=6-2*ibit;
+      //dist=2*ibit;
+      if (dist==0)
+	dist=1;
+#ifdef DEBUGOUT
+      printf("Distance is %d\n",dist);
+#endif
+
+
+   
+      putout("0000010001000000",ALLMOD);
+      putout("0000010001000000",ALLMOD); //output is out0
+      putout("0000010001000000",ALLMOD);
+
+      i=0;
+      k=imod;
+      //for (k=0; k<nModX; k++) {
+      val=readin(k);
+      //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff; 
+#ifdef DEBUGOUT
+      printf("%d %x\n",i*dist,val);     
+#endif
+      for (j=0; j<NCHIP; j++) {
+	v=val & 1<< j;
+	if (pat & (1<<(i*dist))) {
+	  if (v==0) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	  // should be 1
+	} else { 
+	  if (v) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	}
+      }
+      //}
+      putout("0000010001100000",ALLMOD);
+      putout("0000010001100000",ALLMOD); //output is out1
+      putout("0000010001100000",ALLMOD);
+
+      i++;
+      k=imod;
+      //for (k=0; k<nModX; k++) {
+      val=readin(k);
+      //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff; 
+#ifdef DEBUGOUT
+      printf("%d %x\n",i*dist, val);
+#endif
+      for (j=0; j<NCHIP; j++) {
+	v=val & 1<< j;
+	if (pat & (1<<(i*dist))) {
+	  if (v==0) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	  // should be 1
+	} else { 
+	  if (v) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	}
+      }
+      //}
+
+
+
+
+      putout("0000010001010000",ALLMOD);
+      putout("0000010001010000",ALLMOD); //output is out2
+      putout("0000010001010000",ALLMOD);
+
+
+      i++;
+      k=imod;
+      //for (k=0; k<nModX; k++) {
+      val=readin(k);
+      //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff; 
+#ifdef DEBUGOUT
+      printf("%d %x\n",i*dist, val);
+#endif
+      for (j=0; j<NCHIP; j++) {
+	v=val & 1<< j;
+	if (pat & (1<<(i*dist))) {
+	  if (v==0) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	  // should be 1
+	} else { 
+	  if (v) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	}
+      }
+      //}
+
+      putout("0000010001110000",ALLMOD);
+      putout("0000010001110000",ALLMOD); //output is out3
+      putout("0000010001110000",ALLMOD);
+      i++;
+      k=imod;
+      //for (k=0; k<nModX; k++) {
+      val=readin(k);
+      //val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff; 
+#ifdef DEBUGOUT
+      printf("%d %x\n",i*dist, val);
+#endif
+      for (j=0; j<NCHIP; j++) {
+	v=val & 1<< j;
+	if (pat & (1<<(i*dist))) {
+	  if (v==0) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	  // should be 1
+	} else { 
+	  if (v) {
+	    printf("Outmux: module %d chip %i bit %d  read %d instead of %ld\n",k, j,(i*dist), v,pat & (1<<(i*dist) ));
+	    result++;
+	  }
+	}
+      }
+      //}
+
+      putout("0000000000000000",ALLMOD);
+      putout("0010000000000000",ALLMOD); //change mux setting 
+      putout("0000000000000000",ALLMOD);
+    }  
+    
+    printf("Test OutMux module %d : %d errors\n", imod,result);
+  if (result)
+    return 1;
+  else
+    return 0;
+}
+
+
+
+
+
+
+int testFpgaMux(int imod)  {
+  int ibit, i, val, v, j, dist,k;
+  int result=OK;
+  long pat=0xf0f0af;
+  printf("testing fpga mux of module %d\n",imod);
+
+  // Clear outshift reg 
+  putout("0000010000000000",ALLMOD);
+  for (ibit=0; ibit<10;ibit++)
+    putout("0000110000000000",ALLMOD);
+  putout("0000010000000000",ALLMOD);
+
+  // Clear inshift reg 
+  putout("0000000000000000",ALLMOD);
+  for (ibit=0; ibit<10;ibit++)
+    putout("0000100000000000",ALLMOD);
+  putout("0000000000000000",ALLMOD);
+
+  // input pattern 0f0f0f 
+
+  for (ibit=0; ibit<24;ibit++) {
+    if (pat & (1 << ibit)) {
+      putout("0100010000000000",ALLMOD);
+      putout("0110010000000000",ALLMOD); //write in the data 1 
+      putout("0100010000000000",ALLMOD);
+
+    } else {
+      putout("0000010000000000",ALLMOD);
+      putout("0010010000000000",ALLMOD); //write in the data 0 
+      putout("0000010000000000",ALLMOD);
+    }
+  }  
+  
+  putout("0100000000000000",ALLMOD);
+  putout("0110000000000000",ALLMOD); //shift in 1 
+  putout("0100000000000000",ALLMOD);
+
+  for (ibit=0; ibit<20;ibit++) {
+    putout("0000000000000000",ALLMOD);
+    putout("0010000000000000",ALLMOD); //shift in 20 bits 
+    putout("0000000000000000",ALLMOD);
+  }  
+      
+  // check pattern, with different oumux settings 
+
+    for (ibit=0; ibit<4;ibit++) { 
+      dist=6-2*ibit;
+      //dist=2*ibit;
+      if (dist==0)
+	dist=1;
+#ifdef DEBUGOUT
+      printf("Distance is %d\n",dist);
+#endif
+
+
+    
+      //This should test the parallel to serial converter
+
+      putout("0000010000000000",ALLMOD) ; 	
+      putout("0000010100000000",ALLMOD) ; // reset readout		     
+      putout("0000010100000000",ALLMOD) ; 		     
+      putout("0000010000000000",ALLMOD) ; 
+
+
+#ifdef DEBUGOUT
+	  printf("testing FPGA Mux\n");
+#endif  
+		     
+      for (i=0; i<4; i++) {
+	k=imod;
+	//for (k=0; k<nModX; k++) {
+	val=readin(k);
+	//val=bus_r(MCB_DOUT_REG_OFF+(k<<SHIFTMOD)) & 0x3ff; 
+  
+
+#ifdef DEBUGOUT
+	  printf("%d %x\n",i*dist, val);
+#endif    
+	  for (j=0; j<10; j++) {
+	    v=val & 1<< j;
+	    if (pat & (1<<(i*dist))) {
+	      if (v==0) {
+		printf("Fpgamux: module %d chip %i bit %d  read %d instead of %ld\n",k,j,(i*dist), v,pat & (1<<(i*dist) ));
+		result++;
+	      }
+	  // should be 1
+	    } else { 
+	      if (v) {
+		printf("Fpgamux: module %d chip %i bit %d  read %d instead of %ld\n",k,j,(i*dist), v,pat & (1<<(i*dist) ));
+		result++;
+	      }
+	    }
+	  }
+	  //}
+	putout("0000010000000000",ALLMOD);
+	putout("0010010000000000",ALLMOD); //output
+	putout("0000010000000000",ALLMOD );
+
+      }
+      pat = pat >> 1;
+     
+
+      putout("0000000000000000",ALLMOD);
+      putout("0010000000000000",ALLMOD); //change mux setting 
+      putout("0000000000000000",ALLMOD);
+    }  
+    
+    printf("Test FpgaMux module %d : %d errors\n", imod,result);
+  if (result)
+    return 1;
+  else
+    return 0;
+}
+
+
+
+
+
+
+
+
+
+int calibration_sensor(int num, int *v, int *dacs) {
+  int ich, ichip, imod;
+  int val[10];
+
+ 
+    printf("calibrating sensor...");
+  for (imod=0; imod<nModX; imod++) {
+    //selMod(imod);   
+    for (ichip=0; ichip<10; ichip++) { 
+      selChip(ichip,imod);
+      for (ich=0; ich<128; ich++){ 
+	selChannel(ich,imod);
+	initChannel(*(dacs+ichip*NCHAN+ich),0,0,0,0,0,imod); //disable channel; 
+	clearCounter(imod);      
+	//initChannel(*(dacs+ichip*NCHAN+ich),FALSE,FALSE,TRUE,FALSE,0); //disable channel;  
+      }
+    }
+  }
+ 
+  for (imod=0; imod<nModX; imod++) {
+    //selMod(imod);
+    initMCBregisters(1,imod);
+    for (ich=0; ich<NCHAN; ich++){  
+      for (ichip=0; ichip<NCHIP; ichip++) {
+	selChip(ichip,imod); // select channel 
+	selChannel(ich,imod); // select channel 
+	initChannel(*(dacs+imod*NCHAN*NCHIP+ichip*NCHAN+ich),0,0,1,0,0,imod); // enable channel
+	clearCounter(imod);      
+      }
+      setCSregister(imod); 
+      clearSSregister(imod);
+      countEnable(imod);
+      usleep(20);
+      calPulse(num,imod); // give pulses//	  
+      usleep(20);
+      //for (ich=0; ich<128; ich++){  
+      selChannel(ich,imod); // select channel
+    } 
+    readOutChan(val); // readout channel
+    for (imod=0; imod<nModX; imod++) {
+      for (ichip=0; ichip<NCHIP; ichip++) { 
+	*(v+(ichip+imod*NCHIP)*NCHAN+ich)=val[ichip+imod*NCHIP];
+	selChip(ichip,imod); // select channel 
+	selChannel(ich,imod); // select channel 
+	initChannel(*(dacs+ichip*NCHAN+ich),0,0,0,0,0,imod); //disable channel;  
+      }
+    }
+  }
+  printf("done\n");
+  return OK; 
+}
+
+int calibration_chip(int num, int *v, int *dacs) {
+  int ich, ichip, imod;
+  int val[10];
+
+ 
+  printf("calibrating chip...");
+  for (imod=0; imod<nModX; imod++) {
+    //selMod(imod);
+    initMCBregisters(0,imod);
+    for (ichip=0; ichip<10; ichip++) { 
+      selChip(ichip,imod);
+      for (ich=0; ich<128; ich++){ 
+	selChannel(ich,imod);
+	clearCounter(imod); 
+	initChannel(*(dacs+ichip*NCHAN+ich),0,0,0,0,0,imod); //disable channel;  
+      }
+    }
+  }
+  for (ich=0; ich<NCHAN; ich++){  
+    for (imod=0; imod<nModX; imod++) {
+      //selMod(imod);
+      for (ichip=0; ichip<NCHIP; ichip++) {
+	selChip(ichip,imod); // select channel 
+	selChannel(ich,imod); // select channel 
+	initChannel(*(dacs+imod*NCHAN*NCHIP+ichip*NCHAN+ich),1,0,1,0,0,imod); // enable channel
+	clearCounter(imod);      
+      }
+    }
+    //setMSregister();
+    setCSregister(ALLMOD); 
+    clearSSregister(ALLMOD);
+    countEnable(ALLMOD);
+    usleep(20);
+    calPulse(num,ALLMOD); // give pulses//	  
+    usleep(20);  
+    selChannel(ich,ALLMOD); // select channel 
+    readOutChan(val); // readout channel
+    for (imod=0; imod<nModX; imod++) {
+      //selMod(imod);
+      for (ichip=0; ichip<10; ichip++) {
+	*(v+(ichip+imod*NCHIP)*NCHAN+ich)=val[ichip+imod*NCHIP]; 
+	selChip(ichip,imod); // select chip 
+	selChannel(ich,imod); // select channel 
+	initChannel(*(dacs+imod*NCHAN*NCHIP+ichip*NCHAN+ich),0,0,0,0,0,imod); //disable channel;
+      }
+    }
+  }
+  printf("done\n");
+  return OK;  
+}
+
+
+
+ROI* setROI(int n, ROI arg[], int *retvalsize, int *ret){
+
+	int i,adc;
+	ROI temp;
+
+	if(n>=0){
+
+		//clear rois
+		for(i=0;i<MAX_ROIS;i++)
+			rois[i]=temp;
+
+		/*ideal way to set roi
+		for(i=0;i<n;i++)
+			rois[i]=arg[i];
+		nROI = n;
+		 */
+
+		if(n==0)
+			adc=-1;
+		else{
+			//if its for 1 adc or general
+			if ((arg[0].xmin==0) && (arg[0].xmax==GOTTHARDNCHIP*GOTTHARDNCHAN))
+				adc=-1;
+			else{
+				//adc = mid value/numchans also for only 1 roi
+				adc = ((((arg[0].xmax)+(arg[0].xmin))/2)/(GOTTHARDNCHAN*NCHIPS_PER_ADC));
+				if((adc>=0) && (adc<=4));
+				else {
+					printf("warning:adc value greater than 5. deleting roi\n");
+					adc=-1;
+				}
+			}
+		}
+
+
+		//set rois for just 1 adc - take only 1st roi
+		if(adc!=-1){
+			rois[0].xmin=adc*(GOTTHARDNCHAN*NCHIPS_PER_ADC);
+			rois[0].xmax=(adc+1)*(GOTTHARDNCHAN*NCHIPS_PER_ADC)-1;
+			rois[0].ymin=-1;
+			rois[0].ymax=-1;
+			nROI = 1;
+		}else
+			nROI = 0;
+
+		if((arg[0].xmin!=rois[0].xmin)||(arg[0].xmax!=rois[0].xmax)||(arg[0].ymin!=rois[0].ymin)||(arg[0].ymax!=rois[0].ymax))
+			*ret=FAIL;
+		if(n!=nROI)
+			*ret=FAIL;
+
+		//set adc of interest
+		setADC(adc);
+	}
+
+//#ifdef VERBOSE
+	printf("Rois:\n");
+	for( i=0;i<nROI;i++)
+		printf("%d\t%d\t%d\t%d\n",rois[i].xmin,rois[i].xmax,rois[i].ymin,rois[i].ymax);
+//#endif
+	*retvalsize = nROI;
+	return rois;
+}
+
+#endif
+
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.h
new file mode 100755
index 000000000..fc5f17c54
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/mcb_funcs.h
@@ -0,0 +1,174 @@
+#ifdef MCB_FUNCS
+
+#ifndef MCB_FUNCS_H
+#define MCB_FUNCS_H
+
+#include "sls_detector_defs.h"
+
+#define RGPRVALS {100,50,200}
+#define RGSH1VALS {300,200,400}
+#define RGSH2VALS {260,300,260}
+
+//high,dynamic,low,medium,very high
+#define CONF_GAIN     {0,0,  0,  1,  6,  2,  1}//dynamic gain confgain yet to be figured out-probably 8 or 16
+ 
+
+#define DEFAULTGAIN {11.66,9.32,14.99}
+#define DEFAULTOFFSET {817.5,828.6,804.2}
+
+// DAC definitions
+enum dacsVal{VDAC0, VDAC1, VDAC2, VDAC3, VDAC4, VDAC5, VDAC6, VDAC7, HIGH_VOLTAGE, CONFGAIN};
+
+/* DAC adresses */
+#define DACCS   {0,0,1,1,2,2,3,3,4,4,5,5,6,6}
+#define DACADDR {0,1,0,1,0,1,0,1,0,1,0,1,0,1}
+
+//Register Definitions for temp,hv,dac gain
+enum adcVals{TEMP_FPGA, TEMP_ADC};
+
+//dynamic range
+/*
+#define MAX5523 commented out by dhanya
+#ifndef MAX5523
+#define MAX5533
+#endif
+#ifdef MAX5533
+#define DAC_DR 4096
+#endif
+#ifdef MAX5523
+*/
+#define DAC_DR 1024
+//#endif
+
+
+//reference voltage
+#define DAC_REFOUT1
+#ifdef DAC_REFOUT2 
+#define DAC_MAX 2.425
+#define DAC_REFOUT 2 
+#define DAC_REFOUT1
+#endif
+#ifdef DAC_REFOUT3 
+#define DAC_MAX 3.885
+#define DAC_REFOUT 3
+#define DAC_REFOUT1
+#endif
+#ifdef DAC_REFOUT0
+#define DAC_MAX 1.214
+#define DAC_REFOUT 0
+#endif
+#ifdef DAC_REFOUT1
+#define DAC_MAX 1.940
+#define DAC_REFOUT 1
+#endif
+
+/* dac calibration constants */
+
+#define VA 1.11
+
+#define CVTRIM  52.430851
+#define BVTRIM  -0.102022
+#define AVTRIM  0.000050
+
+#define PARTREF {100,1.55,-2.5,-2.5,0,-2.5}
+#define PARTR1 {78,10,10,10,10,10}
+#define PARTR2 {0,4.7,27,47,22,47}
+
+
+//chip shiftin register meaning
+#define OUTMUX_OFFSET 20
+#define PROBES_OFFSET 4
+#define OUTBUF_OFFSET 0
+
+
+void showbits(int h);
+
+int initDetector();
+int copyChannel(sls_detector_channel *destChan, sls_detector_channel *srcChan);
+int copyChip(sls_detector_chip *destChip, sls_detector_chip *srcChip);
+int copyModule(sls_detector_module *destMod, sls_detector_module *srcMod);
+
+/* Register commands */
+int clearDACSregister(int imod );
+int nextDAC(int imod );
+int clearCSregister(int imod );
+int setCSregister(int imod );
+int nextChip(int imod );
+int firstChip(int imod );
+int clearSSregister(int imod );
+int setSSregister(int imod );
+int nextStrip(int imod );
+int selChannel(int strip,int imod );
+int selChip(int chip,int imod );
+int selMod(int mod,int imod );
+
+/* DACs routines */
+int program_one_dac(int addr, int value,int imod );
+int set_one_dac(int imod);
+int initDAC(int dac_addr, int value,int imod );
+int initDACs(int* v,int imod );
+int setSettings(int i,int imod);
+int initDACbyIndex(int ind,int val, int imod);
+int initDACbyIndexDACU(int ind,int val, int imod);
+int getDACbyIndexDACU(int ind,  int imod);
+int getThresholdEnergy();
+int setThresholdEnergy(int ethr);
+
+/* Other DAC index routines*/
+int getTemperatureByModule(int tempSensor, int imod);
+int initHighVoltageByModule(int val, int imod);
+int initConfGainByModule(int isettings,int val,int imod);
+
+/* Initialization*/
+int initChannel(int ft,int cae, int ae, int coe, int ocoe, int counts,int imod );
+int initChannelbyNumber(sls_detector_channel myChan);
+int getChannelbyNumber(sls_detector_channel*);
+
+int getTrimbit(int imod, int ichip, int ichan);
+
+int initChip(int obe, int ow,int imod );
+
+int initChipWithProbes(int obe, int ow,int nprobes, int imod);
+//int getNProbes();
+
+int initChipbyNumber(sls_detector_chip myChip);
+int getChipbyNumber(sls_detector_chip*);
+int initMCBregisters(int cm,int imod );
+int initModulebyNumber(sls_detector_module);
+int getModulebyNumber(sls_detector_module*);
+
+/* To chips */
+int clearCounter(int imod );
+int clearOutReg(int imod);
+int setOutReg(int imod );
+int extPulse(int ncal,int imod );
+int calPulse(int ncal,int imod );
+int counterClear(int imod );
+int countEnable(int imod );
+int counterSet(int imod );
+
+
+/* moved from firmware_funcs */
+
+int readOutChan(int *val);
+
+int getModuleNumber(int modnum);
+int testShiftIn(int imod);
+int testShiftOut(int imod);
+int testShiftStSel(int imod);
+int testDataInOut(int num, int imod);
+int testExtPulse(int imod);
+int testExtPulseMux(int imod, int ow);
+int testDataInOutMux(int imod, int ow, int num);
+int testOutMux(int imod);
+int testFpgaMux(int imod);
+int calibration_sensor(int num, int *values, int *dacs) ;
+int calibration_chip(int num, int *values, int *dacs);
+
+
+
+ROI* setROI(int n, ROI arg[], int *retvalsize, int *ret);
+
+#endif
+
+#endif
diff --git a/slsDetectorSoftware/moenchDetectorServer/moenchDetectorServer b/slsDetectorSoftware/jungfrauDetectorServer/moenchDetectorServer
similarity index 100%
rename from slsDetectorSoftware/moenchDetectorServer/moenchDetectorServer
rename to slsDetectorSoftware/jungfrauDetectorServer/moenchDetectorServer
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/moenchVirtualServer b/slsDetectorSoftware/jungfrauDetectorServer/moenchVirtualServer
new file mode 100755
index 0000000000000000000000000000000000000000..969435789699d62340951de416284240dccda8cc
GIT binary patch
literal 107120
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
Nk5l4rl$-I|{{$6L%BKJT

literal 0
HcmV?d00001

diff --git a/slsDetectorSoftware/jungfrauDetectorServer/registers_m.h b/slsDetectorSoftware/jungfrauDetectorServer/registers_m.h
new file mode 100755
index 000000000..d0f5f762a
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/registers_m.h
@@ -0,0 +1,464 @@
+#ifndef REGISTERS_G_H
+#define REGISTERS_G_H
+
+
+#include "sls_detector_defs.h"
+
+
+/* Definitions for FPGA*/
+#define CSP0 0x20200000
+#define MEM_SIZE 0x100000 
+
+
+
+/* values defined for FPGA */
+#define MCSNUM            0x0
+#define FIXED_PATT_VAL    0xacdc1980
+
+
+#define FPGA_INIT_PAT     0x60008
+#define FPGA_INIT_ADDR    0xb0000000
+
+
+
+ 
+/*   constant FPGAVersionReg_c  : integer:= 0; */
+/*   constant FixedPatternReg_c : integer:= 1; */
+/*   constant StatusReg_c     : integer:= 2; */
+/*   constant LookAtMeReg_c   : integer:= 3; */
+/*   constant SystemStatusReg_c : integer:= 4; */
+ 
+/*   constant PLL_ParamOutReg_c : integer:=5;  -- RO register to check control signals going to the chip */
+ 
+ 
+/*  --time registers use only even numbers! */
+/*   constant TimeFromStartReg_c : integer:= 16; */
+/*   --constant TimeFromStartReg_c : integer:= 17; MSB */
+/*   constant GetDelayReg_c   : integer:= 18; */
+/*   --constant GetDelayReg_c   : integer:= 19; MSB */
+/*   constant GetCyclesReg_c  : integer:= 20; */
+/*   --constant GetTrainsReg_c   : integer:= 21; MSB */
+/*   constant GetFramesReg_c  : integer:= 22; */
+/*   --constant GetFramesReg_c   : integer:= 23; MSB */
+/*   constant GetPeriodReg_c  : integer:= 24; */
+/*   --constant GetPeriodReg_c   : integer:= 25; MSB */
+/*   constant GetExpTimeReg_c  : integer:= 26; */
+/*   --constant GetExpTimeReg_c   : integer:= 27; MSB */
+/*   constant GetGatesReg_c   : integer:= 28;  */
+/*   --constant GetGatesReg_c   : integer:= 29; MSB */
+  
+  
+  
+  
+  
+/*  -----rw: */
+ 
+/*   constant DACReg_c          : integer:= 64; */
+/*   constant ADCWriteReg_c     : integer:= 65; */
+/*   constant ADCsyncReg_c      : integer:= 66; */
+/*   constant HVReg_c           : integer:= 67; */
+/*   constant DummyReg_c        : integer:= 68; */
+
+/*   constant rx_udpip_AReg_c     : integer:= 69; */
+/*   constant udpports_AReg_c   : integer:= 70; */
+/*   constant rx_udpmacL_AReg_c   : integer:= 71; */
+/*   constant rx_udpmacH_AReg_c   : integer:= 72; */
+/*   constant detectormacL_AReg_c : integer:= 73; */
+/*   constant detectormacH_AReg_c : integer:= 74; */
+/*   constant detectorip_AReg_c   : integer:= 75; */
+/*   constant ipchksum_AReg_c : integer:= 76; */
+
+/*   constant ConfigReg_c     : integer:= 77; */
+/*   constant ExtSignalReg_c  : integer:= 78; */
+/*   constant ControlReg_c    : integer:= 79; */
+  
+  
+ 
+/*   constant PLL_ParamReg_c : integer:= 80; */
+/*   constant PLL_CntrlReg_c : integer:=81; */
+
+   
+  
+
+/*   --time registers use only even numbers! */
+/* --     DELAY_AFTER_TRIGGER, */
+/*   constant SetDelayReg_c   : integer:= 96; */
+/*   --constant SetDelayReg_c   : integer:= 97; MSB */
+/* --    CYCLES_NUMBER, */
+/*   constant SetCyclesReg_c  : integer:= 98; */
+/*   --constant SetCyclesReg_c : integer:= 99;MSB */
+/*   -- FRAME_NUMBER, */
+/*   constant SetFramesReg_c  : integer:= 100; */
+/*   --constant SetFramesReg_c : integer:= 101; MSB */
+/* --     FRAME_PERIOD, */
+/*   constant SetPeriodReg_c   : integer:= 102; */
+/*   --constant SetPeriodReg_c : integer:= 103; MSB */
+/* --     ACQUISITION_TIME, */
+/*   constant SetExpTimeReg_c : integer:= 104; */
+/*   --constant SetExpTimeReg_c : integer:= 105; MSB */
+/* --     GATES_NUMBER, */
+/*   constant SetGatesReg_c   : integer:= 106; */
+/*   --constant SetGatesReg_c : integer:= 107; MSB */
+
+
+/* registers defined in FPGA */
+#define PCB_REV_REG			  0x2c<<11
+#define GAIN_REG              0x10<<11
+//#define FLOW_CONTROL_REG      0x11<<11
+//#define FLOW_STATUS_REG       0x12<<11
+//#define FRAME_REG             0x13<<11
+#define MULTI_PURPOSE_REG     0x14<<11
+#define DAQ_REG               0x15<<11
+//#define TIME_FROM_START_REG   0x16<<11
+#define DAC_REG     64<<11//0x17<<11// control the dacs
+//ADC
+#define ADC_WRITE_REG         65<<11//0x18<<11
+#define ADC_SYNC_REG          66<<11//0x19<<11
+//#define MUTIME_REG            0x1a<<11
+//temperature
+#define TEMP_IN_REG           0x1b<<11
+#define TEMP_OUT_REG          0x1c<<11
+//configure MAC
+#define TSE_CONF_REG          0x1d<<11
+#define ENET_CONF_REG         0x1e<<11
+//#define WRTSE_SHAD_REG        0x1f<<11
+//HV
+#define HV_REG                67<<11//0x20<<11
+
+
+#define DUMMY_REG             68<<11//0x21<<11
+#define FPGA_VERSION_REG      0<<11 //0x22<<11
+#define FIX_PATT_REG          1<<11 //0x23<<11
+#define CONTROL_REG           79<<11//0x24<<11
+#define STATUS_REG            2<<11 //0x25<<11
+#define CONFIG_REG            77<<11//0x26<<11
+#define EXT_SIGNAL_REG        78<<11//	  0x27<<11
+#define FPGA_SVN_REG    	  0x29<<11
+
+
+#define CHIP_OF_INTRST_REG    0x2A<<11
+
+//FIFO
+#define LOOK_AT_ME_REG          3<<11 //0x28<<11
+#define SYSTEM_STATUS_REG       4<<11
+
+#define FIFO_DATA_REG_OFF     0x50<<11 ///////
+
+
+//to read back dac registers
+#define MOD_DACS1_REG         0x65<<11
+#define MOD_DACS2_REG         0x66<<11
+#define MOD_DACS3_REG         0x67<<11
+
+//user entered
+
+
+
+
+
+#define GET_ACTUAL_TIME_LSB_REG     16<<11
+#define GET_ACTUAL_TIME_MSB_REG     17<<11
+
+
+#define SET_DELAY_LSB_REG     96<<11 //0x68<<11
+#define SET_DELAY_MSB_REG     97<<11 //0x69<<11
+#define GET_DELAY_LSB_REG     18<<11//0x6a<<11
+#define GET_DELAY_MSB_REG     19<<11//0x6b<<11
+
+#define SET_CYCLES_LSB_REG    98<<11//0x6c<<11
+#define SET_CYCLES_MSB_REG    99<<11//0x6d<<11
+#define GET_CYCLES_LSB_REG    20<<11//0x6e<<11
+#define GET_CYCLES_MSB_REG    21<<11//0x6f<<11
+
+#define SET_FRAMES_LSB_REG    100<<11//0x70<<11
+#define SET_FRAMES_MSB_REG    101<<11//0x71<<11
+#define GET_FRAMES_LSB_REG    22<<11//0x72<<11
+#define GET_FRAMES_MSB_REG    23<<11//0x73<<11
+
+#define SET_PERIOD_LSB_REG    102<<11//0x74<<11
+#define SET_PERIOD_MSB_REG    103<<11//0x75<<11
+#define GET_PERIOD_LSB_REG    24<<11//0x76<<11
+#define GET_PERIOD_MSB_REG    25<<11//0x77<<11
+
+#define SET_EXPTIME_LSB_REG   104<<11//0x78<<11
+#define SET_EXPTIME_MSB_REG   105<<11//0x79<<11
+#define GET_EXPTIME_LSB_REG   26<<11//0x7a<<11
+#define GET_EXPTIME_MSB_REG   27<<11//0x7b<<11
+
+#define SET_GATES_LSB_REG     106<<11//0x7c<<11
+#define SET_GATES_MSB_REG     107<<11//0x7d<<11
+#define GET_GATES_LSB_REG     28<<11//0x7e<<11
+#define GET_GATES_MSB_REG     29<<11//0x7f<<11
+
+
+ 
+   
+
+#define PLL_PARAM_REG  80<<11//0x37<<11
+#define PLL_PARAM_OUT_REG 5<<11 //0x38<<11
+#define PLL_CNTRL_REG 81<<11//0x34<<11
+
+
+
+
+#define RX_UDP_AREG    69<<11 //rx_udpip_AReg_c     : integer:= 69; */
+#define UDPPORTS_AREG 70<<11// udpports_AReg_c   : integer:= 70; */
+#define RX_UDPMACL_AREG 71<<11//rx_udpmacL_AReg_c   : integer:= 71; */
+#define RX_UDPMACH_AREG 72<<11//rx_udpmacH_AReg_c   : integer:= 72; */
+#define DETECTORMACL_AREG 73<<11//detectormacL_AReg_c : integer:= 73; */
+#define DETECTORMACH_AREG 74<<11//detectormacH_AReg_c : integer:= 74; */
+#define DETECTORIP_AREG 75<<11//detectorip_AReg_c   : integer:= 75; */
+#define IPCHKSUM_AREG 76<<11//ipchksum_AReg_c : integer:= 76; */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#define ROI_REG 0x35<<11
+#define OVERSAMPLING_REG 0x36<<11
+#define MOENCH_CNTR_REG 0x31<<11
+#define MOENCH_CNTR_OUT_REG 0x33<<11
+#define MOENCH_CNTR_CONF_REG 0x32<<11
+
+
+
+//image
+#define DARK_IMAGE_REG     0x81<<11
+#define GAIN_IMAGE_REG     0x82<<11
+
+//counter block memory
+#define COUNTER_MEMORY_REG 0x85<<11
+
+
+#define GET_MEASUREMENT_TIME_LSB_REG    0x023000   
+#define GET_MEASUREMENT_TIME_MSB_REG    0x024000 
+  
+//#define GET_ACTUAL_TIME_LSB_REG    0x025000   
+//#define GET_ACTUAL_TIME_MSB_REG    0x026000  
+
+
+//not used
+//#define MCB_DOUT_REG_OFF      0x200000
+//#define FIFO_CNTRL_REG_OFF    0x300000
+//#define FIFO_COUNTR_REG_OFF   0x400000
+//not used so far
+//#define SPEED_REG        0x006000
+//#define SET_NBITS_REG    0x008000
+//not used
+//#define GET_SHIFT_IN_REG      0x022000
+
+
+
+#define SHIFTMOD 2
+#define SHIFTFIFO 9
+
+/** for PCB_REV_REG */
+#define DETECTOR_TYPE_MASK   	0xF0000
+#define DETECTOR_TYPE_OFFSET   	16
+#define BOARD_REVISION_MASK		0xFFFF
+#define MOENCH_MODULE			2
+
+
+
+
+/* for control register */
+#define START_ACQ_BIT      0x00000001
+#define STOP_ACQ_BIT       0x00000002
+#define START_FIFOTEST_BIT 0x00000004 // ?????
+#define STOP_FIFOTEST_BIT  0x00000008  // ??????
+#define START_READOUT_BIT  0x00000010  
+#define STOP_READOUT_BIT   0x00000020 
+#define START_EXPOSURE_BIT  0x00000040  
+#define STOP_EXPOSURE_BIT   0x00000080  
+#define START_TRAIN_BIT     0x00000100  
+#define STOP_TRAIN_BIT      0x00000200  
+#define SYNC_RESET          0x00000400
+
+/* for status register */
+#define RUN_BUSY_BIT             0x00000001
+#define READOUT_BUSY_BIT         0x00000002
+#define FIFOTEST_BUSY_BIT        0x00000004 //????
+#define WAITING_FOR_TRIGGER_BIT  0x00000008
+#define DELAYBEFORE_BIT          0x00000010
+#define DELAYAFTER_BIT           0x00000020
+#define EXPOSING_BIT             0x00000040
+#define COUNT_ENABLE_BIT         0x00000080
+#define READSTATE_0_BIT    		 0x00000100
+#define READSTATE_1_BIT    		 0x00000200
+#define READSTATE_2_BIT    		 0x00000400
+
+#define RUNSTATE_0_BIT     		 0x00001000
+#define RUNSTATE_1_BIT    		 0x00002000
+#define RUNSTATE_2_BIT    		 0x00004000
+#define SOME_FIFO_FULL_BIT       0x00008000 // error!
+#define ALL_FIFO_EMPTY_BIT       0x00010000 // data ready
+#define RUNMACHINE_BUSY_BIT      0x00020000
+#define READMACHINE_BUSY_BIT     0x00040000
+
+
+
+/* for fifo status register */
+#define FIFO_ENABLED_BIT         0x80000000
+#define FIFO_DISABLED_BIT        0x01000000
+#define FIFO_ERROR_BIT           0x08000000
+#define FIFO_EMPTY_BIT           0x04000000
+#define FIFO_DATA_READY_BIT      0x02000000
+#define FIFO_COUNTER_MASK        0x000001ff
+#define FIFO_NM_MASK             0x00e00000
+#define FIFO_NM_OFF              21
+#define FIFO_NC_MASK             0x001ffe00
+#define FIFO_NC_OFF              9
+
+/* for config register *///not really used yet
+#define TOT_ENABLE_BIT           0x00000002
+#define TIMED_GATE_BIT           0x00000004
+#define CONT_RO_ENABLE_BIT       0x00080000
+#define CPU_OR_RECEIVER_BIT		 0x00001000
+
+
+
+/* for speed register */
+#define CLK_DIVIDER_MASK              0x000000ff 
+#define CLK_DIVIDER_OFFSET            0 
+#define SET_LENGTH_MASK               0x00000f00 
+#define SET_LENGTH_OFFSET             8 
+#define WAIT_STATES_MASK              0x0000f000
+#define WAIT_STATES_OFFSET            12  
+#define TOTCLK_DIVIDER_MASK           0xff000000 
+#define TOTCLK_DIVIDER_OFFSET         24  
+#define TOTCLK_DUTYCYCLE_MASK         0x00ff0000 
+#define TOTCLK_DUTYCYCLE_OFFSET       16
+
+/* for external signal register */
+#define SIGNAL_OFFSET                 4
+#define SIGNAL_MASK                   0xF
+#define EXT_SIG_OFF                   0x0
+#define EXT_GATE_IN_ACTIVEHIGH        0x1
+#define EXT_GATE_IN_ACTIVELOW         0x2
+#define EXT_TRIG_IN_RISING            0x3
+#define EXT_TRIG_IN_FALLING           0x4
+#define EXT_RO_TRIG_IN_RISING         0x5
+#define EXT_RO_TRIG_IN_FALLING        0x6
+#define EXT_GATE_OUT_ACTIVEHIGH        0x7
+#define EXT_GATE_OUT_ACTIVELOW         0x8
+#define EXT_TRIG_OUT_RISING            0x9
+#define EXT_TRIG_OUT_FALLING           0xA
+#define EXT_RO_TRIG_OUT_RISING         0xB
+#define EXT_RO_TRIG_OUT_FALLING        0xC
+
+
+
+/* for temperature register */
+#define T1_CLK_BIT             0x00000001
+#define T1_CS_BIT              0x00000002
+#define T2_CLK_BIT             0x00000004
+#define T2_CS_BIT              0x00000008
+
+
+
+/* fifo control register */
+#define FIFO_RESET_BIT              0x00000001 
+#define FIFO_DISABLE_TOGGLE_BIT     0x00000002 
+
+
+//chip shiftin register meaning
+#define OUTMUX_OFF 20
+#define OUTMUX_MASK   0x1f
+#define PROBES_OFF 4
+#define PROBES_MASK 0x7f
+#define OUTBUF_OFF 0
+#define OUTBUF_MASK 1
+
+
+/* multi purpose register */
+#define PHASE_STEP_BIT               0x00000001
+#define PHASE_STEP_OFFSET            0
+// #define xxx_BIT                   0x00000002
+#define RESET_COUNTER_BIT            0x00000004
+#define RESET_COUNTER_OFFSET         2
+//#define xxx_BIT                    0x00000008
+//#define xxx_BIT                    0x00000010
+#define SW1_BIT                      0x00000020
+#define SW1_OFFSET                   5
+#define WRITE_BACK_BIT               0x00000040
+#define WRITE_BACK_OFFSET            6
+#define RESET_BIT                    0x00000080
+#define RESET_OFFSET                 7
+#define ENET_RESETN_BIT              0x00000800
+#define ENET_RESETN_OFFSET           11
+#define INT_RSTN_BIT                 0x00002000
+#define INT_RSTN_OFFSET              13
+#define DIGITAL_TEST_BIT             0x00004000
+#define DIGITAL_TEST_OFFSET          14
+//#define CHANGE_AT_POWER_ON_BIT       0x00008000
+//#define CHANGE_AT_POWER_ON_OFFSET    15
+
+
+/* settings/conf gain register */
+#define GAIN_MASK                    0x0000000f 
+#define GAIN_OFFSET                  0  
+#define SETTINGS_MASK                0x000000f0
+#define SETTINGS_OFFSET              4 
+
+
+/* CHIP_OF_INTRST_REG */
+#define CHANNEL_MASK 			    0xffff0000
+#define CHANNEL_OFFSET				16
+#define ACTIVE_ADC_MASK 		    0x0000001f
+
+
+
+/**ADC SYNC CLEAN FIFO*/
+#define ADCSYNC_CLEAN_FIFO_BITS     0x300000
+#define CLEAN_FIFO_MASK				0x0fffff
+
+
+
+
+
+
+#define PLL_CNTR_ADDR_OFF 16 //PLL_CNTR_REG bits 21 downto 16 represent the counter address
+
+#define PLL_CNTR_RECONFIG_RESET_BIT 0
+#define PLL_CNTR_READ_BIT 1
+#define PLL_CNTR_WRITE_BIT 2
+
+#define PLL_MODE_REG 0x0
+#define PLL_STATUS_REG 0x1
+#define PLL_START_REG 0x2
+#define PLL_N_COUNTER_REG 0x3
+#define PLL_M_COUNTER_REG 0x4
+#define PLL_C_COUNTER_REG 0x5 //which ccounter stands in param 22:18; 7:0 lowcount 15:8 highcount; 16 bypassenable; 17 oddivision
+#define PLL_PHASE_SHIFT_REG 0x6
+#define PLL_K_COUNTER_REG 0x7
+#define PLL_BANDWIDTH_REG 0x8
+#define PLL_CHARGEPUMP_REG 0x9
+#define PLL_VCO_DIV_REG 0x1c
+#define PLL_MIF_REG 0x1f
+
+#define PPL_M_CNT_PARAM_DEFAULT 0x4040
+#define PPL_N_CNT_PARAM_DEFAULT 0x20D0C
+#define PPL_C0_CNT_PARAM_DEFAULT 0x20D0C
+#define PPL_C1_CNT_PARAM_DEFAULT 0xA0A0
+#define PPL_C2_CNT_PARAM_DEFAULT 0x20D0C
+#define PPL_C2_CNT_PARAM_DEFAULT 0x0808
+#define PPL_BW_PARAM_DEFAULT 0x2EE0
+#define PPL_VCO_PARAM_DEFAULT 0x1
+
+
+
+
+
+
+
+#endif
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/server.c b/slsDetectorSoftware/jungfrauDetectorServer/server.c
new file mode 100755
index 000000000..1804b9330
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/server.c
@@ -0,0 +1,137 @@
+/* A simple server in the internet domain using TCP
+   The port number is passed as an argument */
+
+#include "sls_detector_defs.h"
+
+#include "communication_funcs.h"
+#include "server_funcs.h"
+#include <stdlib.h>
+
+
+extern int sockfd;
+extern int phase_shift;
+
+
+
+void error(char *msg)
+{
+    perror(msg);
+}
+
+int main(int argc, char *argv[])
+{
+	int  portno, b;
+	char cmd[500];
+	int retval=OK;
+	int sd, fd;
+	int iarg;
+	int checkType = 1;
+
+
+	for(iarg=1; iarg<argc; iarg++){
+
+		if(!strcasecmp(argv[iarg],"-phaseshift")){
+			if(argc==iarg+1){
+				printf("No phaseshift given. Exiting.\n");
+				return 1;
+			}
+			if ( sscanf(argv[iarg+1],"%d",&phase_shift)==0) {
+				printf("could not decode phase shift\n");
+				return 1;
+			}
+		}
+
+		else if(!strcasecmp(argv[iarg],"-test")){
+			if(argc==iarg+1){
+				printf("No test condition given. Exiting.\n");
+				return 1;
+			}
+			if(!strcasecmp(argv[iarg+1],"with_gotthard")){
+				checkType = 0;
+			}else{
+				printf("could not decode test condition. Possible arguments: with_gotthard. Exiting\n");
+				return 1;
+			}
+
+		}
+	}
+
+
+	//stop server
+	if ((argc > 2) && (!strcasecmp(argv[2],"stopserver"))){
+		portno = DEFAULT_PORTNO+1;
+		if ( sscanf(argv[1],"%d",&portno) ==0) {
+			printf("could not open stop server: unknown port\n");
+			return 1;
+		}
+		b=0;
+		printf("\n\nStop Server\nOpening stop server on port %d\n",portno);
+		checkType=0;
+
+	}
+
+	//control server
+	else {
+		portno = DEFAULT_PORTNO;
+		if(checkType)
+			sprintf(cmd,"%s %d stopserver &",argv[0],DEFAULT_PORTNO+1);
+		else
+			sprintf(cmd,"%s %d stopserver -test with_gotthard &",argv[0],DEFAULT_PORTNO+1);
+		printf("\n\nControl Server\nOpening control server on port %d\n",portno );
+
+		//printf("\n\ncmd:%s\n",cmd);
+		system(cmd);
+		b=1;
+		checkType=1;
+	
+	}
+
+
+
+
+
+	init_detector(b, checkType);
+
+
+	sd=bindSocket(portno);
+	sockfd=sd;
+	if (getServerError(sd)) {
+		printf("server error!\n");
+		return -1;
+	}
+
+	/* assign function table */
+	function_table();
+#ifdef VERBOSE
+	printf("function table assigned \n");
+#endif
+
+
+	/* waits for connection */
+	while(retval!=GOODBYE) {
+#ifdef VERBOSE
+		printf("\n");
+#endif
+#ifdef VERY_VERBOSE
+		printf("Waiting for client call\n");
+#endif
+		fd=acceptConnection(sockfd);
+#ifdef VERY_VERBOSE
+		printf("Conenction accepted\n");
+#endif
+		retval=decode_function(fd);
+#ifdef VERY_VERBOSE
+		printf("function executed\n");
+#endif
+		closeConnection(fd);
+#ifdef VERY_VERBOSE
+		printf("connection closed\n");
+#endif
+	}
+
+	exitServer(sockfd);
+	printf("Goodbye!\n");
+
+	return 0;
+}
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/server_defs.h b/slsDetectorSoftware/jungfrauDetectorServer/server_defs.h
new file mode 100755
index 000000000..850533266
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/server_defs.h
@@ -0,0 +1,63 @@
+#ifndef SERVER_DEFS_H
+#define SERVER_DEFS_H
+
+#include "sls_detector_defs.h"
+
+#include <stdint.h> 
+
+
+// Hardware definitions
+
+#define NCHAN (160*160)
+#define NCHIP 1
+#define NMAXMODX  1
+#define NMAXMODY 1
+#define NMAXMOD (NMAXMODX*NMAXMODY)
+#define NDAC 8
+#define NADC 1
+
+/**when moench readout tested with gotthard module*/
+#define GOTTHARDNCHAN 128
+#define GOTTHARDNCHIP 10
+
+
+
+
+#define NCHANS (NCHAN*NCHIP*NMAXMOD)
+#define NDACS (NDAC*NMAXMOD)
+
+#define NTRIMBITS 6
+#define NCOUNTBITS 24
+
+#define NCHIPS_PER_ADC		2
+
+//#define TRIM_DR ((2**NTRIMBITS)-1)
+//#define COUNT_DR ((2**NCOUNTBITS)-1) 
+#define TRIM_DR (((int)pow(2,NTRIMBITS))-1)
+#define COUNT_DR (((int)pow(2,NCOUNTBITS))-1)
+
+
+#define ALLMOD 0xffff
+#define ALLFIFO 0xffff
+
+#define GOTTHARD_ADCSYNC_VAL		0x32214
+#define ADCSYNC_VAL   				0x02111
+#define TOKEN_RESTART_DELAY			0x88000000
+#define TOKEN_RESTART_DELAY_ROI     0x1b000000
+#define TOKEN_TIMING_REV1           0x1f16
+#define TOKEN_TIMING_REV2           0x1f0f
+
+#define DEFAULT_PHASE_SHIFT		0 //	120
+#define DEFAULT_IP_PACKETSIZE		0x0522
+#define DEFAULT_UDP_PACKETSIZE		0x050E
+#define ADC1_IP_PACKETSIZE			256*2+14+20
+#define ADC1_UDP_PACKETSIZE			256*2+4+8+2
+
+#ifdef VIRTUAL
+#define DEBUGOUT
+#endif
+
+#define CLK_FREQ 65.6E+6
+
+
+#endif
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.c b/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.c
new file mode 100755
index 000000000..0a73341d0
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.c
@@ -0,0 +1,3108 @@
+#include "sls_detector_defs.h"
+#include "server_funcs.h"
+#ifndef PICASSOD
+#include "server_defs.h"
+#else
+#include "picasso_defs.h"
+#endif
+#include "firmware_funcs.h"
+#include "mcb_funcs.h"
+#include "trimming_funcs.h"
+#include "registers_m.h"
+#include "gitInfoMoench.h"
+
+#define FIFO_DATA_REG_OFF     0x50<<11
+//#define CONTROL_REG           0x24<<11
+// Global variables
+
+
+int (*flist[256])(int);
+
+
+//defined in the detector specific file
+#ifdef MYTHEND
+const enum detectorType myDetectorType=MYTHEN;
+#elif GOTTHARDD
+const enum detectorType myDetectorType=GOTTHARD;
+#elif EIGERD
+const enum detectorType myDetectorType=EIGER;
+#elif PICASSOD
+const enum detectorType myDetectorType=PICASSO;
+#elif MOENCHD
+const enum detectorType myDetectorType=MOENCH;
+#else
+const enum detectorType myDetectorType=GENERIC;
+#endif
+
+
+extern int nModX;
+extern int nModY;
+extern int dataBytes;
+extern int dynamicRange;
+extern int  storeInRAM;
+
+extern int lockStatus;
+extern char lastClientIP[INET_ADDRSTRLEN];
+extern char thisClientIP[INET_ADDRSTRLEN];
+extern int differentClients;
+
+/* global variables for optimized readout */
+extern unsigned int *ram_values;
+char *dataretval=NULL;
+int nframes, iframes, dataret;
+char mess[1000]; 
+
+int digitalTestBit = 0;
+
+extern int withGotthard;
+
+
+int init_detector(int b, int checkType) {
+  
+  int i;
+  if (mapCSP0()==FAIL) { printf("Could not map memory\n");
+    exit(1);  
+  }
+
+  //
+  
+  printf("v: 0x%x\n",bus_r(FPGA_VERSION_REG));
+  printf("fp: 0x%x\n",bus_r(FIX_PATT_REG));
+  
+  if (checkType) {
+    printf("Bus test...");
+    for (i=0; i<1000000; i++) {
+      bus_w(SET_DELAY_LSB_REG, i*100);
+      bus_r(FPGA_VERSION_REG);
+      if (i*100!=bus_r(SET_DELAY_LSB_REG))
+	printf("ERROR: wrote 0x%x, read 0x%x\n",i*100,bus_r(SET_DELAY_LSB_REG));
+    }
+    printf("Finished\n");
+  }
+  return 0;
+
+  bus_w16(CONTROL_REG, SYNC_RESET);
+  bus_w16(CONTROL_REG, 0x0);
+
+
+  //confirm if it is really moench
+  if(((bus_r(PCB_REV_REG) & DETECTOR_TYPE_MASK)>>DETECTOR_TYPE_OFFSET) != MOENCH_MODULE ){
+	  if(checkType){
+		  printf("This is a Gotthard detector. Exiting Moench Server.\n\n");
+	  	  exit(-1);
+	  }
+	  //no check required as specified in command line arguments
+	  else if(b){
+		  printf("***This is a GOTTHARD detector with %d chips per module***\n",GOTTHARDNCHIP);
+		  printf("***Assuming this to be a MOENCH detector***\n");
+	  }
+	  withGotthard = 1;
+  }	  else if(b){
+	  printf("***This is a MOENCH detector with %d chips per module***\n",NCHIP);
+  }
+
+  if (b) {
+#ifdef MCB_FUNCS
+	 printf("\nBoard Revision:0x%x\n",(bus_r(PCB_REV_REG)&BOARD_REVISION_MASK));
+    initDetector();
+    printf("Initializing Detector\n");
+    bus_w16(CONTROL_REG, SYNC_RESET); // reset registers
+#endif
+
+
+    testFpga();
+    testRAM();
+    printf("ADC_SYNC_REG:%x\n",bus_r(ADC_SYNC_REG));
+    //moench specific
+  
+    //  setPhaseShiftOnce(); //firmware.h
+
+
+    prepareADC(); // server_funcs
+    setADC(-1); //already does setdaqreg and clean fifo 
+    setSettings(GET_SETTINGS,-1); 
+
+    //Initialization
+    setFrames(1);
+    setTrains(1);
+    setExposureTime(1e3);
+    setPeriod(1E6);
+    setDelay(0);
+    setGates(0);
+
+    setTiming(GET_EXTERNAL_COMMUNICATION_MODE);
+    setMaster(GET_MASTER);
+    setSynchronization(GET_SYNCHRONIZATION_MODE);
+    startReceiver(0); //firmware
+  }
+  strcpy(mess,"dummy message");
+  strcpy(lastClientIP,"none");
+  strcpy(thisClientIP,"none1");
+  lockStatus=0;
+  return OK;
+}
+
+
+int decode_function(int file_des) {
+  int fnum,n;
+  int retval=FAIL;
+#ifdef VERBOSE
+  printf( "receive data\n");
+#endif 
+  n = receiveDataOnly(file_des,&fnum,sizeof(fnum));
+  if (n <= 0) {
+#ifdef VERBOSE
+    printf("ERROR reading from socket %d, %d %d\n", n, fnum, file_des);
+#endif
+    return FAIL;
+  }
+#ifdef VERBOSE
+  else
+    printf("size of data received %d\n",n);
+#endif
+
+#ifdef VERBOSE
+  printf( "calling function fnum = %d %x\n",fnum,(unsigned int)(flist[fnum]));
+#endif
+  if (fnum<0 || fnum>255)
+    fnum=255;
+  retval=(*flist[fnum])(file_des);
+  if (retval==FAIL)
+    printf( "Error executing the function = %d \n",fnum);
+  return retval;
+}
+
+
+int function_table() {
+  int i;
+  for (i=0;i<256;i++){
+    flist[i]=&M_nofunc;
+  }
+  flist[F_EXIT_SERVER]=&exit_server;
+  flist[F_EXEC_COMMAND]=&exec_command;
+  flist[F_GET_DETECTOR_TYPE]=&get_detector_type;
+  flist[F_SET_NUMBER_OF_MODULES]=&set_number_of_modules;
+  flist[F_GET_MAX_NUMBER_OF_MODULES]=&get_max_number_of_modules;
+  flist[F_SET_EXTERNAL_SIGNAL_FLAG]=&set_external_signal_flag;
+  flist[F_SET_EXTERNAL_COMMUNICATION_MODE]=&set_external_communication_mode;
+  flist[F_GET_ID]=&get_id;
+  flist[F_DIGITAL_TEST]=&digital_test;
+  flist[F_WRITE_REGISTER]=&write_register;
+  flist[F_READ_REGISTER]=&read_register;
+  flist[F_SET_DAC]=&set_dac;
+  flist[F_GET_ADC]=&get_adc;
+  flist[F_SET_CHANNEL]=&set_channel;
+  flist[F_SET_CHIP]=&set_chip;
+  flist[F_SET_MODULE]=&set_module;
+  flist[F_GET_CHANNEL]=&get_channel;
+  flist[F_GET_CHIP]=&get_chip;
+  flist[F_GET_MODULE]=&get_module;
+  flist[F_GET_THRESHOLD_ENERGY]=&get_threshold_energy;
+  flist[F_SET_THRESHOLD_ENERGY]=&set_threshold_energy;  
+  flist[F_SET_SETTINGS]=&set_settings;
+  flist[F_START_ACQUISITION]=&start_acquisition;
+  flist[F_STOP_ACQUISITION]=&stop_acquisition;
+  flist[F_START_READOUT]=&start_readout;
+  flist[F_GET_RUN_STATUS]=&get_run_status;
+  flist[F_READ_FRAME]=&read_frame;
+  flist[F_READ_ALL]=&read_all;
+  flist[F_START_AND_READ_ALL]=&start_and_read_all;
+  flist[F_SET_TIMER]=&set_timer;
+  flist[F_GET_TIME_LEFT]=&get_time_left;
+  flist[F_SET_DYNAMIC_RANGE]=&set_dynamic_range;
+  flist[F_SET_ROI]=&set_roi;
+  flist[F_SET_SPEED]=&set_speed;
+  flist[F_SET_READOUT_FLAGS]=&set_readout_flags;
+  flist[F_EXECUTE_TRIMMING]=&execute_trimming;
+  flist[F_LOCK_SERVER]=&lock_server;
+  flist[F_SET_PORT]=&set_port;
+  flist[F_GET_LAST_CLIENT_IP]=&get_last_client_ip;
+  flist[F_UPDATE_CLIENT]=&update_client;
+  flist[F_CONFIGURE_MAC]=&configure_mac;
+  flist[F_LOAD_IMAGE]=&load_image;
+  flist[F_SET_MASTER]=&set_master;
+  flist[F_SET_SYNCHRONIZATION_MODE]=&set_synchronization;
+  flist[F_READ_COUNTER_BLOCK]=&read_counter_block;
+  flist[F_RESET_COUNTER_BLOCK]=&reset_counter_block;
+  flist[F_START_RECEIVER]=&start_receiver;
+  flist[F_STOP_RECEIVER]=&stop_receiver;
+  flist[F_CALIBRATE_PEDESTAL]=&calibrate_pedestal;
+  return OK;
+}
+
+
+int  M_nofunc(int file_des){
+  
+  int ret=FAIL;
+  sprintf(mess,"Unrecognized Function\n");
+  printf(mess);
+
+  sendDataOnly(file_des,&ret,sizeof(ret));
+  sendDataOnly(file_des,mess,sizeof(mess));
+  return GOODBYE;
+}
+
+
+int exit_server(int file_des) {
+  int retval=FAIL;
+  sendDataOnly(file_des,&retval,sizeof(retval));
+  printf("closing server.");
+  sprintf(mess,"closing server");
+  sendDataOnly(file_des,mess,sizeof(mess));
+  return GOODBYE;
+}
+
+int exec_command(int file_des) {
+  char cmd[MAX_STR_LENGTH];
+  char answer[MAX_STR_LENGTH];
+  int retval=OK;
+  int sysret=0;
+  int n=0;
+
+ /* receive arguments */
+  n = receiveDataOnly(file_des,cmd,MAX_STR_LENGTH);
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    retval=FAIL;
+  }
+
+  /* execute action if the arguments correctly arrived*/
+  if (retval==OK) {
+#ifdef VERBOSE
+    printf("executing command %s\n", cmd);
+#endif
+    if (lockStatus==0 || differentClients==0)
+      sysret=system(cmd);
+
+    //should be replaced by popen
+    if (sysret==0) {
+      sprintf(answer,"Succeeded\n");
+      if (lockStatus==1 && differentClients==1)
+	sprintf(answer,"Detector locked by %s\n", lastClientIP);
+    } else {
+      sprintf(answer,"Failed\n");
+      retval=FAIL;
+    }
+  } else {
+    sprintf(answer,"Could not receive the command\n");
+  }
+  
+  /* send answer */
+  n = sendDataOnly(file_des,&retval,sizeof(retval));
+  n = sendDataOnly(file_des,answer,MAX_STR_LENGTH);
+  if (n < 0) {
+    sprintf(mess,"Error writing to socket");
+    retval=FAIL;
+  }
+
+
+  /*return ok/fail*/
+  return retval; 
+ 
+}
+
+
+
+int get_detector_type(int file_des) {
+  int n=0;
+  enum detectorType ret;
+  int retval=OK;
+  
+  sprintf(mess,"Can't return detector type\n");
+
+
+  /* receive arguments */
+  /* execute action */
+  ret=myDetectorType;
+
+#ifdef VERBOSE
+    printf("Returning detector type %d\n",ret);
+#endif
+
+  /* send answer */  
+  /* send OK/failed */
+  if (differentClients==1)
+    retval=FORCE_UPDATE;
+
+  n += sendDataOnly(file_des,&retval,sizeof(retval));      
+  if (retval!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&ret,sizeof(ret));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  /*return ok/fail*/
+  return retval; 
+  
+
+}
+
+
+int set_number_of_modules(int file_des) {
+  int n;
+  int arg[2], ret=0; 
+  int retval=OK;
+  int dim, nm;
+  
+  sprintf(mess,"Can't set number of modules\n");
+
+  /* receive arguments */
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket %d", n);
+    retval=GOODBYE;
+  }
+  if (retval==OK) {
+    dim=arg[0];
+    nm=arg[1];
+
+    /* execute action */
+#ifdef VERBOSE
+    printf("Setting the number of modules in dimension %d to %d\n",dim,nm );
+#endif
+    
+    //if (nm!=GET_FLAG) {
+      if (dim!=X && nm!=GET_FLAG) {
+	retval=FAIL;
+	sprintf(mess,"Can't change module number in dimension %d\n",dim);
+      } else  {
+	if (lockStatus==1 && differentClients==1 && nm!=GET_FLAG) {
+	  sprintf(mess,"Detector locked by %s\n", lastClientIP);
+	  retval=FAIL;
+	} else {
+	  ret=setNMod(nm);
+	  if (nModX==nm || nm==GET_FLAG) {
+	    retval=OK;
+	    if (differentClients==1)
+	      retval=FORCE_UPDATE;
+	  } else
+	    retval=FAIL;
+	}
+      }
+  }
+  /*} else {
+    if (dim==Y) {
+      ret=nModY;
+    } else if (dim==X) {
+      ret=setNMod(-1);
+    }
+  }
+  */
+  
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&retval,sizeof(retval));
+  if (retval!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&ret,sizeof(ret));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  /*return ok/fail*/
+  return retval; 
+  
+}
+
+
+int get_max_number_of_modules(int file_des) {
+  int n;
+  int ret; 
+  int retval=OK;
+  enum dimension arg;
+  
+  sprintf(mess,"Can't get max number of modules\n");
+  /* receive arguments */
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    retval=FAIL;
+  }
+    /* execute action */
+#ifdef VERBOSE
+    printf("Getting the max number of modules in dimension %d \n",arg);
+#endif
+
+
+    switch (arg) {
+    case X:
+      ret=getNModBoard();
+      break;
+    case Y:
+      ret=NMAXMODY;
+      break;
+    default:
+      ret=FAIL;
+      retval=FAIL;
+      break;
+    }
+#ifdef VERBOSE
+    printf("Max number of module in dimension %d is %d\n",arg,ret );
+#endif  
+
+
+
+    if (differentClients==1 && retval==OK) {
+      retval=FORCE_UPDATE;
+    }
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&retval,sizeof(retval));
+  if (retval!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&ret,sizeof(ret));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+
+
+  /*return ok/fail*/
+  return retval; 
+}
+
+
+//index 0 is in gate
+//index 1 is in trigger
+//index 2 is out gate
+//index 3 is out trigger
+
+int set_external_signal_flag(int file_des) {
+	int n;
+	int arg[2];
+	int ret=OK;
+	int signalindex;
+	enum externalSignalFlag flag, retval;
+
+	sprintf(mess,"Can't set external signal flag\n");
+
+	/* receive arguments */
+	n = receiveDataOnly(file_des,&arg,sizeof(arg));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+	retval=SIGNAL_OFF;
+	if (ret==OK) {
+		signalindex=arg[0];
+		flag=arg[1];
+		/* execute action */
+		switch (flag) {
+		case GET_EXTERNAL_SIGNAL_FLAG:
+			retval=getExtSignal(signalindex);
+			break;
+
+		default:
+			if (differentClients==0 || lockStatus==0) {
+				retval=setExtSignal(signalindex,flag);
+			} else {
+				if (lockStatus!=0) {
+					ret=FAIL;
+					sprintf(mess,"Detector locked by %s\n", lastClientIP);
+				}
+			}
+
+		}
+
+#ifdef VERBOSE
+		printf("Setting external signal %d to flag %d\n",signalindex,flag );
+		printf("Set to flag %d\n",retval);
+#endif
+
+	} else {
+		ret=FAIL;
+	}
+
+	if (ret==OK && differentClients!=0)
+		ret=FORCE_UPDATE;
+
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+
+	/*return ok/fail*/
+	return ret;
+
+}
+
+
+int set_external_communication_mode(int file_des) {
+	int n;
+	enum externalCommunicationMode arg, ret=GET_EXTERNAL_COMMUNICATION_MODE;
+	int retval=OK;
+
+	sprintf(mess,"Can't set external communication mode\n");
+
+
+	/* receive arguments */
+	n = receiveDataOnly(file_des,&arg,sizeof(arg));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		retval=FAIL;
+	}
+	/*
+	enum externalCommunicationMode{
+	  GET_EXTERNAL_COMMUNICATION_MODE,
+	  AUTO,
+	  TRIGGER_EXPOSURE_SERIES,
+	  TRIGGER_EXPOSURE_BURST,
+	  TRIGGER_READOUT,
+	  TRIGGER_COINCIDENCE_WITH_INTERNAL_ENABLE,
+	  GATE_FIX_NUMBER,
+	  GATE_FIX_DURATION,
+	  GATE_WITH_START_TRIGGER,
+	  GATE_COINCIDENCE_WITH_INTERNAL_ENABLE
+	};
+	 */
+	if (retval==OK) {
+		/* execute action */
+
+		ret=setTiming(arg);
+
+		/*     switch(arg) { */
+		/*     default: */
+		/*       sprintf(mess,"The meaning of single signals should be set\n"); */
+		/*       retval=FAIL; */
+		/*     } */
+
+
+#ifdef VERBOSE
+		printf("Setting external communication mode to %d\n", arg);
+#endif
+	} else
+		ret=FAIL;
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&retval,sizeof(retval));
+	if (retval!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,&ret,sizeof(ret));
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+	/*return ok/fail*/
+	return retval;
+}
+
+
+
+int get_id(int file_des) {
+  // sends back 64 bits!
+  int64_t retval=-1;
+  int ret=OK;
+  int n=0;
+  enum idMode arg;
+  
+  sprintf(mess,"Can't return id\n");
+
+  /* receive arguments */
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+
+#ifdef VERBOSE
+      printf("Getting id %d\n", arg);
+#endif  
+
+  switch (arg) {
+  case DETECTOR_SERIAL_NUMBER:
+    retval=getDetectorNumber();
+    break;
+  case DETECTOR_FIRMWARE_VERSION:
+    retval=getFirmwareSVNVersion();
+    retval=(retval <<32) | getFirmwareVersion();
+    break;
+  case DETECTOR_SOFTWARE_VERSION:
+	retval= SVNREV;
+	retval= (retval <<32) | SVNDATE;
+    break;
+/*  case DETECTOR_FIRMWARE_SVN_VERSION:
+    retval=getFirmwareSVNVersion();
+    break;*/
+  default:
+    printf("Required unknown id %d \n", arg);
+    ret=FAIL;
+    retval=FAIL;
+    break;
+  }
+  
+#ifdef VERBOSE
+  printf("Id is %llx\n", retval);
+#endif  
+  
+  if (differentClients==1)
+    ret=FORCE_UPDATE;
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+  /*return ok/fail*/
+  return ret; 
+
+}
+
+int digital_test(int file_des) {
+
+  int retval;
+  int ret=OK;
+  int imod=-1;
+  int n=0;
+  int ibit=0;
+  int ow;
+  int ival;
+  enum digitalTestMode arg; 
+  
+  sprintf(mess,"Can't send digital test\n");
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+
+#ifdef VERBOSE
+  printf("Digital test mode %d\n",arg );
+#endif  
+
+  switch (arg) {
+  case  CHIP_TEST:
+    n = receiveDataOnly(file_des,&imod,sizeof(imod));
+    if (n < 0) {
+      sprintf(mess,"Error reading from socket\n");
+      retval=FAIL;
+    }
+#ifdef VERBOSE
+      printf("of module %d\n", imod);
+#endif  
+      retval=0;
+#ifdef MCB_FUNCS  
+      if (differentClients==1 && lockStatus==1) {
+	ret=FAIL;
+	sprintf(mess,"Detector locked by %s\n",lastClientIP);
+	break;
+      }
+      if (imod >= nModX) {
+	ret=FAIL;
+	sprintf(mess,"Module %d disabled\n",imod);
+	break;
+      }
+      if (testShiftIn(imod)) retval|=(1<<(ibit));
+      ibit++;
+      if (testShiftOut(imod)) retval|=(1<<(ibit));
+      ibit++;
+      if (testShiftStSel(imod)) retval|=(1<<(ibit));
+      ibit++;
+      //if ( testDataInOut(0x123456, imod)) retval|=(1<<(ibit++));
+      //if ( testExtPulse(imod)) retval|=(1<<(ibit++));
+      //  for (ow=0; ow<6; ow++)
+      // ow=1;
+      //#ifndef PICASSOD
+      for (ow=0; ow<5; ow++) {
+	//#endif
+	if (testDataInOutMux(imod, ow, 0x789abc)) retval|=(1<<ibit);
+	ibit++;
+      }
+      //for (ow=0; ow<6; ow++)
+	// ow=1;
+      //#ifndef PICASSOD
+      for (ow=0; ow<5; ow++) {
+	//#endif
+	if (testExtPulseMux(imod, ow)) retval|=(1<<ibit);
+	ibit++;
+      }
+      //#ifndef PICASSOD
+      if ( testOutMux(imod)) retval|=(1<<(ibit));
+      ibit++;
+      if (testFpgaMux(imod)) retval|=(1<<(ibit));
+      ibit++;
+      //#endif
+     
+#endif 
+    break;
+  case MODULE_FIRMWARE_TEST:
+    retval=0x2;
+    break;
+  case DETECTOR_FIRMWARE_TEST:
+    retval=testFpga();
+    break;
+  case DETECTOR_MEMORY_TEST:
+    ret=testRAM();
+    break;
+  case DETECTOR_BUS_TEST:
+    retval=testBus();
+      break;
+  case DETECTOR_SOFTWARE_TEST:
+    retval=testFpga();
+    break;
+  case DIGITAL_BIT_TEST:
+	  n = receiveDataOnly(file_des,&ival,sizeof(ival));
+	  if (n < 0) {
+		  sprintf(mess,"Error reading from socket\n");
+		  retval=FAIL;
+	  }
+#ifdef VERBOSE
+	  printf("with value %d\n", ival);
+#endif
+	  if (differentClients==1 && lockStatus==1) {
+		  ret=FAIL;
+		  sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		  break;
+	  }
+	  digitalTestBit = ival;
+	  retval=digitalTestBit;
+	  break;
+  default:
+    printf("Unknown digital test required %d\n",arg);
+    ret=FAIL;
+    retval=FAIL;
+    break;
+  }
+  
+#ifdef VERBOSE
+  printf("digital test result is 0x%x\n", retval);
+#endif  
+  //Always returns force update such that the dynamic range is always updated on the client
+
+  // if (differentClients==1 && ret==OK)
+  ret=FORCE_UPDATE;
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+  /*return ok/fail*/
+  return ret; 
+
+}
+
+int write_register(int file_des) {
+
+  int retval;
+  int ret=OK;
+  int arg[2]; 
+  int addr, val;
+  int n;
+  u_int32_t address;
+
+  sprintf(mess,"Can't write to register\n");
+
+  n = receiveDataOnly(file_des,arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  addr=arg[0];
+  val=arg[1];
+
+#ifdef VERBOSE
+  printf("writing to register 0x%x data 0x%x\n", addr, val);
+#endif  
+
+  if (differentClients==1 && lockStatus==1) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);    
+  }
+
+
+  if(ret!=FAIL){
+    address=(addr<<11);
+    if((address==FIFO_DATA_REG_OFF)||(address==CONTROL_REG))
+    	ret = bus_w16(address,val);
+    else
+    	ret=bus_w(address,val);
+    if(ret==OK){
+    	if((address==FIFO_DATA_REG_OFF)||(address==CONTROL_REG))
+        	retval=bus_r16(address);
+        else
+        	retval=bus_r(address);
+    }
+  }
+  
+
+#ifdef VERBOSE
+  printf("Data set to 0x%x\n",  retval);
+#endif  
+  if (retval==val) {
+    ret=OK;
+    if (differentClients)
+      ret=FORCE_UPDATE;
+  } else {
+    ret=FAIL;
+    sprintf(mess,"Writing to register 0x%x failed: wrote 0x%x but read 0x%x\n", addr, val, retval);
+  }
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+  /*return ok/fail*/
+  return ret; 
+
+}
+
+int read_register(int file_des) {
+
+  int retval;
+  int ret=OK;
+  int arg; 
+  int addr;
+  int n;
+  u_int32_t address;
+
+  sprintf(mess,"Can't read register\n");
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  addr=arg;
+
+ 
+
+  //#ifdef VERBOSE
+  printf("reading  register 0x%x\n", addr);
+  //#endif
+
+  if(ret!=FAIL){
+	  address=(addr<<11);
+	  if((address==FIFO_DATA_REG_OFF)||(address==CONTROL_REG))
+		  retval=bus_r16(address);
+	  else
+		  retval=bus_r(address);
+  }
+
+
+
+#ifdef VERBOSE
+  printf("Returned value 0x%x\n",  retval);
+#endif  
+  if (ret==FAIL) {
+    ret=FAIL;
+    printf("Reading register 0x%x failed\n", addr);
+  } else if (differentClients)
+    ret=FORCE_UPDATE;
+
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+  /*return ok/fail*/
+  return ret; 
+
+}
+
+int set_dac(int file_des) {
+	//default:all mods
+	int retval;
+	int ret=OK;
+	int arg[3];
+	enum dacIndex ind;
+	int imod;
+	int n;
+	int val;
+	int idac=0;
+
+	sprintf(mess,"Can't set DAC\n");
+
+	n = receiveDataOnly(file_des,arg,sizeof(arg));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+	ind=arg[0];
+	imod=arg[1];
+
+	n = receiveDataOnly(file_des,&val,sizeof(val));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+#ifdef VERBOSE
+	printf("Setting DAC %d of module %d to %d V\n", ind, imod, val);
+#endif 
+
+	if (imod>=getNModBoard())
+		ret=FAIL;
+	if (imod<0)
+		imod=ALLMOD;
+
+#ifdef MCB_FUNCS
+	switch (ind) {
+	case V_DAC0 :
+		idac=VDAC0;
+		break;
+	case V_DAC1:
+		idac=VDAC1;
+		break;
+	case V_DAC2:
+		idac=VDAC2;
+		break;
+	case V_DAC3:
+		idac=VDAC3;
+		break;
+	case V_DAC4:
+		idac=VDAC4;
+		break;
+	case V_DAC5:
+		idac=VDAC5;
+		break;
+	case V_DAC6:
+		idac=VDAC6;
+		break;
+	case V_DAC7:
+		idac=VDAC7;
+		break;
+	case HV_POT:
+		idac=HIGH_VOLTAGE;
+		break;
+
+	default:
+		printf("Unknown DAC index %d for Moench\n",ind);
+		sprintf(mess,"Unknown DAC index %d for Moench\n",ind);
+		ret=FAIL;
+	    break;
+	}
+
+	if (ret==OK) {
+		if (differentClients==1 && lockStatus==1) {
+			ret=FAIL;
+			sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		} else{
+			if(idac==HIGH_VOLTAGE)
+				retval=initHighVoltageByModule(val,imod);
+			else
+				retval=initDACbyIndexDACU(idac,val,imod);
+		}
+	}
+	if(ret==OK){
+		ret=FAIL;
+		if(idac==HIGH_VOLTAGE){
+			if(retval==-2)
+				strcpy(mess,"Invalid Voltage.Valid values are 0,90,110,120,150,180,200");
+			else if(retval==-3)
+				strcpy(mess,"Weird value read back or it has not been set yet\n");
+			else
+				ret=OK;
+		}//since v r saving only msb
+		else if ((retval-val)<=3 || val==-1)
+			ret=OK;
+	}
+#endif
+
+#ifdef VERBOSE
+	printf("DAC set to %d V\n",  retval);
+#endif  
+
+	if(ret==FAIL)
+		printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, retval);
+	else{
+		if (differentClients)
+			ret=FORCE_UPDATE;
+	}
+
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+
+	/*return ok/fail*/
+	return ret;
+
+}
+
+
+
+int get_adc(int file_des) {
+	//default: mod 0
+	int retval;
+	int ret=OK;
+	int arg[2];
+	enum dacIndex ind;
+	int imod;
+	int n;
+	int idac=0;
+
+	sprintf(mess,"Can't read ADC\n");
+
+
+	n = receiveDataOnly(file_des,arg,sizeof(arg));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+	ind=arg[0];
+	imod=arg[1];
+
+#ifdef VERBOSE
+	printf("Getting ADC %d of module %d\n", ind, imod);
+#endif
+
+	if (imod>=getNModBoard() || imod<0)
+		ret=FAIL;
+
+#ifdef MCB_FUNCS
+	switch (ind) {
+	case TEMPERATURE_FPGA:
+		idac=TEMP_FPGA;
+		break;
+	case TEMPERATURE_ADC:
+		idac=TEMP_ADC;
+		break;
+	default:
+		printf("Unknown DAC index %d\n",ind);
+		sprintf(mess,"Unknown DAC index %d\n",ind);
+		ret=FAIL;
+	    break;
+	}
+
+	if (ret==OK)
+		retval=getTemperatureByModule(idac,imod);
+#endif
+
+#ifdef VERBOSE
+	printf("ADC is %d V\n",  retval);
+#endif  
+	if (ret==FAIL) {
+		printf("Getting adc %d of module %d failed\n", ind, imod);
+	}
+
+	if (differentClients)
+		ret=FORCE_UPDATE;
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+	/*return ok/fail*/
+	return ret;
+
+}
+
+int set_channel(int file_des) {
+  int ret=OK;
+  sls_detector_channel myChan;
+  int retval;
+  int n;
+  
+
+  sprintf(mess,"Can't set channel\n");
+
+#ifdef VERBOSE
+  printf("Setting channel\n");
+#endif
+  ret=receiveChannel(file_des, &myChan);
+  if (ret>=0)
+    ret=OK;
+  else
+    ret=FAIL;
+#ifdef VERBOSE
+  printf("channel number is %d, chip number is %d, module number is %d, register is %lld\n", myChan.chan,myChan.chip, myChan.module, myChan.reg);
+#endif
+  
+  if (ret==OK) {
+    if (myChan.module>=getNModBoard()) 
+      ret=FAIL;
+    if (myChan.chip>=NCHIP) 
+      ret=FAIL;
+    if (myChan.chan>=NCHAN) 
+      ret=FAIL;
+    if (myChan.module<0)
+      myChan.module=ALLMOD;
+  }
+
+ 
+  if (ret==OK) {
+    if (differentClients==1 && lockStatus==1) {
+      ret=FAIL;
+      sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+    } else {
+#ifdef MCB_FUNCS
+    retval=initChannelbyNumber(myChan);
+#endif
+    }
+  }
+  /* Maybe this is done inside the initialization funcs */
+  //copyChannel(detectorChans[myChan.module][myChan.chip]+(myChan.chan), &myChan);
+  
+
+
+  if (differentClients==1 && ret==OK)
+    ret=FORCE_UPDATE;
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+
+  /*return ok/fail*/
+  return ret; 
+  
+}
+
+
+
+
+int get_channel(int file_des) {
+
+  int ret=OK;
+  sls_detector_channel retval;
+
+  int arg[3];
+  int ichan, ichip, imod;
+  int n;
+  
+  sprintf(mess,"Can't get channel\n");
+
+
+
+  n = receiveDataOnly(file_des,arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  ichan=arg[0];
+  ichip=arg[1];
+  imod=arg[2];
+ 
+  if (ret==OK) {
+    ret=FAIL;
+    if (imod>=0 && imod<getNModBoard()) {
+      ret=OK;
+    }
+  }  
+  if (ret==OK) {
+    ret=FAIL;
+    if (ichip>=0 && ichip<NCHIP) {
+      ret=OK;
+    }
+  }   
+  if (ret==OK) {
+    ret=FAIL;
+    if (ichan>=0 && ichan<NCHAN) {
+      ret=OK;
+    }
+  }   
+
+
+  if (ret==OK) {
+#ifdef MCB_FUNCS
+      ret=getChannelbyNumber(&retval);
+#endif
+    if (differentClients && ret==OK)
+      ret=FORCE_UPDATE;
+  } 
+
+#ifdef VERBOSE
+  printf("Returning channel %d %d %d, 0x%llx\n", ichan, ichip, imod, (retval.reg));
+#endif 
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    ret=sendChannel(file_des, &retval);
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+
+  
+  /*return ok/fail*/
+  return ret; 
+
+
+}
+
+
+int set_chip(int file_des) {
+
+  sls_detector_chip myChip;
+  int ch[NCHAN];
+  int n, retval;
+  int ret=OK;
+  
+
+  myChip.nchan=NCHAN;
+  myChip.chanregs=ch;
+
+
+
+
+
+#ifdef VERBOSE
+  printf("Setting chip\n");
+#endif
+  ret=receiveChip(file_des, &myChip);
+#ifdef VERBOSE
+  printf("Chip received\n");
+#endif
+  if (ret>=0)
+    ret=OK;
+  else
+    ret=FAIL;
+#ifdef VERBOSE
+  printf("chip number is %d, module number is %d, register is %d, nchan %d\n",myChip.chip, myChip.module, myChip.reg, myChip.nchan);
+#endif
+  
+  if (ret==OK) {
+    if (myChip.module>=getNModBoard()) 
+      ret=FAIL;
+    if  (myChip.module<0) 
+      myChip.module=ALLMOD;
+    if (myChip.chip>=NCHIP) 
+      ret=FAIL;
+  }
+    if (differentClients==1 && lockStatus==1) {
+      ret=FAIL;
+      sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+    } else {
+#ifdef MCB_FUNCS
+  retval=initChipbyNumber(myChip);
+#endif
+    }
+  /* Maybe this is done inside the initialization funcs */
+  //copyChip(detectorChips[myChip.module]+(myChip.chip), &myChip);
+
+    if (differentClients && ret==OK)
+      ret=FORCE_UPDATE;
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+
+  return ret;
+}
+
+int get_chip(int file_des) {
+
+  
+  int ret=OK;
+  sls_detector_chip retval;
+  int arg[2];
+  int  ichip, imod;
+  int n;
+  
+
+
+  n = receiveDataOnly(file_des,arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  ichip=arg[0];
+  imod=arg[1];
+ if (ret==OK) {
+    ret=FAIL;
+    if (imod>=0 && imod<getNModBoard()) {
+      ret=OK;
+    }
+  }  
+  if (ret==OK) {
+    ret=FAIL;
+    if (ichip>=0 && ichip<NCHIP) {
+      ret=OK;
+    }
+  }   
+ 
+
+ 
+  if (ret==OK) {
+#ifdef MCB_FUNCS
+    ret=getChipbyNumber(&retval);
+#endif
+    if (differentClients && ret==OK)
+      ret=FORCE_UPDATE;
+  } 
+
+#ifdef VERBOSE
+  printf("Returning chip %d %d\n",  ichip, imod);
+#endif 
+
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */  
+    ret=sendChip(file_des, &retval);
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+
+  
+  /*return ok/fail*/
+  return ret; 
+
+
+}
+int set_module(int file_des) {
+  sls_detector_module myModule;
+  int *myChip=malloc(NCHIP*sizeof(int));
+  int *myChan=malloc(NCHIP*NCHAN*sizeof(int));
+  int *myDac=malloc(NDAC*sizeof(int));/**dhanya*/
+  int *myAdc=malloc(NADC*sizeof(int));/**dhanya*/
+  int retval, n;
+  int ret=OK;
+  int dr;// ow;
+
+  dr=setDynamicRange(-1);
+
+  if (myDac)
+    myModule.dacs=myDac;
+  else {
+    sprintf(mess,"could not allocate dacs\n");
+    ret=FAIL;
+  }
+  if (myAdc)
+    myModule.adcs=myAdc;
+  else {
+    sprintf(mess,"could not allocate adcs\n");
+    ret=FAIL;
+  }
+  if (myChip)
+    myModule.chipregs=myChip;
+  else {
+    sprintf(mess,"could not allocate chips\n");
+    ret=FAIL;
+  }
+  if (myChan)
+    myModule.chanregs=myChan;
+  else {
+    sprintf(mess,"could not allocate chans\n");
+    ret=FAIL;
+  }
+
+  myModule.ndac=NDAC;
+  myModule.nchip=NCHIP;
+  myModule.nchan=NCHAN*NCHIP;
+  myModule.nadc=NADC;
+  
+  
+#ifdef VERBOSE
+  printf("Setting module\n");
+#endif 
+  ret=receiveModule(file_des, &myModule);
+
+  if (ret>=0)
+    ret=OK;
+  else
+    ret=FAIL;
+
+
+#ifdef VERBOSE
+  printf("module number is %d,register is %d, nchan %d, nchip %d, ndac %d, nadc %d, gain %f, offset %f\n",myModule.module, myModule.reg, myModule.nchan, myModule.nchip, myModule.ndac,  myModule.nadc, myModule.gain,myModule.offset);
+#endif
+  
+  if (ret==OK) {
+	  if (myModule.module>=getNModBoard()) {
+      ret=FAIL;
+      printf("Module number is too large %d\n",myModule.module);
+    }
+    if (myModule.module<0) 
+      myModule.module=ALLMOD;
+  }
+    
+  if (ret==OK) {
+    if (differentClients==1 && lockStatus==1) {
+      ret=FAIL;
+      sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+    } else {
+#ifdef MCB_FUNCS
+    retval=initModulebyNumber(myModule);
+#endif
+    }
+  }
+
+  if (differentClients==1 && ret==OK)
+    ret=FORCE_UPDATE;
+
+  /* Maybe this is done inside the initialization funcs */
+  //copyChip(detectorChips[myChip.module]+(myChip.chip), &myChip);
+
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  free(myChip);
+  free(myChan);
+  free(myDac);
+  free(myAdc);
+
+  //  setDynamicRange(dr);  always 16 commented out
+
+  
+  return ret;
+}
+
+
+
+
+int get_module(int file_des) {
+
+  
+  int ret=OK;
+
+
+  int arg;
+  int   imod;
+  int n;
+
+  
+
+  sls_detector_module myModule;
+  int *myChip=malloc(NCHIP*sizeof(int));
+  int *myChan=malloc(NCHIP*NCHAN*sizeof(int));
+  int *myDac=malloc(NDAC*sizeof(int));/**dhanya*/
+  int *myAdc=malloc(NADC*sizeof(int));/**dhanya*/
+
+
+  if (myDac)
+    myModule.dacs=myDac;
+  else {
+    sprintf(mess,"could not allocate dacs\n");
+    ret=FAIL;
+  }
+  if (myAdc)
+    myModule.adcs=myAdc;
+  else {
+    sprintf(mess,"could not allocate adcs\n");
+    ret=FAIL;
+  }
+  if (myChip)
+    myModule.chipregs=myChip;
+  else {
+    sprintf(mess,"could not allocate chips\n");
+    ret=FAIL;
+  }
+  if (myChan)
+    myModule.chanregs=myChan;
+  else {
+    sprintf(mess,"could not allocate chans\n");
+    ret=FAIL;
+  }
+
+  myModule.ndac=NDAC;
+  myModule.nchip=NCHIP;
+  myModule.nchan=NCHAN*NCHIP;
+  myModule.nadc=NADC;
+  
+
+
+
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  imod=arg;
+
+  if (ret==OK) {
+   ret=FAIL;
+   if (imod>=0 && imod<getNModBoard()) {
+     ret=OK;
+     myModule.module=imod;
+#ifdef MCB_FUNCS
+     getModulebyNumber(&myModule);
+#endif
+
+#ifdef VERBOSE
+     printf("Returning module %d of register %x\n",  imod, myModule.reg);
+#endif 
+    }
+ } 
+
+  if (differentClients==1 && ret==OK)
+    ret=FORCE_UPDATE;
+ 
+  /* send answer */
+  /* send OK/failed */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=FAIL) {
+    /* send return argument */  
+    ret=sendModule(file_des, &myModule);
+  } else {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+
+  
+
+  free(myChip);
+  free(myChan);
+  free(myDac);
+  free(myAdc);
+
+
+  /*return ok/fail*/
+  return ret; 
+
+}
+
+
+int get_threshold_energy(int file_des) { 
+  int ret=FAIL;
+  int n;
+  int  imod;
+
+  strcpy(mess,"cannot set threshold for moench");
+
+  n = receiveDataOnly(file_des,&imod,sizeof(imod));
+  if (n < 0)
+    sprintf(mess,"Error reading from socket\n");
+
+
+  /* send answer */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  n += sendDataOnly(file_des,mess,sizeof(mess));
+
+  /*return ok/fail*/
+  return OK;
+
+}
+ 
+int set_threshold_energy(int file_des) { 
+  int ret=FAIL;
+  int arg[3];
+  int n;
+
+  strcpy(mess,"cannot set threshold for moench");
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0)
+    sprintf(mess,"Error reading from socket\n");
+
+
+  /* send answer */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  n += sendDataOnly(file_des,mess,sizeof(mess));
+
+  /*return ok/fail*/
+  return OK;
+
+}
+
+
+ 
+int set_settings(int file_des) {
+
+  int retval;
+  int ret=OK;
+  int arg[2];
+  int n;
+  int  imod;
+  enum detectorSettings isett;
+
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  imod=arg[1];
+  isett=arg[0];
+  
+
+#ifdef VERBOSE
+  printf("Changing settings of module %d to %d\n", imod,  isett);
+#endif 
+
+  if (differentClients==1 && lockStatus==1 && arg[0]!=GET_SETTINGS) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+  } else {
+#ifdef MCB_FUNCS
+    retval=setSettings(arg[0],imod);
+#endif
+#ifdef VERBOSE
+    printf("Settings changed to %d\n",retval);
+#endif  
+    
+    if (retval==isett || isett<0) {
+      ret=OK;
+    } else {
+      ret=FAIL;
+      printf("Changing settings of module %d: wrote %d but read %d\n", imod, isett, retval);
+    }
+    
+  }
+  if (ret==OK && differentClients==1)
+    ret=FORCE_UPDATE;
+
+  /* send answer */
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  } else
+    n += sendDataOnly(file_des,&retval,sizeof(retval));
+    
+ 
+  
+  return ret; 
+
+
+}
+
+int start_acquisition(int file_des) {
+
+  int ret=OK;
+  int n;
+  
+
+  sprintf(mess,"can't start acquisition\n");
+
+#ifdef VERBOSE
+  printf("Starting acquisition\n");
+#endif
+  
+  if (differentClients==1 && lockStatus==1) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+  } else {
+    ret=startStateMachine();
+  }
+  if (ret==FAIL)
+    sprintf(mess,"Start acquisition failed\n");
+  else if (differentClients)
+    ret=FORCE_UPDATE;
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  return ret; 
+
+}
+
+int stop_acquisition(int file_des) {
+
+  int ret=OK;
+  int n;
+  
+
+  sprintf(mess,"can't stop acquisition\n");
+
+#ifdef VERBOSE
+  printf("Stopping acquisition\n");
+#endif 
+
+    
+  if (differentClients==1 && lockStatus==1) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+  } else {
+    ret=stopStateMachine();
+  }
+  
+  if (ret==FAIL)
+    sprintf(mess,"Stop acquisition failed\n");
+  else if (differentClients)
+    ret=FORCE_UPDATE;
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  return ret; 
+
+
+}
+
+int start_readout(int file_des) {
+
+
+  int ret=OK;
+  int n;
+  
+
+  sprintf(mess,"can't start readout\n");
+
+#ifdef VERBOSE
+  printf("Starting readout\n");
+#endif     
+  if (differentClients==1 && lockStatus==1) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+  } else {
+    ret=startReadOut();
+  }
+  if (ret==FAIL)
+    sprintf(mess,"Start readout failed\n");
+  else if (differentClients)
+    ret=FORCE_UPDATE;
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  }
+  return ret; 
+
+
+
+}
+
+int get_run_status(int file_des) {  
+
+  int ret=OK;
+  int n;
+  
+  int retval;
+  enum runStatus s;
+  sprintf(mess,"getting run status\n");
+
+#ifdef VERBOSE
+  printf("Getting status\n");
+#endif 
+
+  retval= runState();
+  printf("\n\nSTATUS=%08x\n",retval);
+
+  //error
+  if(retval&SOME_FIFO_FULL_BIT){
+	  printf("-----------------------------------ERROR--------------------------------------x%0x\n",retval);
+	  s=ERROR;
+  }
+  //runbusy=0
+  // else if(!(retval&RUNMACHINE_BUSY_BIT)){ //commented by Anna 24.10.2012
+    else if(!(retval&RUN_BUSY_BIT)){ // by Anna 24.10.2012
+    
+
+
+	  //and readbusy=1, its last frame read
+      if((retval&READMACHINE_BUSY_BIT)  ){ //
+
+
+		  printf("-----------------------------------READ MACHINE BUSY--------------------------\n");
+		  s=TRANSMITTING;
+      } else if (retval&ALL_FIFO_EMPTY_BIT) {
+		  printf("-----------------------------------DATA IN FIFO--------------------------\n");
+		  s=TRANSMITTING;
+	
+      }
+	  //and readbusy=0,idle
+      else if(!(retval&0xffff)){
+		  //if(!(retval&0x00000001)){
+		  printf("-----------------------------------IDLE--------------------------------------\n");
+		  s=IDLE;
+	  } else {
+	    printf("-----------------------------------Unknown status %08x--------------------------------------\n", retval);
+	    s=ERROR;
+	    ret=FAIL;
+	  }
+  }
+  //if runbusy=1
+    else {
+	  if (retval&WAITING_FOR_TRIGGER_BIT){
+		  printf("-----------------------------------WAITING-----------------------------------\n");
+		  s=WAITING;
+	  }
+	  else{
+		  printf("-----------------------------------RUNNING-----------------------------------\n");
+		  s=RUNNING;
+	  }
+  }
+
+
+
+
+  if (ret!=OK) {
+    printf("get status failed %04x\n",retval);
+    sprintf(mess, "get status failed %08x\n", retval);
+    
+  } else if (differentClients)
+    ret=FORCE_UPDATE;
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n += sendDataOnly(file_des,&s,sizeof(s));
+  }
+  return ret; 
+
+
+
+}
+
+int read_frame(int file_des) {
+
+  if (differentClients==1 && lockStatus==1) {
+    dataret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+    sendDataOnly(file_des,&dataret,sizeof(dataret));
+    sendDataOnly(file_des,mess,sizeof(mess));
+#ifdef VERBOSE
+    printf("dataret %d\n",dataret);
+#endif
+    return dataret;
+
+  }
+ 
+  if (storeInRAM==0) {
+    if ((dataretval=(char*)fifo_read_event())) {
+      dataret=OK;
+#ifdef VERYVERBOSE
+      printf("Sending ptr %x %d\n",(unsigned int)(dataretval), dataBytes);
+#endif
+      sendDataOnly(file_des,&dataret,sizeof(dataret));
+      sendDataOnly(file_des,dataretval,dataBytes);
+#ifdef VERBOSE
+      printf("sent %d bytes \n",dataBytes);
+      printf("dataret OK\n");
+#endif
+      return OK;
+    }  else {
+      //might add delay????
+      if(getFrames()>-2) {
+	dataret=FAIL;
+	sprintf(mess,"no data and run stopped: %d frames left\n",(int)(getFrames()+2));
+	printf("%s\n",mess);
+      } else {
+	dataret=FINISHED;
+	sprintf(mess,"acquisition successfully finished\n");
+	printf("%s\n",mess);
+      }
+#ifdef VERYVERBOSE
+      printf("%d %d %x %s\n",(int)(sizeof(mess)),(int)(strlen(mess)),(unsigned int)( mess),mess);
+#endif
+      sendDataOnly(file_des,&dataret,sizeof(dataret));
+      sendDataOnly(file_des,mess,sizeof(mess));
+#ifdef VERYVERBOSE
+      printf("message sent %s\n",mess);
+#endif
+      printf("dataret %d\n",dataret);
+      return dataret;
+    }
+  } else {
+    nframes=0;
+    while(fifo_read_event()) {
+      nframes++;
+    }
+    dataretval=(char*)ram_values;
+    dataret=OK;
+#ifdef VERBOSE
+    printf("sending data of %d frames\n",nframes);
+#endif
+    for (iframes=0; iframes<nframes; iframes++) {
+      sendDataOnly(file_des,&dataret,sizeof(dataret));
+#ifdef VERYVERBOSE
+      printf("sending pointer %x of size %d\n",(unsigned int)(dataretval),dataBytes);
+#endif
+      sendDataOnly(file_des,dataretval,dataBytes);
+      dataretval+=dataBytes;
+    }
+    if (getFrames()>-2) {
+      dataret=FAIL;
+      sprintf(mess,"no data and run stopped: %d frames left\n",(int)(getFrames()+2));
+      printf("%s\n",mess);
+    } else {
+      dataret=FINISHED;
+      sprintf(mess,"acquisition successfully finished\n");
+      printf("%s\n",mess);
+      if (differentClients)
+	dataret=FORCE_UPDATE;
+    }
+#ifdef VERBOSE
+      printf("Frames left %d\n",(int)(getFrames()));
+#endif
+    sendDataOnly(file_des,&dataret,sizeof(dataret));
+    sendDataOnly(file_des,mess,sizeof(mess));
+    printf("dataret %d\n",dataret);
+    return dataret;
+  }
+  printf("dataret %d\n",dataret);
+  return dataret; 
+}
+
+
+
+
+
+
+
+
+int read_all(int file_des) {
+
+while(read_frame(file_des)==OK) {
+
+#ifdef VERBOSE
+  printf("frame read\n");
+#endif   
+    ;
+  }
+#ifdef VERBOSE
+  printf("Frames finished\n");
+#endif   
+  return OK; 
+
+
+}
+
+int start_and_read_all(int file_des) {
+  //int dataret=OK;
+#ifdef VERBOSE
+  printf("Starting and reading all frames\n");
+#endif 
+
+  if (differentClients==1 && lockStatus==1) {
+    dataret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);  
+    sendDataOnly(file_des,&dataret,sizeof(dataret));
+    sendDataOnly(file_des,mess,sizeof(mess));
+    return dataret;
+
+  }
+
+  startStateMachine();
+
+  /*  ret=startStateMachine();  
+      if (ret!=OK) {
+      sprintf(mess,"could not start state machine\n");
+    sendDataOnly(file_des,&ret,sizeof(ret));
+    sendDataOnly(file_des,mess,sizeof(mess));
+    
+    #ifdef VERBOSE
+    printf("could not start state machine\n");
+#endif
+} else {*/
+  read_all(file_des);
+#ifdef VERBOSE
+  printf("Frames finished\n");
+#endif   
+  //}
+
+
+  return OK; 
+
+
+}
+
+int set_timer(int file_des) {
+  enum timerIndex ind;
+  int64_t tns;
+  int n;
+  int64_t retval;
+  int ret=OK;
+  
+
+  sprintf(mess,"can't set timer\n");
+  
+  n = receiveDataOnly(file_des,&ind,sizeof(ind));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  
+  n = receiveDataOnly(file_des,&tns,sizeof(tns));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  
+  if (ret!=OK) {
+    printf(mess);
+  }
+
+#ifdef VERBOSE
+  printf("setting timer %d to %lld ns\n",ind,tns);
+#endif 
+  if (ret==OK) {
+
+    if (differentClients==1 && lockStatus==1 && tns!=-1) { 
+      ret=FAIL;
+      sprintf(mess,"Detector locked by %s\n",lastClientIP);
+    }  else {
+      switch(ind) {
+      case FRAME_NUMBER:
+	retval=setFrames(tns);
+	break;
+      case ACQUISITION_TIME: 
+	retval=setExposureTime(tns);
+	break;
+      case FRAME_PERIOD: 
+	retval=setPeriod(tns);
+	break;
+      case DELAY_AFTER_TRIGGER: 
+	retval=setDelay(tns);
+	break;
+      case GATES_NUMBER:
+	retval=setGates(tns);
+	break;
+      case PROBES_NUMBER: 
+    sprintf(mess,"can't set timer for moench\n");
+    ret=FAIL;
+	break;
+      case CYCLES_NUMBER: 
+	retval=setTrains(tns);
+	break;
+      default:
+	ret=FAIL;
+	sprintf(mess,"timer index unknown %d\n",ind);
+    break;
+      }
+    }
+  }
+  if (ret!=OK) {
+    printf(mess);
+    if (differentClients)
+      ret=FORCE_UPDATE;
+  }
+
+  if (ret!=OK) {
+    printf(mess);
+    printf("set timer failed\n");
+  } else if (ind==FRAME_NUMBER) {
+    ret=allocateRAM();
+    if (ret!=OK) 
+      sprintf(mess, "could not allocate RAM for %lld frames\n", tns);
+  }
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+#ifdef VERBOSE
+  printf("returning ok %d\n",(int)(sizeof(retval)));
+#endif 
+
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+
+  return ret; 
+
+}
+
+
+
+
+
+
+
+
+int get_time_left(int file_des) {
+
+  enum timerIndex ind;
+  int n;
+  int64_t retval;
+  int ret=OK;
+  
+  sprintf(mess,"can't get timer\n");
+  n = receiveDataOnly(file_des,&ind,sizeof(ind));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  
+
+  //#ifdef VERBOSE
+
+  printf("getting time left on timer %d \n",ind);
+  //#endif
+
+  if (ret==OK) {
+    switch(ind) {
+    case FRAME_NUMBER:
+       printf("getting frames \n");
+      retval=getFrames(); 
+      break;
+    case ACQUISITION_TIME: 
+      retval=getExposureTime();
+      break;
+    case FRAME_PERIOD: 
+      retval=getPeriod();
+      break;
+    case DELAY_AFTER_TRIGGER: 
+      retval=getDelay();
+    break;
+    case GATES_NUMBER:
+      retval=getGates();
+      break;
+    case PROBES_NUMBER: 
+      retval=getProbes();
+      break;
+    case CYCLES_NUMBER: 
+      retval=getTrains();
+      break;
+    case PROGRESS: 
+      retval=getProgress();
+      break;
+    case ACTUAL_TIME:
+      retval=getActualTime();
+      break;
+    case MEASUREMENT_TIME: 
+      retval=getMeasurementTime();
+      break;
+    default:
+      ret=FAIL;
+      sprintf(mess,"timer index unknown %d\n",ind);
+      break;
+    }
+  }
+
+
+  if (ret!=OK) {
+    printf("get time left failed\n");
+  } else if (differentClients)
+      ret=FORCE_UPDATE;
+
+  //#ifdef VERBOSE
+
+  printf("time left on timer %d is %lld\n",ind, retval);
+  //#endif
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret!=OK) {
+    n += sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+#ifdef VERBOSE
+
+  printf("data sent\n");
+#endif 
+
+  return ret; 
+
+
+}
+
+int set_dynamic_range(int file_des) {
+
+
+ 
+  int dr;
+  int n;
+  int retval;
+  int ret=OK;
+  
+
+  sprintf(mess,"can't set dynamic range\n");
+  
+
+  n = receiveDataOnly(file_des,&dr,sizeof(dr));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  
+   
+  if (differentClients==1 && lockStatus==1 && dr>=0) {
+      ret=FAIL;
+      sprintf(mess,"Detector locked by %s\n",lastClientIP);
+  }  else {
+    retval=setDynamicRange(dr);
+  }
+
+  //if (dr>=0 && retval!=dr)   ret=FAIL;
+  if (ret!=OK) {
+    sprintf(mess,"set dynamic range failed\n");
+  } else {
+    ret=allocateRAM();
+    if (ret!=OK)
+      sprintf(mess,"Could not allocate RAM for the dynamic range selected\n");
+    else  if (differentClients)
+      ret=FORCE_UPDATE;
+  }
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+  return ret; 
+}
+
+int set_roi(int file_des) {
+
+	int i;
+	int ret=OK;
+	int nroi=-1;
+	int n=0;
+	int retvalsize=0;
+	ROI arg[MAX_ROIS];
+	ROI* retval=0;
+
+	strcpy(mess,"Could not set/get roi\n");
+
+
+	n = receiveDataOnly(file_des,&nroi,sizeof(nroi));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	if(nroi!=-1){
+		n = receiveDataOnly(file_des,arg,nroi*sizeof(ROI));
+		if (n != (nroi*sizeof(ROI))) {
+			sprintf(mess,"Received wrong number of bytes for ROI\n");
+			ret=FAIL;
+		}
+//#ifdef VERBOSE
+		/*
+		printf("Setting ROI to:");
+		for( i=0;i<nroi;i++)
+			printf("%d\t%d\t%d\t%d\n",arg[i].xmin,arg[i].xmax,arg[i].ymin,arg[i].ymax);
+*/
+
+		printf("Error: Function 41 or Setting ROI is not yet implemented in Moench!\n");
+//#endif
+	}
+	/* execute action if the arguments correctly arrived*/
+
+
+	ret = FAIL;
+	/* NOT IMPLEMENTED
+#ifdef MCB_FUNCS
+	if (lockStatus==1 && differentClients==1){//necessary???
+		sprintf(mess,"Detector locked by %s\n", lastClientIP);
+		ret=FAIL;
+	}
+	else{
+		retval=setROI(nroi,arg,&retvalsize,&ret);
+
+		if (ret==FAIL){
+			printf("mess:%s\n",mess);
+			sprintf(mess,"Could not set all roi, should have set %d rois, but only set %d rois\n",nroi,retvalsize);
+		}
+	}
+
+#endif
+*/
+	if(ret==OK && differentClients){
+		printf("Force update\n");
+		ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if(ret==FAIL)
+		n = sendDataOnly(file_des,mess,sizeof(mess));
+	else{
+		sendDataOnly(file_des,&retvalsize,sizeof(retvalsize));
+		sendDataOnly(file_des,retval,retvalsize*sizeof(ROI));
+	}
+	/*return ok/fail*/
+	return ret;
+}
+
+int get_roi(int file_des) {
+
+
+  return FAIL;
+}
+
+int set_speed(int file_des) {
+
+  enum speedVariable arg;
+  int val,n;
+  int ret=OK;
+  int retval;
+  
+  n=receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+  n=receiveDataOnly(file_des,&val,sizeof(val));
+   if (n < 0) {
+     sprintf(mess,"Error reading from socket\n");
+     ret=FAIL;
+   }
+  
+  
+  
+  if (ret==OK) {
+
+    if (val>=0) {
+      if (differentClients==1 && lockStatus==1 && val>=0) {
+	ret=FAIL;
+	sprintf(mess,"Detector locked by %s\n",lastClientIP);
+      }  else {
+	switch (arg) {
+	case CLOCK_DIVIDER:
+	  retval=setClockDivider(val);
+	  break;
+
+	case PHASE_SHIFT:
+	  retval=phaseStep(val);
+	  break;
+
+	case OVERSAMPLING:
+	  retval=setOversampling(val);
+	  break;
+
+	default:
+	  ret=FAIL;
+	  sprintf(mess,"Unknown speed parameter %d",arg);
+	}
+      }
+    }
+
+
+    switch (arg) {
+    case CLOCK_DIVIDER:
+      retval=getClockDivider();
+      break;
+
+    case PHASE_SHIFT:
+      retval=phaseStep(-1);
+      break;
+
+	case OVERSAMPLING:
+	  retval=setOversampling(-1);
+	  break;
+
+    default:
+      ret=FAIL;
+      sprintf(mess,"Unknown speed parameter %d",arg);
+    }
+  }
+
+  
+
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+  return ret; 
+}
+
+
+
+int set_readout_flags(int file_des) {
+
+  enum readOutFlags arg;
+  int n;
+  int ret=FAIL;
+  
+
+  receiveDataOnly(file_des,&arg,sizeof(arg));
+
+  sprintf(mess,"can't set readout flags for moench\n");
+  
+  sendDataOnly(file_des,&ret,sizeof(ret));
+  sendDataOnly(file_des,mess,sizeof(mess));
+
+  return ret; 
+}
+
+
+
+
+
+int execute_trimming(int file_des) {
+ 
+  int arg[3];
+  int ret=FAIL;
+  enum trimMode mode;
+  
+  sprintf(mess,"can't set execute trimming for moench\n");
+  
+  receiveDataOnly(file_des,&mode,sizeof(mode));
+  receiveDataOnly(file_des,arg,sizeof(arg));
+
+
+  sendDataOnly(file_des,&ret,sizeof(ret));
+  sendDataOnly(file_des,mess,sizeof(mess));
+
+  return ret; 
+}
+
+
+int lock_server(int file_des) {
+
+  
+  int n;
+  int ret=OK;
+
+  int lock;
+  n = receiveDataOnly(file_des,&lock,sizeof(lock));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    printf("Error reading from socket (lock)\n");
+    ret=FAIL;
+  }
+  if (lock>=0) {
+    if (lockStatus==0 || strcmp(lastClientIP,thisClientIP)==0 || strcmp(lastClientIP,"none")==0)
+      lockStatus=lock;
+    else {
+      ret=FAIL;
+      sprintf(mess,"Server already locked by %s\n", lastClientIP);
+    }
+  }
+ if (differentClients && ret==OK)
+   ret=FORCE_UPDATE;
+  
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  }  else
+    n = sendDataOnly(file_des,&lockStatus,sizeof(lockStatus));
+  
+  return ret;
+
+}
+
+int set_port(int file_des) {
+	int n;
+	int ret=OK;
+	int sd=-1;
+
+	enum portType p_type; /** data? control? stop? Unused! */
+	int p_number; /** new port number */
+
+	n = receiveDataOnly(file_des,&p_type,sizeof(p_type));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		printf("Error reading from socket (ptype)\n");
+		ret=FAIL;
+	}
+
+	n = receiveDataOnly(file_des,&p_number,sizeof(p_number));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		printf("Error reading from socket (pnum)\n");
+		ret=FAIL;
+	}
+	if (differentClients==1 && lockStatus==1 ) {
+		ret=FAIL;
+		sprintf(mess,"Detector locked by %s\n",lastClientIP);
+	}  else {
+		if (p_number<1024) {
+			sprintf(mess,"Too low port number %d\n", p_number);
+			printf("\n");
+			ret=FAIL;
+		}
+
+		printf("set port %d to %d\n",p_type, p_number);
+
+		sd=bindSocket(p_number);
+	}
+	if (sd>=0) {
+		ret=OK;
+		if (differentClients )
+			ret=FORCE_UPDATE;
+	} else {
+		ret=FAIL;
+		sprintf(mess,"Could not bind port %d\n", p_number);
+		printf("Could not bind port %d\n", p_number);
+		if (sd==-10) {
+			sprintf(mess,"Port %d already set\n", p_number);
+			printf("Port %d already set\n", p_number);
+
+		}
+	}
+
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret==FAIL) {
+		n = sendDataOnly(file_des,mess,sizeof(mess));
+	} else {
+		n = sendDataOnly(file_des,&p_number,sizeof(p_number));
+		closeConnection(file_des);
+		exitServer(sockfd);
+		sockfd=sd;
+
+	}
+
+	return ret;
+
+}
+
+int get_last_client_ip(int file_des) {
+  int ret=OK;
+  int n;
+ if (differentClients )
+   ret=FORCE_UPDATE;
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  n = sendDataOnly(file_des,lastClientIP,sizeof(lastClientIP));
+  
+  return ret;
+
+}
+
+
+int send_update(int file_des) {
+
+  int ret=OK;
+  enum detectorSettings t;
+  int n;//int thr, n;
+  //int it;
+  int64_t retval, tns=-1;
+  n = sendDataOnly(file_des,lastClientIP,sizeof(lastClientIP));
+  n = sendDataOnly(file_des,&nModX,sizeof(nModX));
+  n = sendDataOnly(file_des,&nModY,sizeof(nModY));
+  n = sendDataOnly(file_des,&dynamicRange,sizeof(dynamicRange));
+  n = sendDataOnly(file_des,&dataBytes,sizeof(dataBytes));
+  t=setSettings(GET_SETTINGS,-1);
+  n = sendDataOnly(file_des,&t,sizeof(t));
+/*  thr=getThresholdEnergy();
+  n = sendDataOnly(file_des,&thr,sizeof(thr));*/
+  retval=setFrames(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+  retval=setExposureTime(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+  retval=setPeriod(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+  retval=setDelay(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+  retval=setGates(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+/*  retval=setProbes(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));*/
+  retval=setTrains(tns);
+  n = sendDataOnly(file_des,&retval,sizeof(int64_t));
+
+  if (lockStatus==0) {
+    strcpy(lastClientIP,thisClientIP);
+  }
+
+  return ret;
+  
+
+}
+int update_client(int file_des) {
+
+  int ret=OK;
+
+  sendDataOnly(file_des,&ret,sizeof(ret));
+  return send_update(file_des);
+  
+  
+
+}
+
+
+int configure_mac(int file_des) {
+
+	int ret=OK;
+	char arg[5][50];
+	int n;
+
+	int imod=0;//should be in future sent from client as -1, arg[2]
+	int ipad;
+	long long int imacadd;
+	long long int idetectormacadd;
+	int udpport;
+	int detipad;
+	int retval=-100;
+
+	sprintf(mess,"Can't configure MAC\n");
+
+
+	n = receiveDataOnly(file_des,arg,sizeof(arg));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	sscanf(arg[0], "%x", 		&ipad);
+	sscanf(arg[1], "%llx", 	&imacadd);
+	sscanf(arg[2], "%x", 		&udpport);
+	sscanf(arg[3], "%llx",	&idetectormacadd);
+	sscanf(arg[4], "%x",		&detipad);
+
+#ifdef VERBOSE
+	int i;
+	printf("\ndigital_test_bit in server %d\t",digitalTestBit);
+	printf("\nipadd %x\t",ipad);
+	printf("destination ip is %d.%d.%d.%d = 0x%x \n",(ipad>>24)&0xff,(ipad>>16)&0xff,(ipad>>8)&0xff,(ipad)&0xff,ipad);
+	printf("macad:%llx\n",imacadd);
+	for (i=0;i<6;i++)
+		printf("mac adress %d is 0x%x \n",6-i,(unsigned int)(((imacadd>>(8*i))&0xFF)));
+	printf("udp port:0x%x\n",udpport);
+	printf("detector macad:%llx\n",idetectormacadd);
+	for (i=0;i<6;i++)
+		printf("detector mac adress %d is 0x%x \n",6-i,(unsigned int)(((idetectormacadd>>(8*i))&0xFF)));
+	printf("detipad %x\n",detipad);
+	printf("\n");
+#endif
+
+
+
+	if (imod>=getNModBoard())
+		ret=FAIL;
+	if (imod<0)
+		imod=ALLMOD;
+
+	//#ifdef VERBOSE
+	printf("Configuring MAC of module %d at port %x\n", imod, udpport);
+	//#endif
+#ifdef MCB_FUNCS
+	if (ret==OK){
+		if(runBusy()){
+			ret=stopStateMachine();
+			if(ret==FAIL)
+				strcpy(mess,"could not stop detector acquisition to configure mac");
+		}
+
+		if(ret==OK)
+			configureMAC(ipad,imacadd,idetectormacadd,detipad,digitalTestBit,udpport);
+		retval=getAdcConfigured();
+	}
+#endif
+	if (ret==FAIL)
+		printf("configuring MAC of mod %d failed\n", imod);
+	else
+		printf("Configuremac successful of mod %d and adc %d\n",imod,retval);
+
+	if (differentClients)
+		ret=FORCE_UPDATE;
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret==FAIL)
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	else
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+	/*return ok/fail*/
+	return ret;
+
+}
+
+
+
+int load_image(int file_des) {
+	int retval;
+	int ret=OK;
+	int n;
+	enum imageType index;
+	short int ImageVals[NCHAN*NCHIP];
+
+	sprintf(mess,"Loading image failed\n");
+
+	n = receiveDataOnly(file_des,&index,sizeof(index));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	n = receiveDataOnly(file_des,ImageVals,dataBytes);
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	switch (index) {
+	case DARK_IMAGE :
+#ifdef VERBOSE
+		printf("Loading Dark image\n");
+#endif
+		break;
+	case GAIN_IMAGE :
+#ifdef VERBOSE
+		printf("Loading Gain image\n");
+#endif
+		break;
+	default:
+		printf("Unknown index %d\n",index);
+		sprintf(mess,"Unknown index %d\n",index);
+		ret=FAIL;
+	    break;
+	}
+
+	if (ret==OK) {
+		if (differentClients==1 && lockStatus==1) {
+			ret=FAIL;
+			sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		} else{
+			retval=loadImage(index,ImageVals);
+			if (retval==-1)
+				ret = FAIL;
+		}
+	}
+
+	if(ret==OK){
+		if (differentClients)
+			ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+	/*return ok/fail*/
+	return ret;
+}
+
+
+
+int set_master(int file_des) {
+
+  enum masterFlags retval=GET_MASTER;
+  enum masterFlags arg;
+  int n;
+  int ret=OK;
+  // int regret=OK;
+
+
+  sprintf(mess,"can't set master flags\n");
+
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+
+
+#ifdef VERBOSE
+  printf("setting master flags  to %d\n",arg);
+#endif
+
+  if (differentClients==1 && lockStatus==1 && arg!=GET_READOUT_FLAGS) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);
+  }  else {
+    retval=setMaster(arg);
+
+  }
+  if (retval==GET_MASTER) {
+    ret=FAIL;
+  }
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+  return ret;
+}
+
+
+
+
+
+
+int set_synchronization(int file_des) {
+
+  enum synchronizationMode retval=GET_MASTER;
+  enum synchronizationMode arg;
+  int n;
+  int ret=OK;
+  //int regret=OK;
+
+
+  sprintf(mess,"can't set synchronization mode\n");
+
+
+  n = receiveDataOnly(file_des,&arg,sizeof(arg));
+  if (n < 0) {
+    sprintf(mess,"Error reading from socket\n");
+    ret=FAIL;
+  }
+#ifdef VERBOSE
+  printf("setting master flags  to %d\n",arg);
+#endif
+
+  if (differentClients==1 && lockStatus==1 && arg!=GET_READOUT_FLAGS) {
+    ret=FAIL;
+    sprintf(mess,"Detector locked by %s\n",lastClientIP);
+  }  else {
+    //ret=setStoreInRAM(0);
+    // initChipWithProbes(0,0,0, ALLMOD);
+    retval=setSynchronization(arg);
+  }
+  if (retval==GET_SYNCHRONIZATION_MODE) {
+    ret=FAIL;
+  }
+  n = sendDataOnly(file_des,&ret,sizeof(ret));
+  if (ret==FAIL) {
+    n = sendDataOnly(file_des,mess,sizeof(mess));
+  } else {
+    n = sendDataOnly(file_des,&retval,sizeof(retval));
+  }
+  return ret;
+}
+
+
+
+
+
+
+int read_counter_block(int file_des) {
+
+	int ret=OK;
+	int n;
+	int startACQ;
+	//char *retval=NULL;
+	short int CounterVals[NCHAN*NCHIP];
+
+	sprintf(mess,"Read counter block failed\n");
+
+	n = receiveDataOnly(file_des,&startACQ,sizeof(startACQ));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	if (ret==OK) {
+		if (differentClients==1 && lockStatus==1) {
+			ret=FAIL;
+			sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		} else{
+			ret=readCounterBlock(startACQ,CounterVals);
+#ifdef VERBOSE
+			int i;
+			for(i=0;i<6;i++)
+				printf("%d:%d\t",i,CounterVals[i]);
+#endif
+		}
+	}
+
+	if(ret!=FAIL){
+		if (differentClients)
+			ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret!=FAIL) {
+		/* send return argument */
+		n += sendDataOnly(file_des,CounterVals,dataBytes);//1280*2
+	} else {
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	}
+
+	/*return ok/fail*/
+	return ret;
+}
+
+
+
+
+
+int reset_counter_block(int file_des) {
+
+	int ret=OK;
+	int n;
+	int startACQ;
+
+	sprintf(mess,"Reset counter block failed\n");
+
+	n = receiveDataOnly(file_des,&startACQ,sizeof(startACQ));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	if (ret==OK) {
+		if (differentClients==1 && lockStatus==1) {
+			ret=FAIL;
+			sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		} else
+			ret=resetCounterBlock(startACQ);
+	}
+
+	if(ret==OK){
+		if (differentClients)
+			ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret==FAIL)
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+
+	/*return ok/fail*/
+	return ret;
+}
+
+
+
+
+
+
+int start_receiver(int file_des) {
+	int ret=OK;
+	int n=0;
+	strcpy(mess,"Could not start receiver\n");
+
+	/* execute action if the arguments correctly arrived*/
+#ifdef MCB_FUNCS
+	if (lockStatus==1 && differentClients==1){//necessary???
+		sprintf(mess,"Detector locked by %s\n", lastClientIP);
+		ret=FAIL;
+	}
+	else
+		ret = startReceiver(1);
+
+#endif
+
+
+	if(ret==OK && differentClients){
+		printf("Force update\n");
+		ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if(ret==FAIL)
+		n = sendDataOnly(file_des,mess,sizeof(mess));
+	/*return ok/fail*/
+	return ret;
+}
+
+
+
+
+
+
+int stop_receiver(int file_des) {
+	int ret=OK;
+	int n=0;
+
+	strcpy(mess,"Could not stop receiver\n");
+
+	/* execute action if the arguments correctly arrived*/
+#ifdef MCB_FUNCS
+	if (lockStatus==1 && differentClients==1){//necessary???
+		sprintf(mess,"Detector locked by %s\n", lastClientIP);
+		ret=FAIL;
+	}
+	else
+		ret=startReceiver(0);
+
+#endif
+
+
+	if(ret==OK && differentClients){
+		printf("Force update\n");
+		ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if(ret==FAIL)
+		n = sendDataOnly(file_des,mess,sizeof(mess));
+	/*return ok/fail*/
+	return ret;
+}
+
+
+
+
+
+int calibrate_pedestal(int file_des){
+
+	int ret=OK;
+	int retval=-1;
+	int n;
+	int frames;
+
+	sprintf(mess,"Could not calibrate pedestal\n");
+
+	n = receiveDataOnly(file_des,&frames,sizeof(frames));
+	if (n < 0) {
+		sprintf(mess,"Error reading from socket\n");
+		ret=FAIL;
+	}
+
+	if (ret==OK) {
+		if (differentClients==1 && lockStatus==1) {
+			ret=FAIL;
+			sprintf(mess,"Detector locked by %s\n",lastClientIP);
+		} else
+			ret=calibratePedestal(frames);
+	}
+
+	if(ret==OK){
+		if (differentClients)
+			ret=FORCE_UPDATE;
+	}
+
+	/* send answer */
+	/* send OK/failed */
+	n = sendDataOnly(file_des,&ret,sizeof(ret));
+	if (ret==FAIL)
+		n += sendDataOnly(file_des,mess,sizeof(mess));
+	else
+		n += sendDataOnly(file_des,&retval,sizeof(retval));
+
+	/*return ok/fail*/
+	return ret;
+}
+
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.h
new file mode 100755
index 000000000..5e371278a
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/server_funcs.h
@@ -0,0 +1,97 @@
+#ifndef SERVER_FUNCS_H
+#define SERVER_FUNCS_H
+
+
+#include "sls_detector_defs.h"
+
+
+#include <stdio.h>
+/*
+#include <sys/types.h> 
+#include <sys/socket.h>
+#include <netinet/in.h>
+*/
+#include "communication_funcs.h"
+
+
+
+
+#define GOODBYE -200
+
+int sockfd;
+
+int function_table();
+
+int decode_function(int);
+int init_detector(int,int);
+
+int M_nofunc(int);
+int exit_server(int);
+
+
+
+
+// General purpose functions
+int get_detector_type(int);
+int set_number_of_modules(int);
+int get_max_number_of_modules(int);
+
+
+int exec_command(int);
+int set_external_signal_flag(int);
+int set_external_communication_mode(int);
+int get_id(int);
+int digital_test(int);
+int write_register(int);
+int read_register(int);
+int set_dac(int);
+int get_adc(int);
+int set_channel(int);
+int set_chip(int);
+int set_module(int);
+int get_channel(int);
+int get_chip(int);
+int get_module(int);
+
+int get_threshold_energy(int); 
+int set_threshold_energy(int);  
+int set_settings(int);
+int start_acquisition(int);
+int stop_acquisition(int);
+int start_readout(int);
+int get_run_status(int);
+int read_frame(int);
+int read_all(int);
+int start_and_read_all(int);
+int set_timer(int);
+int get_time_left(int);
+int set_dynamic_range(int);
+int set_roi(int);
+int get_roi(int);
+int set_speed(int);
+void prepareADC(void);
+int set_readout_flags(int);
+int execute_trimming(int);
+int lock_server(int);
+int set_port(int);
+int get_last_client_ip(int);
+int set_master(int);
+int set_synchronization(int);
+
+int update_client(int);
+int send_update(int);
+int configure_mac(int);
+
+int load_image(int);
+int read_counter_block(int);
+int reset_counter_block(int);
+
+int start_receiver(int);
+int stop_receiver(int);
+
+
+int calibrate_pedestal(int);
+
+int set_roi(int);
+
+#endif
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.c b/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.c
new file mode 100755
index 000000000..4504cfe05
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.c
@@ -0,0 +1,39 @@
+#include "sharedmemory.h"
+
+struct statusdata *stdata;
+
+int inism(int clsv) {
+
+static int scansmid;
+
+    if (clsv==SMSV) {
+	if ( (scansmid=shmget(SMKEY,1024,IPC_CREAT | 0666 ))==-1 ) {
+	    return -1;
+	}
+	if ( (stdata=shmat(scansmid,NULL,0))==(void*)-1) {
+	    return -2;
+	}
+    }
+
+    if (clsv==SMCL) {
+	if ( (scansmid=shmget(SMKEY,0,0) )==-1 ) {
+	    return -3;
+	}
+	if ( (stdata=shmat(scansmid,NULL,0))==(void*)-1) {
+	    return -4;
+	}
+    }
+    return 1;
+}
+
+void write_status_sm(char *status) {
+  strcpy(stdata->status,status);
+}
+
+void write_stop_sm(int v) {
+  stdata->stop=v;
+}
+
+void write_runnumber_sm(int v) {
+  stdata->runnumber=v;
+}
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.h b/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.h
new file mode 100755
index 000000000..bdbddf719
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sharedmemory.h
@@ -0,0 +1,48 @@
+#ifndef SM
+#define SM
+
+#include "sls_detector_defs.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <unistd.h>
+//#include <asm/page.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+
+#include <sys/shm.h>
+
+#include <sys/ipc.h>
+#include <sys/stat.h>
+
+/* key for shared memory */
+#define SMKEY 10001
+
+#define SMSV 1
+#define SMCL 2
+
+
+struct statusdata {
+  int runnumber;
+  int stop;
+  char status[20];
+} ;
+
+
+/* for shared memory */
+
+int inism(int clsv);
+void write_status_sm(char *status);
+void write_stop_sm(int v);
+void write_runnumber_sm(int v);
+
+#endif
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_defs.h b/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_defs.h
new file mode 120000
index 000000000..c5062e03f
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_defs.h
@@ -0,0 +1 @@
+../commonFiles/sls_detector_defs.h
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_funcs.h
new file mode 120000
index 000000000..844b67129
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sls_detector_funcs.h
@@ -0,0 +1 @@
+../commonFiles/sls_detector_funcs.h
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_defs.h b/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_defs.h
new file mode 120000
index 000000000..a07bf98e7
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_defs.h
@@ -0,0 +1 @@
+../../slsReceiverSoftware/includes/sls_receiver_defs.h
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_funcs.h
new file mode 120000
index 000000000..67df52bf4
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/sls_receiver_funcs.h
@@ -0,0 +1 @@
+../../slsReceiverSoftware/includes/sls_receiver_funcs.h
\ No newline at end of file
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/stop_server.c b/slsDetectorSoftware/jungfrauDetectorServer/stop_server.c
new file mode 100755
index 000000000..e3c8ff7e1
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/stop_server.c
@@ -0,0 +1,46 @@
+/* A simple server in the internet domain using TCP
+   The port number is passed as an argument */
+
+
+#include "sls_detector_defs.h"
+
+
+#include "communication_funcs.h"
+#include "firmware_funcs.h"
+
+
+int sockfd;
+
+int main(int argc, char *argv[])
+{
+  int  portno;
+  int retval=0;
+
+  portno = DEFAULT_PORTNO;
+
+
+  bindSocket(portno);
+  if (getServerError())
+    return -1;
+
+
+
+  /* waits for connection */
+  while(retval!=GOODBYE) {
+#ifdef VERBOSE
+    printf("\n");
+#endif
+#ifdef VERY_VERBOSE
+    printf("Stop server: waiting for client call\n");
+#endif
+    acceptConnection();
+    retval=stopStateMachine();
+    closeConnection();
+  }
+
+  exitServer();
+  printf("Goodbye!\n");
+
+  return 0; 
+}
+
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.c b/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.c
new file mode 100755
index 000000000..9a28b9b4a
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.c
@@ -0,0 +1,749 @@
+#ifndef PICASSOD
+#include "server_defs.h"
+#else
+#include "picasso_defs.h"
+#endif
+#include "trimming_funcs.h"
+#include "mcb_funcs.h"
+#include "firmware_funcs.h"
+#include <math.h>
+
+
+
+extern int nModX;
+//extern int *values;
+
+extern const int nChans;
+extern const int nChips;
+extern const int nDacs;
+extern const int nAdcs;
+
+
+int trim_fixed_settings(int countlim, int par2, int im)
+{
+
+  int retval=OK;
+#ifdef VERBOSE
+  printf("Trimming with fixed settings\n");
+#endif
+#ifdef VIRTUAL
+  return OK;
+#endif
+
+  if (par2<=0)
+    retval=trim_with_level(countlim, im);
+  else
+    retval=trim_with_median(countlim,im);
+
+
+  return retval;
+}
+
+
+int trim_with_noise(int countlim, int nsigma, int im)
+{
+
+
+  int retval=OK, retval1=OK, retval2=OK;
+#ifdef VERBOSE
+  printf("Trimming using noise\n");
+#endif
+#ifdef VIRTUAL
+  return OK;
+#endif
+
+  /* threshold scan */
+
+#ifdef VERBOSE
+  printf("chosing vthresh and vtrim.....");
+#endif
+  retval1=choose_vthresh_and_vtrim(countlim,nsigma, im);
+ 
+#ifdef VERBOSE
+  printf("trimming with noise.....\n");
+#endif
+  retval2=trim_with_level(countlim, im);
+  
+#ifdef DEBUGOUT
+  printf("done\n");
+#endif
+  if (retval1==OK && retval2==OK)
+    retval=OK;
+  else
+    retval=FAIL;
+
+  return retval;
+
+}
+
+int trim_with_beam(int countlim, int nsigma, int im) //rpc
+{
+
+
+  int retval=OK, retval1=OK, retval2=OK;
+
+  printf("Trimming using beam\n");
+  //return OK;
+#ifdef VIRTUAL
+  printf("Trimming using beam\n");
+  return OK;
+#endif
+  /* threshold scan */
+#ifdef DEBUGOUT
+  printf("chosing vthresh and vtrim.....");
+#endif
+  
+  retval1=choose_vthresh_and_vtrim(countlim,nsigma,im);
+  retval2=trim_with_median(TRIM_DR, im);
+
+#ifdef DEBUGOUT
+    printf("done\n");
+#endif
+
+  if (retval1==OK && retval2==OK)
+    retval=OK;
+  else
+    retval=FAIL;
+
+  return retval;
+
+}
+
+
+int  trim_improve(int maxit, int par2, int im) //rpc
+{
+
+  int retval=OK, retval1=OK, retval2=OK;
+
+
+#ifdef VERBOSE
+  printf("Improve the trimming\n");
+#endif
+#ifdef VIRTUAL
+  return OK;
+#endif
+ 
+
+  if (par2!=0 && im==ALLMOD)
+    retval1=choose_vthresh();
+
+  retval2=trim_with_median(2*maxit+1, im);
+#ifdef DEBUGOUT
+    printf("done\n");
+#endif
+  if (retval1==OK && retval2==OK)
+    retval=OK;
+  else
+    retval=FAIL;
+
+  return retval;
+
+}
+
+int calcthr_from_vcal(int vcal) {
+  int thrmin;
+  //thrmin=140+3*vcal/5;
+  thrmin=180+3*vcal/5;
+  return thrmin;
+}
+
+int calccal_from_vthr(int vthr) {
+  int vcal;
+  vcal=5*(vthr-140)/3;
+  return vcal;
+}
+
+int choose_vthresh_and_vtrim(int countlim,  int nsigma, int im) {
+  int retval=OK;
+#ifdef MCB_FUNCS
+  int modma, modmi, nm;
+  int thr, thrstep=5, nthr=31;
+
+  int *fifodata;
+
+  double vthreshmean, vthreshSTDev;
+  int *thrmi, *thrma;
+  double c;
+  double b=BVTRIM;
+  double a=AVTRIM;
+  int *trim;
+  int ich, imod, ichan;
+  int nvalid=0;
+  u_int32_t *scan;
+  int ithr;
+  sls_detector_channel myChan;
+
+
+
+  setFrames(1);
+  // setNMod(getNModBoard());
+
+  if (im==ALLMOD){
+    modmi=0;
+    modma=nModX;
+  } else {
+    modmi=im;
+    modma=im+1;
+  } 
+  nm=modma-modmi;
+  
+  trim=malloc(sizeof(int)*nChans*nChips*nModX);
+  thrmi=malloc(sizeof(int)*nModX);
+  thrma=malloc(sizeof(int)*nModX);
+
+
+  for (ich=0; ich<nChans*nChips*nm; ich++)
+    trim[ich]=-1;
+  /*
+  setCSregister(im);
+  setSSregister(im);
+  initChannel(0,0,0,1,0,0,im);
+  counterClear(im);
+  clearSSregister(im); 
+  usleep(500); 
+  */
+  myChan.chan=-1;
+  myChan.chip=-1;
+  myChan.module=ALLMOD;
+  myChan.reg=COMPARATOR_ENABLE;
+  initChannelbyNumber(myChan);
+
+
+  for (ithr=0; ithr<nthr; ithr++) {
+    fifoReset();
+    /* scanning threshold */
+    for (imod=modmi; imod<modma; imod++) {
+      //commented out by dhanya      thr=getDACbyIndexDACU(VTHRESH,imod);
+      if (ithr==0) {
+	thrmi[imod]=thr;
+//commented out by dhanya  	initDACbyIndexDACU(VTHRESH,thr,imod);
+      } else
+	;//commented out by dhanya  	initDACbyIndexDACU(VTHRESH,thr+thrstep,imod);
+    } 
+
+    /*    setCSregister(ALLMOD);
+    setSSregister(ALLMOD);
+    initChannel(0,0,0,1,0,0,im);
+    setDynamicRange(32);
+    */
+
+
+
+    counterClear(ALLMOD);
+    clearSSregister(ALLMOD); 
+    usleep(500); 
+    startStateMachine();
+    while (runBusy()) {
+    }
+    usleep(500);
+    fifodata=fifo_read_event();
+    scan=decode_data(fifodata);
+    for (imod=modmi; imod<modma; imod++) {
+      for (ichan=0; ichan<nChans*nChips; ichan++){
+	ich=imod*nChips*nChans+ichan;
+	if (scan[ich]>countlim && trim[ich]==-1) {
+//commented out by dhanya  	  trim[ich]=getDACbyIndexDACU(VTHRESH,imod);
+#ifdef VERBOSE
+	  //	  printf("yes: %d %d %d\n",ich,ithr,scan[ich]);
+#endif
+	} 
+#ifdef VERBOSE
+	/*	else {
+	  printf("no: %d %d %d\n",ich,ithr,scan[ich]);
+	  }*/
+#endif
+      }
+    }
+    free(scan);
+  }
+  
+  for (imod=modmi; imod<modma; imod++) {
+    vthreshmean=0;
+    vthreshSTDev=0;
+    nvalid=0;
+//commented out by dhanya      thrma[imod]=getDACbyIndexDACU(VTHRESH,imod);
+    
+    for (ichan=0; ichan<nChans*nChips; ichan++){
+      ich=imod*nChans*nChips+ichan;
+      if(trim[ich]>thrmi[imod] && trim[ich]<thrma[imod]) {
+	vthreshmean=vthreshmean+trim[ich];
+	vthreshSTDev=vthreshSTDev+trim[ich]*trim[ich];
+	nvalid++;
+      }	
+    }
+      
+    if (nvalid>0) {
+      vthreshmean=vthreshmean/nvalid;
+  //commented out by dhanya      vthreshSTDev=sqrt((vthreshSTDev/nvalid)-vthreshmean*vthreshmean);
+    } else {
+      vthreshmean=thrmi[imod];
+      vthreshSTDev=nthr*thrstep;
+      printf("No valid channel for module %d\n",imod);
+      retval=FAIL;
+    }
+
+#ifdef DEBUGOUT
+    printf("module= %d nvalid = %d mean=%f RMS=%f\n",imod, nvalid, vthreshmean,vthreshSTDev);
+#endif
+    // *vthresh=round(vthreshmean-nsigma*vthreshSTDev);
+    thr=(int)(vthreshmean-nsigma*vthreshSTDev);
+    if (thr<0 || thr>(DAC_DR-1)) {
+      thr=thrmi[imod]/2;
+      printf("Can't find correct threshold for module %d\n",imod);
+      retval=FAIL;
+    }
+//commented out by dhanya      initDACbyIndexDACU(VTHRESH,thr,imod);
+#ifdef VERBOSE
+    printf("vthresh=%d  \n",thr);
+#endif 
+    c=CVTRIM-2.*nsigma*vthreshSTDev/63.;
+ //commented out by dhanya     thr=(int)((-b-sqrt(b*b-4*a*c))/(2*a));
+    if (thr<500 || thr>(DAC_DR-1)) {
+      thr=750;
+      printf("Can't find correct trimbit size for module %d\n",imod);
+      retval=FAIL;
+    }
+      
+    //commented out by dhanya    initDACbyIndexDACU(VTRIM,thr,imod);
+    
+#ifdef VERBOSE
+    printf("vtrim=%d  \n",thr);
+#endif 
+
+  }
+  free(trim);
+  free(thrmi);
+  free(thrma);
+
+#endif
+  return retval;
+}
+
+
+
+
+
+int trim_with_level(int countlim, int im) {
+  int ich, itrim, ichan, ichip, imod;
+  u_int32_t *scan;
+  int *inttrim;
+  int modma, modmi, nm;
+  int retval=OK;
+  int *fifodata;
+  sls_detector_channel myChan;
+  printf("trimming module number %d", im);
+
+
+#ifdef MCB_FUNCS
+  setFrames(1);
+  // setNMod(getNModBoard());
+
+  if (im==ALLMOD){
+    modmi=0;
+    modma=nModX;
+  } else {
+    modmi=im;
+    modma=im+1;
+  } 
+  nm=modma-modmi;
+  
+  inttrim=malloc(sizeof(int)*nChips*nChans*nModX);
+  printf("countlim=%d\n",countlim);
+  for (ich=0; ich<nChans*nChips*nModX; ich++) 
+    inttrim[ich]=-1;
+
+  for (itrim=0; itrim<TRIM_DR+1; itrim++) { 
+    fifoReset(); 
+    printf("Trimbit %d\n",itrim);  
+    myChan.chan=-1;
+    myChan.chip=-1;
+    myChan.module=ALLMOD;
+    myChan.reg=COMPARATOR_ENABLE|(itrim<<TRIMBIT_OFF);
+    initChannelbyNumber(myChan);
+
+    /*
+      setCSregister(im); 
+      setSSregister(im);
+      initChannel(itrim,0,0,1,0,0,ALLMOD);
+      setDynamicRange(32);
+    */
+    setCSregister(ALLMOD); 
+    setSSregister(ALLMOD);
+    counterClear(ALLMOD);
+    clearSSregister(ALLMOD); 
+    usleep(500);
+    startStateMachine();
+    while (runBusy()) {
+    }
+    usleep(500);
+
+    fifodata=fifo_read_event();
+    scan=decode_data(fifodata);
+    for (imod=modmi; imod<modma; imod++) {
+      for (ichan=0; ichan<nChans*nChips; ichan++) {
+	ich=ichan+imod*nChans*nChips;
+	if (inttrim[ich]==-1) {
+	  if (scan[ich]>countlim){
+	    inttrim[ich]=itrim;
+	    if (scan[ich]>2*countlim && itrim>0) {
+	    //if (scan[ich]>2*countlim || itrim==0) {
+	      inttrim[ich]=itrim-1;
+	    }
+#ifdef VERBOSE
+	      printf("Channel %d trimbit %d counted %d (%08x) countlim %d\n",ich,itrim,scan[ich],fifodata[ich],countlim);
+#endif
+	  } 
+	}
+#ifdef VERBOSE
+	/*	  else  
+	  printf("Channel %d trimbit %d counted %d countlim %d\n",ich,itrim,scan[ich],countlim);*/
+#endif
+      }
+    }
+    free(scan);
+  }
+
+  for (imod=modmi; imod<modma; imod++) {
+    clearCSregister(imod); 
+    firstChip(im); 
+    for (ichip=0; ichip<nChips; ichip++) {
+      clearSSregister(imod); 
+      for (ichan=0; ichan<nChans; ichan++) {
+	nextStrip(imod);
+	ich=ichan+imod*nChans*nChips+ichip*nChans;
+	if (*(inttrim+ich)==-1) {
+	  *(inttrim+ich)=TRIM_DR;
+	  //	  printf("could not trim channel %d chip %d module %d - set to %d\n", ichan, ichip, imod, *(inttrim+ich) );
+	  retval=FAIL;
+	}
+#ifdef VERBOSE 
+	//	else
+	//  printf("channel %d trimbit %d\n",ich,*(inttrim+ich) );
+#endif
+	initChannel(inttrim[ich],0,0,1,0,0,imod);
+      }
+      nextChip(imod); 
+    }
+  }
+  free(inttrim);
+  
+#endif
+  return retval;
+}
+
+
+#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }
+#define median(a,n) kth_smallest(a,n,(((n)&1)?((n)/2):(((n)/2)-1)))
+
+
+int kth_smallest(int *a, int n, int k)
+{
+    register int i,j,l,m ;
+    register double x ;
+
+    l=0 ; m=n-1 ;
+    while (l<m) {
+        x=a[k] ;
+        i=l ;
+        j=m ;
+        do {
+            while (a[i]<x) i++ ;
+            while (x<a[j]) j-- ;
+            if (i<=j) {
+                ELEM_SWAP(a[i],a[j]) ;
+                i++ ; j-- ;
+            }
+        } while (i<=j) ;
+        if (j<k) l=i ;
+        if (k<i) m=j ;
+    }
+    return a[k] ;
+}
+
+
+
+int ave(int *a, int n)
+{
+  int av=0,i;
+  for (i=0; i<n; i++)
+    av=av+((double)*(a+i))/((double)n);
+  return av;
+}
+
+
+int choose_vthresh() {
+
+  int retval=OK;
+#ifdef MCB_FUNCS
+  int imod,  ichan;
+  u_int32_t  *scan, *scan1;
+  int olddiff[nModX], direction[nModX];
+  int med[nModX], med1[nModX], diff, media;
+  int change_flag=1;
+  int iteration=0;
+  int maxiterations=10;
+  int vthreshmean=0;
+  int vthresh;
+  int im=ALLMOD;
+  int modma, modmi, nm;
+  int *fifodata;
+
+  setFrames(1);
+  // setNMod(getNModBoard());
+
+  if (im==ALLMOD){
+    modmi=0;
+    modma=nModX;
+  } else {
+    modmi=im;
+    modma=im+1;
+  } 
+  nm=modma-modmi;
+  
+
+
+    setDynamicRange(32);
+
+  setCSregister(ALLMOD);
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD);
+  clearSSregister(ALLMOD); 
+  usleep(500); 
+  startStateMachine();
+  while (runBusy()) {
+    //printf(".");
+  }
+  usleep(500);
+  
+    fifodata=fifo_read_event();
+    scan=decode_data(fifodata);
+    //
+    scan1=decode_data(fifodata);
+
+
+  for (imod=modmi; imod<modma; imod++) {
+    //
+    med[imod]=median(scan1+imod*nChans*nChips,nChans*nChips);
+    med1[imod]=med[imod];
+    //commented out by dhanya    vthreshmean=vthreshmean+getDACbyIndexDACU(VTHRESH,imod);
+    olddiff[imod]=0xffffff;
+    direction[imod]=0;
+    printf("Median of module %d=%d\n",imod,med[imod]);
+  }
+  vthreshmean=vthreshmean/nm;
+  //media=median(scan,nChans*nChips*nModX);
+  //printf("Median overall=%d\n",media);
+  media=median(med1+modmi,nm);
+  printf("Median of modules=%d\n",media);
+  free(scan);
+  free(scan1);
+
+
+  while(change_flag && iteration<maxiterations) {
+
+    setDynamicRange(32);
+    fifoReset(); 
+    setCSregister(ALLMOD);
+    setSSregister(ALLMOD);
+    counterClear(ALLMOD);
+    clearSSregister(ALLMOD); 
+    usleep(500); 
+    startStateMachine();
+    while (runBusy()) {
+    }
+    usleep(500);
+
+    fifodata=fifo_read_event();
+    scan=decode_data(fifodata);
+    //
+    scan1=decode_data(fifodata);
+
+    change_flag=0;
+    printf("Vthresh iteration %3d 0f %3d\n",iteration, maxiterations);
+    for (ichan=modmi; ichan<modma; ichan++) {
+      med[ichan]=median(scan1+ichan*nChans*nChips,nChans*nChips);
+      med1[imod]=med[imod];
+      media=median(med1+modmi,nm);
+
+      diff=med[ichan]-media;
+      if (direction[ichan]==0) {
+	if (diff>0) 
+	  direction[ichan]=1;
+	else
+	  direction[ichan]=-1;
+      }
+   //commented out by dhanya     vthresh=getDACbyIndexDACU(VTHRESH,imod);
+      if ( direction[ichan]!=-3) { 
+	if (abs(diff)>abs(olddiff[ichan])) {
+	  vthresh=vthresh-direction[ichan];
+	  if (vthresh>(DAC_DR-1)) {
+	    vthresh=(DAC_DR-1);
+	    printf("can't equalize threshold for module %d\n", ichan);
+	    retval=FAIL;
+	  }
+	  if (vthresh<0) {
+	    vthresh=0;
+	    printf("can't equalize threshold for module %d\n", ichan);
+	    retval=FAIL;
+	  }
+	  direction[ichan]=-3;
+	} else {
+	  vthresh=vthresh+direction[ichan];
+	  olddiff[ichan]=diff;
+	  change_flag=1;
+	}
+//commented out by dhanya  	initDACbyIndex(VTHRESH,vthresh, ichan);
+      }
+    }
+    iteration++;
+    free(scan);
+    free(scan1);
+  }
+#endif
+  return retval;
+}
+
+
+
+
+
+int trim_with_median(int stop, int im) {
+ 
+ 
+  int retval=OK;
+
+#ifdef MCB_FUNCS
+  int  ichan, imod, ichip, ich;
+  u_int32_t  *scan, *scan1;
+  int *olddiff, *direction;
+  int med, diff;
+  int change_flag=1;
+  int iteration=0;
+  int me[nModX], me1[nModX];
+  int modma, modmi, nm;
+  int trim;
+  int *fifodata;
+
+  setFrames(1);
+  // setNMod(getNModBoard());
+
+  if (im==ALLMOD){
+    modmi=0;
+    modma=nModX;
+  } else {
+    modmi=im;
+    modma=im+1;
+  } 
+  nm=modma-modmi;
+
+  olddiff=malloc(4*nModX*nChips*nChans);
+  direction=malloc(4*nModX*nChips*nChans);
+  for (imod=modmi; imod<modma; imod++) {  
+    for (ichip=0; ichip<nChips; ichip++) {
+      for (ich=0; ich<nChans; ich++) {
+	ichan=imod*nChips*nChans+ichip*nChans+ich;
+	direction[ichan]=0;
+	olddiff[ichan]=0x0fffffff;
+      }
+    }
+  }
+  /********
+  fifoReset(); 
+  setCSregister(ALLMOD);
+  setSSregister(ALLMOD);
+  counterClear(ALLMOD);
+  clearSSregister(ALLMOD); 
+  usleep(500); 
+  startStateMachine();
+  while (runBusy()) {
+  }
+  usleep(500);
+  scan=decode_data(fifo_read_event());
+  for (imod=modmi; imod<modma; imod++) {
+    me[imod]=median(scan+imod*nChans*nChips,nChans*nChips);
+    printf("Median of module %d=%d\n",imod,me[imod]);
+  }
+  med=median(me,nm);
+  printf("median is %d\n",med);
+  free(scan);
+  **************/
+  while(change_flag && iteration<stop) {
+
+    setDynamicRange(32);
+    fifoReset(); 
+    setCSregister(ALLMOD);
+    setSSregister(ALLMOD);
+    counterClear(ALLMOD);
+    clearSSregister(ALLMOD); 
+    usleep(500); 
+    startStateMachine();
+    while (runBusy()) {
+    }
+    usleep(500);
+    fifodata=fifo_read_event();
+    scan=decode_data(fifodata);
+    scan1=decode_data(fifodata);
+
+
+
+    /********* calculates median every time ***********/
+
+    for (imod=modmi; imod<modma; imod++) {
+      me[imod]=median(scan1+imod*nChans*nChips,nChans*nChips);
+      me1[imod]=me[imod];
+      printf("Median of module %d=%d\n",imod,me[imod]);
+    }
+    med=median(me1,nm);
+    printf("median is %d\n",med);
+
+    change_flag=0;
+    printf("Trimbits iteration %d of %d\n",iteration, stop);
+    for (imod=modmi; imod<modma; imod++) {
+      for (ichip=0; ichip<nChips; ichip++) {
+	selChip(ichip,imod);
+	clearSSregister(imod);
+	for (ich=0; ich<nChans; ich++) {
+	  ichan=imod*nChips*nChans+ichip*nChans+ich;
+	  nextStrip(imod);
+	  diff=scan[ichan]-me[imod];
+	  if (direction[ichan]==0) {
+	    if (diff>0) {
+	      direction[ichan]=1;
+	    } else {
+	      direction[ichan]=-1;
+	    }
+	  } 
+	  if ( direction[ichan]!=-3) { 
+	    if (abs(diff)>abs(olddiff[ichan])) {
+	      trim=getTrimbit(imod,ichip,ich)+direction[ichan];
+	      printf("%d old diff %d < new diff %d   %d - trimbit %d\n",ichan, olddiff[ichan], diff, direction[ichan], trim);
+	      direction[ichan]=-3;
+	    } else {
+	      trim=getTrimbit(imod,ichip,ich)-direction[ichan];
+	      olddiff[ichan]=diff;
+	      change_flag=1;
+	    }
+	    if (trim>TRIM_DR) {
+	      trim=63;
+	      printf("can't trim channel %d chip %d module %d to trim %d\n",ich, ichip, imod, trim);
+	      retval=FAIL;
+	    }
+	    if (trim<0) {
+	      printf("can't trim channel %d chip %d module %d to trim %d\n",ich, ichip, imod, trim);
+	      trim=0;
+	      retval=FAIL;
+	    }
+	    initChannel(trim,0,0,1,0,0,imod);
+	  }
+	}
+      }
+    }
+    iteration++;
+    free(scan);
+    free(scan1);
+  }
+  free(olddiff);
+  free(direction);
+#endif
+  return retval;
+}
diff --git a/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.h b/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.h
new file mode 100755
index 000000000..42ecea24a
--- /dev/null
+++ b/slsDetectorSoftware/jungfrauDetectorServer/trimming_funcs.h
@@ -0,0 +1,20 @@
+#ifndef TRIMMING_FUNCS_H
+#define TRIMMING_FUNCS_H
+
+#include "sls_detector_defs.h"
+
+int trim_fixed_settings(int countlim, int par2, int imod);
+int trim_with_noise(int countlim, int nsigma, int imod);
+int trim_with_beam(int countlim, int nsigma, int imod);
+int  trim_improve(int maxit, int par2, int imod);
+int calcthr_from_vcal(int vcal);
+int calccal_from_vthr(int vthr);
+int choose_vthresh_and_vtrim(int countlim, int nsigma, int imod);
+
+int choose_vthresh();
+int trim_with_level(int countlim, int imod);
+int trim_with_median(int stop, int imod);
+int calcthr_from_vcal(int vcal);
+int calccal_from_vthr(int vthr);
+
+#endif