Act on linter hints from cppcheck

[willend]

Using the new --lint flag of mctest (corresponding to the --c-lint of mcrun) I have tested the generated c-code across the McStas instruments via the cppcheck static code analyser. (Warning: The run took a couple of days to complete!)

Most of the output relates to missing free() calls, lack of protection in case of failed malloc(), uninitialised struct members...

The output is available in html table form here and a .tgz file here
(was also added as a column to today's test output)

The length of the compile_stdout.txt files are a hint wrt. work is needed - mostly in the "advanced" instruments... :-)
(@mads-bertelsen Union stuff and @farhi e.g. Isotropic_Sqw)

I have started fixing the instruments "bottom up" and the 4.0K/8.0K outputs at the end are "clean" - nothing left to fix there.

@mads-bertelsen @farhi @Lomholy status update:

McStas is "close to done", big chunks of output still for these instruments:

• Conditional_test
• Logger_test done
• Test_texture (I think I fixed ~ half)
• IncoherentPhonon_test
• ILL_SALSA
• Supermirror_thin_substrate done
• FZJ_BenchmarkSfin2dene

Common denominators for "everything else" has been lack of error-handling on malloc()'s, fopen()'s and un-initialised vars...

For McXtrace, this will have to wait until a later point. :-)

[willend]

As an example of another 'noisy' component, have a look how many warnings are issued by inclusion of Elliptic_guide_gravity()...

POWTOF_texture.c:22370:3: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
  xplus[i] =  tempx + guideInfo.ellipseMinorOffset[RightSide];
  ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22370:3: note: Null pointer dereference
  xplus[i] =  tempx + guideInfo.ellipseMinorOffset[RightSide];
  ^
POWTOF_texture.c:22371:3: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
  xminus[i]= -tempx + guideInfo.ellipseMinorOffset[RightSide];
  ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22371:3: note: Null pointer dereference
  xminus[i]= -tempx + guideInfo.ellipseMinorOffset[RightSide];
  ^
POWTOF_texture.c:22384:3: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
  yplus[i] =  tempy + guideInfo.ellipseMinorOffset[TopSide];
  ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22384:3: note: Null pointer dereference
  yplus[i] =  tempy + guideInfo.ellipseMinorOffset[TopSide];
  ^
POWTOF_texture.c:22385:3: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
  yminus[i]= -tempy + guideInfo.ellipseMinorOffset[TopSide];
  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22385:3: note: Null pointer dereference
  yminus[i]= -tempy + guideInfo.ellipseMinorOffset[TopSide];
  ^
POWTOF_texture.c:22397:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0    , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22397:8: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0    , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22397:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0    , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22397:18: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0    , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22398:16: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22398:16: note: Null pointer dereference
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22398:42: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
                                         ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22398:42: note: Null pointer dereference
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
                                         ^
POWTOF_texture.c:22399:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22399:8: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22399:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22399:19: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22400:13: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta,xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22400:13: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta,xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22400:40: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta,xplus[j], yminus[j], zvalue+j*zdelta);
                                       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22400:40: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta,xplus[j], yminus[j], zvalue+j*zdelta);
                                       ^
POWTOF_texture.c:22401:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22401:8: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22401:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22401:18: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22402:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22402:8: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22402:51: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
                                                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22402:51: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
                                                  ^
