INFO: No output directory specified (--dir)
INFO: Using directory: "Test_texture_20250815_193547"
INFO: Regenerating c-file: Test_texture.c
DEBUG: CMD: /home/willend/micromamba/bin/mcstas -t -o ./Test_texture.c Test_texture.instr
Warning: DECLARE block contains 2 assignments (= sign).
         Move them into an INITIALIZE section. May fail at compile.
CFLAGS= -DFUNNEL 

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

Generating single GPU kernel or single CPU section layout: 
-> SPLIT N at component simulation_master

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

Generating GPU/CPU -DFUNNEL layout:
Component simulation_master is NOACC, CPUONLY=1
-> FUNNEL mode enabled, SPLIT within buffer.
-> SPLIT within buffer at component simulation_master
-> GPU kernel from component monitor

-----------------------------------------------------------
DEBUG: CMD: /home/willend/micromamba/bin/mcstas finished
INFO: Linting generated code: ./Test_texture.c
DEBUG: CMD: cppcheck ./Test_texture.c --check-level=exhaustive --force -DMCDEFAULT_NCOUNT=1000000 -UMC_PORTABLE -DND_BUFFER=10000000 -UNOABSORB_INF_NAN -UOMPI_MPI_H -DSIGABRT -DSIGBREAK -DSIGBUS -DSIGPE -DSIGHUP -DSIGILL -DSIGINT -DSIGKILL -DSIGUSR1 -DSIGUSR2 -DSIGPIPE -DSIGQUIT -DSIGSEGV -DSIGTRAP -DSIGURG -DSIGFPE -DSIGKILL -DSIGTERM -UTEST -UUSE_OPENCL -UWIN32 -UOPENACC -UGCCOFFLOAD -U_MSC_VER -U_MSC_EXTENSIONS -U_WIN32 -UWIN32 -D__unix__ -UDANSE -UFUNNEL -UMC_ANCIENT_COMPATIBILITY -UMC_POL_COMPAT -UNEUTRONICS -Uisnan -Uisinf
Checking Test_texture.c ...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1...
Test_texture.c:19995:46: error: Invalid sqrt() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]
          (ctemp->cr)[l][l+m][l+n] = -sqrt(-1.0);
                                             ^
Test_texture.c:19996:46: error: Invalid sqrt() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]
          (ctemp->ci)[l][l+m][l+n] = -sqrt(-1.0);
                                             ^
Test_texture.c:7812:5: error: Memory leak: temp_logger_with_data.logger_pointers [memleak]
    } else {
    ^
Test_texture.c:7842:5: error: Memory leak: temp_abs_logger_with_data.abs_logger_pointers [memleak]
    } else {
    ^
Test_texture.c:8473:5: error: Memory leak: temp_history.elements [memleak]
    } else {
    ^
Test_texture.c:14718:5: error: Memory leak: removed_under_2.elements [memleak]
    };
    ^
Test_texture.c:7703: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];
                                                                 ^
Test_texture.c:7702:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Test_texture.c:7702:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Test_texture.c:7703:66: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                                 ^
Test_texture.c:7706: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];
                                                                                           ^
Test_texture.c:7702:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Test_texture.c:7702:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Test_texture.c:7706:92: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) list->elements[iterate] = temp[iterate];
                                                                                           ^
Test_texture.c:7740: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];
                                                           ^
Test_texture.c:7738:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7738:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7740:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Test_texture.c:7744: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];
                                                                                       ^
Test_texture.c:7738:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7738:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7744:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Test_texture.c:7758: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];
                                                           ^
Test_texture.c:7756:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7756:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7758:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Test_texture.c:7762: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];
                                                                                       ^
Test_texture.c:7756:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7756:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Test_texture.c:7762:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Test_texture.c:7777: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];
                                                                       ^
Test_texture.c:7775:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
Test_texture.c:7775: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));
                                           ^
Test_texture.c:7777:72: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements;iterate++) temp[iterate] = focus_data_array->elements[iterate];
                                                                       ^
Test_texture.c:7781: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];
                                                                                                               ^
Test_texture.c:7775:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
Test_texture.c:7775: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));
                                           ^
Test_texture.c:7781:112: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements-1;iterate++) focus_data_array->elements[iterate] = temp[iterate];
                                                                                                               ^
Test_texture.c:7864:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
Test_texture.c:7859:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
Test_texture.c:7859: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));
                                                ^
Test_texture.c:7864:7: note: Null pointer dereference
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
Test_texture.c:7865: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];
      ^
Test_texture.c:7860:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
Test_texture.c:7860: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));
                                                 ^
Test_texture.c:7865:7: note: Null pointer dereference
      temp_du[iterate] = list->p_data_unions[iterate];
      ^
Test_texture.c:7874:46: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
Test_texture.c:7859:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
Test_texture.c:7859: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));
                                                ^
Test_texture.c:7874:46: note: Null pointer dereference
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
Test_texture.c:7875: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];
                                     ^
Test_texture.c:7860:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
Test_texture.c:7860: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));
                                                 ^
Test_texture.c:7875:38: note: Null pointer dereference
      list->p_data_unions[iterate] = temp_du[iterate];
                                     ^
Test_texture.c:7968:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->positions[iterate];
        ^
Test_texture.c:7963:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Test_texture.c:7963:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Test_texture.c:7968:9: note: Null pointer dereference
        temp[iterate] = list->positions[iterate];
        ^
Test_texture.c:7975:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->positions[iterate] = temp[iterate];
                                   ^
Test_texture.c:7963:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Test_texture.c:7963:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Test_texture.c:7975:36: note: Null pointer dereference
        list->positions[iterate] = temp[iterate];
                                   ^
Test_texture.c:7991:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->rotations[iterate];
        ^
Test_texture.c:7988:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Test_texture.c:7988:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Test_texture.c:7991:9: note: Null pointer dereference
        temp[iterate] = list->rotations[iterate];
        ^
Test_texture.c:7997:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->rotations[iterate] = temp[iterate];
                                   ^
Test_texture.c:7988:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Test_texture.c:7988:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Test_texture.c:7997:36: note: Null pointer dereference
        list->rotations[iterate] = temp[iterate];
                                   ^
Test_texture.c:8012: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];
                                                         ^
Test_texture.c:8010:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
Test_texture.c:8010: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));
                                                       ^
Test_texture.c:8012:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8016: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];
                                                                                     ^
Test_texture.c:8010:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
Test_texture.c:8010: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));
                                                       ^
Test_texture.c:8016:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8031: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];
                                                         ^
Test_texture.c:8029:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
Test_texture.c:8029: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));
                                                      ^
Test_texture.c:8031:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8035: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];
                                                                                     ^
Test_texture.c:8029:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
Test_texture.c:8029: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));
                                                      ^
Test_texture.c:8035:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8050: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];
                                                         ^
Test_texture.c:8048:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
Test_texture.c:8048: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));
                                                      ^
Test_texture.c:8050:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8054: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];
                                                                                     ^
Test_texture.c:8048:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
Test_texture.c:8048: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));
                                                      ^
Test_texture.c:8054:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8069: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];
                                                         ^
Test_texture.c:8067:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
Test_texture.c:8067: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));
                                                    ^
Test_texture.c:8069:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8073: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];
                                                                                     ^
Test_texture.c:8067:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
Test_texture.c:8067: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));
                                                    ^
Test_texture.c:8073:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8088: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];
                                                           ^
Test_texture.c:8086:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
Test_texture.c:8086: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));
                                                          ^
Test_texture.c:8088:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Test_texture.c:8092: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];
                                                                                       ^
Test_texture.c:8086:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
Test_texture.c:8086: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));
                                                          ^
Test_texture.c:8092:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Test_texture.c:8107: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];
                                                         ^
Test_texture.c:8105:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
Test_texture.c:8105: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));
                                                                 ^
Test_texture.c:8107:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8111: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];
                                                                                     ^
Test_texture.c:8105:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
Test_texture.c:8105: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));
                                                                 ^
Test_texture.c:8111:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8126: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];
                                                         ^
Test_texture.c:8124:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
Test_texture.c:8124: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));
                                                    ^
Test_texture.c:8126:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Test_texture.c:8130: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];
                                                                                     ^
Test_texture.c:8124:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
Test_texture.c:8124: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));
                                                    ^
Test_texture.c:8130:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Test_texture.c:8149: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];
                                                            ^
Test_texture.c:8147:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
Test_texture.c:8147: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));
                                                    ^
Test_texture.c:8149:61: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements;iterate++) temp[iterate] = loggers->p_logger_volume[iterate];
                                                            ^
Test_texture.c:8153: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];
                                                                                                  ^
Test_texture.c:8147:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
Test_texture.c:8147: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));
                                                    ^
Test_texture.c:8153:99: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements-1;iterate++) loggers->p_logger_volume[iterate] = temp[iterate];
                                                                                                  ^
Test_texture.c:8200: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];
                                                                ^
Test_texture.c:8198:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
Test_texture.c:8198: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 *));
                                          ^
