Prime Cores V1.0 Freeware

apix_1024

voilà:

Xstreme

Le085 ha scritto:

no 32

lo puoi ricaricare ?

stesso link

stesso zip

ma è aggiornato

thanks

Xstreme

apix_1024 ha scritto:

voilà:

nel limite dello scarso programmatore che sono,

e di certo non al livello di

Franck Delattre / CPU-Z,

mi dici che voci si possono aggiungere o togliere ?

gear667

bonis62 ha scritto:

------------------------------------------------------------------------
abbiate una sana pazienza

http://www.xstreme.it/XSSI5.zip

avrei bisogno di...........beta testing.......grazieeee

questo lo dedico a TOTO

------------------------------------------------------------------------

l'ho provato ma si appena rileva i dati si chiude immediatamente senza il tempo di fare screen o altro

Xstreme

gear667 ha scritto:

l'ho provato ma si appena rileva i dati si chiude immediatamente senza il tempo di fare screen o altro

ok

lancialo dalla shell (cmd.exe) e dimmi che errore ti da....

xp ?

gear667

bonis62 ha scritto:

ok
lancialo dalla shell (cmd.exe) e dimmi che errore ti da....

xp ?

si sono sotto xp 32bit

non so come fare a lanciarlo da shell, se mi puoi spiegare la procedura

Timon85

Spero ti sia ultile per risolvere... Errore dal prompt; xp 32 bit su eeepc

Xstreme

Timon85 ha scritto:

Spero ti sia ultile per risolvere... Errore dal prompt; xp 32 bit su eeepc

ok, grazie, il mio software ha problemi con le periferiche di massa del tuo pc , cd vuoto ? usb key lenta ? hard disk esterno ?

---------------------------------------------------------------------

se vi da errore questa versione provate questa che usa la gui

http://www.xstreme.it/alpha.exe

-----------------------------------------------------------------------

Xstreme

gear667 ha scritto:

si sono sotto xp 32bit
non so come fare a lanciarlo da shell, se mi puoi spiegare la procedura

manu di avvio

esegui

cmd.exe

metti l'exe in

vai alla radice

cd ..

digita xssi5.exe

invio

Timon85

bonis62 ha scritto:

ok, grazie, il mio software ha problemi con le periferiche di massa del tuo pc , cd vuoto ? usb key lenta ? hard disk esterno ?
---------------------------------------------------------------------

se vi da errore questa versione provate questa che usa la gui

http://www.xstreme.it/alpha.exe

-----------------------------------------------------------------------

Ho provato anche a disabilitare tutte le periferiche esterne.. solito errore.

Invece l'altra versione che mi hai consigliato mi da questo tipo di errore:

devo aggiornare il framework??

One1ros

ti interessano i test su notebook?

apix_1024

bonis62 ha scritto:

nel limite dello scarso programmatore che sono,
e di certo non al livello di

Franck Delattre / CPU-Z,

mi dici che voci si possono aggiungere o togliere ?

guarda secondo me se già riuscissi a sistemare il fatto della frequenza del processore e della ram che scala sempre a 200mhz di bus invece del bus reale io direi che vada più che bene. certo se proprio volessi fare lo sborone dovresti tirare fuori anche timings ram e cache varie del processore ma per quello c'è pur sempre cpuz

Xstreme

Timon85 ha scritto:

Ho provato anche a disabilitare tutte le periferiche esterne.. solito errore.
Invece l'altra versione che mi hai consigliato mi da questo tipo di errore:

devo aggiornare il framework??

beh, male non farebbe

Xstreme

apix_1024 ha scritto:

guarda secondo me se già riuscissi a sistemare il fatto della frequenza del processore e della ram che scala sempre a 200mhz di bus invece del bus reale io direi che vada più che bene. certo se proprio volessi fare lo sborone dovresti tirare fuori anche timings ram e cache varie del processore ma per quello c'è pur sempre cpuz

lo scaling ,quello si puo fare facendo dei calcoli adatti, per i timings

delle ram mi devo inventare qualcosa in assembler per leggere gli SPD

dei moduli, è già da un pò che ci penso

Xstreme

One1ros ha scritto:

ti interessano i test su notebook?

si

gear667

bonis62 ha scritto:

manu di avvio
esegui

cmd.exe

metti l'exe in

vai alla radice

cd ..

cd ..

digita xssi5.exe

invio

ecco qui

Xstreme

gear667 ha scritto:

ecco qui

ok ti ringrazio

Totocellux

bonis62 ha scritto:

------------------------------------------------------------------------
abbiate una sana pazienza

http://www.xstreme.it/XSSI5.zip

avrei bisogno di...........beta testing.......grazieeee

questo lo dedico a TOTO

------------------------------------------------------------------------

appena potrò trovare qualche ora libera in santa pace. vedrò di interessarmi a ciò che mi hai chiesto precedentemente

Per ora, grazie del pensiero ed ecco un pò di testing

Windows 7 Ultimate 64bit

direi che sei già ad un discreto punto

a parte l'impreciso riconoscimento del Fattore di Velocità dei moduli e della Massima Velocità di Clock

l'unica lieve anomalia è che non ha completato correttamente la routine di uscita: per far ritornare il controllo al prompt è stato necessario un Ctrl+C.

Per quanto riguarda la versione Alpha (con GUI) dà anche a me lo stesso errore del .NET Framework.

Hai fatto comunque un buon lavoro

Xstreme

apix_1024 ha scritto:

guarda secondo me se già riuscissi a sistemare il fatto della frequenza del processore e della ram che scala sempre a 200mhz di bus invece del bus reale io direi che vada più che bene. certo se proprio volessi fare lo sborone dovresti tirare fuori anche timings ram e cache varie del processore ma per quello c'è pur sempre cpuz

MA TU INTENDEVI UNA COSETTA COSI DA NULLA ? :asd:

/*
* Serial Presence Detect (SPD) memory identification
*/

#include 
#include 
#include 

#include 

/* Encodings of the size used/total byte for certain memory types    */
#define    SPDMEM_SPDSIZE_MASK        0x0F    /* SPD EEPROM Size   */

#define    SPDMEM_SPDLEN_128        0x00    /* SPD EEPROM Sizes  */
#define    SPDMEM_SPDLEN_176        0x10
#define    SPDMEM_SPDLEN_256        0x20
#define    SPDMEM_SPDLEN_MASK        0x70    /* Bits 4 - 6        */

#define    SPDMEM_SPDCRC_116        0x80    /* CRC Bytes covered */
#define    SPDMEM_SPDCRC_125        0x00
#define    SPDMEM_SPDCRC_MASK        0x80    /* Bit 7             */


/* possible values for the memory type */
#define    SPDMEM_MEMTYPE_FPM        0x01
#define    SPDMEM_MEMTYPE_EDO        0x02
#define    SPDMEM_MEMTYPE_PIPE_NIBBLE    0x03
#define    SPDMEM_MEMTYPE_SDRAM        0x04
#define    SPDMEM_MEMTYPE_ROM        0x05
#define    SPDMEM_MEMTYPE_DDRSGRAM        0x06
#define    SPDMEM_MEMTYPE_DDRSDRAM        0x07
#define    SPDMEM_MEMTYPE_DDR2SDRAM    0x08
#define    SPDMEM_MEMTYPE_FBDIMM        0x09
#define    SPDMEM_MEMTYPE_FBDIMM_PROBE    0x0a
#define    SPDMEM_MEMTYPE_DDR3SDRAM    0x0b
#define    SPDMEM_MEMTYPE_NONE        0xff

#define SPDMEM_MEMTYPE_DIRECT_RAMBUS    0x01
#define SPDMEM_MEMTYPE_RAMBUS        0x11

/* possible values for the supply voltage */
#define    SPDMEM_VOLTAGE_TTL_5V        0x00
#define    SPDMEM_VOLTAGE_TTL_LV        0x01
#define    SPDMEM_VOLTAGE_HSTTL_1_5V    0x02
#define    SPDMEM_VOLTAGE_SSTL_3_3V    0x03
#define    SPDMEM_VOLTAGE_SSTL_2_5V    0x04
#define    SPDMEM_VOLTAGE_SSTL_1_8V    0x05

/* possible values for module configuration */
#define    SPDMEM_MODCONFIG_PARITY        0x01
#define    SPDMEM_MODCONFIG_ECC        0x02