POWTOF_texture.c:22403:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22403:8: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22403:52: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22403:52: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22404:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22404:8: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22404:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22404:18: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22408:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22408:8: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22408:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22408:18: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22409:16: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( 0     , yplus[j],zvalue+j*zdelta,xminus[j] , yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22409:16: note: Null pointer dereference
 line( 0     , yplus[j],zvalue+j*zdelta,xminus[j] , yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22409:41: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( 0     , yplus[j],zvalue+j*zdelta,xminus[j] , yplus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22409:41: note: Null pointer dereference
 line( 0     , yplus[j],zvalue+j*zdelta,xminus[j] , yplus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22410:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0      , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22410:8: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0      , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22410:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0      , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22410:19: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0      , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22411:13: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22411:13: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22411:41: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22411:41: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22412:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22412:8: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22412:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22412:18: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22413:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22413:8: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22413:51: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
                                                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22413:51: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta,xminus[j],yminus[j], zvalue+j*zdelta);
                                                  ^
POWTOF_texture.c:22414:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22414:8: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22414:52: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22414:52: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22415:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j], 0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22415:8: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j], 0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22415:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j], 0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22415:18: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta,xplus[j], 0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22424:29: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
  if( boardestPlace <= fabs(yplus[m0]) ){
                            ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22424:29: note: Null pointer dereference
  if( boardestPlace <= fabs(yplus[m0]) ){
                            ^
POWTOF_texture.c:22431:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22431:8: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22431:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22431:18: note: Null pointer dereference
 line( xplus[j], yplus[j], zvalue+j*zdelta,0   , yplus[j], zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22432:16: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22432:16: note: Null pointer dereference
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
               ^
POWTOF_texture.c:22432:42: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
                                         ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22432:42: note: Null pointer dereference
 line( 0     , yplus[j], zvalue+j*zdelta,xminus[j], yplus[j], zvalue+j*zdelta);
                                         ^
POWTOF_texture.c:22433:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22433:8: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22433:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22433:19: note: Null pointer dereference
 line( xminus[j], yminus[j], zvalue+j*zdelta,0     , yminus[j], zvalue+j*zdelta);
                  ^
POWTOF_texture.c:22434:13: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22434:13: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
            ^
POWTOF_texture.c:22434:41: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22434:41: note: Null pointer dereference
 line( 0,   yminus[j], zvalue+j*zdelta, xplus[j], yminus[j], zvalue+j*zdelta);
                                        ^
POWTOF_texture.c:22435:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22435:8: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22435:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22435:18: note: Null pointer dereference
 line( xminus[j],yplus[j], zvalue+j*zdelta, xminus[j],0   , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22436:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta, xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22436:8: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta, xminus[j],yminus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22436:52: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xminus[j],0    , zvalue+j*zdelta, xminus[j],yminus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22436:52: note: Null pointer dereference
 line( xminus[j],0    , zvalue+j*zdelta, xminus[j],yminus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22437:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22437:8: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
       ^
POWTOF_texture.c:22437:52: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22437:52: note: Null pointer dereference
 line( xplus[j], 0,     zvalue+j*zdelta, xplus[j], yplus[j], zvalue+j*zdelta);
                                                   ^
POWTOF_texture.c:22438:8: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta, xplus[j], 0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22438:8: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta, xplus[j], 0    , zvalue+j*zdelta);
       ^
POWTOF_texture.c:22438:18: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
 line( xplus[j], yminus[j], zvalue+j*zdelta, xplus[j], 0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22438:18: note: Null pointer dereference
 line( xplus[j], yminus[j], zvalue+j*zdelta, xplus[j], 0    , zvalue+j*zdelta);
                 ^
POWTOF_texture.c:22447:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
  line( xplus[k], yplus[k], zvalue+k*zdelta,xplus[k+1], yplus[k+1], zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22447:9: note: Null pointer dereference
  line( xplus[k], yplus[k], zvalue+k*zdelta,xplus[k+1], yplus[k+1], zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22447:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
  line( xplus[k], yplus[k], zvalue+k*zdelta,xplus[k+1], yplus[k+1], zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22447:19: note: Null pointer dereference
  line( xplus[k], yplus[k], zvalue+k*zdelta,xplus[k+1], yplus[k+1], zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22448:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
  line( xminus[k],yplus[k], zvalue+k*zdelta,xminus[k+1],yplus[k+1], zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22448:9: note: Null pointer dereference
  line( xminus[k],yplus[k], zvalue+k*zdelta,xminus[k+1],yplus[k+1], zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22448:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
  line( xminus[k],yplus[k], zvalue+k*zdelta,xminus[k+1],yplus[k+1], zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22448:19: note: Null pointer dereference
  line( xminus[k],yplus[k], zvalue+k*zdelta,xminus[k+1],yplus[k+1], zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22450:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
  line( xplus[k], yminus[k],zvalue+k*zdelta,xplus[k+1], yminus[k+1],zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22450:9: note: Null pointer dereference
  line( xplus[k], yminus[k],zvalue+k*zdelta,xplus[k+1], yminus[k+1],zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22450:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
  line( xplus[k], yminus[k],zvalue+k*zdelta,xplus[k+1], yminus[k+1],zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22450:19: note: Null pointer dereference
  line( xplus[k], yminus[k],zvalue+k*zdelta,xplus[k+1], yminus[k+1],zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22452:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
  line( xminus[k],yminus[k],zvalue+k*zdelta,xminus[k+1],yminus[k+1],zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22452:9: note: Null pointer dereference
  line( xminus[k],yminus[k],zvalue+k*zdelta,xminus[k+1],yminus[k+1],zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22452:19: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
  line( xminus[k],yminus[k],zvalue+k*zdelta,xminus[k+1],yminus[k+1],zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22452:19: note: Null pointer dereference
  line( xminus[k],yminus[k],zvalue+k*zdelta,xminus[k+1],yminus[k+1],zvalue+(k+1)*zdelta);
                  ^
POWTOF_texture.c:22454:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xminus [nullPointerOutOfMemory]
  line( xminus[k],0   , zvalue+k*zdelta, xminus[k+1],0  , zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22328:23: note: Assuming allocation function fails
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22328:23: note: Assignment 'xminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22454:9: note: Null pointer dereference
  line( xminus[k],0   , zvalue+k*zdelta, xminus[k+1],0  , zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22455:9: warning: If memory allocation fails, then there is a possible null pointer dereference: xplus [nullPointerOutOfMemory]
  line( xplus[k], 0   , zvalue+k*zdelta, xplus[k+1], 0  , zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22327:22: note: Assuming allocation function fails
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22327:22: note: Assignment 'xplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *xplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22455:9: note: Null pointer dereference
  line( xplus[k], 0   , zvalue+k*zdelta, xplus[k+1], 0  , zvalue+(k+1)*zdelta);
        ^
POWTOF_texture.c:22457:14: warning: If memory allocation fails, then there is a possible null pointer dereference: yminus [nullPointerOutOfMemory]
  line( 0  , yminus[k],  zvalue+k*zdelta, 0     ,yminus[k+1],zvalue+(k+1)*zdelta);
             ^
POWTOF_texture.c:22330:23: note: Assuming allocation function fails
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22330:23: note: Assignment 'yminus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yminus=malloc((ApproximationMirrors+1)*sizeof(double));
                      ^
POWTOF_texture.c:22457:14: note: Null pointer dereference
  line( 0  , yminus[k],  zvalue+k*zdelta, 0     ,yminus[k+1],zvalue+(k+1)*zdelta);
             ^
POWTOF_texture.c:22458:13: warning: If memory allocation fails, then there is a possible null pointer dereference: yplus [nullPointerOutOfMemory]
  line( 0  ,yplus[k]  , zvalue+k*zdelta , 0   ,yplus[k] , zvalue+(k+1)*zdelta);
            ^
POWTOF_texture.c:22329:22: note: Assuming allocation function fails
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22329:22: note: Assignment 'yplus=malloc((ApproximationMirrors+1)*sizeof(double))', assigned value is 0
 double *yplus=malloc((ApproximationMirrors+1)*sizeof(double));
                     ^
POWTOF_texture.c:22458:13: note: Null pointer dereference
  line( 0  ,yplus[k]  , zvalue+k*zdelta , 0   ,yplus[k] , zvalue+(k+1)*zdelta);
            ^
POWTOF_texture.c:9910:9: warning: Uninitialized variable: boolean [uninitvar]
 return boolean;
        ^
POWTOF_texture.c:9865:16: note: Assuming condition is true
 if (solutionH <= 0)
               ^
POWTOF_texture.c:9910:9: note: Uninitialized variable: boolean
 return boolean;
        ^

(And some call this "excellent code"...! Yes, most of the affected code is "just visualisation", yet the noise clutters everything!)

[willend]

https://github.com/mccode-dev/McCode/tree/cleanup-linter-noisy-comps is intended for work in this direction.

[willend]

@mads-bertelsen, 1800 lines of hints and warnings from the linter by insertion of Union_init() and Union_stop() only.

I might take steps to fix at least part of all this since I am in the process of hunting down a weird bug in the Texture_process() with some versions of clang on macOS...

[POWTOF_texture.c:7887:5: error: Memory leak: temp_logger_with_data.logger_pointers [memleak]
    } else {
    ^
POWTOF_texture.c:7917:5: error: Memory leak: temp_abs_logger_with_data.abs_logger_pointers [memleak]
    } else {
    ^
POWTOF_texture.c:8590:5: error: Memory leak: temp_history.elements [memleak]
    } else {
    ^
POWTOF_texture.c:15253:5: error: Memory leak: removed_under_2.elements [memleak]
    };
    ^
POWTOF_texture.c:7760:66: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        for (iterate = 0;iterate < list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                                 ^
POWTOF_texture.c:7759:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
POWTOF_texture.c:7759:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
POWTOF_texture.c:7760:66: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                                 ^
POWTOF_texture.c:7763:92: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        for (iterate = 0;iterate < list->num_elements;iterate++) list->elements[iterate] = temp[iterate];
                                                                                           ^
POWTOF_texture.c:7759:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
POWTOF_texture.c:7759:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
POWTOF_texture.c:7763:92: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) list->elements[iterate] = temp[iterate];
                                                                                           ^
POWTOF_texture.c:7797:60: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:7795:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7795:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7797:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:7801:88: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:7795:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7795:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7801:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:7815:60: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:7813:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7813:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7815:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:7819:88: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:7813:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7813:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
POWTOF_texture.c:7819:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:7834:72: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<focus_data_array->num_elements;iterate++) temp[iterate] = focus_data_array->elements[iterate];
                                                                       ^
POWTOF_texture.c:7832:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
POWTOF_texture.c:7832:44: note: Assignment 'temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct))', assigned value is 0
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
POWTOF_texture.c:7834:72: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements;iterate++) temp[iterate] = focus_data_array->elements[iterate];
                                                                       ^
POWTOF_texture.c:7838:112: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<focus_data_array->num_elements-1;iterate++) focus_data_array->elements[iterate] = temp[iterate];
                                                                                                               ^
POWTOF_texture.c:7832:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
POWTOF_texture.c:7832:44: note: Assignment 'temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct))', assigned value is 0
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
POWTOF_texture.c:7838:112: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements-1;iterate++) focus_data_array->elements[iterate] = temp[iterate];
                                                                                                               ^
POWTOF_texture.c:7939:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
POWTOF_texture.c:7934:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
POWTOF_texture.c:7934:49: note: Assignment 'temp_fp=malloc(list->num_elements*sizeof(intconditional_function_pointer))', assigned value is 0
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
POWTOF_texture.c:7939:7: note: Null pointer dereference
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
POWTOF_texture.c:7940:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_du [nullPointerOutOfMemory]
      temp_du[iterate] = list->p_data_unions[iterate];
      ^
POWTOF_texture.c:7935:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
POWTOF_texture.c:7935:50: note: Assignment 'temp_du=malloc(list->num_elements*sizeof(union conditional_data_union))', assigned value is 0
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
POWTOF_texture.c:7940:7: note: Null pointer dereference
      temp_du[iterate] = list->p_data_unions[iterate];
      ^
POWTOF_texture.c:7949:46: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
POWTOF_texture.c:7934:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
POWTOF_texture.c:7934:49: note: Assignment 'temp_fp=malloc(list->num_elements*sizeof(intconditional_function_pointer))', assigned value is 0
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
POWTOF_texture.c:7949:46: note: Null pointer dereference
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
POWTOF_texture.c:7950:38: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_du [nullPointerOutOfMemory]
      list->p_data_unions[iterate] = temp_du[iterate];
                                     ^
POWTOF_texture.c:7935:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
POWTOF_texture.c:7935:50: note: Assignment 'temp_du=malloc(list->num_elements*sizeof(union conditional_data_union))', assigned value is 0
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
POWTOF_texture.c:7950:38: note: Null pointer dereference
      list->p_data_unions[iterate] = temp_du[iterate];
                                     ^
POWTOF_texture.c:8043:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->positions[iterate];
        ^
POWTOF_texture.c:8038:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
POWTOF_texture.c:8038:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
POWTOF_texture.c:8043:9: note: Null pointer dereference
        temp[iterate] = list->positions[iterate];
        ^
POWTOF_texture.c:8050:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->positions[iterate] = temp[iterate];
                                   ^
POWTOF_texture.c:8038:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
POWTOF_texture.c:8038:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
POWTOF_texture.c:8050:36: note: Null pointer dereference
        list->positions[iterate] = temp[iterate];
                                   ^
POWTOF_texture.c:8066:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->rotations[iterate];
        ^
POWTOF_texture.c:8063:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
POWTOF_texture.c:8063:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
POWTOF_texture.c:8066:9: note: Null pointer dereference
        temp[iterate] = list->rotations[iterate];
        ^
POWTOF_texture.c:8072:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->rotations[iterate] = temp[iterate];
                                   ^
POWTOF_texture.c:8063:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
POWTOF_texture.c:8063:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
POWTOF_texture.c:8072:36: note: Null pointer dereference
        list->rotations[iterate] = temp[iterate];
                                   ^
POWTOF_texture.c:8087:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8085:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
POWTOF_texture.c:8085:56: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_process_element_struct))', assigned value is 0
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
POWTOF_texture.c:8087:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8091:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8085:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
POWTOF_texture.c:8085:56: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_process_element_struct))', assigned value is 0
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
POWTOF_texture.c:8091:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8106:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8104:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
POWTOF_texture.c:8104:55: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_material_element_struct))', assigned value is 0
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
POWTOF_texture.c:8106:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8110:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8104:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
POWTOF_texture.c:8104:55: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_material_element_struct))', assigned value is 0
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
POWTOF_texture.c:8110:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8125:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8123:56: note: Assuming allocation function fails
      struct global_surface_element_struct *temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct));
                                                       ^
POWTOF_texture.c:8123:56: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct))', assigned value is 0
      struct global_surface_element_struct *temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct));
                                                       ^
POWTOF_texture.c:8125:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8129:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8123:56: note: Assuming allocation function fails
      struct global_surface_element_struct *temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct));
                                                       ^
POWTOF_texture.c:8123:56: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct))', assigned value is 0
      struct global_surface_element_struct *temp=malloc(list->num_elements*sizeof(struct global_surface_element_struct));
                                                       ^
POWTOF_texture.c:8129:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8167:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8165:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
POWTOF_texture.c:8165:55: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct))', assigned value is 0
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
POWTOF_texture.c:8167:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8171:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8165:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
POWTOF_texture.c:8165:55: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct))', assigned value is 0
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
POWTOF_texture.c:8171:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8186:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8184:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
POWTOF_texture.c:8184:53: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct))', assigned value is 0
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
POWTOF_texture.c:8186:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8190:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8184:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
POWTOF_texture.c:8184:53: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct))', assigned value is 0
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
POWTOF_texture.c:8190:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8205:60: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:8203:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
POWTOF_texture.c:8203:59: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct))', assigned value is 0
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
POWTOF_texture.c:8205:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
POWTOF_texture.c:8209:88: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:8203:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
POWTOF_texture.c:8203:59: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct))', assigned value is 0
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
POWTOF_texture.c:8209:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
POWTOF_texture.c:8224:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8222:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
POWTOF_texture.c:8222:66: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct))', assigned value is 0
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
POWTOF_texture.c:8224:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8228:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8222:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
POWTOF_texture.c:8222:66: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct))', assigned value is 0
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
POWTOF_texture.c:8228:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8243:58: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8241:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
POWTOF_texture.c:8241:53: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_master_element_struct))', assigned value is 0
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
POWTOF_texture.c:8243:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
POWTOF_texture.c:8247:86: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8241:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
POWTOF_texture.c:8241:53: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct global_master_element_struct))', assigned value is 0
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
POWTOF_texture.c:8247:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
POWTOF_texture.c:8266:61: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<loggers->num_elements;iterate++) temp[iterate] = loggers->p_logger_volume[iterate];
                                                            ^
