INFO: No output directory specified (--dir)
INFO: Using directory: "Samples_Incoherent_20250815_082647"
INFO: Regenerating c-file: Samples_Incoherent.c
DEBUG: CMD: /home/willend/micromamba/bin/mcstas -t -o ./Samples_Incoherent.c Samples_Incoherent.instr
Info:    'ISIS_moderator' is a contributed component.
CFLAGS=  -DUSE_OFF 
          
WARNING:
 The parameter format of PowN is initialized 
 using a static {,,,} vector.
  -> Such static vectors support literal numbers ONLY.
  -> Any vector use of variables or defines must happen via a 
     DECLARE/INITIALIZE pointer.


WARNING:
 The parameter mosaic_AB of SX is initialized 
 using a static {,,,} vector.
  -> Such static vectors support literal numbers ONLY.
  -> Any vector use of variables or defines must happen via a 
     DECLARE/INITIALIZE pointer.


WARNING:
 The parameter powder_format of Sqw is initialized 
 using a static {,,,} vector.
  -> Such static vectors support literal numbers ONLY.
  -> Any vector use of variables or defines must happen via a 
     DECLARE/INITIALIZE pointer.


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

Generating single GPU kernel or single CPU section layout: 

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

Generating GPU/CPU -DFUNNEL layout:

-----------------------------------------------------------
DEBUG: CMD: /home/willend/micromamba/bin/mcstas finished
INFO: Linting generated code: ./Samples_Incoherent.c
DEBUG: CMD: cppcheck ./Samples_Incoherent.c --check-level=exhaustive --force -DMCDEFAULT_NCOUNT=1000000 -UMC_PORTABLE -DND_BUFFER=10000000 -UNOABSORB_INF_NAN -UOMPI_MPI_H -DSIGABRT -DSIGBREAK -DSIGBUS -DSIGPE -DSIGHUP -DSIGILL -DSIGINT -DSIGKILL -DSIGUSR1 -DSIGUSR2 -DSIGPIPE -DSIGQUIT -DSIGSEGV -DSIGTRAP -DSIGURG -DSIGFPE -DSIGKILL -DSIGTERM -UTEST -UUSE_OPENCL -UWIN32 -UOPENACC -UGCCOFFLOAD -U_MSC_VER -U_MSC_EXTENSIONS -U_WIN32 -UWIN32 -D__unix__ -UDANSE -UFUNNEL -UMC_ANCIENT_COMPATIBILITY -UMC_POL_COMPAT -UNEUTRONICS -Uisnan -Uisinf
Checking Samples_Incoherent.c ...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1...
Samples_Incoherent.c:7073:3: warning: If memory allocation fails, then there is a possible null pointer dereference: C [nullPointerOutOfMemory]
  C[0]=Y[0];
  ^
Samples_Incoherent.c:7063:21: note: Assuming allocation function fails
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7063:21: note: Assignment 'C=malloc(Psize*sizeof(double))', assigned value is 0
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7073:3: note: Null pointer dereference
  C[0]=Y[0];
  ^
Samples_Incoherent.c:7074:3: warning: If memory allocation fails, then there is a possible null pointer dereference: D [nullPointerOutOfMemory]
  D[0]=Y[0];
  ^
Samples_Incoherent.c:7064:21: note: Assuming allocation function fails
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7064:21: note: Assignment 'D=malloc(Psize*sizeof(double))', assigned value is 0
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7074:3: note: Null pointer dereference
  D[0]=Y[0];
  ^
Samples_Incoherent.c:7083:7: warning: If memory allocation fails, then there is a possible null pointer dereference: C [nullPointerOutOfMemory]
      C[i]=Y[i];
      ^
Samples_Incoherent.c:7063:21: note: Assuming allocation function fails
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7063:21: note: Assignment 'C=malloc(Psize*sizeof(double))', assigned value is 0
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7083:7: note: Null pointer dereference
      C[i]=Y[i];
      ^
Samples_Incoherent.c:7084:7: warning: If memory allocation fails, then there is a possible null pointer dereference: D [nullPointerOutOfMemory]
      D[i]=Y[i];
      ^