Test_texture.c:8200:65: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements;iterate++) temp[iterate] = abs_loggers->p_abs_logger[iterate];
                                                                ^
Test_texture.c:8205: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];
                                                                                                       ^
Test_texture.c:8198:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
Test_texture.c:8198: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 *));
                                          ^
Test_texture.c:8205:104: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements-1;iterate++) abs_loggers->p_abs_logger[iterate] = temp[iterate];
                                                                                                       ^
Test_texture.c:8499: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);
            ^
Test_texture.c:8663:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
Test_texture.c:8663:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
Test_texture.c:8663:3: note: Calling function 'fprintf_total_history', 2nd argument 'fp' value is 0
  MPI_MASTER(
  ^
Test_texture.c:8499:13: note: Null pointer dereference
    fprintf(fp,"%d\t N I=%E \t", history->number_of_rays, history->intensity);
            ^
Test_texture.c:8663:3: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  MPI_MASTER(
  ^
Test_texture.c:8663:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
Test_texture.c:8663:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
Test_texture.c:8663:3: note: Null pointer dereference
  MPI_MASTER(
  ^
Test_texture.c:8785: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];
                                                                        ^
Test_texture.c:8784:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
Test_texture.c:8784: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));
                       ^
Test_texture.c:8785:73: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) temp_lines[iterate] = lines_master->lines[iterate];
                                                                        ^
Test_texture.c:8788: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];
                                                                                                       ^
Test_texture.c:8784:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
Test_texture.c:8784: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));
                       ^
Test_texture.c:8788:104: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) lines_master->lines[iterate] = temp_lines[iterate];
                                                                                                       ^
Test_texture.c:8952: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]);
    ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8952:5: note: Null pointer dereference
    points[0] = coords_set(r1[0],r1[1],r1[2]);
    ^
Test_texture.c:8953: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]);
    ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8953:5: note: Null pointer dereference
    points[intersection_list.num_elements+1] = coords_set(r2[0],r2[1],r2[2]);
    ^
Test_texture.c:8955: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];
        ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8955:9: note: Null pointer dereference
        points[iterate].x = r1[0] + direction[0]*intersection_list.elements[iterate-1];
        ^
Test_texture.c:8956: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];
        ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8956:9: note: Null pointer dereference
        points[iterate].y = r1[1] + direction[1]*intersection_list.elements[iterate-1];
        ^
Test_texture.c:8957: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];
        ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8957:9: note: Null pointer dereference
        points[iterate].z = r1[2] + direction[2]*intersection_list.elements[iterate-1];
        ^
Test_texture.c:8977:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
        ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8977:9: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
        ^
Test_texture.c:8977:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
                                ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8977:33: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
                                ^
Test_texture.c:8978:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
        ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8978:9: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
        ^
Test_texture.c:8978:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
                                ^
Test_texture.c:8951:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Test_texture.c:8951: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));
                         ^
Test_texture.c:8978:33: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
                                ^
Test_texture.c:8979: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);
                          ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8979:27: note: Null pointer dereference
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                          ^
Test_texture.c:8979:53: 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);
                                                    ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8979:53: note: Null pointer dereference
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                                                    ^
Test_texture.c:8980: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);
                          ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8980:27: note: Null pointer dereference
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                          ^
Test_texture.c:8980:53: 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);
                                                    ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8980:53: note: Null pointer dereference
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                                                    ^
Test_texture.c:8981: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);
                          ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8981:27: note: Null pointer dereference
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                          ^
Test_texture.c:8981:53: 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);
                                                    ^
Test_texture.c:8966:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Test_texture.c:8966: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));
                                     ^
Test_texture.c:8981:53: note: Null pointer dereference
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                                                    ^
Test_texture.c:9193: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;
               ^
Test_texture.c:9191:38: note: Assuming allocation function fails
  union_output.p_box_storage = malloc(sizeof(struct box_storage));
                                     ^
Test_texture.c:9191: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));
                                     ^
Test_texture.c:9193:16: note: Null pointer dereference
  *union_output.p_box_storage = *union_input->p_box_storage;
               ^
Test_texture.c:9204: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;
               ^
Test_texture.c:9202:43: note: Assuming allocation function fails
  union_output.p_cylinder_storage = malloc(sizeof(struct cylinder_storage));
                                          ^
Test_texture.c:9202: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));
                                          ^
Test_texture.c:9204:16: note: Null pointer dereference
  *union_output.p_cylinder_storage = *union_input->p_cylinder_storage;
               ^
Test_texture.c:9214: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;
               ^
Test_texture.c:9212:41: note: Assuming allocation function fails
  union_output.p_sphere_storage = malloc(sizeof(struct sphere_storage));
                                        ^
Test_texture.c:9212: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));
                                        ^
Test_texture.c:9214:16: note: Null pointer dereference
  *union_output.p_sphere_storage = *union_input->p_sphere_storage;
               ^
Test_texture.c:9224: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;
               ^
Test_texture.c:9222:39: note: Assuming allocation function fails
  union_output.p_cone_storage = malloc(sizeof(struct cone_storage));
                                      ^
Test_texture.c:9222: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));
                                      ^
Test_texture.c:9224:16: note: Null pointer dereference
  *union_output.p_cone_storage = *union_input->p_cone_storage;
               ^
Test_texture.c:9234: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;
               ^
Test_texture.c:9232:39: note: Assuming allocation function fails
  union_output.p_mesh_storage = malloc(sizeof(struct mesh_storage));
                                      ^
Test_texture.c:9232: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));
                                      ^
Test_texture.c:9234:16: note: Null pointer dereference
  *union_output.p_mesh_storage = *union_input->p_mesh_storage;
               ^
Test_texture.c:9292: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);
        ^
Test_texture.c:12603:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:12603: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));
                               ^
Test_texture.c:12605: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);
                     ^
Test_texture.c:9292: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);
        ^
Test_texture.c:9293: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);
        ^
Test_texture.c:12603:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:12603: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));
                               ^
Test_texture.c:12605: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);
                     ^
Test_texture.c:9293:9: note: Null pointer dereference
        output[point_nr] = coords_add(output[point_nr],center);
        ^
Test_texture.c:9293:39: warning: If memory allocation fails, then there is a possible null pointer dereference: output [nullPointerOutOfMemory]
        output[point_nr] = coords_add(output[point_nr],center);
                                      ^
Test_texture.c:12603:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:12603: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));
                               ^
Test_texture.c:12605: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);
                     ^
Test_texture.c:9293:39: note: Null pointer dereference
        output[point_nr] = coords_add(output[point_nr],center);
                                      ^
Test_texture.c:11803: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) {
                                          ^
Test_texture.c:11797:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:11797: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));
                               ^
Test_texture.c:11803:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
Test_texture.c:11811: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) {
                                          ^
Test_texture.c:11797:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:11797: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));
                               ^
Test_texture.c:11803:85: note: Assuming condition is false
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                                                                    ^
Test_texture.c:11811:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
Test_texture.c:12610: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) {
                                             ^
Test_texture.c:12603:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:12603: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));
                               ^
Test_texture.c:12610:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
Test_texture.c:12618: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) {
                                             ^
Test_texture.c:12603:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Test_texture.c:12603: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));
                               ^
Test_texture.c:12610:91: note: Assuming condition is false
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                                                                          ^
Test_texture.c:12618:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
Test_texture.c:13434: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;
  ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13434:3: note: Null pointer dereference
  temporary_children_lists[0].num_elements = number_of_volumes - 1;
  ^
Test_texture.c:13435: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));
  ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13435:3: note: Null pointer dereference
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
  ^
Test_texture.c:13435:49: 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));
                                                ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13435:49: note: Null pointer dereference
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
                                                ^
Test_texture.c:13439: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;
      ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13439:7: note: Null pointer dereference
      temporary_children_lists[0].elements[parent-1] = parent;
      ^
Test_texture.c:13448: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));
  ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13448:3: note: Null pointer dereference
  true_children_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Test_texture.c:13449: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;
  ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13449:3: note: Null pointer dereference
  true_children_lists[0]->num_elements = number_of_volumes - 1;
  ^
Test_texture.c:13450: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));
  ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13450:3: note: Null pointer dereference
  true_children_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
Test_texture.c:13456: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;
      ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13456:7: note: Null pointer dereference
      true_children_lists[0]->elements[parent-1] = parent;
      ^
Test_texture.c:13491: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;
      ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13491:7: note: Null pointer dereference
      temporary_children_lists[parent].num_elements=0;
      ^
Test_texture.c:13495:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13495:7: note: Null pointer dereference
      MPI_MASTER(
      ^
Test_texture.c:13619: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));
    ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13619:5: note: Null pointer dereference
    true_children_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Test_texture.c:13620: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;
    ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13620:5: note: Null pointer dereference
    true_children_lists[parent]->num_elements = 0;
    ^
Test_texture.c:13621: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]);
                                                               ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13621:64: note: Null pointer dereference
    allocate_list_from_temp(used_elements,true_temp_list_local,true_children_lists[parent]);
                                                               ^
Test_texture.c:13623:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15069: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);
                                     ^