POWTOF_texture.c:8264:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
POWTOF_texture.c:8264:53: note: Assignment 'temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list))', assigned value is 0
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
POWTOF_texture.c:8266:61: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements;iterate++) temp[iterate] = loggers->p_logger_volume[iterate];
                                                            ^
POWTOF_texture.c:8270:99: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<loggers->num_elements-1;iterate++) loggers->p_logger_volume[iterate] = temp[iterate];
                                                                                                  ^
POWTOF_texture.c:8264:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
POWTOF_texture.c:8264:53: note: Assignment 'temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list))', assigned value is 0
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
POWTOF_texture.c:8270:99: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements-1;iterate++) loggers->p_logger_volume[iterate] = temp[iterate];
                                                                                                  ^
POWTOF_texture.c:8317:65: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<abs_loggers->num_elements;iterate++) temp[iterate] = abs_loggers->p_abs_logger[iterate];
                                                                ^
POWTOF_texture.c:8315:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
POWTOF_texture.c:8315:43: note: Assignment 'temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct*))', assigned value is 0
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
POWTOF_texture.c:8317:65: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements;iterate++) temp[iterate] = abs_loggers->p_abs_logger[iterate];
                                                                ^
POWTOF_texture.c:8322:104: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
    for (iterate=0;iterate<abs_loggers->num_elements-1;iterate++) abs_loggers->p_abs_logger[iterate] = temp[iterate];
                                                                                                       ^
POWTOF_texture.c:8315:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
POWTOF_texture.c:8315:43: note: Assignment 'temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct*))', assigned value is 0
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
POWTOF_texture.c:8322:104: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements-1;iterate++) abs_loggers->p_abs_logger[iterate] = temp[iterate];
                                                                                                       ^
POWTOF_texture.c:8616:13: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
    fprintf(fp,"%d\t N I=%E \t", history->number_of_rays, history->intensity);
            ^