/* for DDR2, module configuration is a bit-mask field */
#define    SPDMEM_MODCONFIG_HAS_DATA_PARITY    0x01
#define    SPDMEM_MODCONFIG_HAS_DATA_ECC        0x02
#define    SPDMEM_MODCONFIG_HAS_ADDR_CMD_PARITY    0x04

/* possible values for the refresh field */
#define    SPDMEM_REFRESH_STD        0x00
#define    SPDMEM_REFRESH_QUARTER        0x01
#define    SPDMEM_REFRESH_HALF        0x02
#define    SPDMEM_REFRESH_TWOX        0x03
#define    SPDMEM_REFRESH_FOURX        0x04
#define    SPDMEM_REFRESH_EIGHTX        0x05
#define    SPDMEM_REFRESH_SELFREFRESH    0x80

/* superset types */
#define    SPDMEM_SUPERSET_ESDRAM        0x01
#define    SPDMEM_SUPERSET_DDR_ESDRAM    0x02
#define    SPDMEM_SUPERSET_EDO_PEM        0x03
#define    SPDMEM_SUPERSET_SDR_PEM        0x04

/* FPM and EDO DIMMS */
#define SPDMEM_FPM_ROWS            0x00
#define SPDMEM_FPM_COLS            0x01
#define SPDMEM_FPM_BANKS        0x02
#define SPDMEM_FPM_CONFIG        0x08
#define SPDMEM_FPM_REFRESH        0x09
#define SPDMEM_FPM_SUPERSET        0x0c

/* PC66/PC100/PC133 SDRAM */
#define SPDMEM_SDR_ROWS            0x00
#define SPDMEM_SDR_COLS            0x01
#define SPDMEM_SDR_BANKS        0x02
#define SPDMEM_SDR_CYCLE        0x06
#define SPDMEM_SDR_BANKS_PER_CHIP    0x0e
#define SPDMEM_SDR_MOD_ATTRIB        0x12
#define SPDMEM_SDR_SUPERSET        0x1d

#define SPDMEM_SDR_FREQUENCY        126
#define SPDMEM_SDR_CAS            127
#define SPDMEM_SDR_FREQ_66        0x66
#define SPDMEM_SDR_FREQ_100        0x64
#define SPDMEM_SDR_FREQ_133        0x85
#define SPDMEM_SDR_CAS2            (1 sm_len ia_name, "spd") == 0)
return (1);

/* dumb, need sanity checks */
if (strcmp(ia->ia_name, "eeprom") != 0)
return (0);

sc.sc_tag = ia->ia_tag;
sc.sc_addr = ia->ia_addr;

type = spdmem_read(&sc, 2);
/* For older memory types, validate the checksum over 1st 63 bytes */
if (type  spd_len)
return 0;
crc_calc = spdmem_crc16(&sc, spd_crc_cover);
crc_spd = spdmem_read(&sc, 127) sm_type];

if (s->sm_data[sPDMEM_SDR_SUPERSET] == SPDMEM_SUPERSET_SDR_PEM)
type = spdmem_superset_types[sPDMEM_SUPERSET_SDR_PEM];
if (s->sm_data[sPDMEM_SDR_SUPERSET] == SPDMEM_SUPERSET_ESDRAM)
type = spdmem_superset_types[sPDMEM_SUPERSET_ESDRAM];

num_banks = s->sm_data[sPDMEM_SDR_BANKS];
per_chip = s->sm_data[sPDMEM_SDR_BANKS_PER_CHIP];
rows = s->sm_data[sPDMEM_SDR_ROWS] & 0x0f;
cols = s->sm_data[sPDMEM_SDR_COLS] & 0x0f;
dimm_size = (1  0) {
if (dimm_size sm_data[sPDMEM_DDR_MOD_ATTRIB] & SPDMEM_DDR_ATTRIB_REG)
printf(" registered");

if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]);