Test_texture.c:13623:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Test_texture.c:13632: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);
                                                    ^
Test_texture.c:13431:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Test_texture.c:13431: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));
                                   ^
Test_texture.c:13632:53: note: Null pointer dereference
  for(child=0;child<number_of_volumes;child++) free(temporary_children_lists[child].elements);
                                                    ^
Test_texture.c:13654: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));
  ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13654:3: note: Null pointer dereference
  true_overlap_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Test_texture.c:13655: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;
  ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13655:3: note: Null pointer dereference
  true_overlap_lists[0]->num_elements = number_of_volumes-1;
  ^
Test_texture.c:13656: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));
  ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13656:3: note: Null pointer dereference
  true_overlap_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
Test_texture.c:13658: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));
  ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13658:3: note: Null pointer dereference
  raw_overlap_lists[0] =  malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Test_texture.c:13659: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;
  ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13659:3: note: Null pointer dereference
  raw_overlap_lists[0]->num_elements = number_of_volumes;
  ^
Test_texture.c:13660: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));
  ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13660:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements = malloc(number_of_volumes*sizeof(int));
  ^
Test_texture.c:13661: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
  ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13661:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements[0] = 0; // Volume 0 overlaps itself
  ^
Test_texture.c:13665: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;
      ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13665:7: note: Null pointer dereference
      true_overlap_lists[0]->elements[parent-1] = parent;
      ^
Test_texture.c:13666: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;
      ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13666:7: note: Null pointer dereference
      raw_overlap_lists[0]->elements[parent] = parent;
      ^
Test_texture.c:13670:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  MPI_MASTER(
  ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13670:3: note: Null pointer dereference
  MPI_MASTER(
  ^
Test_texture.c:13683: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));
      ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13683:7: note: Null pointer dereference
      true_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
Test_texture.c:13756: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));
      ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13756:7: note: Null pointer dereference
      raw_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
Test_texture.c:13757: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;
      ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13757:7: note: Null pointer dereference
      raw_overlap_lists[parent]->num_elements = 0;
      ^
Test_texture.c:13758: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]);
                                                            ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15077: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);
                                               ^
Test_texture.c:13758:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,raw_overlap_lists[parent]);
                                                            ^
Test_texture.c:13761:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_overlap_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
Test_texture.c:13651:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
Test_texture.c:13651: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));
                                  ^
Test_texture.c:13761:7: note: Null pointer dereference
      MPI_MASTER(
      ^
Test_texture.c:13874: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]);
                                                          ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13874:59: note: Null pointer dereference
    allocate_list_from_temp(used_elements,temp_list_local,true_overlap_lists[parent]);
                                                          ^
Test_texture.c:13876:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15077: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);
                           ^
Test_texture.c:13876:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Test_texture.c:13882: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);
                                                    ^
Test_texture.c:13651:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
Test_texture.c:13651: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));
                                  ^
Test_texture.c:13882:53: note: Null pointer dereference
  for(child=1;child<number_of_volumes;child++) free(temporary_overlap_lists[child].elements);
                                                    ^
Test_texture.c:14174: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));
    ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15085: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
                           ^
Test_texture.c:14174:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Test_texture.c:14180: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]);
                                                            ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15085: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
                           ^
Test_texture.c:14180:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
Test_texture.c:14222: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
    ^
Test_texture.c:15094:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15094: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*));
                               ^
Test_texture.c:15095: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);
                                ^
Test_texture.c:14222:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list)); // allocate_list_from_temp allocates
    ^
Test_texture.c:14225: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))
                         ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15095: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);
                                                    ^
Test_texture.c:14225:26: note: Null pointer dereference
        if (on_int_list(*true_children_lists[parent],iterate))
                         ^
Test_texture.c:14229: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]);
                                                            ^
Test_texture.c:15094:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15094: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*));
                               ^
Test_texture.c:15095: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);
                                ^
Test_texture.c:14229:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
Test_texture.c:14429: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));
    ^
Test_texture.c:15106:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15106: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*));
                               ^
Test_texture.c:15107: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);
                                ^
Test_texture.c:14429:5: note: Null pointer dereference
    grandparents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Test_texture.c:14431: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++) {
                            ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15107: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);
                                                   ^
Test_texture.c:14431:29: note: Null pointer dereference
    for (parent = 0; parent<parents_lists[iterate]->num_elements; parent++) {
                            ^
Test_texture.c:14433: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);
                          ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15107: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);
                                                   ^
Test_texture.c:14433:27: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                          ^
Test_texture.c:14433:41: 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);
                                        ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15107: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);
                                                   ^
Test_texture.c:14433:41: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                                        ^
Test_texture.c:14433:84: 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);
                                                                                   ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15107: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);
                                                   ^
Test_texture.c:14433:84: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                                                                                   ^
Test_texture.c:14442: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]);
                                                            ^
Test_texture.c:15106:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15106: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*));
                               ^
Test_texture.c:15107: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);
                                ^
Test_texture.c:14442:61: note: Null pointer dereference
    allocate_list_from_temp(used_elements, temp_list_local, grandparents_lists[iterate]);
                                                            ^
Test_texture.c:14445:5: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Test_texture.c:15106:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15106: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*));
                               ^
Test_texture.c:15107: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);
                                ^
Test_texture.c:14445:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Test_texture.c:14472: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;
                             ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15125: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);
                                             ^
Test_texture.c:14472:30: note: Null pointer dereference
    work_list.num_elements = true_overlap_lists[volume_index]->num_elements;
                             ^
Test_texture.c:14474: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];
                                                                                           ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15125: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);
                                             ^
Test_texture.c:14474: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];
                                                                                           ^
Test_texture.c:14519: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++)
                           ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15125: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);
                                                                 ^
Test_texture.c:14519:28: note: Null pointer dereference
    for (iterate=0;iterate<true_children_lists[volume_index]->num_elements;iterate++)
                           ^
Test_texture.c:14520: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]);
                                                 ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15125: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);
                                                                 ^
Test_texture.c:14520:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_children_lists[volume_index]->elements[iterate]);
                                                 ^
Test_texture.c:14525: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++)
                           ^
Test_texture.c:15120:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Test_texture.c:15120: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*));
                                             ^
Test_texture.c:15125: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);
                                                                                                                   ^
Test_texture.c:14525:28: note: Null pointer dereference
    for (iterate=0;iterate<true_grandparents_lists[volume_index]->num_elements;iterate++)
                           ^
Test_texture.c:14526: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]);
                                                 ^
Test_texture.c:15120:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Test_texture.c:15120: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*));
                                             ^
Test_texture.c:15125: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);
                                                                                                                   ^
Test_texture.c:14526:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_grandparents_lists[volume_index]->elements[iterate]);
                                                 ^
Test_texture.c:14540: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])){
                       ^
Test_texture.c:15099:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Test_texture.c:15099: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*));
                                        ^
Test_texture.c:15125: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);
                                                                                      ^
Test_texture.c:14540:24: note: Null pointer dereference
      if (on_int_list(*true_parents_lists[volume_index],work_list.elements[iterate])){
                       ^
Test_texture.c:14840: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++) {
                                 ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15132: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);
                                   ^
Test_texture.c:14840:34: note: Null pointer dereference
            for (parent=0;parent<parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->num_elements;parent++) {
                                 ^
Test_texture.c:14841: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]))
                                                                         ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15132: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);
                                   ^
Test_texture.c:14841: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]))
                                                                         ^
Test_texture.c:15147: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);
            ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15147:13: note: Null pointer dereference
        if (true_overlap_lists[iterate]->num_elements > 0) free(true_overlap_lists[iterate]->elements);
            ^
Test_texture.c:15148:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
        free(true_overlap_lists[iterate]);
             ^
Test_texture.c:15073:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15073: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*));
                               ^
Test_texture.c:15148:14: note: Null pointer dereference
        free(true_overlap_lists[iterate]);
             ^
Test_texture.c:15151: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);
            ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15151:13: note: Null pointer dereference
        if (raw_overlap_lists[iterate]->num_elements > 0) free(raw_overlap_lists[iterate]->elements);
            ^
Test_texture.c:15152:14: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
        free(raw_overlap_lists[iterate]);
             ^
Test_texture.c:15075:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Test_texture.c:15075: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*));
                              ^
Test_texture.c:15152:14: note: Null pointer dereference
        free(raw_overlap_lists[iterate]);
             ^
Test_texture.c:15155: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);
            ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15155:13: note: Null pointer dereference
        if (parents_lists[iterate]->num_elements > 0) free(parents_lists[iterate]->elements);
            ^
Test_texture.c:15156:14: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
        free(parents_lists[iterate]);
             ^
Test_texture.c:15084:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Test_texture.c:15084: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*));
                          ^
Test_texture.c:15156:14: note: Null pointer dereference
        free(parents_lists[iterate]);
             ^
Test_texture.c:15159: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);
            ^
Test_texture.c:15089:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
Test_texture.c:15089: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*));
                                   ^
Test_texture.c:15159:13: note: Null pointer dereference
        if (parents_lists_no_masks[iterate]->num_elements > 0) free(parents_lists_no_masks[iterate]->elements);
            ^