POWTOF_texture.c:8780:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
POWTOF_texture.c:8780:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
POWTOF_texture.c:8780:3: note: Calling function 'fprintf_total_history', 2nd argument 'fp' value is 0
  MPI_MASTER(
  ^
POWTOF_texture.c:8616:13: note: Null pointer dereference
    fprintf(fp,"%d\t N I=%E \t", history->number_of_rays, history->intensity);
            ^
POWTOF_texture.c:8780:3: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  MPI_MASTER(
  ^
POWTOF_texture.c:8780:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
POWTOF_texture.c:8780:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
POWTOF_texture.c:8780:3: note: Null pointer dereference
  MPI_MASTER(
  ^
POWTOF_texture.c:8912:73: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_lines [nullPointerOutOfMemory]
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) temp_lines[iterate] = lines_master->lines[iterate];
                                                                        ^
POWTOF_texture.c:8911:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
POWTOF_texture.c:8911:24: note: Assignment 'temp_lines=malloc(lines_master->number_of_lines*sizeof(struct line_segment))', assigned value is 0
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
POWTOF_texture.c:8912:73: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) temp_lines[iterate] = lines_master->lines[iterate];
                                                                        ^
POWTOF_texture.c:8915:104: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_lines [nullPointerOutOfMemory]
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) lines_master->lines[iterate] = temp_lines[iterate];
                                                                                                       ^
POWTOF_texture.c:8911:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
POWTOF_texture.c:8911:24: note: Assignment 'temp_lines=malloc(lines_master->number_of_lines*sizeof(struct line_segment))', assigned value is 0
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
POWTOF_texture.c:8915:104: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) lines_master->lines[iterate] = temp_lines[iterate];
                                                                                                       ^
POWTOF_texture.c:9085:5: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
    points[0] = coords_set(r1[0],r1[1],r1[2]);
    ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9085:5: note: Null pointer dereference
    points[0] = coords_set(r1[0],r1[1],r1[2]);
    ^
POWTOF_texture.c:9086:5: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
    points[intersection_list.num_elements+1] = coords_set(r2[0],r2[1],r2[2]);
    ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9086:5: note: Null pointer dereference
    points[intersection_list.num_elements+1] = coords_set(r2[0],r2[1],r2[2]);
    ^
POWTOF_texture.c:9088:9: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        points[iterate].x = r1[0] + direction[0]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9088:9: note: Null pointer dereference
        points[iterate].x = r1[0] + direction[0]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9089:9: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        points[iterate].y = r1[1] + direction[1]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9089:9: note: Null pointer dereference
        points[iterate].y = r1[1] + direction[1]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9090:9: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        points[iterate].z = r1[2] + direction[2]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9090:9: note: Null pointer dereference
        points[iterate].z = r1[2] + direction[2]*intersection_list.elements[iterate-1];
        ^
POWTOF_texture.c:9110:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
        ^
POWTOF_texture.c:9099:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9099:38: note: Assignment 'lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment))', assigned value is 0
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9110:9: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
        ^
POWTOF_texture.c:9110:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
                                ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9110:33: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
                                ^
POWTOF_texture.c:9111:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
        ^
POWTOF_texture.c:9099:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9099:38: note: Assignment 'lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment))', assigned value is 0
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9111:9: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
        ^
POWTOF_texture.c:9111:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
                                ^
POWTOF_texture.c:9084:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9084:26: note: Assignment 'points=malloc((intersection_list.num_elements+2)*sizeof(struct Coords))', assigned value is 0
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
POWTOF_texture.c:9111:33: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
                                ^
POWTOF_texture.c:9112:27: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                          ^
POWTOF_texture.c:9099:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9099:38: note: Assignment 'lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment))', assigned value is 0
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9112:27: note: Null pointer dereference
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                          ^
POWTOF_texture.c:9113:27: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                          ^
POWTOF_texture.c:9099:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9099:38: note: Assignment 'lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment))', assigned value is 0
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9113:27: note: Null pointer dereference
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                          ^
POWTOF_texture.c:9114:27: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                          ^
POWTOF_texture.c:9099:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9099:38: note: Assignment 'lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment))', assigned value is 0
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
POWTOF_texture.c:9114:27: note: Null pointer dereference
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                          ^
POWTOF_texture.c:9326:16: warning: If memory allocation fails, then there is a possible null pointer dereference: union_output.p_box_storage [nullPointerOutOfMemory]
  *union_output.p_box_storage = *union_input->p_box_storage;
               ^
POWTOF_texture.c:9324:38: note: Assuming allocation function fails
  union_output.p_box_storage = malloc(sizeof(struct box_storage));
                                     ^
POWTOF_texture.c:9324:38: note: Assignment 'union_output.p_box_storage=malloc(sizeof(struct box_storage))', assigned value is 0
  union_output.p_box_storage = malloc(sizeof(struct box_storage));
                                     ^
POWTOF_texture.c:9326:16: note: Null pointer dereference
  *union_output.p_box_storage = *union_input->p_box_storage;
               ^
POWTOF_texture.c:9337:16: warning: If memory allocation fails, then there is a possible null pointer dereference: union_output.p_cylinder_storage [nullPointerOutOfMemory]
  *union_output.p_cylinder_storage = *union_input->p_cylinder_storage;
               ^
POWTOF_texture.c:9335:43: note: Assuming allocation function fails
  union_output.p_cylinder_storage = malloc(sizeof(struct cylinder_storage));
                                          ^
POWTOF_texture.c:9335:43: note: Assignment 'union_output.p_cylinder_storage=malloc(sizeof(struct cylinder_storage))', assigned value is 0
  union_output.p_cylinder_storage = malloc(sizeof(struct cylinder_storage));
                                          ^
POWTOF_texture.c:9337:16: note: Null pointer dereference
  *union_output.p_cylinder_storage = *union_input->p_cylinder_storage;
               ^
POWTOF_texture.c:9347:16: warning: If memory allocation fails, then there is a possible null pointer dereference: union_output.p_sphere_storage [nullPointerOutOfMemory]
  *union_output.p_sphere_storage = *union_input->p_sphere_storage;
               ^
POWTOF_texture.c:9345:41: note: Assuming allocation function fails
  union_output.p_sphere_storage = malloc(sizeof(struct sphere_storage));
                                        ^
POWTOF_texture.c:9345:41: note: Assignment 'union_output.p_sphere_storage=malloc(sizeof(struct sphere_storage))', assigned value is 0
  union_output.p_sphere_storage = malloc(sizeof(struct sphere_storage));
                                        ^
POWTOF_texture.c:9347:16: note: Null pointer dereference
  *union_output.p_sphere_storage = *union_input->p_sphere_storage;
               ^
POWTOF_texture.c:9357:16: warning: If memory allocation fails, then there is a possible null pointer dereference: union_output.p_cone_storage [nullPointerOutOfMemory]
  *union_output.p_cone_storage = *union_input->p_cone_storage;
               ^
POWTOF_texture.c:9355:39: note: Assuming allocation function fails
  union_output.p_cone_storage = malloc(sizeof(struct cone_storage));
                                      ^
POWTOF_texture.c:9355:39: note: Assignment 'union_output.p_cone_storage=malloc(sizeof(struct cone_storage))', assigned value is 0
  union_output.p_cone_storage = malloc(sizeof(struct cone_storage));
                                      ^
POWTOF_texture.c:9357:16: note: Null pointer dereference
  *union_output.p_cone_storage = *union_input->p_cone_storage;
               ^