p_clk = 66;
if (s->sm_len >= 128) {
switch (spdmem_read(sc, SPDMEM_SDR_FREQUENCY)) {
case SPDMEM_SDR_FREQ_100:
case SPDMEM_SDR_FREQ_133:
/* We need to check ns to decide here */
if (s->sm_data[sPDMEM_SDR_CYCLE] sm_len sm_data[sPDMEM_RDR_ROWS_COLS] >> 4;
col_bits = s->sm_data[sPDMEM_RDR_ROWS_COLS] & 0x0f;
bank_bits = s->sm_data[sPDMEM_RDR_BANK] & 0x07;

/* subtracting 13 here is a cheaper way of dividing by 8k later */
rimm_size = 1 sm_data[sPDMEM_RDR_MODULE_TYPE]) {
case SPDMEM_RDR_TYPE_RIMM:
printf("RIMM");
break;
case SPDMEM_RDR_TYPE_SORIMM:
printf("SO-RIMM");
break;
case SPDMEM_RDR_TYPE_EMBED:
printf("Embedded Rambus");
break;
case SPDMEM_RDR_TYPE_RIMM32:
printf("RIMM32");
break;
}
}

void
spdmem_ddr_decode(struct spdmem_softc *sc, struct spdmem *s)
{
const char *type;
int dimm_size, cycle_time, d_clk, p_clk, bits;
int i, num_banks, per_chip;
uint8_t config, rows, cols, cl;

type = spdmem_basic_types[s->sm_type];

if (s->sm_data[sPDMEM_DDR_SUPERSET] == SPDMEM_SUPERSET_DDR_ESDRAM)
type = spdmem_superset_types[sPDMEM_SUPERSET_DDR_ESDRAM];

num_banks = s->sm_data[sPDMEM_SDR_BANKS];
per_chip = s->sm_data[sPDMEM_SDR_BANKS_PER_CHIP];
rows = s->sm_data[sPDMEM_SDR_ROWS] & 0x0f;
cols = s->sm_data[sPDMEM_SDR_COLS] & 0x0f;
dimm_size = (1  0) {
if (dimm_size sm_data[sPDMEM_DDR_MOD_ATTRIB] & SPDMEM_DDR_ATTRIB_REG)
printf(" registered");

if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]);

/* cycle_time is expressed in units of 0.01 ns */
cycle_time = (s->sm_data[sPDMEM_DDR_CYCLE] >> 4) * 100 +
(s->sm_data[sPDMEM_DDR_CYCLE] & 0x0f) * 10;

if (cycle_time != 0) {
/*
* cycle time is scaled by a factor of 100 to avoid using
* floating point.  Calculate memory speed as the number
* of cycles per microsecond.
* DDR uses dual-pumped clock
*/
d_clk = 100 * 1000 * 2;
config = s->sm_data[sPDMEM_FPM_CONFIG];
bits = s->sm_data[sPDMEM_DDR_DATAWIDTH] |
(s->sm_data[sPDMEM_DDR_DATAWIDTH + 1] = 50)
p_clk += 50;
p_clk -= p_clk % 100;
printf(" PC%d", p_clk);
}

/* Print CAS latency */
for (i = 6; i >= 0; i--) {
if (s->sm_data[sPDMEM_DDR_CAS] & (1 sm_type];

num_ranks = (s->sm_data[sPDMEM_DDR2_RANKS] & 0x7) + 1;
density = (s->sm_data[sPDMEM_DDR2_RANK_DENSITY] & 0xf0) |
((s->sm_data[sPDMEM_DDR2_RANK_DENSITY] & 0x0f)  0) {
if (dimm_size sm_data[sPDMEM_DDR2_DIMMTYPE] & SPDMEM_DDR2_TYPE_REGMASK)
printf(" registered");

if (s->sm_data[sPDMEM_FPM_CONFIG] sm_data[sPDMEM_FPM_CONFIG]]);

/* cycle_time is expressed in units of 0.01 ns */
cycle_time = (s->sm_data[sPDMEM_DDR2_CYCLE] >> 4) * 100 +
ddr2_cycle_tenths[(s->sm_data[sPDMEM_DDR2_CYCLE] & 0x0f)];

if (cycle_time != 0) {
/*
* cycle time is scaled by a factor of 100 to avoid using
* floating point.  Calculate memory speed as the number
* of cycles per microsecond.
* DDR2 uses quad-pumped clock
*/
d_clk = 100 * 1000 * 4;
config = s->sm_data[sPDMEM_FPM_CONFIG];
bits = s->sm_data[sPDMEM_DDR2_DATAWIDTH];
if ((config & 0x03) != 0)
bits -= 8;
d_clk /= cycle_time;
d_clk = (d_clk + 1) / 2;
p_clk = d_clk * bits / 8;
p_clk -= p_clk % 100;
printf(" PC2-%d", p_clk);
}

/* Print CAS latency */
for (i = 5; i >= 2; i--) {
if (s->sm_data[sPDMEM_DDR_CAS] & (i sm_data[sPDMEM_DDR2_DIMMTYPE]) {
case SPDMEM_DDR2_SODIMM:
printf(" SO-DIMM");
break;
case SPDMEM_DDR2_MICRO_DIMM:
printf(" Micro-DIMM");
break;
case SPDMEM_DDR2_MINI_RDIMM:
case SPDMEM_DDR2_MINI_UDIMM:
printf(" Mini-DIMM");
break;
}
}

void
spdmem_fbdimm_decode(struct spdmem_softc *sc, struct spdmem *s)
{
int dimm_size, num_banks, cycle_time, d_clk, p_clk, bits;
uint8_t rows, cols, banks, dividend, divisor;
/*
* FB-DIMM is very much like DDR3
*/

banks = s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_BANKS;
cols = (s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_COL) >>
SPDMEM_FBDIMM_ADDR_COL_SHIFT;
rows = (s->sm_data[sPDMEM_FBDIMM_ADDR] & SPDMEM_FBDIMM_ADDR_ROW) >>
SPDMEM_FBDIMM_ADDR_ROW_SHIFT;
dimm_size = rows + 12 + cols +  9 - 20 - 3;
num_banks = 1 sm_data[sPDMEM_FBDIMM_MTB_DIVIDEND];
divisor = s->sm_data[sPDMEM_FBDIMM_MTB_DIVISOR];

cycle_time = (1000 * dividend + (divisor / 2)) / divisor;

if (cycle_time != 0) {
/*
* cycle time is scaled by a factor of 1000 to avoid using
* floating point.  Calculate memory speed as the number
* of cycles per microsecond.
*/
d_clk = 1000 * 1000;

/* DDR2 FB-DIMM uses a dual-pumped clock */
d_clk *= 2;
bits = 1 sm_data[sPDMEM_FBDIMM_RANKS] &
SPDMEM_FBDIMM_RANKS_WIDTH) + 2);

p_clk = (d_clk * bits) / 8 / cycle_time;
d_clk = ((d_clk + cycle_time / 2) ) / cycle_time;
p_clk -= p_clk % 100;
printf(" PC2-%d", p_clk);
}
}

void
spdmem_ddr3_decode(struct spdmem_softc *sc, struct spdmem *s)
{
const char *type;
int dimm_size, cycle_time, d_clk, p_clk, bits;
uint8_t mtype, chipsize, dividend, divisor;
uint8_t datawidth, chipwidth, physbanks;

type = spdmem_basic_types[s->sm_type];

chipsize = s->sm_data[sPDMEM_DDR3_DENSITY] &
SPDMEM_DDR3_DENSITY_CAPMASK;
datawidth = s->sm_data[sPDMEM_DDR3_DATAWIDTH] &
SPDMEM_DDR3_DATAWIDTH_PRIMASK;
chipwidth = s->sm_data[sPDMEM_DDR3_MOD_ORG] &
SPDMEM_DDR3_MOD_ORG_CHIPWIDTH_MASK;
physbanks = (s->sm_data[sPDMEM_DDR3_MOD_ORG] >> 
SPDMEM_DDR3_MOD_ORG_BANKS_SHIFT) & SPDMEM_DDR3_MOD_ORG_BANKS_MASK;

dimm_size = (chipsize + 28 - 20) - 3 + (datawidth + 3) -
(chipwidth + 2);
dimm_size = (1 sm_data[sPDMEM_DDR3_MODTYPE];
if (mtype == SPDMEM_DDR3_RDIMM || mtype == SPDMEM_DDR3_MINI_RDIMM)
printf(" registered");

if (s->sm_data[sPDMEM_DDR3_DATAWIDTH] & SPDMEM_DDR3_DATAWIDTH_ECCMASK) 
printf(" ECC");

dividend = s->sm_data[sPDMEM_DDR3_MTB_DIVIDEND];
divisor = s->sm_data[sPDMEM_DDR3_MTB_DIVISOR];
cycle_time = (1000 * dividend +  (divisor / 2)) / divisor;
cycle_time *= s->sm_data[sPDMEM_DDR3_TCKMIN];

if (cycle_time != 0) {
/*
* cycle time is scaled by a factor of 1000 to avoid using
* floating point.  Calculate memory speed as the number
* of cycles per microsecond.
* DDR3 uses a dual-pumped clock
*/
d_clk = 1000 * 1000;
d_clk *= 2;
bits = 1 sm_data[sPDMEM_DDR3_DATAWIDTH] &
SPDMEM_DDR3_DATAWIDTH_PRIMASK) + 3);
/*
* Calculate p_clk first, since for DDR3 we need maximum
* significance.  DDR3 rating is not rounded to a multiple
* of 100.  This results in cycle_time of 1.5ns displayed
* as p_clk PC3-10666 (d_clk DDR3-1333)
*/
p_clk = (d_clk * bits) / 8 / cycle_time;
p_clk -= (p_clk % 100);
d_clk = ((d_clk + cycle_time / 2) ) / cycle_time;
printf(" PC3-%d", p_clk);
}

switch (s->sm_data[sPDMEM_DDR3_MODTYPE]) {
case SPDMEM_DDR3_SODIMM:
printf(" SO-DIMM");
break;
case SPDMEM_DDR3_MICRO_DIMM:
printf(" Micro-DIMM");
break;
case SPDMEM_DDR3_MINI_RDIMM:
case SPDMEM_DDR3_MINI_UDIMM:
printf(" Mini-DIMM");
break;
}

if (s->sm_data[sPDMEM_DDR3_THERMAL] & SPDMEM_DDR3_THERMAL_PRESENT)
printf(" with thermal sensor");
}

void
spdmem_attach(struct device *parent, struct device *self, void *aux)
{
struct spdmem_softc *sc = (struct spdmem_softc *)self;
struct i2c_attach_args *ia = aux;
struct spdmem *s = &(sc->sc_spd_data);
int i;

sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;

printf(":");

/* All SPD have at least 64 bytes of data including checksum */
for (i = 0; i sm_len sm_type == SPDMEM_MEMTYPE_DIRECT_RAMBUS)
spdmem_rdr_decode(sc, s);
else
printf(" no decode method for Rambus memory");
} else {
switch(s->sm_type) {
case SPDMEM_MEMTYPE_EDO:
case SPDMEM_MEMTYPE_SDRAM:
spdmem_sdram_decode(sc, s);
break;
case SPDMEM_MEMTYPE_DDRSDRAM:
spdmem_ddr_decode(sc, s);
break;
case SPDMEM_MEMTYPE_DDR2SDRAM:
spdmem_ddr2_decode(sc, s);
break;
case SPDMEM_MEMTYPE_FBDIMM:
case SPDMEM_MEMTYPE_FBDIMM_PROBE:
spdmem_fbdimm_decode(sc, s);
break;
case SPDMEM_MEMTYPE_DDR3SDRAM:
spdmem_ddr3_decode(sc, s);
break;
case SPDMEM_MEMTYPE_NONE:
printf(" no EEPROM found");
break;
default:
if (s->sm_type sm_type]);
else
printf(" unknown memory type %d", s->sm_type);
break;
}
}

printf("
");
}

uint8_t
spdmem_read(struct spdmem_softc *sc, uint8_t reg)
{
uint8_t val = 0xff;

iic_acquire_bus(sc->sc_tag,0);
iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
&reg, sizeof reg, &val, sizeof val, 0);
iic_release_bus(sc->sc_tag, 0);

return val;
}

Xstreme

ciao

XSSI BETA 1

ho rimesso la rilevazione dei dischi che prima

crashava, ma ho aggiunto un salto

quando trova un errore, non dovrebbe

più bloccarsi, lanciatelo, aspettate qualche

secondo e dovrebbe aprirsi Notepad

con la lista di tutto, a me mi funziona tutto,

quindi se salta o non salta gli eventuali errori

me lo dovete dire voi

http://www.xstreme.it/xssi_beta.zip