Test_texture.c:15160: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]);
             ^
Test_texture.c:15089:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
Test_texture.c:15089: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*));
                                   ^
Test_texture.c:15160:14: note: Null pointer dereference
        free(parents_lists_no_masks[iterate]);
             ^
Test_texture.c:15163: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);
            ^
Test_texture.c:15094:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15094: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*));
                               ^
Test_texture.c:15163:13: note: Null pointer dereference
        if (true_parents_lists[iterate]->num_elements > 0) free(true_parents_lists[iterate]->elements);
            ^
Test_texture.c:15164:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists [nullPointerOutOfMemory]
        free(true_parents_lists[iterate]);
             ^
Test_texture.c:15094:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15094: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*));
                               ^
Test_texture.c:15164:14: note: Null pointer dereference
        free(true_parents_lists[iterate]);
             ^
Test_texture.c:15167: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);
            ^
Test_texture.c:15099:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Test_texture.c:15099: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*));
                                        ^
Test_texture.c:15167:13: note: Null pointer dereference
        if (true_parents_lists_no_masks[iterate]->num_elements > 0) free(true_parents_lists_no_masks[iterate]->elements);
            ^
Test_texture.c:15168: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]);
             ^
Test_texture.c:15099:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Test_texture.c:15099: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*));
                                        ^
Test_texture.c:15168:14: note: Null pointer dereference
        free(true_parents_lists_no_masks[iterate]);
             ^
Test_texture.c:15171: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);
            ^
Test_texture.c:15106:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15106: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*));
                               ^
Test_texture.c:15171:13: note: Null pointer dereference
        if (grandparents_lists[iterate]->num_elements > 0) free(grandparents_lists[iterate]->elements);
            ^
Test_texture.c:15172:14: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
        free(grandparents_lists[iterate]);
             ^
Test_texture.c:15106:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Test_texture.c:15106: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*));
                               ^
Test_texture.c:15172:14: note: Null pointer dereference
        free(grandparents_lists[iterate]);
             ^
Test_texture.c:15175: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);
            ^
Test_texture.c:15116:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
Test_texture.c:15116: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*));
                                    ^
Test_texture.c:15175:13: note: Null pointer dereference
        if (true_grandparents_lists[iterate]->num_elements > 0) free(true_grandparents_lists[iterate]->elements);
            ^
Test_texture.c:15176:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
        free(true_grandparents_lists[iterate]);
             ^
Test_texture.c:15116:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
Test_texture.c:15116: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*));
                                    ^
Test_texture.c:15176:14: note: Null pointer dereference
        free(true_grandparents_lists[iterate]);
             ^
Test_texture.c:15179: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);
            ^
Test_texture.c:15111:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Test_texture.c:15111: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*));
                                        ^
Test_texture.c:15179:13: note: Null pointer dereference
        if (grandparents_lists_no_masks[iterate]->num_elements > 0) free(grandparents_lists_no_masks[iterate]->elements);
            ^
Test_texture.c:15180: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]);
             ^
Test_texture.c:15111:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Test_texture.c:15111: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*));
                                        ^
Test_texture.c:15180:14: note: Null pointer dereference
        free(grandparents_lists_no_masks[iterate]);
             ^
Test_texture.c:15183: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);
            ^
Test_texture.c:15120:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Test_texture.c:15120: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*));
                                             ^
Test_texture.c:15183:13: note: Null pointer dereference
        if (true_grandparents_lists_no_masks[iterate]->num_elements > 0) free(true_grandparents_lists_no_masks[iterate]->elements);
            ^
Test_texture.c:15184: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]);
             ^
Test_texture.c:15120:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Test_texture.c:15120: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*));
                                             ^
Test_texture.c:15184:14: note: Null pointer dereference
        free(true_grandparents_lists_no_masks[iterate]);
             ^
Test_texture.c:15187: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);
            ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15187:13: note: Null pointer dereference
        if (true_children_lists[iterate]->num_elements > 0) free(true_children_lists[iterate]->elements);
            ^
Test_texture.c:15188:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
        free(true_children_lists[iterate]);
             ^
Test_texture.c:15067:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Test_texture.c:15067: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*));
                                ^
Test_texture.c:15188:14: note: Null pointer dereference
        free(true_children_lists[iterate]);
             ^
Test_texture.c:15376: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");
          ^
Test_texture.c:15375:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
Test_texture.c:15375:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
Test_texture.c:15376: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");
          ^
Test_texture.c:15378:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
Test_texture.c:15375:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
Test_texture.c:15375:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
Test_texture.c:15378:10: note: Null pointer dereference
  fclose(fp);
         ^
Test_texture.c:15391: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",
            ^
Test_texture.c:15384:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
Test_texture.c:15384:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
Test_texture.c:15391:13: note: Null pointer dereference
    fprintf(fp,"%g, %g, %g, %g, %g, %g, %g, %g, %e, %i, %i \n",
            ^
Test_texture.c:15399:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
Test_texture.c:15384:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
Test_texture.c:15384:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
Test_texture.c:15399:10: note: Null pointer dereference
  fclose(fp);
         ^
Test_texture.c:18788:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->lmax = lmax;
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18788:3: note: Null pointer dereference
  lgdr->lmax = lmax;
  ^
Test_texture.c:18789:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->index = (int **)malloc((lmax+1)*sizeof(int *));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18789:3: note: Null pointer dereference
  lgdr->index = (int **)malloc((lmax+1)*sizeof(int *));
  ^
Test_texture.c:18790:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->l = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18790:3: note: Null pointer dereference
  lgdr->l = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18791:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->m = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18791:3: note: Null pointer dereference
  lgdr->m = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18792:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->nplm = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18792:3: note: Null pointer dereference
  lgdr->nplm = (int *)malloc(nlm*sizeof(int));
  ^
Test_texture.c:18793:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->x = (double **)malloc(nlm*sizeof(double *));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18793:3: note: Null pointer dereference
  lgdr->x = (double **)malloc(nlm*sizeof(double *));
  ^
Test_texture.c:18794:3: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
  lgdr->Plm = (double **)malloc(nlm*sizeof(double *));
  ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18794:3: note: Null pointer dereference
  lgdr->Plm = (double **)malloc(nlm*sizeof(double *));
  ^
Test_texture.c:18797:5: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
    lgdr->index[l] = (int *)malloc((2*l+1)*sizeof(int));
    ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18797:5: note: Null pointer dereference
    lgdr->index[l] = (int *)malloc((2*l+1)*sizeof(int));
    ^
Test_texture.c:18800:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->index)[l][l+m] = i;
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18800:8: note: Null pointer dereference
      (lgdr->index)[l][l+m] = i;
       ^
Test_texture.c:18801:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->l)[i] = l;
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18801:8: note: Null pointer dereference
      (lgdr->l)[i] = l;
       ^
Test_texture.c:18802:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->m)[i] = m;
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18802:8: note: Null pointer dereference
      (lgdr->m)[i] = m;
       ^
Test_texture.c:18803:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->nplm)[i] = 100*(l+1);
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18803:8: note: Null pointer dereference
      (lgdr->nplm)[i] = 100*(l+1);
       ^
Test_texture.c:18804:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->x)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18804:8: note: Null pointer dereference
      (lgdr->x)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
       ^
Test_texture.c:18804:41: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->x)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
                                        ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18804:41: note: Null pointer dereference
      (lgdr->x)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
                                        ^
Test_texture.c:18805:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->Plm)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18805:8: note: Null pointer dereference
      (lgdr->Plm)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
       ^
Test_texture.c:18805:43: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->Plm)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
                                          ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18805:43: note: Null pointer dereference
      (lgdr->Plm)[i] = (double *)malloc(((lgdr->nplm)[i])*sizeof(double));
                                          ^
Test_texture.c:18806:18: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      dx = 2.0/((lgdr->nplm)[i]-1);
                 ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18806:18: note: Null pointer dereference
      dx = 2.0/((lgdr->nplm)[i]-1);
                 ^