POWTOF_texture.c:9367:16: warning: If memory allocation fails, then there is a possible null pointer dereference: union_output.p_mesh_storage [nullPointerOutOfMemory]
  *union_output.p_mesh_storage = *union_input->p_mesh_storage;
               ^
POWTOF_texture.c:9365:39: note: Assuming allocation function fails
  union_output.p_mesh_storage = malloc(sizeof(struct mesh_storage));
                                      ^
POWTOF_texture.c:9365:39: note: Assignment 'union_output.p_mesh_storage=malloc(sizeof(struct mesh_storage))', assigned value is 0
  union_output.p_mesh_storage = malloc(sizeof(struct mesh_storage));
                                      ^
POWTOF_texture.c:9367:16: note: Null pointer dereference
  *union_output.p_mesh_storage = *union_input->p_mesh_storage;
               ^
POWTOF_texture.c:9425:9: warning: If memory allocation fails, then there is a possible null pointer dereference: output [nullPointerOutOfMemory]
        rotate(output[point_nr].x,output[point_nr].y,output[point_nr].z,cross_product.x,cross_product.y,cross_product.z,rotate_angle,direction.x,direction.y,direction.z);
        ^
POWTOF_texture.c:13135:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13135:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13137:22: note: Calling function 'points_on_circle', 1st argument 'circle_point_array' value is 0
    points_on_circle(circle_point_array,cyl_top_point,cyl_direction,radius,number_of_points);
                     ^
POWTOF_texture.c:9425:9: note: Null pointer dereference
        rotate(output[point_nr].x,output[point_nr].y,output[point_nr].z,cross_product.x,cross_product.y,cross_product.z,rotate_angle,direction.x,direction.y,direction.z);
        ^
POWTOF_texture.c:9426:9: warning: If memory allocation fails, then there is a possible null pointer dereference: output [nullPointerOutOfMemory]
        output[point_nr] = coords_add(output[point_nr],center);
        ^
POWTOF_texture.c:13135:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13135:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13137:22: note: Calling function 'points_on_circle', 1st argument 'circle_point_array' value is 0
    points_on_circle(circle_point_array,cyl_top_point,cyl_direction,radius,number_of_points);
                     ^
POWTOF_texture.c:9426:9: note: Null pointer dereference
        output[point_nr] = coords_add(output[point_nr],center);
        ^
POWTOF_texture.c:12335:43: warning: If memory allocation fails, then there is a possible null pointer dereference: circle_point_array [nullPointerOutOfMemory]
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
POWTOF_texture.c:12329:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:12329:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:12335:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
POWTOF_texture.c:12343:43: warning: If memory allocation fails, then there is a possible null pointer dereference: circle_point_array [nullPointerOutOfMemory]
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
POWTOF_texture.c:12329:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:12329:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:12335:85: note: Assuming condition is false
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                                                                    ^
POWTOF_texture.c:12343:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
POWTOF_texture.c:13142:46: warning: If memory allocation fails, then there is a possible null pointer dereference: circle_point_array [nullPointerOutOfMemory]
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
POWTOF_texture.c:13135:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13135:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13142:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
POWTOF_texture.c:13150:46: warning: If memory allocation fails, then there is a possible null pointer dereference: circle_point_array [nullPointerOutOfMemory]
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
POWTOF_texture.c:13135:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13135:32: note: Assignment 'circle_point_array=malloc(number_of_points*sizeof(struct Coords))', assigned value is 0
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
POWTOF_texture.c:13142:91: note: Assuming condition is false
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                                                                          ^
POWTOF_texture.c:13150:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
POWTOF_texture.c:13969:3: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
  temporary_children_lists[0].num_elements = number_of_volumes - 1;
  ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13969:3: note: Null pointer dereference
  temporary_children_lists[0].num_elements = number_of_volumes - 1;
  ^
POWTOF_texture.c:13970:3: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
  ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13970:3: note: Null pointer dereference
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
  ^
POWTOF_texture.c:13974:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
      temporary_children_lists[0].elements[parent-1] = parent;
      ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13974:7: note: Null pointer dereference
      temporary_children_lists[0].elements[parent-1] = parent;
      ^
POWTOF_texture.c:13983:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
  true_children_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:13983:3: note: Null pointer dereference
  true_children_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:13984:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
  true_children_lists[0]->num_elements = number_of_volumes - 1;
  ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:13984:3: note: Null pointer dereference
  true_children_lists[0]->num_elements = number_of_volumes - 1;
  ^
POWTOF_texture.c:13985:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
  true_children_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:13985:3: note: Null pointer dereference
  true_children_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
POWTOF_texture.c:13991:7: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
      true_children_lists[0]->elements[parent-1] = parent;
      ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:13991:7: note: Null pointer dereference
      true_children_lists[0]->elements[parent-1] = parent;
      ^
POWTOF_texture.c:14026:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
      temporary_children_lists[parent].num_elements=0;
      ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:14026:7: note: Null pointer dereference
      temporary_children_lists[parent].num_elements=0;
      ^