Samples_Incoherent.c:7064:21: note: Assuming allocation function fails
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7064:21: note: Assignment 'D=malloc(Psize*sizeof(double))', assigned value is 0
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7084:7: note: Null pointer dereference
      D[i]=Y[i];
      ^
Samples_Incoherent.c:7096:6: warning: If memory allocation fails, then there is a possible null pointer dereference: C [nullPointerOutOfMemory]
   w=C[i+1]-D[i];
     ^
Samples_Incoherent.c:7063:21: note: Assuming allocation function fails
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7063:21: note: Assignment 'C=malloc(Psize*sizeof(double))', assigned value is 0
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7096:6: note: Null pointer dereference
   w=C[i+1]-D[i];
     ^
Samples_Incoherent.c:7096:13: warning: If memory allocation fails, then there is a possible null pointer dereference: D [nullPointerOutOfMemory]
   w=C[i+1]-D[i];
            ^
Samples_Incoherent.c:7064:21: note: Assuming allocation function fails
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7064:21: note: Assignment 'D=malloc(Psize*sizeof(double))', assigned value is 0
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7096:13: note: Null pointer dereference
   w=C[i+1]-D[i];
            ^
Samples_Incoherent.c:7099:4: warning: If memory allocation fails, then there is a possible null pointer dereference: D [nullPointerOutOfMemory]
   D[i]=hp*den;
   ^
Samples_Incoherent.c:7064:21: note: Assuming allocation function fails
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7064:21: note: Assignment 'D=malloc(Psize*sizeof(double))', assigned value is 0
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7099:4: note: Null pointer dereference
   D[i]=hp*den;
   ^
Samples_Incoherent.c:7100:4: warning: If memory allocation fails, then there is a possible null pointer dereference: C [nullPointerOutOfMemory]
   C[i]=ho*den;
   ^
Samples_Incoherent.c:7063:21: note: Assuming allocation function fails
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7063:21: note: Assignment 'C=malloc(Psize*sizeof(double))', assigned value is 0
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7100:4: note: Null pointer dereference
   C[i]=ho*den;
   ^
Samples_Incoherent.c:7103:38: warning: If memory allocation fails, then there is a possible null pointer dereference: C [nullPointerOutOfMemory]
      errOut= (2*(ns+1)<(Psize-m)) ? C[ns+1] : D[ns--];
                                     ^
Samples_Incoherent.c:7063:21: note: Assuming allocation function fails
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7063:21: note: Assignment 'C=malloc(Psize*sizeof(double))', assigned value is 0
  double *C = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7103:38: note: Null pointer dereference
      errOut= (2*(ns+1)<(Psize-m)) ? C[ns+1] : D[ns--];
                                     ^
Samples_Incoherent.c:7103:48: warning: If memory allocation fails, then there is a possible null pointer dereference: D [nullPointerOutOfMemory]
      errOut= (2*(ns+1)<(Psize-m)) ? C[ns+1] : D[ns--];
                                               ^
Samples_Incoherent.c:7064:21: note: Assuming allocation function fails
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7064:21: note: Assignment 'D=malloc(Psize*sizeof(double))', assigned value is 0
  double *D = malloc(Psize*sizeof(double));
                    ^
Samples_Incoherent.c:7103:48: note: Null pointer dereference
      errOut= (2*(ns+1)<(Psize-m)) ? C[ns+1] : D[ns--];
                                               ^
Samples_Incoherent.c:7167:7: warning: If memory allocation fails, then there is a possible null pointer dereference: ss [nullPointerOutOfMemory]
      ss[j]=mc[i];
      ^
Samples_Incoherent.c:7162:12: note: Assuming allocation function fails
  ss=malloc(sizeof(char)*(len+1));
           ^
Samples_Incoherent.c:7162:12: note: Assignment 'ss=malloc(sizeof(char)*(len+1))', assigned value is 0
  ss=malloc(sizeof(char)*(len+1));
           ^
Samples_Incoherent.c:7167:7: note: Null pointer dereference
      ss[j]=mc[i];
      ^
Samples_Incoherent.c:7635:4: warning: If memory allocation fails, then there is a possible null pointer dereference: ss [nullPointerOutOfMemory]
   ss[j]=mc[i];
   ^