Test_texture.c:18807:18: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      for(j=0;j<(lgdr->nplm)[i]-1;j++) {
                 ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18807:18: note: Null pointer dereference
      for(j=0;j<(lgdr->nplm)[i]-1;j++) {
                 ^
Test_texture.c:18809:10: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
        (lgdr->x)[i][j] = x;
         ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18809:10: note: Null pointer dereference
        (lgdr->x)[i][j] = x;
         ^
Test_texture.c:18810:10: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
        (lgdr->Plm)[i][j] = plgndr_mod(l,m,x);
         ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18810:10: note: Null pointer dereference
        (lgdr->Plm)[i][j] = plgndr_mod(l,m,x);
         ^
Test_texture.c:18812:12: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      j = (lgdr->nplm)[i]-1;
           ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18812:12: note: Null pointer dereference
      j = (lgdr->nplm)[i]-1;
           ^
Test_texture.c:18814:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->x)[i][j] = x;
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18814:8: note: Null pointer dereference
      (lgdr->x)[i][j] = x;
       ^
Test_texture.c:18815:8: warning: If memory allocation fails, then there is a possible null pointer dereference: lgdr [nullPointerOutOfMemory]
      (lgdr->Plm)[i][j] = plgndr_mod(l,m,x);
       ^
Test_texture.c:18786:35: note: Assuming allocation function fails
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
                                  ^
Test_texture.c:18786:10: note: Assignment 'lgdr=(struct legendre*)malloc(sizeof(struct legendre))', assigned value is 0
  lgdr = (struct legendre *)malloc(sizeof(struct legendre));
         ^
Test_texture.c:18815:8: note: Null pointer dereference
      (lgdr->Plm)[i][j] = plgndr_mod(l,m,x);
       ^
Test_texture.c:18871:13: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e %.6e %.6e\n",
            ^
Test_texture.c:18870:18: note: Assuming allocation function fails
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18870:18: note: Assignment 'filep=fopen("negativeXS.txt","a")', assigned value is 0
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18871:13: note: Null pointer dereference
    fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e %.6e %.6e\n",
            ^
Test_texture.c:18873:12: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fclose(filep);
           ^
Test_texture.c:18870:18: note: Assuming allocation function fails
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18870:18: note: Assignment 'filep=fopen("negativeXS.txt","a")', assigned value is 0
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18873:12: note: Null pointer dereference
    fclose(filep);
           ^
Test_texture.c:18914:13: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e %.6e %.6e\n",
            ^
Test_texture.c:18913:18: note: Assuming allocation function fails
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18913:18: note: Assignment 'filep=fopen("negativeXS.txt","a")', assigned value is 0
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18914:13: note: Null pointer dereference
    fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e %.6e %.6e\n",
            ^
Test_texture.c:18916:12: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fclose(filep);
           ^
Test_texture.c:18913:18: note: Assuming allocation function fails
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18913:18: note: Assignment 'filep=fopen("negativeXS.txt","a")', assigned value is 0
    filep = fopen("negativeXS.txt","a");
                 ^
Test_texture.c:18916:12: note: Null pointer dereference
    fclose(filep);
           ^
Test_texture.c:18964:5: warning: If memory allocation fails, then there is a possible null pointer dereference: Upsilon_l [nullPointerOutOfMemory]
    Upsilon_l[l] = (double **)malloc(nctk_l[l]*sizeof(double *));
    ^
Test_texture.c:18951:36: note: Assuming allocation function fails
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                                   ^
Test_texture.c:18951:18: note: Assignment 'L->Upsilon_l=(double***)malloc((lmax+1)*sizeof(double**))', assigned value is 0
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                 ^
Test_texture.c:18957:16: note: Assignment 'Upsilon_l=L->Upsilon_l', assigned value is 0
  Upsilon_l = L->Upsilon_l;
               ^
Test_texture.c:18964:5: note: Null pointer dereference
    Upsilon_l[l] = (double **)malloc(nctk_l[l]*sizeof(double *));
    ^
Test_texture.c:18966:7: warning: If memory allocation fails, then there is a possible null pointer dereference: Upsilon_l [nullPointerOutOfMemory]
      Upsilon_l[l][i] = (double *)malloc(nphik_l[l]*sizeof(double));
      ^
Test_texture.c:18951:36: note: Assuming allocation function fails
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                                   ^
Test_texture.c:18951:18: note: Assignment 'L->Upsilon_l=(double***)malloc((lmax+1)*sizeof(double**))', assigned value is 0
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                 ^
Test_texture.c:18957:16: note: Assignment 'Upsilon_l=L->Upsilon_l', assigned value is 0
  Upsilon_l = L->Upsilon_l;
               ^
Test_texture.c:18966:7: note: Null pointer dereference
      Upsilon_l[l][i] = (double *)malloc(nphik_l[l]*sizeof(double));
      ^
Test_texture.c:18980:9: warning: If memory allocation fails, then there is a possible null pointer dereference: Upsilon_l [nullPointerOutOfMemory]
        Upsilon_l[l][i][j] = computeUpsilon_l(ctk_l[l][i],phik_l[l][j],l,L,lgdr);
        ^
Test_texture.c:18951:36: note: Assuming allocation function fails
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                                   ^
Test_texture.c:18951:18: note: Assignment 'L->Upsilon_l=(double***)malloc((lmax+1)*sizeof(double**))', assigned value is 0
  L->Upsilon_l = (double ***)malloc((lmax+1)*sizeof(double **));
                 ^
Test_texture.c:18957:16: note: Assignment 'Upsilon_l=L->Upsilon_l', assigned value is 0
  Upsilon_l = L->Upsilon_l;
               ^
Test_texture.c:18980:9: note: Null pointer dereference
        Upsilon_l[l][i][j] = computeUpsilon_l(ctk_l[l][i],phik_l[l][j],l,L,lgdr);
        ^
Test_texture.c:19048:5: warning: If memory allocation fails, then there is a possible null pointer dereference: R [nullPointerOutOfMemory]
    R[l] = (double *)malloc((2*l+1)*sizeof(double));
    ^
Test_texture.c:19046:24: note: Assuming allocation function fails
  R = (double **)malloc((lmax+1)*sizeof(double *));
                       ^
Test_texture.c:19046:7: note: Assignment 'R=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  R = (double **)malloc((lmax+1)*sizeof(double *));
      ^
Test_texture.c:19048:5: note: Null pointer dereference
    R[l] = (double *)malloc((2*l+1)*sizeof(double));
    ^
Test_texture.c:19052:5: warning: If memory allocation fails, then there is a possible null pointer dereference: Phi [nullPointerOutOfMemory]
    Phi[l] = (double *)malloc((2*l+1)*sizeof(double));
    ^
Test_texture.c:19050:26: note: Assuming allocation function fails
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
                         ^
Test_texture.c:19050:9: note: Assignment 'Phi=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
        ^
Test_texture.c:19052:5: note: Null pointer dereference
    Phi[l] = (double *)malloc((2*l+1)*sizeof(double));
    ^
Test_texture.c:19069:7: warning: If memory allocation fails, then there is a possible null pointer dereference: R [nullPointerOutOfMemory]
      R[l][l+m] = sqrt(vr*vr+vi*vi);
      ^
Test_texture.c:19046:24: note: Assuming allocation function fails
  R = (double **)malloc((lmax+1)*sizeof(double *));
                       ^
Test_texture.c:19046:7: note: Assignment 'R=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  R = (double **)malloc((lmax+1)*sizeof(double *));
      ^
Test_texture.c:19069:7: note: Null pointer dereference
      R[l][l+m] = sqrt(vr*vr+vi*vi);
      ^
Test_texture.c:19070:7: warning: If memory allocation fails, then there is a possible null pointer dereference: Phi [nullPointerOutOfMemory]
      Phi[l][l+m] = atan2(vi,vr);
      ^
Test_texture.c:19050:26: note: Assuming allocation function fails
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
                         ^
Test_texture.c:19050:9: note: Assignment 'Phi=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
        ^
Test_texture.c:19070:7: note: Null pointer dereference
      Phi[l][l+m] = atan2(vi,vr);
      ^
Test_texture.c:19071:10: warning: If memory allocation fails, then there is a possible null pointer dereference: R [nullPointerOutOfMemory]
      if(R[l][l+m]>tolTexture) { numV++; }
         ^
Test_texture.c:19046:24: note: Assuming allocation function fails
  R = (double **)malloc((lmax+1)*sizeof(double *));
                       ^
Test_texture.c:19046:7: note: Assignment 'R=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  R = (double **)malloc((lmax+1)*sizeof(double *));
      ^
Test_texture.c:19071:10: note: Null pointer dereference
      if(R[l][l+m]>tolTexture) { numV++; }
         ^
Test_texture.c:19095:10: warning: If memory allocation fails, then there is a possible null pointer dereference: R [nullPointerOutOfMemory]
      if(R[l][l+m] > tolTexture) {
         ^
Test_texture.c:19046:24: note: Assuming allocation function fails
  R = (double **)malloc((lmax+1)*sizeof(double *));
                       ^
Test_texture.c:19046:7: note: Assignment 'R=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  R = (double **)malloc((lmax+1)*sizeof(double *));
      ^
Test_texture.c:19095:10: note: Null pointer dereference
      if(R[l][l+m] > tolTexture) {
         ^
Test_texture.c:19117:10: warning: If memory allocation fails, then there is a possible null pointer dereference: R [nullPointerOutOfMemory]
    free(R[l]);
         ^
Test_texture.c:19046:24: note: Assuming allocation function fails
  R = (double **)malloc((lmax+1)*sizeof(double *));
                       ^
Test_texture.c:19046:7: note: Assignment 'R=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  R = (double **)malloc((lmax+1)*sizeof(double *));
      ^
Test_texture.c:19117:10: note: Null pointer dereference
    free(R[l]);
         ^
Test_texture.c:19118:10: warning: If memory allocation fails, then there is a possible null pointer dereference: Phi [nullPointerOutOfMemory]
    free(Phi[l]);
         ^
Test_texture.c:19050:26: note: Assuming allocation function fails
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
                         ^
Test_texture.c:19050:9: note: Assignment 'Phi=(double**)malloc((lmax+1)*sizeof(double*))', assigned value is 0
  Phi = (double **)malloc((lmax+1)*sizeof(double *));
        ^
Test_texture.c:19118:10: note: Null pointer dereference
    free(Phi[l]);
         ^
Test_texture.c:19361:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"#Plane hkl: %d %d %d\n",L->h,L->k,L->l);
          ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19361:11: note: Null pointer dereference
  fprintf(filep,"#Plane hkl: %d %d %d\n",L->h,L->k,L->l);
          ^
Test_texture.c:19362:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"#Incoming neutron:\n");
          ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19362:11: note: Null pointer dereference
  fprintf(filep,"#Incoming neutron:\n");
          ^
Test_texture.c:19363:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"#kx: %.6e ky: %.6e kz: %.6e\n",ki[0],ki[1],ki[2]);
          ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19363:11: note: Null pointer dereference
  fprintf(filep,"#kx: %.6e ky: %.6e kz: %.6e\n",ki[0],ki[1],ki[2]);
          ^