POWTOF_texture.c:14030:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:14030:7: note: Null pointer dereference
      MPI_MASTER(
      ^
POWTOF_texture.c:14154:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    true_children_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:14154:5: note: Null pointer dereference
    true_children_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:14155:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    true_children_lists[parent]->num_elements = 0;
    ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:14155:5: note: Null pointer dereference
    true_children_lists[parent]->num_elements = 0;
    ^
POWTOF_texture.c:14156:64: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    allocate_list_from_temp(used_elements,true_temp_list_local,true_children_lists[parent]);
                                                               ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:14156:64: note: Null pointer dereference
    allocate_list_from_temp(used_elements,true_temp_list_local,true_children_lists[parent]);
                                                               ^
POWTOF_texture.c:14158:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15604:38: note: Calling function 'generate_children_lists', 2nd argument 'true_children_lists' value is 0
    generate_children_lists(Volumes, true_children_lists, number_of_volumes,verbal);
                                     ^
POWTOF_texture.c:14158:5: note: Null pointer dereference
    MPI_MASTER(
    ^
POWTOF_texture.c:14167:53: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
  for(child=0;child<number_of_volumes;child++) free(temporary_children_lists[child].elements);
                                                    ^
POWTOF_texture.c:13966:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:13966:36: note: Assignment 'temporary_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
POWTOF_texture.c:14167:53: note: Null pointer dereference
  for(child=0;child<number_of_volumes;child++) free(temporary_children_lists[child].elements);
                                                    ^
POWTOF_texture.c:14189:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  true_overlap_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14189:3: note: Null pointer dereference
  true_overlap_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:14190:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  true_overlap_lists[0]->num_elements = number_of_volumes-1;
  ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14190:3: note: Null pointer dereference
  true_overlap_lists[0]->num_elements = number_of_volumes-1;
  ^
POWTOF_texture.c:14191:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  true_overlap_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14191:3: note: Null pointer dereference
  true_overlap_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
POWTOF_texture.c:14193:3: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
  raw_overlap_lists[0] =  malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14193:3: note: Null pointer dereference
  raw_overlap_lists[0] =  malloc(sizeof(struct pointer_to_1d_int_list));
  ^
POWTOF_texture.c:14194:3: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
  raw_overlap_lists[0]->num_elements = number_of_volumes;
  ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14194:3: note: Null pointer dereference
  raw_overlap_lists[0]->num_elements = number_of_volumes;
  ^
POWTOF_texture.c:14195:3: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
  raw_overlap_lists[0]->elements = malloc(number_of_volumes*sizeof(int));
  ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14195:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements = malloc(number_of_volumes*sizeof(int));
  ^
POWTOF_texture.c:14196:3: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
  raw_overlap_lists[0]->elements[0] = 0; // Volume 0 overlaps itself
  ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14196:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements[0] = 0; // Volume 0 overlaps itself
  ^
POWTOF_texture.c:14200:7: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
      true_overlap_lists[0]->elements[parent-1] = parent;
      ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14200:7: note: Null pointer dereference
      true_overlap_lists[0]->elements[parent-1] = parent;
      ^
POWTOF_texture.c:14201:7: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
      raw_overlap_lists[0]->elements[parent] = parent;
      ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14201:7: note: Null pointer dereference
      raw_overlap_lists[0]->elements[parent] = parent;
      ^
POWTOF_texture.c:14205:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  MPI_MASTER(
  ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14205:3: note: Null pointer dereference
  MPI_MASTER(
  ^
POWTOF_texture.c:14218:7: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
      true_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14218:7: note: Null pointer dereference
      true_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
POWTOF_texture.c:14291:7: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
      raw_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14291:7: note: Null pointer dereference
      raw_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
POWTOF_texture.c:14292:7: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
      raw_overlap_lists[parent]->num_elements = 0;
      ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14292:7: note: Null pointer dereference
      raw_overlap_lists[parent]->num_elements = 0;
      ^
POWTOF_texture.c:14293:61: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
      allocate_list_from_temp(used_elements,temp_list_local,raw_overlap_lists[parent]);
                                                            ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15612:48: note: Calling function 'generate_overlap_lists', 2nd argument 'raw_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                                               ^
POWTOF_texture.c:14293:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,raw_overlap_lists[parent]);
                                                            ^
POWTOF_texture.c:14296:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_overlap_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
POWTOF_texture.c:14186:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
POWTOF_texture.c:14186:35: note: Assignment 'temporary_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
POWTOF_texture.c:14296:7: note: Null pointer dereference
      MPI_MASTER(
      ^
POWTOF_texture.c:14409:59: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    allocate_list_from_temp(used_elements,temp_list_local,true_overlap_lists[parent]);
                                                          ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14409:59: note: Null pointer dereference
    allocate_list_from_temp(used_elements,temp_list_local,true_overlap_lists[parent]);
                                                          ^
POWTOF_texture.c:14411:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15612:28: note: Calling function 'generate_overlap_lists', 1st argument 'true_overlap_lists' value is 0
    generate_overlap_lists(true_overlap_lists, raw_overlap_lists, Volumes,number_of_volumes,verbal);
                           ^
POWTOF_texture.c:14411:5: note: Null pointer dereference
    MPI_MASTER(
    ^
POWTOF_texture.c:14417:53: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_overlap_lists [nullPointerOutOfMemory]
  for(child=1;child<number_of_volumes;child++) free(temporary_overlap_lists[child].elements);
                                                    ^
POWTOF_texture.c:14186:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
POWTOF_texture.c:14186:35: note: Assignment 'temporary_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list))', assigned value is 0
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
POWTOF_texture.c:14417:53: note: Null pointer dereference
  for(child=1;child<number_of_volumes;child++) free(temporary_overlap_lists[child].elements);
                                                    ^
POWTOF_texture.c:14709:5: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15620:28: note: Calling function 'generate_parents_lists', 1st argument 'parents_lists' value is 0
    generate_parents_lists(parents_lists,Volumes,number_of_volumes,verbal,1); // The last 1 means masks are taken into account
                           ^
POWTOF_texture.c:14709:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:14715:61: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15620:28: note: Calling function 'generate_parents_lists', 1st argument 'parents_lists' value is 0
    generate_parents_lists(parents_lists,Volumes,number_of_volumes,verbal,1); // The last 1 means masks are taken into account
                           ^
POWTOF_texture.c:14715:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
POWTOF_texture.c:14757:5: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list)); // allocate_list_from_temp allocates
    ^
POWTOF_texture.c:15629:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15629:32: note: Assignment 'true_parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15630:33: note: Calling function 'generate_true_parents_lists', 1st argument 'true_parents_lists' value is 0
    generate_true_parents_lists(true_parents_lists, true_children_lists, Volumes, number_of_volumes, verbal, 1);
                                ^
POWTOF_texture.c:14757:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list)); // allocate_list_from_temp allocates
    ^
POWTOF_texture.c:14760:26: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
        if (on_int_list(*true_children_lists[parent],iterate))
                         ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15630:53: note: Calling function 'generate_true_parents_lists', 2nd argument 'true_children_lists' value is 0
    generate_true_parents_lists(true_parents_lists, true_children_lists, Volumes, number_of_volumes, verbal, 1);
                                                    ^
POWTOF_texture.c:14760:26: note: Null pointer dereference
        if (on_int_list(*true_children_lists[parent],iterate))
                         ^
POWTOF_texture.c:14764:61: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
POWTOF_texture.c:15629:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15629:32: note: Assignment 'true_parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15630:33: note: Calling function 'generate_true_parents_lists', 1st argument 'true_parents_lists' value is 0
    generate_true_parents_lists(true_parents_lists, true_children_lists, Volumes, number_of_volumes, verbal, 1);
                                ^
POWTOF_texture.c:14764:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
POWTOF_texture.c:14964:5: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
    grandparents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:15641:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15641:32: note: Assignment 'grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15642:33: note: Calling function 'generate_grandparents_lists', 1st argument 'grandparents_lists' value is 0
    generate_grandparents_lists(grandparents_lists,parents_lists,number_of_volumes,verbal);
                                ^
POWTOF_texture.c:14964:5: note: Null pointer dereference
    grandparents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
POWTOF_texture.c:14966:29: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
    for (parent = 0; parent<parents_lists[iterate]->num_elements; parent++) {
                            ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15642:52: note: Calling function 'generate_grandparents_lists', 2nd argument 'parents_lists' value is 0
    generate_grandparents_lists(grandparents_lists,parents_lists,number_of_volumes,verbal);
                                                   ^
POWTOF_texture.c:14966:29: note: Null pointer dereference
    for (parent = 0; parent<parents_lists[iterate]->num_elements; parent++) {
                            ^
POWTOF_texture.c:14968:27: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                          ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15642:52: note: Calling function 'generate_grandparents_lists', 2nd argument 'parents_lists' value is 0
    generate_grandparents_lists(grandparents_lists,parents_lists,number_of_volumes,verbal);
                                                   ^
POWTOF_texture.c:14968:27: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                          ^
POWTOF_texture.c:14977:61: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
    allocate_list_from_temp(used_elements, temp_list_local, grandparents_lists[iterate]);
                                                            ^
POWTOF_texture.c:15641:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15641:32: note: Assignment 'grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15642:33: note: Calling function 'generate_grandparents_lists', 1st argument 'grandparents_lists' value is 0
    generate_grandparents_lists(grandparents_lists,parents_lists,number_of_volumes,verbal);
                                ^
POWTOF_texture.c:14977:61: note: Null pointer dereference
    allocate_list_from_temp(used_elements, temp_list_local, grandparents_lists[iterate]);
                                                            ^
POWTOF_texture.c:14980:5: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
POWTOF_texture.c:15641:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15641:32: note: Assignment 'grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15642:33: note: Calling function 'generate_grandparents_lists', 1st argument 'grandparents_lists' value is 0
    generate_grandparents_lists(grandparents_lists,parents_lists,number_of_volumes,verbal);
                                ^
POWTOF_texture.c:14980:5: note: Null pointer dereference
    MPI_MASTER(
    ^
POWTOF_texture.c:15007:30: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    work_list.num_elements = true_overlap_lists[volume_index]->num_elements;
                             ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15660:46: note: Calling function 'generate_destinations_lists_experimental', 1st argument 'true_overlap_lists' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                             ^
POWTOF_texture.c:15007:30: note: Null pointer dereference
    work_list.num_elements = true_overlap_lists[volume_index]->num_elements;
                             ^
POWTOF_texture.c:15009:92: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    for (iterate=0;iterate<work_list.num_elements;iterate++) work_list.elements[iterate] = true_overlap_lists[volume_index]->elements[iterate];
                                                                                           ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15660:46: note: Calling function 'generate_destinations_lists_experimental', 1st argument 'true_overlap_lists' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                             ^
POWTOF_texture.c:15009:92: note: Null pointer dereference
    for (iterate=0;iterate<work_list.num_elements;iterate++) work_list.elements[iterate] = true_overlap_lists[volume_index]->elements[iterate];
                                                                                           ^
POWTOF_texture.c:15054:28: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    for (iterate=0;iterate<true_children_lists[volume_index]->num_elements;iterate++)
                           ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15660:66: note: Calling function 'generate_destinations_lists_experimental', 2nd argument 'true_children_lists' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                                                 ^
POWTOF_texture.c:15054:28: note: Null pointer dereference
    for (iterate=0;iterate<true_children_lists[volume_index]->num_elements;iterate++)
                           ^
POWTOF_texture.c:15055:50: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
      remove_element_in_list_by_value(&work_list,true_children_lists[volume_index]->elements[iterate]);
                                                 ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15660:66: note: Calling function 'generate_destinations_lists_experimental', 2nd argument 'true_children_lists' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                                                 ^
POWTOF_texture.c:15055:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_children_lists[volume_index]->elements[iterate]);
                                                 ^
POWTOF_texture.c:15060:28: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
    for (iterate=0;iterate<true_grandparents_lists[volume_index]->num_elements;iterate++)
                           ^
POWTOF_texture.c:15655:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15655:46: note: Assignment 'true_grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15660:116: note: Calling function 'generate_destinations_lists_experimental', 4th argument 'true_grandparents_lists_no_masks' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                                                                                                   ^
POWTOF_texture.c:15060:28: note: Null pointer dereference
    for (iterate=0;iterate<true_grandparents_lists[volume_index]->num_elements;iterate++)
                           ^
POWTOF_texture.c:15061:50: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
      remove_element_in_list_by_value(&work_list,true_grandparents_lists[volume_index]->elements[iterate]);
                                                 ^
POWTOF_texture.c:15655:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15655:46: note: Assignment 'true_grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15660:116: note: Calling function 'generate_destinations_lists_experimental', 4th argument 'true_grandparents_lists_no_masks' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                                                                                                   ^
POWTOF_texture.c:15061:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_grandparents_lists[volume_index]->elements[iterate]);
                                                 ^
POWTOF_texture.c:15075:24: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists [nullPointerOutOfMemory]
      if (on_int_list(*true_parents_lists[volume_index],work_list.elements[iterate])){
                       ^
POWTOF_texture.c:15634:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15634:41: note: Assignment 'true_parents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15660:87: note: Calling function 'generate_destinations_lists_experimental', 3rd argument 'true_parents_lists_no_masks' value is 0
    generate_destinations_lists_experimental(true_overlap_lists, true_children_lists, true_parents_lists_no_masks, true_grandparents_lists_no_masks, Volumes, number_of_volumes, verbal);
                                                                                      ^
POWTOF_texture.c:15075:24: note: Null pointer dereference
      if (on_int_list(*true_parents_lists[volume_index],work_list.elements[iterate])){
                       ^
POWTOF_texture.c:15375:34: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
            for (parent=0;parent<parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->num_elements;parent++) {
                                 ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15667:36: note: Calling function 'generate_direct_children_lists', 1st argument 'parents_lists' value is 0
    generate_direct_children_lists(parents_lists,Volumes,number_of_volumes,verbal);
                                   ^
POWTOF_texture.c:15375:34: note: Null pointer dereference
            for (parent=0;parent<parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->num_elements;parent++) {
                                 ^
POWTOF_texture.c:15376:74: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
                if (on_int_list(Volumes[volume_index]->geometry.children,parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->elements[parent]))
                                                                         ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15667:36: note: Calling function 'generate_direct_children_lists', 1st argument 'parents_lists' value is 0
    generate_direct_children_lists(parents_lists,Volumes,number_of_volumes,verbal);
                                   ^
POWTOF_texture.c:15376:74: note: Null pointer dereference
                if (on_int_list(Volumes[volume_index]->geometry.children,parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->elements[parent]))
                                                                         ^
POWTOF_texture.c:15682:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
        if (true_overlap_lists[iterate]->num_elements > 0) free(true_overlap_lists[iterate]->elements);
            ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15682:13: note: Null pointer dereference
        if (true_overlap_lists[iterate]->num_elements > 0) free(true_overlap_lists[iterate]->elements);
            ^
POWTOF_texture.c:15683:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
        free(true_overlap_lists[iterate]);
             ^
POWTOF_texture.c:15608:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15608:32: note: Assignment 'true_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15683:14: note: Null pointer dereference
        free(true_overlap_lists[iterate]);
             ^
POWTOF_texture.c:15686:13: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
        if (raw_overlap_lists[iterate]->num_elements > 0) free(raw_overlap_lists[iterate]->elements);
            ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15686:13: note: Null pointer dereference
        if (raw_overlap_lists[iterate]->num_elements > 0) free(raw_overlap_lists[iterate]->elements);
            ^
POWTOF_texture.c:15687:14: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
        free(raw_overlap_lists[iterate]);
             ^
POWTOF_texture.c:15610:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15610:31: note: Assignment 'raw_overlap_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
POWTOF_texture.c:15687:14: note: Null pointer dereference
        free(raw_overlap_lists[iterate]);
             ^
POWTOF_texture.c:15690:13: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
        if (parents_lists[iterate]->num_elements > 0) free(parents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15690:13: note: Null pointer dereference
        if (parents_lists[iterate]->num_elements > 0) free(parents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15691:14: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
        free(parents_lists[iterate]);
             ^
POWTOF_texture.c:15619:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15619:27: note: Assignment 'parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
POWTOF_texture.c:15691:14: note: Null pointer dereference
        free(parents_lists[iterate]);
             ^
POWTOF_texture.c:15694:13: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists_no_masks [nullPointerOutOfMemory]
        if (parents_lists_no_masks[iterate]->num_elements > 0) free(parents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15624:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
POWTOF_texture.c:15624:36: note: Assignment 'parents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
POWTOF_texture.c:15694:13: note: Null pointer dereference
        if (parents_lists_no_masks[iterate]->num_elements > 0) free(parents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15695:14: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists_no_masks [nullPointerOutOfMemory]
        free(parents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15624:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
POWTOF_texture.c:15624:36: note: Assignment 'parents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
POWTOF_texture.c:15695:14: note: Null pointer dereference
        free(parents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15698:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists [nullPointerOutOfMemory]
        if (true_parents_lists[iterate]->num_elements > 0) free(true_parents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15629:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15629:32: note: Assignment 'true_parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15698:13: note: Null pointer dereference
        if (true_parents_lists[iterate]->num_elements > 0) free(true_parents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15699:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists [nullPointerOutOfMemory]
        free(true_parents_lists[iterate]);
             ^
POWTOF_texture.c:15629:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15629:32: note: Assignment 'true_parents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15699:14: note: Null pointer dereference
        free(true_parents_lists[iterate]);
             ^
POWTOF_texture.c:15702:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists_no_masks [nullPointerOutOfMemory]
        if (true_parents_lists_no_masks[iterate]->num_elements > 0) free(true_parents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15634:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15634:41: note: Assignment 'true_parents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15702:13: note: Null pointer dereference
        if (true_parents_lists_no_masks[iterate]->num_elements > 0) free(true_parents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15703:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists_no_masks [nullPointerOutOfMemory]
        free(true_parents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15634:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15634:41: note: Assignment 'true_parents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15703:14: note: Null pointer dereference
        free(true_parents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15706:13: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
        if (grandparents_lists[iterate]->num_elements > 0) free(grandparents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15641:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15641:32: note: Assignment 'grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15706:13: note: Null pointer dereference
        if (grandparents_lists[iterate]->num_elements > 0) free(grandparents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15707:14: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
        free(grandparents_lists[iterate]);
             ^
POWTOF_texture.c:15641:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15641:32: note: Assignment 'grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
POWTOF_texture.c:15707:14: note: Null pointer dereference
        free(grandparents_lists[iterate]);
             ^
POWTOF_texture.c:15710:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
        if (true_grandparents_lists[iterate]->num_elements > 0) free(true_grandparents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15651:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
POWTOF_texture.c:15651:37: note: Assignment 'true_grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
POWTOF_texture.c:15710:13: note: Null pointer dereference
        if (true_grandparents_lists[iterate]->num_elements > 0) free(true_grandparents_lists[iterate]->elements);
            ^
POWTOF_texture.c:15711:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
        free(true_grandparents_lists[iterate]);
             ^
POWTOF_texture.c:15651:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
POWTOF_texture.c:15651:37: note: Assignment 'true_grandparents_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
POWTOF_texture.c:15711:14: note: Null pointer dereference
        free(true_grandparents_lists[iterate]);
             ^
POWTOF_texture.c:15714:13: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists_no_masks [nullPointerOutOfMemory]
        if (grandparents_lists_no_masks[iterate]->num_elements > 0) free(grandparents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15646:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15646:41: note: Assignment 'grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15714:13: note: Null pointer dereference
        if (grandparents_lists_no_masks[iterate]->num_elements > 0) free(grandparents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15715:14: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists_no_masks [nullPointerOutOfMemory]
        free(grandparents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15646:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15646:41: note: Assignment 'grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
POWTOF_texture.c:15715:14: note: Null pointer dereference
        free(grandparents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15718:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists_no_masks [nullPointerOutOfMemory]
        if (true_grandparents_lists_no_masks[iterate]->num_elements > 0) free(true_grandparents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15655:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15655:46: note: Assignment 'true_grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15718:13: note: Null pointer dereference
        if (true_grandparents_lists_no_masks[iterate]->num_elements > 0) free(true_grandparents_lists_no_masks[iterate]->elements);
            ^
POWTOF_texture.c:15719:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists_no_masks [nullPointerOutOfMemory]
        free(true_grandparents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15655:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15655:46: note: Assignment 'true_grandparents_lists_no_masks=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
POWTOF_texture.c:15719:14: note: Null pointer dereference
        free(true_grandparents_lists_no_masks[iterate]);
             ^
POWTOF_texture.c:15722:13: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
        if (true_children_lists[iterate]->num_elements > 0) free(true_children_lists[iterate]->elements);
            ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15722:13: note: Null pointer dereference
        if (true_children_lists[iterate]->num_elements > 0) free(true_children_lists[iterate]->elements);
            ^
POWTOF_texture.c:15723:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
        free(true_children_lists[iterate]);
             ^
POWTOF_texture.c:15602:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15602:33: note: Assignment 'true_children_lists=malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*))', assigned value is 0
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
POWTOF_texture.c:15723:14: note: Null pointer dereference
        free(true_children_lists[iterate]);
             ^
POWTOF_texture.c:15910:11: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fprintf(fp,"r_old x, r_old y, r_old z, old t, r x, r y, r z, new t, weight change, volume index, neutron id \n");
          ^
POWTOF_texture.c:15909:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
POWTOF_texture.c:15909:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
POWTOF_texture.c:15910:11: note: Null pointer dereference
  fprintf(fp,"r_old x, r_old y, r_old z, old t, r x, r y, r z, new t, weight change, volume index, neutron id \n");
          ^
POWTOF_texture.c:15912:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
POWTOF_texture.c:15909:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
POWTOF_texture.c:15909:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
POWTOF_texture.c:15912:10: note: Null pointer dereference
  fclose(fp);
         ^
POWTOF_texture.c:15925:13: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
    fprintf(fp,"%g, %g, %g, %g, %g, %g, %g, %g, %e, %i, %i \n",
            ^
POWTOF_texture.c:15918:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
POWTOF_texture.c:15918:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
POWTOF_texture.c:15925:13: note: Null pointer dereference
    fprintf(fp,"%g, %g, %g, %g, %g, %g, %g, %g, %e, %i, %i \n",
            ^
POWTOF_texture.c:15933:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
POWTOF_texture.c:15918:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
POWTOF_texture.c:15918:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
POWTOF_texture.c:15933:10: note: Null pointer dereference
  fclose(fp);
         ^
POWTOF_texture.c:9140:12: warning: Uninitialized variable: draw_order.lines [uninitvar]
    return draw_order;
           ^
POWTOF_texture.c:9124:36: note: Assuming condition is false
    if (draw_order.number_of_lines > 0) {
                                   ^
POWTOF_texture.c:9140:12: note: Uninitialized variable: draw_order.lines
    return draw_order;
           ^
POWTOF_texture.c:11265:12: warning: Uninitialized variable: output [uninitvar]
    return output;
           ^
POWTOF_texture.c:11172:113: note: Assuming condition is true
 if (sqrt(rotated_velocity.x*rotated_velocity.x+rotated_velocity.z*rotated_velocity.z)/fabs(rotated_velocity.y) < 0.00001) {
                                                                                                                ^
POWTOF_texture.c:11265:12: note: Uninitialized variable: output
    return output;
           ^
POWTOF_texture.c:12998:66: error: Uninitialized variable: square_center [uninitvar]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
POWTOF_texture.c:13874:25: error: Uninitialized variable: temp_pointer [uninitvar]
                ListA = temp_pointer;
                        ^
POWTOF_texture.c:15225:79: warning: Uninitialized variable: logic_list.elements [uninitvar]
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
POWTOF_texture.c:15208:32: note: Assuming condition is false
    if (logic_list.num_elements>0) logic_list.elements = malloc(logic_list.num_elements*sizeof(int));
                               ^
POWTOF_texture.c:15225:79: note: Uninitialized variable: logic_list.elements
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
POWTOF_texture.c:15892:63: error: Uninitialized variable: focus_data.RayAim [uninitvar]
  add_element_to_focus_data_array(&geometry->focus_data_array,focus_data);
                                                              ^
POWTOF_texture.c:12998:66: error: Uninitialized struct member: square_center.x [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
POWTOF_texture.c:12998:66: error: Uninitialized struct member: square_center.y [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
POWTOF_texture.c:12998:66: error: Uninitialized struct member: square_center.z [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);](`url`)