Samples_Incoherent.c:7630:16: note: Assuming allocation function fails
      ss=malloc(sizeof(char)*(len+1));
               ^
Samples_Incoherent.c:7630:16: note: Assignment 'ss=malloc(sizeof(char)*(len+1))', assigned value is 0
      ss=malloc(sizeof(char)*(len+1));
               ^
Samples_Incoherent.c:7635:4: note: Null pointer dereference
   ss[j]=mc[i];
   ^
Samples_Incoherent.c:12236:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].h = h;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12236:7: note: Null pointer dereference
      list[i].h = h;
      ^
Samples_Incoherent.c:12237:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].k = k;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12237:7: note: Null pointer dereference
      list[i].k = k;
      ^
Samples_Incoherent.c:12238:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].l = l;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12238:7: note: Null pointer dereference
      list[i].l = l;
      ^
Samples_Incoherent.c:12239:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].F2 = F2;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12239:7: note: Null pointer dereference
      list[i].F2 = F2;
      ^
Samples_Incoherent.c:12242:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12242:7: note: Null pointer dereference
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Samples_Incoherent.c:12243:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12243:7: note: Null pointer dereference
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Samples_Incoherent.c:12244:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12244:7: note: Null pointer dereference
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Samples_Incoherent.c:12245:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12245:7: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Samples_Incoherent.c:12245:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12245:26: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Samples_Incoherent.c:12245:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12245:40: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Samples_Incoherent.c:12246:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                         ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12246:26: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                         ^
Samples_Incoherent.c:12246:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                                       ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12246:40: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                                       ^
Samples_Incoherent.c:12247:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                         ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12247:26: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                         ^
Samples_Incoherent.c:12247:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                                       ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12247:40: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                                       ^
Samples_Incoherent.c:12248:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12248:7: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Samples_Incoherent.c:12248:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12248:21: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Samples_Incoherent.c:12248:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12248:35: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Samples_Incoherent.c:12249:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12249:7: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Samples_Incoherent.c:12249:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12249:21: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Samples_Incoherent.c:12249:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12249:35: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Samples_Incoherent.c:12250:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12250:7: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Samples_Incoherent.c:12250:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12250:21: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Samples_Incoherent.c:12250:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12250:35: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Samples_Incoherent.c:12251:41: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12251:41: note: Null pointer dereference
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Samples_Incoherent.c:12255:18: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12255:18: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Samples_Incoherent.c:12255:31: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12255:31: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Samples_Incoherent.c:12255:44: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12255:44: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Samples_Incoherent.c:12256:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      vec_prod(b2[0], b2[1], b2[2],
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12256:7: note: Null pointer dereference
      vec_prod(b2[0], b2[1], b2[2],
      ^
Samples_Incoherent.c:12263:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2x = b1[0];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12263:9: note: Null pointer dereference
        list[i].u2x = b1[0];
        ^
Samples_Incoherent.c:12264:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2y = b1[1];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12264:9: note: Null pointer dereference
        list[i].u2y = b1[1];
        ^
Samples_Incoherent.c:12265:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2z = b1[2];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12265:9: note: Null pointer dereference
        list[i].u2z = b1[2];
        ^
Samples_Incoherent.c:12266:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12266:25: note: Null pointer dereference
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Samples_Incoherent.c:12267:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3x = b2[0];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12267:9: note: Null pointer dereference
        list[i].u3x = b2[0];
        ^
Samples_Incoherent.c:12268:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3y = b2[1];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12268:9: note: Null pointer dereference
        list[i].u3y = b2[1];
        ^
Samples_Incoherent.c:12269:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3z = b2[2];
        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12269:9: note: Null pointer dereference
        list[i].u3z = b2[2];
        ^
Samples_Incoherent.c:12270:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12270:25: note: Null pointer dereference
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Samples_Incoherent.c:12388:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].sig123 = sig1*sig2*sig3;
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12388:7: note: Null pointer dereference
      list[i].sig123 = sig1*sig2*sig3;
      ^
Samples_Incoherent.c:12389:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12389:7: note: Null pointer dereference
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Samples_Incoherent.c:12390:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12390:7: note: Null pointer dereference
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Samples_Incoherent.c:12391:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12391:7: note: Null pointer dereference
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Samples_Incoherent.c:12407:11: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    qsort(list, i, sizeof(struct hkl_data),  SX_list_compare);
          ^
Samples_Incoherent.c:12219:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Samples_Incoherent.c:12219:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Samples_Incoherent.c:12407:11: note: Null pointer dereference
    qsort(list, i, sizeof(struct hkl_data),  SX_list_compare);
          ^
Samples_Incoherent.c:13703:37: warning: If memory allocation fails, then there is a possible null pointer dereference: w_file2full [nullPointerOutOfMemory]
  for (index_w=0; index_w < w_bins; w_file2full[index_w++]=0);
                                    ^
Samples_Incoherent.c:13701:31: note: Assuming allocation function fails
  double *w_file2full = malloc(w_bins*sizeof(double)); /* lookup table for fast file -> Sqw_full allocation */
                              ^
Samples_Incoherent.c:13701:31: note: Assignment 'w_file2full=malloc(w_bins*sizeof(double))', assigned value is 0
  double *w_file2full = malloc(w_bins*sizeof(double)); /* lookup table for fast file -> Sqw_full allocation */
                              ^
Samples_Incoherent.c:13703:37: note: Null pointer dereference
  for (index_w=0; index_w < w_bins; w_file2full[index_w++]=0);
                                    ^
Samples_Incoherent.c:13743:39: warning: If memory allocation fails, then there is a possible null pointer dereference: q_file2full [nullPointerOutOfMemory]
  for   (index_q=0; index_q < q_bins; q_file2full[index_q++]=0);
                                      ^
Samples_Incoherent.c:13742:29: note: Assuming allocation function fails
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13742:29: note: Assignment 'q_file2full=malloc(q_bins*sizeof(double))', assigned value is 0
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13743:39: note: Null pointer dereference
  for   (index_q=0; index_q < q_bins; q_file2full[index_q++]=0);
                                      ^
Samples_Incoherent.c:13762:5: warning: If memory allocation fails, then there is a possible null pointer dereference: q_file2full [nullPointerOutOfMemory]
    q_file2full[index_q] = index_q_file;
    ^
Samples_Incoherent.c:13742:29: note: Assuming allocation function fails
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13742:29: note: Assignment 'q_file2full=malloc(q_bins*sizeof(double))', assigned value is 0
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13762:5: note: Null pointer dereference
    q_file2full[index_q] = index_q_file;
    ^
Samples_Incoherent.c:13772:20: warning: If memory allocation fails, then there is a possible null pointer dereference: q_file2full [nullPointerOutOfMemory]
    index_q_file = q_file2full[index_q];
                   ^
Samples_Incoherent.c:13742:29: note: Assuming allocation function fails
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13742:29: note: Assignment 'q_file2full=malloc(q_bins*sizeof(double))', assigned value is 0
  double *q_file2full=malloc(q_bins*sizeof(double));
                            ^
Samples_Incoherent.c:13772:20: note: Null pointer dereference
    index_q_file = q_file2full[index_q];
                   ^
Samples_Incoherent.c:12361:14: error: Uninitialized variable: c1 [legacyUninitvar]
        if ((c1==0) && (c2==0)){
             ^
Samples_Incoherent.c:12367:74: error: Uninitialized variable: c2 [legacyUninitvar]
        sig_tau_c = MIN2RAD*sqrt(c1*SC_mosaic_AB[0]*c1*SC_mosaic_AB[0] + c2*SC_mosaic_AB[1]*c2*SC_mosaic_AB[1]);
                                                                         ^
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;OFF_LEGACY...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;SIGKILL;SIGUSR1;SIGUSR2...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_MPI...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_MPI;USE_NEXUS...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_NEXUS...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;_WIN64...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__APPLE__;__GNUC__...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__APPLE__;__unix__...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__FreeBSD__...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__GNUC__...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__GNUC__;__clang__...
Checking Samples_Incoherent.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__dest_os...
DEBUG: CMD: cppcheck finished
INFO: End of linting ./Samples_Incoherent.c