Test_texture.c:19366:13: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fprintf(filep,"%f %.6e %.6e %.6e %.6e\n",phi,aa[j]+phi*bb[j],phipts[j],probpts[j],maxProb);
            ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19366:13: note: Null pointer dereference
    fprintf(filep,"%f %.6e %.6e %.6e %.6e\n",phi,aa[j]+phi*bb[j],phipts[j],probpts[j],maxProb);
            ^
Test_texture.c:19368:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"\n\n");
          ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19368:11: note: Null pointer dereference
  fprintf(filep,"\n\n");
          ^
Test_texture.c:19376:13: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
    fprintf(filep,"%f %.6e %.6e\n",phi,p,maxProb);
            ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19376:13: note: Null pointer dereference
    fprintf(filep,"%f %.6e %.6e\n",phi,p,maxProb);
            ^
Test_texture.c:19379:10: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fclose(filep);
         ^
Test_texture.c:19359:16: note: Assuming allocation function fails
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19359:16: note: Assignment 'filep=fopen("sampleKprime_hkl_fail.txt","w")', assigned value is 0
  filep = fopen("sampleKprime_hkl_fail.txt","w");
               ^
Test_texture.c:19379:10: note: Null pointer dereference
  fclose(filep);
         ^
Test_texture.c:19452:25: warning: If memory allocation fails, then there is a possible null pointer dereference: probQ [nullPointerOutOfMemory]
  for(i=0;i<nctq;i++) { probQ[i] = (double *)malloc(nphiq*sizeof(double)); }
                        ^
Test_texture.c:19451:28: note: Assuming allocation function fails
  probQ = (double **)malloc(nctq*sizeof(double *));
                           ^
Test_texture.c:19451:11: note: Assignment 'probQ=(double**)malloc(nctq*sizeof(double*))', assigned value is 0
  probQ = (double **)malloc(nctq*sizeof(double *));
          ^
Test_texture.c:19452:25: note: Null pointer dereference
  for(i=0;i<nctq;i++) { probQ[i] = (double *)malloc(nphiq*sizeof(double)); }
                        ^
Test_texture.c:19457:27: warning: If memory allocation fails, then there is a possible null pointer dereference: ctq [nullPointerOutOfMemory]
  for(i=0;i<nctq-1;i++) { ctq[i] = -1.0 + i*dctq; }
                          ^
Test_texture.c:19449:25: note: Assuming allocation function fails
  ctq = (double *)malloc(nctq*sizeof(double));
                        ^
Test_texture.c:19449:9: note: Assignment 'ctq=(double*)malloc(nctq*sizeof(double))', assigned value is 0
  ctq = (double *)malloc(nctq*sizeof(double));
        ^
Test_texture.c:19457:27: note: Null pointer dereference
  for(i=0;i<nctq-1;i++) { ctq[i] = -1.0 + i*dctq; }
                          ^
Test_texture.c:19458:3: warning: If memory allocation fails, then there is a possible null pointer dereference: ctq [nullPointerOutOfMemory]
  ctq[nctq-1] = 1.0;
  ^
Test_texture.c:19449:25: note: Assuming allocation function fails
  ctq = (double *)malloc(nctq*sizeof(double));
                        ^
Test_texture.c:19449:9: note: Assignment 'ctq=(double*)malloc(nctq*sizeof(double))', assigned value is 0
  ctq = (double *)malloc(nctq*sizeof(double));
        ^
Test_texture.c:19458:3: note: Null pointer dereference
  ctq[nctq-1] = 1.0;
  ^
Test_texture.c:19459:28: warning: If memory allocation fails, then there is a possible null pointer dereference: phiq [nullPointerOutOfMemory]
  for(j=0;j<nphiq-1;j++) { phiq[j] = -PI + j*dphiq; }
                           ^
Test_texture.c:19450:26: note: Assuming allocation function fails
  phiq = (double *)malloc(nphiq*sizeof(double));
                         ^
Test_texture.c:19450:10: note: Assignment 'phiq=(double*)malloc(nphiq*sizeof(double))', assigned value is 0
  phiq = (double *)malloc(nphiq*sizeof(double));
         ^
Test_texture.c:19459:28: note: Null pointer dereference
  for(j=0;j<nphiq-1;j++) { phiq[j] = -PI + j*dphiq; }
                           ^
Test_texture.c:19460:3: warning: If memory allocation fails, then there is a possible null pointer dereference: phiq [nullPointerOutOfMemory]
  phiq[nphiq-1] = PI;
  ^
Test_texture.c:19450:26: note: Assuming allocation function fails
  phiq = (double *)malloc(nphiq*sizeof(double));
                         ^
Test_texture.c:19450:10: note: Assignment 'phiq=(double*)malloc(nphiq*sizeof(double))', assigned value is 0
  phiq = (double *)malloc(nphiq*sizeof(double));
         ^
Test_texture.c:19460:3: note: Null pointer dereference
  phiq[nphiq-1] = PI;
  ^
Test_texture.c:19464:7: warning: If memory allocation fails, then there is a possible null pointer dereference: probQ [nullPointerOutOfMemory]
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
      ^
Test_texture.c:19451:28: note: Assuming allocation function fails
  probQ = (double **)malloc(nctq*sizeof(double *));
                           ^
Test_texture.c:19451:11: note: Assignment 'probQ=(double**)malloc(nctq*sizeof(double*))', assigned value is 0
  probQ = (double **)malloc(nctq*sizeof(double *));
          ^
Test_texture.c:19464:7: note: Null pointer dereference
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
      ^
Test_texture.c:19464:30: warning: If memory allocation fails, then there is a possible null pointer dereference: ctq [nullPointerOutOfMemory]
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
                             ^
Test_texture.c:19449:25: note: Assuming allocation function fails
  ctq = (double *)malloc(nctq*sizeof(double));
                        ^
Test_texture.c:19449:9: note: Assignment 'ctq=(double*)malloc(nctq*sizeof(double))', assigned value is 0
  ctq = (double *)malloc(nctq*sizeof(double));
        ^
Test_texture.c:19464:30: note: Null pointer dereference
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
                             ^
Test_texture.c:19464:37: warning: If memory allocation fails, then there is a possible null pointer dereference: phiq [nullPointerOutOfMemory]
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
                                    ^
Test_texture.c:19450:26: note: Assuming allocation function fails
  phiq = (double *)malloc(nphiq*sizeof(double));
                         ^
Test_texture.c:19450:10: note: Assignment 'phiq=(double*)malloc(nphiq*sizeof(double))', assigned value is 0
  phiq = (double *)malloc(nphiq*sizeof(double));
         ^
Test_texture.c:19464:37: note: Null pointer dereference
      probQ[i][j] = probPhiq(ctq[i],phiq[j],L,lgdr);
                                    ^
Test_texture.c:19775:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"Direct lattice:\n");
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19775:11: note: Null pointer dereference
  fprintf(filep,"Direct lattice:\n");
          ^
Test_texture.c:19776:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"a: %f %f %f\n",info->m_ax,info->m_ay,info->m_az);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19776:11: note: Null pointer dereference
  fprintf(filep,"a: %f %f %f\n",info->m_ax,info->m_ay,info->m_az);
          ^
Test_texture.c:19777:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"b: %f %f %f\n",info->m_bx,info->m_by,info->m_bz);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19777:11: note: Null pointer dereference
  fprintf(filep,"b: %f %f %f\n",info->m_bx,info->m_by,info->m_bz);
          ^
Test_texture.c:19778:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"c: %f %f %f\n",info->m_cx,info->m_cy,info->m_cz);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19778:11: note: Null pointer dereference
  fprintf(filep,"c: %f %f %f\n",info->m_cx,info->m_cy,info->m_cz);
          ^
Test_texture.c:19779:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"Reciprocal lattice:\n");
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19779:11: note: Null pointer dereference
  fprintf(filep,"Reciprocal lattice:\n");
          ^
Test_texture.c:19780:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"a: %f %f %f\n",info->asx,info->asy,info->asz);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19780:11: note: Null pointer dereference
  fprintf(filep,"a: %f %f %f\n",info->asx,info->asy,info->asz);
          ^
Test_texture.c:19781:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"b: %f %f %f\n",info->bsx,info->bsy,info->bsz);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19781:11: note: Null pointer dereference
  fprintf(filep,"b: %f %f %f\n",info->bsx,info->bsy,info->bsz);
          ^
Test_texture.c:19782:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"c: %f %f %f\n",info->csx,info->csy,info->csz);
          ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19782:11: note: Null pointer dereference
  fprintf(filep,"c: %f %f %f\n",info->csx,info->csy,info->csz);
          ^
Test_texture.c:19783:10: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fclose(filep);
         ^
Test_texture.c:19774:16: note: Assuming allocation function fails
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19774:16: note: Assignment 'filep=fopen("crystal.txt","w")', assigned value is 0
  filep = fopen("crystal.txt","w");
               ^
Test_texture.c:19783:10: note: Null pointer dereference
  fclose(filep);
         ^
Test_texture.c:19799:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].h = h;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19799:5: note: Null pointer dereference
    list[i].h = h;
    ^
Test_texture.c:19800:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].k = k;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19800:5: note: Null pointer dereference
    list[i].k = k;
    ^
Test_texture.c:19801:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].l = l;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19801:5: note: Null pointer dereference
    list[i].l = l;
    ^
Test_texture.c:19802:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].F2 = F2;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19802:5: note: Null pointer dereference
    list[i].F2 = F2;
    ^
Test_texture.c:19803:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].mult = mult;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19803:5: note: Null pointer dereference
    list[i].mult = mult;
    ^
Test_texture.c:19805:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gx = h*info->asx + k*info->bsx + l*info->csx;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19805:5: note: Null pointer dereference
    list[i].Gx = h*info->asx + k*info->bsx + l*info->csx;
    ^
Test_texture.c:19806:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gy = h*info->asy + k*info->bsy + l*info->csy;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19806:5: note: Null pointer dereference
    list[i].Gy = h*info->asy + k*info->bsy + l*info->csy;
    ^
Test_texture.c:19807:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gz = h*info->asz + k*info->bsz + l*info->csz;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19807:5: note: Null pointer dereference
    list[i].Gz = h*info->asz + k*info->bsz + l*info->csz;
    ^
Test_texture.c:19808:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19808:5: note: Null pointer dereference
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
    ^
Test_texture.c:19808:22: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
                     ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19808:22: note: Null pointer dereference
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
                     ^
Test_texture.c:19808:33: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
                                ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19808:33: note: Null pointer dereference
    list[i].G = sqrt(list[i].Gx*list[i].Gx +
                                ^
Test_texture.c:19809:22: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                     list[i].Gy*list[i].Gy +
                     ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19809:22: note: Null pointer dereference
                     list[i].Gy*list[i].Gy +
                     ^
Test_texture.c:19809:33: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                     list[i].Gy*list[i].Gy +
                                ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19809:33: note: Null pointer dereference
                     list[i].Gy*list[i].Gy +
                                ^
Test_texture.c:19810:22: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                     list[i].Gz*list[i].Gz);
                     ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19810:22: note: Null pointer dereference
                     list[i].Gz*list[i].Gz);
                     ^
Test_texture.c:19810:33: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                     list[i].Gz*list[i].Gz);
                                ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19810:33: note: Null pointer dereference
                     list[i].Gz*list[i].Gz);
                                ^
Test_texture.c:19811:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGx = list[i].Gx/list[i].G;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19811:5: note: Null pointer dereference
    list[i].uGx = list[i].Gx/list[i].G;
    ^
Test_texture.c:19811:19: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGx = list[i].Gx/list[i].G;
                  ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19811:19: note: Null pointer dereference
    list[i].uGx = list[i].Gx/list[i].G;
                  ^
Test_texture.c:19811:30: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGx = list[i].Gx/list[i].G;
                             ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19811:30: note: Null pointer dereference
    list[i].uGx = list[i].Gx/list[i].G;
                             ^
Test_texture.c:19812:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGy = list[i].Gy/list[i].G;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19812:5: note: Null pointer dereference
    list[i].uGy = list[i].Gy/list[i].G;
    ^
Test_texture.c:19812:19: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGy = list[i].Gy/list[i].G;
                  ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19812:19: note: Null pointer dereference
    list[i].uGy = list[i].Gy/list[i].G;
                  ^
Test_texture.c:19812:30: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGy = list[i].Gy/list[i].G;
                             ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19812:30: note: Null pointer dereference
    list[i].uGy = list[i].Gy/list[i].G;
                             ^
Test_texture.c:19813:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGz = list[i].Gz/list[i].G;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19813:5: note: Null pointer dereference
    list[i].uGz = list[i].Gz/list[i].G;
    ^
Test_texture.c:19813:19: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGz = list[i].Gz/list[i].G;
                  ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19813:19: note: Null pointer dereference
    list[i].uGz = list[i].Gz/list[i].G;
                  ^
Test_texture.c:19813:30: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].uGz = list[i].Gz/list[i].G;
                             ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19813:30: note: Null pointer dereference
    list[i].uGz = list[i].Gz/list[i].G;
                             ^
Test_texture.c:19814:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gct = list[i].uGz;
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19814:5: note: Null pointer dereference
    list[i].Gct = list[i].uGz;
    ^
Test_texture.c:19814:19: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gct = list[i].uGz;
                  ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19814:19: note: Null pointer dereference
    list[i].Gct = list[i].uGz;
                  ^
Test_texture.c:19815:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19815:5: note: Null pointer dereference
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
    ^
Test_texture.c:19815:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
                         ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19815:26: note: Null pointer dereference
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
                         ^
Test_texture.c:19815:38: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
                                     ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19815:38: note: Null pointer dereference
    list[i].Gphi = atan2(list[i].uGy,list[i].uGx);
                                     ^
Test_texture.c:19819:15: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
              ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19819:15: note: Null pointer dereference
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
              ^
Test_texture.c:19819:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                        ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19819:25: note: Null pointer dereference
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                        ^
Test_texture.c:19819:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                  ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19819:35: note: Null pointer dereference
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                  ^
Test_texture.c:19819:45: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                            ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19819:45: note: Null pointer dereference
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                            ^
Test_texture.c:19819:56: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                                       ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19819:56: note: Null pointer dereference
          i+1,list[i].h,list[i].k,list[i].l,list[i].F2,list[i].mult,
                                                       ^
Test_texture.c:19820:4: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
   list[i].G,list[i].Gct,list[i].Gphi);
   ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19820:4: note: Null pointer dereference
   list[i].G,list[i].Gct,list[i].Gphi);
   ^
Test_texture.c:19820:14: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
   list[i].G,list[i].Gct,list[i].Gphi);
             ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19820:14: note: Null pointer dereference
   list[i].G,list[i].Gct,list[i].Gphi);
             ^
Test_texture.c:19820:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
   list[i].G,list[i].Gct,list[i].Gphi);
                         ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19820:26: note: Null pointer dereference
   list[i].G,list[i].Gct,list[i].Gphi);
                         ^
Test_texture.c:19825:16: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
               list[i].uGx, list[i].uGy, list[i].uGz);
               ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19825:16: note: Null pointer dereference
               list[i].uGx, list[i].uGy, list[i].uGz);
               ^
Test_texture.c:19825:29: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
               list[i].uGx, list[i].uGy, list[i].uGz);
                            ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19825:29: note: Null pointer dereference
               list[i].uGx, list[i].uGy, list[i].uGz);
                            ^
Test_texture.c:19825:42: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
               list[i].uGx, list[i].uGy, list[i].uGz);
                                         ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19825:42: note: Null pointer dereference
               list[i].uGx, list[i].uGy, list[i].uGz);
                                         ^
Test_texture.c:19826:5: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    vec_prod(b2[0], b2[1], b2[2],
    ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19826:5: note: Null pointer dereference
    vec_prod(b2[0], b2[1], b2[2],
    ^
Test_texture.c:19834:8: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
 qsort(list, i, sizeof(struct hkl_data_texture),  SX_list_compare_texture);
       ^
Test_texture.c:19786:42: note: Assuming allocation function fails
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
                                         ^
Test_texture.c:19786:10: note: Assignment 'list=(struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture))', assigned value is 0
  list = (struct hkl_data_texture*)malloc(size*sizeof(struct hkl_data_texture));
         ^
Test_texture.c:19834:8: note: Null pointer dereference
 qsort(list, i, sizeof(struct hkl_data_texture),  SX_list_compare_texture);
       ^
Test_texture.c:19995:12: warning: If memory allocation fails, then there is a possible null pointer dereference: ctemp [nullPointerOutOfMemory]
          (ctemp->cr)[l][l+m][l+n] = -sqrt(-1.0);
           ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19995:12: note: Null pointer dereference
          (ctemp->cr)[l][l+m][l+n] = -sqrt(-1.0);
           ^
Test_texture.c:19996:12: warning: If memory allocation fails, then there is a possible null pointer dereference: ctemp [nullPointerOutOfMemory]
          (ctemp->ci)[l][l+m][l+n] = -sqrt(-1.0);
           ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19996:12: note: Null pointer dereference
          (ctemp->ci)[l][l+m][l+n] = -sqrt(-1.0);
           ^
Test_texture.c:20037:19: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
          fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e\n",
                  ^
Test_texture.c:20027:18: note: Assuming allocation function fails
    filep = fopen("coef_modified.txt","w");
                 ^
Test_texture.c:20027:18: note: Assignment 'filep=fopen("coef_modified.txt","w")', assigned value is 0
    filep = fopen("coef_modified.txt","w");
                 ^
Test_texture.c:20037:19: note: Null pointer dereference
          fprintf(filep,"%d %d %d %.6e %.6e %.6e %.6e %.6e\n",
                  ^
Test_texture.c:20052:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->lmax = lmax;
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20052:5: note: Null pointer dereference
    c->lmax = lmax;
    ^
Test_texture.c:20053:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->cr = (double ***)malloc((lmax+1)*sizeof(double));
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20053:5: note: Null pointer dereference
    c->cr = (double ***)malloc((lmax+1)*sizeof(double));
    ^
Test_texture.c:20054:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->ci = (double ***)malloc((lmax+1)*sizeof(double));
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20054:5: note: Null pointer dereference
    c->ci = (double ***)malloc((lmax+1)*sizeof(double));
    ^
Test_texture.c:20056:8: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
      (c->cr)[l] = (double **)malloc((2*l+1)*sizeof(double));
       ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20056:8: note: Null pointer dereference
      (c->cr)[l] = (double **)malloc((2*l+1)*sizeof(double));
       ^
Test_texture.c:20057:8: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
      (c->ci)[l] = (double **)malloc((2*l+1)*sizeof(double));
       ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20057:8: note: Null pointer dereference
      (c->ci)[l] = (double **)malloc((2*l+1)*sizeof(double));
       ^
Test_texture.c:20059:3: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
 (c->cr)[l][m+l] = (double *)malloc((2*l+1)*sizeof(double));
  ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20059:3: note: Null pointer dereference
 (c->cr)[l][m+l] = (double *)malloc((2*l+1)*sizeof(double));
  ^
Test_texture.c:20060:3: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
 (c->ci)[l][m+l] = (double *)malloc((2*l+1)*sizeof(double));
  ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20060:3: note: Null pointer dereference
 (c->ci)[l][m+l] = (double *)malloc((2*l+1)*sizeof(double));
  ^
Test_texture.c:20064:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->lmax = -1;
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20064:5: note: Null pointer dereference
    c->lmax = -1;
    ^
Test_texture.c:20065:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->cr = NULL;
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20065:5: note: Null pointer dereference
    c->cr = NULL;
    ^
Test_texture.c:20066:5: warning: If memory allocation fails, then there is a possible null pointer dereference: c [nullPointerOutOfMemory]
    c->ci = NULL;
    ^
Test_texture.c:19990:42: note: Assuming allocation function fails
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                         ^
Test_texture.c:19990:13: note: Assignment 'ctemp=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
    ctemp = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
            ^
Test_texture.c:19991:30: note: Calling function 'allocateFourierCoef', 2nd argument 'ctemp' value is 0
    allocateFourierCoef(lmax,ctemp);
                             ^
Test_texture.c:20066:5: note: Null pointer dereference
    c->ci = NULL;
    ^
Test_texture.c:20208:3: warning: If memory allocation fails, then there is a possible null pointer dereference: fc [nullPointerOutOfMemory]
  fc->lmax = info->lmax;
  ^
Test_texture.c:20207:37: note: Assuming allocation function fails
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                    ^
Test_texture.c:20207:8: note: Assignment 'fc=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
       ^
Test_texture.c:20208:3: note: Null pointer dereference
  fc->lmax = info->lmax;
  ^
Test_texture.c:20211:45: warning: If memory allocation fails, then there is a possible null pointer dereference: fc [nullPointerOutOfMemory]
  printf("victor: fourier read. lmax: %d\n",fc->lmax);
                                            ^
Test_texture.c:20207:37: note: Assuming allocation function fails
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                    ^
Test_texture.c:20207:8: note: Assignment 'fc=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
       ^
Test_texture.c:20211:45: note: Null pointer dereference
  printf("victor: fourier read. lmax: %d\n",fc->lmax);
                                            ^
Test_texture.c:20215:29: warning: If memory allocation fails, then there is a possible null pointer dereference: fc [nullPointerOutOfMemory]
  info->lgdr = initLegendre(fc->lmax);
                            ^
Test_texture.c:20207:37: note: Assuming allocation function fails
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
                                    ^
Test_texture.c:20207:8: note: Assignment 'fc=(struct fourier_coef*)malloc(sizeof(struct fourier_coef))', assigned value is 0
  fc = (struct fourier_coef *)malloc(sizeof(struct fourier_coef));
       ^
Test_texture.c:20215:29: note: Null pointer dereference
  info->lgdr = initLegendre(fc->lmax);
                            ^
Test_texture.c:27019:11: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
  fprintf(filep,"%d %d %d %.6e %.6e\n",L[i].h,L[i].k,L[i].l,L[i].numReject,L[i].numScatt);
          ^
Test_texture.c:27016:20: note: Assuming allocation function fails
FILE *filep = fopen("rejectioStatistics.txt","w");
                   ^
Test_texture.c:27016:20: note: Assignment 'filep=fopen("rejectioStatistics.txt","w")', assigned value is 0
FILE *filep = fopen("rejectioStatistics.txt","w");
                   ^
Test_texture.c:27019:11: note: Null pointer dereference
  fprintf(filep,"%d %d %d %.6e %.6e\n",L[i].h,L[i].k,L[i].l,L[i].numReject,L[i].numScatt);
          ^
Test_texture.c:27021:8: warning: If resource allocation fails, then there is a possible null pointer dereference: filep [nullPointerOutOfResources]
fclose(filep);
       ^
Test_texture.c:27016:20: note: Assuming allocation function fails
FILE *filep = fopen("rejectioStatistics.txt","w");
                   ^
Test_texture.c:27016:20: note: Assignment 'filep=fopen("rejectioStatistics.txt","w")', assigned value is 0
FILE *filep = fopen("rejectioStatistics.txt","w");
                   ^
Test_texture.c:27021:8: note: Null pointer dereference
fclose(filep);
       ^
Test_texture.c:9007:12: warning: Uninitialized variable: draw_order.lines [uninitvar]
    return draw_order;
           ^
Test_texture.c:8991:36: note: Assuming condition is false
    if (draw_order.number_of_lines > 0) {
                                   ^
Test_texture.c:9007:12: note: Uninitialized variable: draw_order.lines
    return draw_order;
           ^
Test_texture.c:12466:66: error: Uninitialized variable: square_center [uninitvar]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Test_texture.c:13339:25: error: Uninitialized variable: temp_pointer [uninitvar]
                ListA = temp_pointer;
                        ^
Test_texture.c:14690:79: warning: Uninitialized variable: logic_list.elements [uninitvar]
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
Test_texture.c:14673:32: note: Assuming condition is false
    if (logic_list.num_elements>0) logic_list.elements = malloc(logic_list.num_elements*sizeof(int));
                               ^
Test_texture.c:14690:79: note: Uninitialized variable: logic_list.elements
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
Test_texture.c:18753:14: warning: Uninitialized variable: pll [uninitvar]
      return pll;
             ^
Test_texture.c:18748:21: note: Assuming condition is false
      for (ll=m+2;ll<=l;ll++) {
                    ^
Test_texture.c:18753:14: note: Uninitialized variable: pll
      return pll;
             ^
Test_texture.c:12466:66: error: Uninitialized struct member: square_center.x [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Test_texture.c:12466:66: error: Uninitialized struct member: square_center.y [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Test_texture.c:12466:66: error: Uninitialized struct member: square_center.z [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;MULTICORE...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;OFF_LEGACY...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_AF_HB_1D_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_INCOHERENTPHONON_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_INCOHERENT_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_NCRYSTAL_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_PHONONSIMPLE_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_POWDER_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_SINGLE_CRYSTAL_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;PROCESS_TEMPLATE_DETECTOR...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;SIGKILL;SIGUSR1;SIGUSR2...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_MPI...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_MPI;USE_NEXUS...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;USE_NEXUS...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;Union_trace_verbal_setting...
Test_texture.c:25306:17: error: printf format string requires 2 parameters but only 1 is given. [wrongPrintfScanfArgNum]
                printf("chance to get through this length of absorber: %f \%\n", 100*exp(-Volumes[current_volume]->p_physics->my_a*length_to_boundery));
                ^
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__APPLE__;__GNUC__...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__APPLE__;__unix__...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__FreeBSD__...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__GNUC__...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__GNUC__;__clang__...
Checking Test_texture.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;__dest_os...
DEBUG: CMD: cppcheck finished
INFO: End of linting ./Test_texture.c